Frustum SetCameraBuffer(Camera a_camera)
{
lock (a_camera)
{
if (a_camera.Transform == null)
{
return(null);
}
Graphics.CameraContainer camContainer = new Graphics.CameraContainer
{
Transform = a_camera.Transform.ToMatrix(),
Projection = a_camera.Projection
};
camContainer.View = camContainer.Transform.Inverted();
Matrix4 viewProjection = camContainer.View * camContainer.Projection;
camContainer.ViewProjection = viewProjection;
UniformBufferObject ubo = m_graphics.CameraBufferObject;
ubo.UpdateData(camContainer);
ubo.UpdateBuffer();
return(new Frustum(viewProjection));
}
}
/// <summary>
/// Create or update resources defined by this IGraphicsState, based on the associated <see cref="ShaderProgram"/>.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> used for allocating resources.
/// </param>
/// <param name="shaderProgram">
/// A <see cref="ShaderProgram"/> that will be used in conjunction with this IGraphicsState.
/// </param>
private void CreateUniformBuffer(GraphicsContext ctx, ShaderProgram shaderProgram)
{
if (ctx.Extensions.UniformBufferObject_ARB == false)
{
return; // No uniform buffer support
}
if (UniformBlockTag == null)
{
return; // No uniform block support by this class
}
if (shaderProgram == null)
{
return; // No uniform buffer support by fixed pipeline
}
Debug.Assert(_UniformBuffer == null);
if (shaderProgram.IsActiveUniformBlock(UniformBlockTag))
{
_UniformBuffer = shaderProgram.CreateUniformBlock(UniformBlockTag, UniformBlockHint);
_UniformBuffer.Create(ctx);
_UniformBuffer.IncRef();
}
// Base implementation
base.CreateState(ctx, shaderProgram);
}
public UniformBlock()
{
GL.GetInteger(GetPName.MaxUniformBufferBindings, out maxUniformIndex);
engineUBO = new UniformBufferObject <EngineUniformStruct>(nextUniformIndex++, () => engine);
modelUBO = new UniformBufferObject <ModelUniformStruct>(nextUniformIndex++, () => model);
lightUBO = new UniformBufferObject <LightUniformStruct>(nextUniformIndex++, () => light);
}
private void UpdateUniformBuffer()
{
long currentTimestamp = Stopwatch.GetTimestamp();
float totalTime = (currentTimestamp - this.initialTimestamp) / (float)Stopwatch.Frequency;
UniformBufferObject ubo = new UniformBufferObject
{
Model = mat4.Rotate((float)Math.Sin(totalTime) * (float)Math.PI, vec3.UnitZ),
View = mat4.LookAt(new vec3(1), vec3.Zero, vec3.UnitZ),
Proj = mat4.Perspective((float)Math.PI / 4f, this.swapChainExtent.Width / (float)this.swapChainExtent.Height, 0.1f, 10)
};
ubo.Proj[1, 1] *= -1;
uint uboSize = (uint)Unsafe.SizeOf <UniformBufferObject>();
IntPtr memoryBuffer = this.uniformStagingBufferMemory.Map(0, uboSize, MemoryMapFlags.None);
Marshal.StructureToPtr(ubo, memoryBuffer, false);
this.uniformStagingBufferMemory.Unmap();
this.CopyBuffer(this.uniformStagingBuffer, this.uniformBuffer, uboSize);
}
void LightingPass(MultiRenderTexture a_renderTexture)
{
GL.Disable(EnableCap.DepthTest);
// GL.Disable(EnableCap.Blend);
GL.Enable(EnableCap.Blend);
// GL.BlendFunc(BlendingFactor.One, BlendingFactor.One);
foreach (Light light in Light.LightList)
{
if (light.Draw)
{
UniformBufferObject ubo = m_graphics.LightBufferObject;
Material material = light.BindLightDrawing();
ubo.UpdateData(light.GetLightData());
BindCamera();
BindTransform(light.Transform.ToMatrix(), light.Transform.RotationMatrix);
BindableContainer cont = BindMaterial(material);
GL.ActiveTexture(TextureUnit.Texture0 + cont.Textures);
GL.BindTexture(TextureTarget.Texture2D, ((OpenTKTexture)a_renderTexture.RenderTextures[0].InternalObject).Handle);
GL.Uniform1(0, cont.Textures++);
GL.ActiveTexture(TextureUnit.Texture0 + cont.Textures);
GL.BindTexture(TextureTarget.Texture2D, ((OpenTKTexture)a_renderTexture.RenderTextures[1].InternalObject).Handle);
GL.Uniform1(1, cont.Textures++);
GL.ActiveTexture(TextureUnit.Texture0 + cont.Textures);
GL.BindTexture(TextureTarget.Texture2D, ((OpenTKTexture)a_renderTexture.RenderTextures[2].InternalObject).Handle);
GL.Uniform1(2, cont.Textures++);
GL.ActiveTexture(TextureUnit.Texture0 + cont.Textures);
GL.BindTexture(TextureTarget.Texture2D, ((OpenTKTexture)m_renderTarget.DepthBuffer.InternalObject).Handle);
GL.Uniform1(3, cont.Textures++);
ubo.UpdateBuffer();
GL.BindBufferBase(BufferRangeTarget.UniformBuffer, Material.LightUBOIndex, ((OpenTKUniformBufferObject)ubo.InternalObject).Handle);
light.BindShadowMap(cont);
GL.DrawArrays(PrimitiveType.TriangleStrip, 0, 4);
#if DEBUG_INFO
Pipeline.GLError("Graphics: Lighting: ");
#endif
}
}
GL.Disable(EnableCap.Blend);
GL.Enable(EnableCap.DepthTest);
}
void BindTime()
{
UniformBufferObject ubo = m_graphics.TimeBufferObject;
GL.BindBufferBase(BufferRangeTarget.UniformBuffer, Material.TimeUBOIndex, ((OpenTKUniformBufferObject)ubo.InternalObject).Handle);
#if DEBUG_INFO
Pipeline.GLError("Graphics: Binding Time: ");
#endif
}
internal void Init()
{
m_transformBuffer = new UniformBufferObject(new TransformContainer(), 0, m_pipeline);
m_cameraBuffer = new UniformBufferObject(new CameraContainer(), 1, m_pipeline);
m_lightBuffer = new UniformBufferObject(new LightContainer(), 2, m_pipeline);
m_timeBuffer = new UniformBufferObject(new TimeContainer(), 3, m_pipeline);
m_internalGraphics.Init();
m_init = true;
}
public void UpdateFrame()
{
var oneFullRotPer4SecInRad = (DateTime.Now.Ticks % (4 * TimeSpan.TicksPerSecond))
* ((Math.PI / 2f) / TimeSpan.TicksPerSecond);
var ubo = new UniformBufferObject()
{
Model = Matrix4x4.CreateRotationZ((float)oneFullRotPer4SecInRad),
View = Matrix4x4.CreateLookAt(new Vector3(2.0f, 2.0f, 2.0f), Vector3.Zero, Vector3.UnitZ),
Projection = VK_SPACE_CORRECTION * Matrix4x4.CreatePerspectiveFieldOfView((float)Math.PI / 4.0f, width / (float)height, 0.1f, 10.0f),
};
DeviceSize bufferSize = Marshal.SizeOf <UniformBufferObject>();
IntPtr buffer = vkDevice.MapMemory(vkUniformBufferMemory, 0, bufferSize);
Marshal.StructureToPtr(ubo, buffer, false);
vkDevice.UnmapMemory(vkUniformBufferMemory);
}
public override void Update()
{
double rotationTime = 30.0;
double rotation = ((Stopwatch.GetTimestamp() / (double)Stopwatch.Frequency) % rotationTime) / rotationTime;
var ubo = new UniformBufferObject
{
World = mat4.RotateY((float)Math.PI * 2 * (float)rotation),
View = mat4.LookAt(new vec3(0, 0, -3f), vec3.Zero, vec3.UnitY),
Projection = mat4.Perspective((float)Math.PI / 3f, this.aspectRatio, 0.1f, 10f)
};
ubo.InvTransWorld = (ubo.World).Inverse.Transposed;
//ubo.Projection[1, 1] *= -1;
this.uniformBuffer.Update(ubo);
}
void BindTransform(Matrix4 a_transform, Matrix3 a_rotationMatrix)
{
UniformBufferObject ubo = m_graphics.TransformBufferObject;
Graphics.TransformContainer transContainer = new Graphics.TransformContainer
{
Transform = a_transform,
RotationMatrix = a_rotationMatrix
};
ubo.UpdateData(transContainer);
ubo.UpdateBuffer();
GL.BindBufferBase(BufferRangeTarget.UniformBuffer, Material.TransformUBOIndex, ((OpenTKUniformBufferObject)ubo.InternalObject).Handle);
#if DEBUG_INFO
Pipeline.GLError("Graphics: Binding Transform: ");
#endif
}
public void UpdateUniformBuffer(uint currentImage)
{
if (angle > 360)
{
angle -= 360;
}
angle += DeltaTime.TotalSeconds * 45f;
var ubo = new UniformBufferObject
{
model = mat4.Identity * mat4.Rotate(glm.Radians((float)angle), vec3.UnitY),
view = mat4.Translate(0, 0, -5),
proj = mat4.Perspective(glm.Radians(90f), extent.Width / (float)extent.Height, .1f, 10f)
};
ubo.proj[1, 1] *= -1;
var values = ubo.Values;
var dst = device.MapMemory(unifromBuffersMemory[currentImage], 0, values.Length);
Marshal.Copy(values, 0, dst, values.Length);
device.UnmapMemory(unifromBuffersMemory[currentImage]);
}
void initShaders()
{
deformableObjShader = new DeformablesShader("Shaders/objects.vert", "Shaders/objects.frag");
deformableObjShader.ShadowMap = shadowMap;
instancedObjShader = new InstancedShader("Shaders/objInstanced.vert", "Shaders/objects.frag");
instancedObjShader.ShadowMap = shadowMap;
//objShader.DiffuseTexture = heolienneTex;
shaderSharedData = new UniformBufferObject <UBOSharedData> (BufferUsageHint.DynamicCopy);
shaderSharedData.Datas.Color = new Vector4(0.8f, 0.8f, 0.8f, 1.0f);
shaderSharedData.Datas.Shared.X = 1.0f;
shaderSharedData.Datas.SetPass(ShadingPass.Normal);
shaderSharedData.Bind(0);
fogData = new UniformBufferObject <UBOFogData> (
UBOFogData.CreateUBOFogData(), BufferUsageHint.StaticCopy);
fogData.Bind(1);
material = new UniformBufferObject <UBOMaterialData> (BufferUsageHint.DynamicCopy);
material.Bind(2);
}
void initShaders()
{
deformableObjShader = new DeformablesShader ("Shaders/objects.vert", "Shaders/objects.frag");
deformableObjShader.ShadowMap = shadowMap;
instancedObjShader = new InstancedShader ("Shaders/objInstanced.vert", "Shaders/objects.frag");
instancedObjShader.ShadowMap = shadowMap;
//objShader.DiffuseTexture = heolienneTex;
shaderSharedData = new UniformBufferObject<UBOSharedData> (BufferUsageHint.DynamicCopy);
shaderSharedData.Datas.Color = new Vector4 (0.8f,0.8f,0.8f,1.0f);
shaderSharedData.Datas.Shared.X = 1.0f;
shaderSharedData.Datas.SetPass (ShadingPass.Normal);
shaderSharedData.Bind (0);
fogData = new UniformBufferObject<UBOFogData> (
UBOFogData.CreateUBOFogData (), BufferUsageHint.StaticCopy);
fogData.Bind (1);
material = new UniformBufferObject<UBOMaterialData> (BufferUsageHint.DynamicCopy);
material.Bind (2);
}
public void Render()
{
//--
var ubo = new UniformBufferObject();
ubo.Create();
// if (RenderContext.LightObjects.Count >= 2)
// {
// var lightsData = new GlslLight[2];
// lightsData[0].Position = RenderContext.LightObjects[0].Position;
// lightsData[0].Color = new Vector3(0.5f, 0.5f, 0.5f);
// lightsData[0].ShadowLayer = RenderContext.LightObjects[0].ShadowTextureIndex;
// lightsData[0].DirectionalLight = RenderContext.LightObjects[0].LightType == LightType.Directional ? 1 : 0;
// lightsData[0].LightSpaceMatrix = Matrix4.Transpose(RenderContext.LightObjects[0].LightCamera.ViewMatrix * RenderContext.LightObjects[0].LightCamera.ProjectionMatrix);
// lightsData[0].Linear = 0.1f;
// lightsData[0].Quadric = 0f;
// lightsData[1].Position = RenderContext.LightObjects[1].Position;
// lightsData[1].Color = new Vector3(0.5f, 0.5f, 0.5f);
// lightsData[1].ShadowLayer = RenderContext.LightObjects[1].ShadowTextureIndex;
// lightsData[1].DirectionalLight = RenderContext.LightObjects[1].LightType == LightType.Directional ? 1 : 0;
// lightsData[1].LightSpaceMatrix = Matrix4.Transpose(RenderContext.LightObjects[1].LightCamera.ViewMatrix * RenderContext.LightObjects[1].LightCamera.ProjectionMatrix);
// lightsData[1].Linear = 0.1f;
// lightsData[1].Quadric = 0f;
// ubo.SetData(BufferData.Create(lightsData));
// ubo.SetBindingPoint(RenderContext.LightBinding);
// }
if (RenderContext.LightObjects.Count > 0)
{
var lightDataList = new List <GlslLight>();
foreach (var light in RenderContext.LightObjects)
{
var lightData = new GlslLight();
lightData.Position = light.Position;
lightData.Color = light.Color;
lightData.ShadowLayer = light.ShadowTextureIndex;
lightData.DirectionalLight = light.LightType == LightType.Directional ? 1 : 0;
lightData.LightSpaceMatrix = Matrix4.Transpose(light.LightCamera.ViewMatrix * light.LightCamera.ProjectionMatrix);
lightData.Linear = light.Linear;
lightData.Quadric = light.Quadric;
lightData.FarPlane = light.LightCamera.FarPlane;
lightData.Direction = light.Direction.Normalized();
lightDataList.Add(lightData);
}
ubo.SetData(BufferData.Create(lightDataList.ToArray()));
ubo.SetBindingPoint(RenderContext.LightBinding);
}
//--
GL.Enable(EnableCap.DepthTest);
//--
RenderContext.InitRender();
RenderContext.Render();
RenderContext.OnWorldRendered();
//--
// Configure
// Render objects
// Render Screen Surface
//CheckForProgramError();
ubo.Free();
if (FlushRenderBackend == FlushRenderBackend.End)
{
GL.Finish();
}
}
public readonly void SetUniformNow(UniformBufferObject uniform)
{
GraphicsContext.graphicsDevice.WaitIdle();
GraphicsContext.uniform0.SetData(uniform);
}
public readonly void SetUniformCmd(CommandBuffer cmd, UniformBufferObject uniform)
{
cmd.UpdateBuffer(uniform, GraphicsContext.uniform0, 0);
}
public WorldShaderData()
{
_ubo = new UniformBufferObject(Objects);
_ubo.BindToBase(0);
_millis = 0;
}
