protected override void load_Buffers()
{
_ssboExposure = new ShaderStorageBuffer(new EngineHelper.size[]
{
EngineHelper.size.vec2
});
_ssboExposure.bind();
Vector2 default_luminosity = new Vector2(1000.0f, 0.0f);
GL.BufferData(BufferTarget.ShaderStorageBuffer, (int)EngineHelper.size.vec2, ref default_luminosity, BufferUsageHint.DynamicCopy);
_ssboExposure.unbind();
_tLuminosity = new Texture(TextureTarget.Texture2D,
_resolution.W, _resolution.H,
0, true, false,
PixelInternalFormat.R16f, PixelFormat.Red, PixelType.Float,
TextureMinFilter.LinearMipmapLinear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tLuminosity.load();
_tTempScene = new Texture(TextureTarget.Texture2D,
_resolution.W, _resolution.H,
0, false, false,
PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.Float,
TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tTempScene.load();
}
protected override void CreateGpuBuffer(Buffer buffer)
{
ShaderStorageBuffer arrayBuffer = (ShaderStorageBuffer)buffer;
// Create CPU buffer with 16 elements
arrayBuffer.Create(_Context, 16);
}
public static FreeCamera SetUpFreeCamera()
{
CameraSavedViews = new Dictionary <int, TransformationManager>();
var freeCamera = new FreeCamera((float)Game.Resolution.Width / (float)Game.Resolution.Height, MathHelper.PiOver3 / 1);
FreeCam = freeCamera;
PickingResult = new ShaderStorageBuffer();
MousePicker = new ComputeShader("MousePicker.compute.glsl");
return(freeCamera);
}
public void ShaderStorageBuffer_TestShaderProgram()
{
if (!_Context.Extensions.ComputeShader_ARB)
{
Assert.Inconclusive("GL_ARB_compute_shader not supported");
}
if (!_Context.Extensions.ShaderStorageBufferObject_ARB)
{
Assert.Inconclusive("GL_ARB_shader_storage_buffer_object not supported");
}
const uint Size = 1024;
using (ShaderProgram program = new ShaderProgram(""))
using (Shader computeShader = new Shader(ShaderType.ComputeShader))
using (ShaderStorageBuffer storageBuffer = new ShaderStorageBuffer(MapBufferUsageMask.MapReadBit))
{
computeShader.LoadSource(new[] {
"#version 430",
"layout(local_size_x = 1, local_size_y = 1) in;",
"layout(std430, binding = 3) buffer glo_Buffer {",
" uint data[];",
"};",
"",
"void main() {",
" data[gl_WorkGroupID.x * gl_WorkGroupID.y] = uint(gl_WorkGroupID.x * gl_WorkGroupID.y);",
"}"
});
program.Attach(computeShader);
program.Create(_Context);
storageBuffer.Create(_Context, Size * Size * 4);
program.SetStorageBuffer(_Context, "glo_Buffer", storageBuffer);
program.Compute(_Context, Size, Size);
program.MemoryBarrier(MemoryBarrierMask.ShaderStorageBarrierBit);
uint[] storage = new uint[Size * Size];
storageBuffer.Load(_Context, storage, Size * Size * 4);
for (uint x = 0; x < Size; x++)
{
for (uint y = 0; y < Size; y++)
{
Assert.AreEqual(x * y, storage[x * y]);
}
}
}
}
private static async UniTask <Plain> CreateFloor2(WorldLayer layer)
{
var bufSize = new Vector2i(256, 256);
var buffer = ShaderStorageBuffer.CreateUninitialized <Color4>(bufSize.X * bufSize.Y);
var dispatcher = new TestComputeShader(() => buffer.Ssbo).CreateDispatcher();
var plain = new Plain();
plain.Position.Z = -10;
plain.Dead += _ =>
{
buffer.Dispose();
dispatcher.Dispose();
};
plain.Updated += _ => dispatcher.Dispatch(bufSize.X, bufSize.Y, 1);
plain.Scale = new Vector3(10f);
plain.Shader = new TestShader(() => (buffer.Ssbo, bufSize.X, bufSize.Y));
plain.Rotation = Quaternion.FromAxisAngle(Vector3.UnitX, -90.ToRadian());
return(await plain.Activate(layer));
}
protected override void DoInitialize()
{
base.DoInitialize();
using (var buffer = new ShaderStorageBuffer <vec4>(BufferUsage.StaticDraw))
{
buffer.Create(vertexCount);
unsafe
{
var array = (vec4 *)buffer.Header.ToPointer();
array[0] = new vec4(0, 0, 1, 1);
array[1] = new vec4(1, 0, 0, 1);
array[2] = new vec4(-1, 0, 0, 1);
array[3] = new vec4(0, 1, 0, 1);
}
var bufferPtr = buffer.GetBufferPtr() as ShaderStorageBufferPtr;
bufferPtr.Binding(this.Program, "PositionBuffer", 0);
bufferPtr.Unbind();
//this.shaderStorageBufferPtr = bufferPtr;
}
using (var buffer = new ShaderStorageBuffer <vec4>(BufferUsage.StaticDraw))
{
buffer.Create(vertexCount);
unsafe
{
var array = (vec4 *)buffer.Header.ToPointer();
array[0] = new vec4(+1, +0, +0, 0);
array[1] = new vec4(+0, +1, +0, 0);
array[2] = new vec4(+0, +0, +1, 0);
array[3] = new vec4(+1, +1, +1, 0);
//array[0] = new vec3(new vec3(0, 0, 0));
//array[1] = new vec3(new vec3(1, 1, +1));
//array[2] = new vec3(new vec3(0, +1, 0));
}
var bufferPtr = buffer.GetBufferPtr() as ShaderStorageBufferPtr;
bufferPtr.Binding(this.Program, "ColorBuffer", 1);
bufferPtr.Unbind();
//this.shaderStorageBufferPtr = bufferPtr;
}
this.groundRenderer.Initialize();
}
protected override void DoInitialize()
{
base.DoInitialize();
{
const int length = vertexCount;
ShaderStorageBuffer buffer = ShaderStorageBuffer.Create(typeof(vec4), length, BufferUsage.StaticDraw);
IntPtr pointer = buffer.MapBuffer(MapBufferAccess.WriteOnly);
unsafe
{
var array = (vec4 *)pointer;
array[0] = new vec4(0, 0, 1, 1);
array[1] = new vec4(1, 0, 0, 1);
array[2] = new vec4(-1, 0, 0, 1);
array[3] = new vec4(0, 1, 0, 1);
}
buffer.UnmapBuffer();
buffer.Binding(this.Program, "PositionBuffer", 0);
buffer.Unbind();
//this.shaderStorageBuffer = buffer;
}
{
const int length = vertexCount;
ShaderStorageBuffer buffer = ShaderStorageBuffer.Create(typeof(vec4), length, BufferUsage.StaticDraw);
IntPtr pointer = buffer.MapBuffer(MapBufferAccess.WriteOnly);
unsafe
{
var array = (vec4 *)pointer;
array[0] = new vec4(+1, +0, +0, 0);
array[1] = new vec4(+0, +1, +0, 0);
array[2] = new vec4(+0, +0, +1, 0);
array[3] = new vec4(+1, +1, +1, 0);
}
buffer.Binding(this.Program, "ColorBuffer", 1);
buffer.Unbind();
//this.shaderStorageBuffer = buffer;
}
this.groundRenderer.Initialize();
}
public void PopulateSSBOs(ShaderStorageBuffer triangleStream, ShaderStorageBuffer boxes)
{
Serialize();
while(ContainerIndices.Count % 4 != 0)
ContainerIndices.Add(0);
triangleStream.MapData(ContainerIndices.ToArray());
boxes.MapData(SerializerBytes.ToArray());
}
protected override void DoInitialize()
{
base.DoInitialize();
var texture = new Texture(TextureTarget.Texture2D,
new NullImageFiller(WIDTH, HEIGHT, OpenGL.GL_RGBA8, OpenGL.GL_RGBA, OpenGL.GL_UNSIGNED_BYTE),
new SamplerParameters(
TextureWrapping.Repeat, TextureWrapping.Repeat, TextureWrapping.Repeat,
TextureFilter.Linear, TextureFilter.Linear));
texture.Initialize();
this.texture = texture;
this.SetUniform("u_texture", texture);
{
var shaderCodes = new ShaderCode[] { new ShaderCode(File.ReadAllText(@"shaders\RayTracingRenderer\raytrace.comp.glsl"), ShaderType.ComputeShader), };
this.computeProgram = shaderCodes.CreateProgram();
this.computeProgram.Bind();
g_directionBuffer.glusRaytracePerspectivef(
DIRECTION_BUFFER_PADDING, 30.0f, WIDTH, HEIGHT);
using (var buffer = new ShaderStorageBuffer <float>(BufferUsage.StaticDraw))
{
buffer.Create(g_directionBuffer.Length);
unsafe
{
var array = (float *)buffer.Header.ToPointer();
for (int i = 0; i < g_directionBuffer.Length; i++)
{
array[i] = g_directionBuffer[i];
}
}
this.g_directionSSBO = buffer.GetBufferPtr() as ShaderStorageBufferPtr;
}
using (var buffer = new ShaderStorageBuffer <float>(BufferUsage.StaticDraw))
{
buffer.Create(g_positionBuffer.Length);
unsafe
{
var array = (float *)buffer.Header.ToPointer();
for (int i = 0; i < g_positionBuffer.Length; i++)
{
array[i] = g_positionBuffer[i];
}
}
this.g_positionSSBO = buffer.GetBufferPtr() as ShaderStorageBufferPtr;
}
using (var buffer = new ShaderStorageBuffer <float>(BufferUsage.StaticDraw))
{
buffer.Create(g_stackBuffer.Length);
unsafe
{
var array = (float *)buffer.Header.ToPointer();
for (int i = 0; i < g_stackBuffer.Length; i++)
{
array[i] = g_stackBuffer[i];
}
}
this.g_stackSSBO = buffer.GetBufferPtr() as ShaderStorageBufferPtr;
}
using (var buffer = new ShaderStorageBuffer <Sphere>(BufferUsage.StaticDraw))
{
buffer.Create(g_sphereBuffer.Length);
unsafe
{
var array = (Sphere *)buffer.Header.ToPointer();
for (int i = 0; i < g_sphereBuffer.Length; i++)
{
array[i] = g_sphereBuffer[i];
}
}
this.g_sphereSSBO = buffer.GetBufferPtr() as ShaderStorageBufferPtr;
}
using (var buffer = new ShaderStorageBuffer <PointLight>(BufferUsage.StaticDraw))
{
buffer.Create(g_lightBuffer.Length);
unsafe
{
var array = (PointLight *)buffer.Header.ToPointer();
for (int i = 0; i < g_lightBuffer.Length; i++)
{
array[i] = g_lightBuffer[i];
}
}
this.g_pointLightSSBO = buffer.GetBufferPtr() as ShaderStorageBufferPtr;
}
}
}
public PhysicsTest()
{
var scene = Game.World.Scene;
Game.Invoke(() =>
{
Object3dInfo point3dinfo = new Object3dInfo(new VertexInfo[] { new VertexInfo()
{
Position = Vector3.One,
Normal = Vector3.UnitZ,
UV = Vector2.Zero
} });
Object3dInfo point3dinfo2 = Object3dGenerator.CreateCube(Vector3.One * 0.1f, Vector2.One).AsObject3dInfo();
OpenTK.Graphics.OpenGL4.GL.PointSize(111);
GenericMaterial whitemat = new GenericMaterial()
{
DiffuseColor = Vector3.One
};
Mesh3d points = Mesh3d.Create(point3dinfo2, whitemat);
//point3dinfo.DrawMode = OpenTK.Graphics.OpenGL4.PrimitiveType.Points;
//whitemat.CustomShaderProgram = ShaderProgram.Compile("Points.vertex.glsl", "Points.fragment.glsl");
points.ClearInstances();
ComputeShader updateShader = new ComputeShader("PhysicsUpdater.compute.glsl");
ShaderStorageBuffer pointsBuffer = new ShaderStorageBuffer();
var parts = new List <Particle>();
List <byte> bytes = new List <byte>();
for (int i = 0; i < 1024 * 2; i++)
{
var part = new Particle()
{
Position = new Vector3(rand(-20, 20), rand(0, 20), rand(-10, 10)),
Velocity = Vector3.Zero
};
points.AddInstance(new TransformationManager(part.Position));
bytes.AddRange(BitConverter.GetBytes(part.Position.X));
bytes.AddRange(BitConverter.GetBytes(part.Position.Y));
bytes.AddRange(BitConverter.GetBytes(part.Position.Z));
bytes.AddRange(BitConverter.GetBytes(part.Position.X));
bytes.AddRange(BitConverter.GetBytes(part.Velocity.X));
bytes.AddRange(BitConverter.GetBytes(part.Velocity.Y));
bytes.AddRange(BitConverter.GetBytes(part.Velocity.Z));
bytes.AddRange(BitConverter.GetBytes(part.Velocity.X));
}
pointsBuffer.MapData(bytes.ToArray());
pointsBuffer.Use(9);
Game.OnBeforeDraw += (z, x) =>
{
updateShader.Use();
pointsBuffer.Use(9);
updateShader.SetUniform("ParticlesCount", 1024 * 2);
updateShader.Dispatch(2, 1, 1);
pointsBuffer.Use(9);
};
points.UpdateMatrix();
scene.Add(points);
});
}
protected override void load_Buffers()
{
//------------------------------------------------------
// AutoFocus
//------------------------------------------------------
_ssboAutoFocus = new ShaderStorageBuffer(new EngineHelper.size[]
{
EngineHelper.size.vec2
});
//------------------------------------------------------
// COC
//------------------------------------------------------
_tCOC = new Texture(TextureTarget.Texture2D,
_resolution_half.W, _resolution_half.H, 0,
false, false,
PixelInternalFormat.R32f, PixelFormat.Red, PixelType.Float,
TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tCOC.load();
_tCOC_Foreground_Blurred = new Texture(TextureTarget.Texture2D,
_resolution_half.W, _resolution_half.H, 0,
false, false,
PixelInternalFormat.R32f, PixelFormat.Red, PixelType.Float,
TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tCOC_Foreground_Blurred.load();
_tCOC_Foreground = new Texture(TextureTarget.Texture2D,
_resolution_half.W, _resolution_half.H, 0,
false, false,
PixelInternalFormat.R32f, PixelFormat.Red, PixelType.Float,
TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tCOC_Foreground.load();
_tCOC_Foreground_Final = new Texture(TextureTarget.Texture2D,
_resolution_half.W, _resolution_half.H, 0,
false, false,
PixelInternalFormat.R32f, PixelFormat.Red, PixelType.Float,
TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tCOC_Foreground_Final.load();
_tCOC_Final = new Texture(TextureTarget.Texture2D,
_resolution.W, _resolution.H, 0,
false, false,
PixelInternalFormat.R32f, PixelFormat.Red, PixelType.Float,
TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tCOC_Final.load();
//------------------------------------------------------
// Bokeh
//------------------------------------------------------
_iBokehShape = _tLoader.createImage(_path_static_textures + "bokeh_circle.png", TextureTarget.Texture2D, TextureWrapMode.Clamp, true);
_tBokeh_Positions = new Texture(TextureTarget.Texture1D,
_bokeh_max_shapes, 0, 0,
false, false,
PixelInternalFormat.Rgba32f, PixelFormat.Rgba, PixelType.Float,
TextureMinFilter.Nearest, TextureMagFilter.Nearest, TextureWrapMode.Clamp);
_tBokeh_Positions.load();
_tBokeh_Colors = new Texture(TextureTarget.Texture1D,
_bokeh_max_shapes, 0, 0,
false, false,
PixelInternalFormat.Rgba32f, PixelFormat.Rgba, PixelType.Float,
TextureMinFilter.Nearest, TextureMagFilter.Nearest, TextureWrapMode.Clamp);
_tBokeh_Colors.load();
_tBokeh_Points = new Texture(TextureTarget.Texture2D,
_resolution_half.W, _resolution_half.H, 0,
false, false,
PixelInternalFormat.Rgb16f, PixelFormat.Rgb, PixelType.Float,
TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tBokeh_Points.load();
load_BuffersBokeh();
//------------------------------------------------------
// DOF
//------------------------------------------------------
_tDOF_Scene = new Texture(TextureTarget.Texture2D,
_resolution_half.W, _resolution_half.H, 0,
false, false,
PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.Float,
TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tDOF_Scene.load();
_tDOF_Scene_2 = new Texture(TextureTarget.Texture2D,
_resolution_half.W, _resolution_half.H, 0,
false, false,
PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.Float,
TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp);
_tDOF_Scene_2.load();
//------------------------------------------------------
// Frame Buffers
//------------------------------------------------------
_fHalfResolution = new FrameBuffer("DOF - Half Resolution");
_fHalfResolution.load(new Dictionary <FramebufferAttachment, Texture>()
{
{ FramebufferAttachment.ColorAttachment0, _tCOC },
{ FramebufferAttachment.ColorAttachment1, _tCOC_Foreground_Blurred },
{ FramebufferAttachment.ColorAttachment2, _tCOC_Foreground },
{ FramebufferAttachment.ColorAttachment3, _tCOC_Foreground_Final },
{ FramebufferAttachment.ColorAttachment4, _tBokeh_Points },
{ FramebufferAttachment.ColorAttachment5, _tDOF_Scene },
{ FramebufferAttachment.ColorAttachment6, _tDOF_Scene_2 }
});
_fFullResoution = new FrameBuffer("DOF - Full Resolution");
_fFullResoution.load(new Dictionary <FramebufferAttachment, Texture>()
{
{ FramebufferAttachment.ColorAttachment0, _tCOC_Final }
});
}
public void PrepareTrianglesData(List<Mesh3d> meshes)
{
List<Triangle> triangles = new List<Triangle>();
foreach(var mesh in meshes)
{
var Triangle = new Triangle();
var vertices = mesh.MainObjectInfo.GetOrderedVertices();
var normals = mesh.MainObjectInfo.GetOrderedNormals();
for(int i = 0; i < vertices.Count; i++)
{
var vertex = new Vertex()
{
Position = vertices[i],
Normal = normals[i],
Albedo = mesh.MainMaterial.Color.Xyz
};
vertex.Tranform(mesh.Matrix);
Triangle.Vertices.Add(vertex);
if(Triangle.Vertices.Count == 3)
{
triangles.Add(Triangle);
Triangle = new Triangle();
}
}
}
SceneOctalTree tree = new SceneOctalTree();
Triangle[] trcopy = new Triangle[triangles.Count];
triangles.CopyTo(trcopy);
tree.CreateFromTriangleList(trcopy.ToList());
TriangleCount = triangles.Count;
// lets prepare byte array
// layout
// posx, posy, poz, norx, nory, norz, albr, albg, albz
List<byte> bytes = new List<byte>();
foreach(var triangle in triangles)
{
foreach(var vertex in triangle.Vertices)
{
bytes.AddRange(BitConverter.GetBytes(vertex.Position.X));
bytes.AddRange(BitConverter.GetBytes(vertex.Position.Y));
bytes.AddRange(BitConverter.GetBytes(vertex.Position.Z));
bytes.AddRange(BitConverter.GetBytes(0.0f));
bytes.AddRange(BitConverter.GetBytes(vertex.Normal.X));
bytes.AddRange(BitConverter.GetBytes(vertex.Normal.Y));
bytes.AddRange(BitConverter.GetBytes(vertex.Normal.Z));
bytes.AddRange(BitConverter.GetBytes(0.0f));
bytes.AddRange(BitConverter.GetBytes(vertex.Albedo.X));
bytes.AddRange(BitConverter.GetBytes(vertex.Albedo.Y));
bytes.AddRange(BitConverter.GetBytes(vertex.Albedo.Z));
bytes.AddRange(BitConverter.GetBytes(0.0f));
}
}
MeshDataSSBO = new ShaderStorageBuffer();
TrianglesStream = new ShaderStorageBuffer();
OctreeBoxes = new ShaderStorageBuffer();
GLThread.Invoke(() =>
{
MeshDataSSBO.MapData(bytes.ToArray());
tree.PopulateSSBOs(TrianglesStream, OctreeBoxes);
BoxesCount = tree.TotalBoxesCount;
});
RandomsSSBO = new ShaderStorageBuffer();
}
public PathTracer()
{
TracerShader = new ComputeShader("PathTracer.compute.glsl");
LightsSSBO = new ShaderStorageBuffer();
}
public void ShaderStorageBuffer_TestCreation()
{
using (ShaderStorageBuffer ssbo = new ShaderStorageBuffer(BufferUsage.DynamicDraw)) {
ssbo.Create(_Context, (uint)Math.Min(1024 * 1024, _Context.Limits.MaxShaderStorageBlockSize));
}
}
