387 lines
14 KiB
C#
387 lines
14 KiB
C#
//-----------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------
|
|
// file="Partical.cs"
|
|
// Project: StgSharp
|
|
// AuthorGroup: Nitload Space
|
|
// Copyright (c) Nitload Space. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person
|
|
// obtaining a copy of this software and associated documentation
|
|
// files (the “Software”), to deal in the Software without restriction,
|
|
// including without limitation the rights to use, copy, modify, merge,
|
|
// publish, distribute, sublicense, and/or sell copies of the Software,
|
|
// and to permit persons to whom the Software is furnished to do so,
|
|
// subject to the following conditions:
|
|
//
|
|
// The above copyright notice and
|
|
// this permission notice shall be included in all copies
|
|
// or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED “AS IS”,
|
|
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
|
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
|
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
//-----------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------
|
|
using StgSharp.Controls;
|
|
using StgSharp.Geometries;
|
|
using StgSharp.Graphics;
|
|
using StgSharp.Graphics.OpenGL;
|
|
|
|
using StgSharp.Math;
|
|
using StgSharp.Timing;
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace StgSharp
|
|
{
|
|
public class ParticleRenderStream : glRenderStream
|
|
{
|
|
|
|
private ElementBuffer ebo;
|
|
private ElementBuffer f_ebo;
|
|
private FrameBuffer fbo;
|
|
private Image i;
|
|
private PlainInstancingBuffer<ParticleOnPlain> buffer;
|
|
private RenderBuffer rbo;
|
|
private ShaderProgram frameMainShader;
|
|
private ShaderProgram s;
|
|
|
|
private AutoTextureGL autoT;
|
|
private TextureGL f_t;
|
|
private TextureGL t;
|
|
private Uniform<int> texUniform;
|
|
private Uniform<float> time;
|
|
private VertexArray f_vao;
|
|
private VertexArray vao;
|
|
|
|
private VertexBuffer f_vbo;
|
|
private VertexBuffer vbo;
|
|
|
|
public ParticleRenderStream() { }
|
|
|
|
public override bool IsContextSharable => true;
|
|
|
|
public Rectangle ButtonBounding { get; private set; }
|
|
|
|
public TextureProvider ButtonTextureProvider { get; private set; }
|
|
|
|
int temp = 0;
|
|
|
|
//render a controlling item
|
|
public void OtherMain( IEnumerable<PlainGeometryMesh> items )
|
|
{
|
|
//Console.WriteLine("Render Button Itself");
|
|
|
|
GL.BindFrameBuffer( FrameBufferTarget.All, GlHandle.Zero ); //_gl.Assert(true);
|
|
GL.ClearColor( 0.4f, TimePassed % 1.0f, 0f, 1.0f ); //_gl.Assert(true);
|
|
GL.Clear( MaskBufferBit.COLOR /**/ | MaskBufferBit.DEPTH/**/ ); //_gl.Assert(true);
|
|
|
|
f_vao.Bind( 0 ); //_gl.Assert(true);
|
|
|
|
foreach( PlainGeometryMesh mesh in items )
|
|
{
|
|
autoT.SelectTextureAndBind(mesh.TextureImage);
|
|
//f_t.LoadTexture( 0, mesh.TextureImage );
|
|
//_gl.Assert(true);
|
|
|
|
frameMainShader.Use(); //_gl.Assert(true);
|
|
|
|
GL.DrawElements(GeometryType.TRIANGLES, 6, TypeCode.UInt32, IntPtr.Zero);
|
|
|
|
}
|
|
|
|
//_gl.Assert(true);
|
|
|
|
//_gl.DrawElements(GeometryType.LINES, 6, TypeCode.UInt32, IntPtr.Zero);
|
|
//BlueprintPipeline.SkipAll(output);
|
|
|
|
SwapBuffers();
|
|
}
|
|
|
|
public void RenderButton(
|
|
ButtonStatus status,
|
|
float statusBegin,
|
|
in TextureProvider provider )
|
|
{ provider.UpdateFromImage( i ); }
|
|
|
|
internal static vec3d DefaultRotation( TimeSpanProvider provider, out float rotation )
|
|
{
|
|
rotation = provider.SpanLengthLowPrecession;
|
|
float angle = provider.CurrentSecond * 2;
|
|
return ( new vec3d( Scaler.Cos( angle ), Scaler.Sin( angle ), 0 ) ) *
|
|
provider.SpanLengthLowPrecession;
|
|
}
|
|
|
|
protected override void CustomizeDeinit() { }
|
|
|
|
protected override void CustomizeInit()
|
|
{
|
|
//_gl.ClearError();
|
|
//_gl.Assert(true);
|
|
|
|
|
|
buffer = new PlainInstancingBuffer<ParticleOnPlain>();
|
|
for( int i = 0; i < 10; i++ )
|
|
{
|
|
float ai = Scaler.Abs( i - 5.0f );
|
|
for( int t = 0; t < 10; t++ )
|
|
{
|
|
float at = Scaler.Abs( t - 5.0f );
|
|
|
|
ParticleOnPlain p = new ParticleOnPlain( buffer );
|
|
( ( IInstancing )p ).Coord = new vec3d(
|
|
( ( ( -5 ) + i ) * 0.2f ) + 0.1f, ( ( ( -5 ) + t ) * 0.2f ) + 0.1f, 0 );
|
|
( ( IInstancing )p ).Scale =
|
|
Scaler.MinOf( i, t ) * 0.15f;
|
|
( ( IInstancing )p ).Motion = new GeometryMotion(
|
|
true, this._timeProvider, DefaultRotation );
|
|
}
|
|
}
|
|
|
|
//_gl.Assert(true);
|
|
|
|
//SetSizeLimit(800, 800, 800, 800);
|
|
|
|
s = CreateShaderProgram();
|
|
frameMainShader = CreateShaderProgram();
|
|
Shader pvs = CreateShaderSegment( ShaderType.Vertex, 2 );
|
|
Shader pfs = CreateShaderSegment( ShaderType.Fragment, 2 );
|
|
|
|
//_gl.Assert(true);
|
|
pvs.Compile( 0, Shader.FromCodeFile( "Shader\\particle.vert" ) );
|
|
|
|
//_gl.Assert(true);
|
|
pvs.AttachTo( 0, s );
|
|
|
|
//_gl.Assert(true);
|
|
pfs.Compile( 0, Shader.FromCodeFile( "Shader\\particle.frag" ) );
|
|
pfs.AttachTo( 0, s );
|
|
s.Link();
|
|
|
|
//_gl.Assert(true);
|
|
|
|
pvs.Compile( 1, Shader.FromCodeFile( "Shader\\fbo.vert" ) );
|
|
pvs.AttachTo( 1, frameMainShader );
|
|
pfs.Compile( 1, Shader.FromCodeFile( "Shader\\fbo.frag" ) );
|
|
pfs.AttachTo( 1, frameMainShader );
|
|
frameMainShader.Link();
|
|
|
|
//_gl.Assert(true);
|
|
vbo = CreateVertexBuffer( 3 );
|
|
vao = CreateVertexArray( 1 );
|
|
ebo = CreateElementBuffer( 1 );
|
|
vbo.Bind( 0 );
|
|
|
|
Rectangle rec = new Rectangle(
|
|
0.05f, 0.05f, 0.05f, -0.05f, -0.05f, -0.05f, -0.05f, 0.05f );
|
|
|
|
//_gl.Assert(true);
|
|
vao.Bind( 0 );
|
|
vbo.WriteVectorData( 0, rec.VertexStream, BufferUsage.StaticDraw );
|
|
ebo.SetValue( 0, rec.VertexIndices, BufferUsage.StaticDraw );
|
|
vao.SetVertexAttribute( 0, 3, TypeCode.Single, false, 4 * sizeof( float ), 0 );
|
|
|
|
vbo.WriteVectorData<vec4d>( 1, buffer.CoordAndRotationSpan, BufferUsage.StreamDraw );
|
|
vao.SetVertexAttribute( 1, 3, TypeCode.Single, false, 4 * sizeof( float ), 0 );
|
|
vao.SetVertexAttribute(
|
|
2, 1, TypeCode.Single, false, 4 * sizeof( float ), 3 * sizeof( float ) );
|
|
|
|
GL.VertexAttributeDivisor( 1, 1 );
|
|
GL.VertexAttributeDivisor( 2, 1 );
|
|
|
|
vbo.WriteScalerData<float>( 2, buffer.ScalingSpan, BufferUsage.StaticDraw );
|
|
vao.SetVertexAttribute( 3, 1, TypeCode.Single, false, sizeof( float ), 0 );
|
|
|
|
GL.VertexAttributeDivisor( 3, 1 );
|
|
|
|
vbo.Unbind();
|
|
GL.BindVertexArray( GlHandle.Zero );
|
|
|
|
NativeCameraViewTarget( (0, 0, -100), (0, 0, 0), (0, 1, 0) );
|
|
NativeCameraViewRange( new Degree( 1.5f ), Vec2d.Zero, (50, 50) );
|
|
NativeCameraUniform( s, "Camera" );
|
|
|
|
s.Use();
|
|
fbo = CreateFrameBuffer( 1 );
|
|
rbo = CreateRenderBuffer( 1 );
|
|
|
|
fbo.Bind( 0 );
|
|
rbo.Bind( 0 );
|
|
GL.SetRenderBufferStorage( RenderBufferInternalFormat.Depth24_Stencil8, this.Size );
|
|
|
|
//_gl.Assert(true);
|
|
t = CreateTexture( 1 );
|
|
t.Bind2D( 0 );
|
|
GL.TextureImage2d<byte>(
|
|
Texture2DTarget.Texture2D, 0, ( int )ImageChannel.WithAlphaChannel, ( uint )Width,
|
|
( uint )Height, ( int )ImageChannel.WithAlphaChannel, PixelChannelLayout.Byte,
|
|
null );
|
|
t.Set2dWrapProperty( 0, TextureWrap.Repeat, TextureWrap.Repeat );
|
|
t.Set2dFilterProperty( 0, TextureFilter.Nearest, TextureFilter.Nearest );
|
|
|
|
//_gl.Assert(true);
|
|
GL.FrameBufferTexture2d(
|
|
FrameBufferTarget.All, glAttachment.Color( 0 ), Texture2DTarget.Texture2D, t[ 0 ],
|
|
0 );
|
|
|
|
//_gl.Assert(true);
|
|
GL.CombineFrameBufferRenderBuffer(
|
|
FrameBufferAttachment.Stencil | FrameBufferAttachment.Depth, rbo[ 0 ] );
|
|
|
|
Console.WriteLine( GL.CheckFrameBufferStatus( FrameBufferTarget.All ) );
|
|
|
|
FrameBuffer.BindNull();
|
|
|
|
//_gl.Assert(true);
|
|
int streamLength = this.Width * this.Height * 4;
|
|
byte[] imageStream = new byte[streamLength];
|
|
i = Image.FromMemory( this.Size, ImageChannel.WithAlphaChannel, imageStream );
|
|
|
|
time = s.GetUniform<float>( "time" );
|
|
|
|
vec2d[] buttonTextureCoordArray = {
|
|
(0f, 1f),
|
|
(1f, 1f),
|
|
(1f, 0f),
|
|
(0f, 0f)
|
|
};
|
|
ButtonBounding = new Rectangle( -0.9f, 0.9f, 0.9f, 0.9f, 0.9f, -0.9f, -0.9f, -0.9f );
|
|
|
|
//_gl.Assert(true);
|
|
ButtonTextureProvider = new TextureProvider( i, buttonTextureCoordArray );
|
|
|
|
f_vao = CreateVertexArray( 1 );
|
|
f_vbo = CreateVertexBuffer( 2 );
|
|
f_ebo = CreateElementBuffer( 1 );
|
|
|
|
//_gl.Assert(true);
|
|
f_vao.Bind( 0 );
|
|
|
|
f_ebo.Bind( 0 );
|
|
f_ebo.SetValue( 0, ButtonBounding.VertexIndices, BufferUsage.StaticDraw );
|
|
|
|
//_gl.Assert(true);
|
|
f_vbo.Bind( 0 );
|
|
f_vbo.WriteVectorData( 0, ButtonBounding.VertexStream, BufferUsage.StaticDraw );
|
|
f_vao.SetVertexAttribute( 0, 3, TypeCode.Single, false, 4 * sizeof( float ), 0 );
|
|
|
|
//_gl.Assert(true);
|
|
f_vbo.Bind( 1 );
|
|
f_vbo.WriteVectorData( 1, buttonTextureCoordArray, BufferUsage.StaticDraw );
|
|
f_vao.SetVertexAttribute( 1, 3, TypeCode.Single, false, 4 * sizeof( float ), 0 );
|
|
|
|
//_gl.Assert(true);
|
|
|
|
autoT = CreateAutoTexture(4);
|
|
autoT.DefaultTextureProperty = new TextureProperty(
|
|
TextureFilter.Nearest, TextureFilter.Nearest,
|
|
TextureWrap.Repeat, TextureWrap.Repeat
|
|
);
|
|
|
|
f_t = CreateTexture( 1 );
|
|
f_t.Bind2D( 0 );
|
|
f_t.Set2dWrapProperty( 0, TextureWrap.Repeat, TextureWrap.Repeat );
|
|
f_t.Set2dFilterProperty( 0, TextureFilter.Nearest, TextureFilter.Nearest );
|
|
|
|
//_gl.Assert(true);
|
|
f_t.ActivateAs( TextureUnit.Unit1 );
|
|
|
|
//_gl.Assert(true);
|
|
frameMainShader.Use();
|
|
texUniform = frameMainShader.GetUniform<int>( "tex" );
|
|
|
|
//_gl.Assert(true);
|
|
GL.SetUniformValue( texUniform, 1 );
|
|
|
|
//_gl.Assert(true);
|
|
}
|
|
|
|
protected override void Main()
|
|
{
|
|
temp++;
|
|
//_gl.ClearError();
|
|
//Console.Clear();
|
|
buffer.UpdateAllParticles();
|
|
|
|
//Console.WriteLine(_gl.CheckFrameBufferStatus(FrameBufferTarget.All));
|
|
|
|
fbo.Bind( 0 ); //_gl.Assert(true);
|
|
vao.Bind( 0 ); //_gl.Assert(true);
|
|
t.Bind2D( 0 ); //_gl.Assert(true);
|
|
/**/
|
|
|
|
GL.TextureImage2d(
|
|
Texture2DTarget.Texture2D, 0, ( int )ImageChannel.WithAlphaChannel, ( uint )Width,
|
|
( uint )Height, ( int )ImageChannel.WithAlphaChannel, PixelChannelLayout.Byte,
|
|
new byte[1] );
|
|
/**/
|
|
|
|
//_gl.Assert(true);
|
|
|
|
GL.ClearColor( ( 0.6f + TimePassed ) % 1.0f, 0.1f, 0.3f, 1 );
|
|
GL.Clear( MaskBufferBit.COLOR | MaskBufferBit.DEPTH );
|
|
|
|
//_gl.Assert(true);
|
|
|
|
vbo.Bind( 1 );
|
|
vbo.WriteVectorData<vec4d>( 1, buffer.CoordAndRotationSpan, BufferUsage.StreamDraw );
|
|
|
|
|
|
s.Use();
|
|
NativeCamera.SetAllUniforms();
|
|
GL.SetUniformValue( time, TimePassed );
|
|
|
|
GL.DrawElementsInstanced( GeometryType.TRIANGLES, 6, TypeCode.UInt32, IntPtr.Zero,
|
|
100 );
|
|
|
|
//Console.WriteLine(TimePassed);
|
|
//_gl.Assert(true);
|
|
|
|
GL.WaitAccomplishment();
|
|
GL.BindVertexArray( GlHandle.Zero );
|
|
/**/
|
|
|
|
//_gl.Assert(true);
|
|
|
|
ImageHelper.Resize( i, Width, Height, ImageMovement.Discard );
|
|
|
|
//_gl.ClearError();
|
|
|
|
GL.GetTextureImage(
|
|
Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel,
|
|
PixelChannelLayout.Byte, i.PixelBuffer );
|
|
/*
|
|
for (int num = 0; num < i.PixelBuffer.Length; num+=10000)
|
|
{
|
|
Console.Write($"{i.PixelBuffer[num]}\t");
|
|
}
|
|
/**/
|
|
|
|
//_gl.Assert(true);
|
|
//Array.Fill<byte>(i.PixelBuffer, 24);
|
|
|
|
GL.BindFrameBuffer( FrameBufferTarget.All, GlHandle.Zero );
|
|
|
|
//_gl.Assert(true);
|
|
/**/
|
|
|
|
/*
|
|
//BlueprintPipeline.SkipAll(output);
|
|
SwapBuffers();
|
|
PollEvents();
|
|
/**/
|
|
}
|
|
|
|
}
|
|
}
|