protected void ScreenQuadPass(StandardFrameData frameData)
{
CurrentPass = Pass.ScreenQuadPass;
GetContext.OutputMerger.SetRenderTargets(null, GetDisplay.RenderTargetViewRef);
if (postProcessSettings.MotionBlurEnabled)
{
// TODO: shader with motion blur
GetContext.PixelShader.SetShaderResource(0, ScreenQuadTarget.ResourceView);
GetContext.PixelShader.SetShaderResource(1, VelocityTarget.ResourceView);
GetContext.PixelShader.SetShaderResource(2, GetDisplay.DepthStencilSRVRef);
}
else
{
SetVertexShader("ScreenQuadVS");
GetContext.InputAssembler.InputLayout = QuadLayoyt;
SetPixelShader("ScreenQuadPS");
GetContext.PixelShader.SetShaderResource(0, ScreenQuadTarget.ResourceView);
//GetContext.PixelShader.SetShaderResource(0, ShadowMapsAtlasTarget.ResourceView);
GetContext.PixelShader.SetShaderResource(2, GetDisplay.DepthStencilSRVRef);
}
GetContext.PixelShader.SetSampler(0, GetSharedItems.GetSamplerState(SamplerType.BilinearClamp));
DX_Draw(4, 0);
}
public override void Draw(StandardFrameData frameData)
{
ShadowMapsPass(frameData);
DepthPrePass(frameData);
ColourPass(frameData);
ScreenQuadPass(frameData);
}
public override void Draw(StandardFrameData frameData)
{
// Clear
DepthStencilView depthStencilView = RenderBackend.DisplayRef.DepthStencilViewRef;
RenderTargetView renderTargetView = RenderBackend.DisplayRef.RenderTargetViewRef;
GetContext.ClearRenderTargetView(renderTargetView, Color.Gray);
GetContext.ClearRenderTargetView(hdrRenderTargetView, Color.Gray);
GetContext.ClearDepthStencilView(
depthStencilView,
DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil,
0.0f, 0
);
if (isWireframe)
{
WireframePass(frameData, depthStencilView, renderTargetView);
return;
}
//DepthPrePassWithVelocity(frameData, depthStencilView);
DepthPrePass(frameData, depthStencilView, renderTargetView);
// TODO: shadow maps draw pass
ColourPass(frameData, depthStencilView, renderTargetView);
ScreenQuadPass(frameData, depthStencilView, renderTargetView);
}
public void OnRenderFrame()
{
if (!IsInitialized)
{
return;
}
StandardFrameData sFrameData = (StandardFrameData)EngineUpdateAction();
EngineRef.Statistics.ClearDrawcalls();
RenderPath.Draw(sFrameData);
//TODO: D2D draw
DisplayRef.RenderTarget2D.BeginDraw();
m_ConsoleRenderer.Draw();
DisplayRef.RenderTarget2D.EndDraw();
if (!firstFrame)
{
return;
}
firstFrame = false;
if (DisplayRef is FormDisplay)
{
(DisplayRef as FormDisplay).Surface?.Show();
}
}
private void ColourPass(StandardFrameData frameData, DepthStencilView depthStencilView, RenderTargetView renderTargetView)
{
CurrentPass = Pass.Colour;
GetContext.OutputMerger.SetRenderTargets(depthStencilView, renderTargetView);
SetDepthStencilState(DepthStencilStates.EqualAndDisableWrite);
SetRasterizerState(RasterizerStates.SolidBackCull);
GetContext.InputAssembler.InputLayout = GetSharedItems.StandardInputLayout;
SetVertexShader("CommonVS");
SetPixelShader("ForwardPlusScenePS");
GetContext.PixelShader.SetSampler(0, GetSharedItems.GetSamplerState(SamplerType.BilinearWrap));
GetContext.UpdateSubresource(m_DirLightsConstBuffer, DirLightBuffer);
GetContext.PixelShader.SetConstantBuffer(2, DirLightBuffer);
// PreFiltered
GetContext.PixelShader.SetShaderResource(5, GetSharedItems.PreFilteredMap);
// Irradiance
GetContext.PixelShader.SetShaderResource(6, GetSharedItems.IrradianceMap);
//Lights data
GetContext.PixelShader.SetShaderResource(7, LightCenterAndRadiusSRV);
GetContext.PixelShader.SetShaderResource(8, LightParamsSRV);
GetContext.PixelShader.SetShaderResource(9, LightColorSRV);
GetContext.PixelShader.SetShaderResource(10, LightIndexSRV);
// Draw scene
string MeshName = "";
string MaterialName = "";
int MaterialQueue = -999999;
foreach (var rendererData in frameData.RenderersList)
{
if (MaterialName != rendererData.MaterialName)
{
MaterialName = rendererData.MaterialName;
SetMaterial(MaterialName, MaterialQueue != rendererData.MaterialQueue);
MaterialQueue = rendererData.MaterialQueue;
}
if (MeshName != rendererData.MeshName)
{
MeshName = rendererData.MeshName;
SetMesh(MeshName);
}
m_PerObjectConstBuffer.WorldMatrix = rendererData.TransformMatrix;
m_PerObjectConstBuffer.WorldViewMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].View;
m_PerObjectConstBuffer.WorldViewProjMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].ViewProjection;
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
DX_DrawIndexed(m_CachedMesh.IndexCount, 0, 0);
}
}
protected void ColourPass(StandardFrameData frameData)
{
CurrentPass = Pass.ColourPass;
GetContext.OutputMerger.SetRenderTargets(GetDisplay.DepthStencilViewRef, ScreenQuadTarget.View);
SetDepthStencilState(DepthStencilStates.EqualAndDisableWrite);
SetVertexShader("CommonVS");
GetContext.InputAssembler.InputLayout = GetSharedItems.StandardInputLayout;
if (EnabledHDR)
{
}
else
{
}
// Draw scene
string MeshName = "";
string MaterialName = "";
int MaterialQueue = -999999;
m_ShadowLightsDataBuffer[0].LightViewProjectionMatrix = frameData.LightsList[0].ViewProjection;
m_ShadowLightsDataBuffer[0].LeftTop = Vector2.Zero;
m_ShadowLightsDataBuffer[0].RightBottom = Vector2.One;
GetContext.UpdateSubresource(m_ShadowLightsDataBuffer, ShadowLightsDataBuffer);
StandardFrameData.RendererData rendererData;
foreach (var index in frameData.PerCameraRenderersList[0])
{
rendererData = frameData.RenderersList[index];
if (MaterialName != rendererData.MaterialName)
{
MaterialName = rendererData.MaterialName;
SetMaterial(MaterialName, MaterialQueue != rendererData.MaterialQueue);
MaterialQueue = rendererData.MaterialQueue;
}
if (MeshName != rendererData.MeshName)
{
MeshName = rendererData.MeshName;
SetMesh(MeshName);
}
m_PerObjectConstBuffer.WorldMatrix = rendererData.TransformMatrix;
m_PerObjectConstBuffer.WorldViewMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].View;
m_PerObjectConstBuffer.WorldViewProjMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].ViewProjection;
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
DX_DrawIndexed(m_CachedMesh.IndexCount, 0, 0);
}
}
public override void Draw(StandardFrameData frameData)
{
GeometryPass(frameData);
LightPass(frameData);
if (FirstTranslucentRendererIndex > -1)
{
ForwardPass(frameData);
}
if (EnabledHDR)
{
ScreenQuadPass();
}
ResetShaderResourcesViews();
}
public override void Draw(StandardFrameData frameData)
{
// Clear
DepthStencilView depthStencilView = GetDisplay.DepthStencilViewRef;
RenderTargetView renderTargetView = GetDisplay.RenderTargetViewRef;
GetContext.ClearRenderTargetView(renderTargetView, Color.Gray);
GetContext.ClearDepthStencilView(depthStencilView,
DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 0.0f, 0);
DepthPrePass(frameData, depthStencilView, renderTargetView);
LightCullingPass(frameData);
ColourPass(frameData, depthStencilView, renderTargetView);
//TODO: colour pass
}
private void ScreenQuadPass(StandardFrameData frameData, DepthStencilView depthStencilView, RenderTargetView renderTargetView)
{
GetContext.OutputMerger.SetRenderTargets(null, downSamplingTargetView);
SetDepthStencilState(DepthStencilStates.Greater);
SetBlendState(BlendStates.Opaque);
GetContext.Rasterizer.SetViewport(new Viewport(
0, 0,
RenderBackend.DisplayRef.Width / 4,
RenderBackend.DisplayRef.Height / 4,
0.0f, 1.0f
));
SetVertexShader("ScreenQuadVS");
//GetContext.VertexShader.SetConstantBuffer(0, null);
//GetContext.VertexShader.SetConstantBuffer(1, null);
GetContext.InputAssembler.InputLayout = QuadLayoyt;
//GetContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList;
SetPixelShader("DownSamplingPS");
GetContext.PixelShader.SetConstantBuffer(0, ScreenParameters);
ScreenParametersBuffer.CurrentFPS = (int)(1.0f / RenderBackend.EngineRef.Time.DeltaTime);
GetContext.UpdateSubresource(ref ScreenParametersBuffer, ScreenParameters);
GetContext.PixelShader.SetShaderResource(0, hdrSRV);
GetContext.PixelShader.SetShaderResource(1, null);
GetContext.PixelShader.SetShaderResource(2, null);
GetContext.PixelShader.SetSampler(0, RenderBackend.SharedRenderItems.GetSamplerState(SamplerType.BilinearClamp));
RenderBackend.DrawWrapper(4, 0);
GetContext.Rasterizer.SetViewport(new Viewport(
0, 0,
RenderBackend.DisplayRef.Width,
RenderBackend.DisplayRef.Height,
0.0f, 1.0f
));
GetContext.OutputMerger.SetRenderTargets(null, renderTargetView);
SetPixelShader("ScreenQuadPS");
GetContext.PixelShader.SetConstantBuffer(0, ScreenParameters);
ScreenParametersBuffer.CurrentFPS = (int)(1.0f / RenderBackend.EngineRef.Time.DeltaTime);
GetContext.UpdateSubresource(ref ScreenParametersBuffer, ScreenParameters);
GetContext.PixelShader.SetShaderResource(0, hdrSRV);
GetContext.PixelShader.SetShaderResource(1, velocitySRV);
GetContext.PixelShader.SetShaderResource(2, RenderBackend.DisplayRef.DepthStencilSRVRef);
GetContext.PixelShader.SetSampler(0, RenderBackend.SharedRenderItems.GetSamplerState(SamplerType.BilinearClamp));
RenderBackend.DrawWrapper(4, 0);
GetContext.PixelShader.SetConstantBuffer(0, PerObjConstantBuffer);
}
private void ForwardPass(StandardFrameData frameData)
{
CurrentPass = Pass.Forward;
if (frameData.PerCameraLightsList[0].Count == 0)
{
if (EnabledHDR)
{
GetContext.OutputMerger.SetRenderTargets(ReadonlyDepthStencilView, HDRTarget.View);
}
else
{
GetContext.OutputMerger.SetRenderTargets(ReadonlyDepthStencilView, GetDisplay.RenderTargetViewRef);
}
}
SetDepthStencilState(DepthStencilStates.GreaterAndDisableWrite);
SetBlendState(BlendStates.AlphaEnabledBlending);
SetInputLayout(GetSharedItems.StandardInputLayout);
SetVertexShader("CommonVS");
string MaterialName = "";
StandardFrameData.RendererData rendererData;
for (int i = FirstTranslucentRendererIndex; i < frameData.PerCameraRenderersList[0].Count; i++)
{
rendererData = frameData.RenderersList[frameData.PerCameraRenderersList[0][i]];
SetMesh(rendererData.MeshName);
if (MaterialName != rendererData.MaterialName)
{
MaterialName = rendererData.MaterialName;
SetMaterial(MaterialName, true);
}
m_PerObjectConstantBufferValue = new CommonStructs.ConstBufferPerObjectDefferedStruct()
{
World = rendererData.TransformMatrix,
WorldInverse = Matrix.Transpose(Matrix.Invert(rendererData.TransformMatrix)),
};
D3DUtils.WriteToDynamicBuffer(GetContext, PerObjectConstantBuffer, m_PerObjectConstantBufferValue);
DX_DrawIndexed(m_CachedMesh.IndexCount, 0, 0);
}
}
private void WireframePass(StandardFrameData frameData, DepthStencilView depthStencilView, RenderTargetView renderTargetView)
{
CurrentPass = Pass.Wireframe;
GetContext.OutputMerger.SetTargets(depthStencilView, renderTargetView);
SetDepthStencilState(DepthStencilStates.Greater);
// Bind buffers
m_PerFrameConstBuffer = new CommonStructs.ConstBufferPerFrameStruct()
{
Projection = frameData.CamerasList[0].Projection,
ProjectionInv = Matrix.Invert(frameData.CamerasList[0].Projection),
CameraPos = frameData.CamerasList[0].Position,
AlphaTest = 0.5f,
MaxNumLightsPerTile = (uint)0,
//TODO: provide lights number
NumLights = (uint)400,
WindowHeight = (uint)RenderBackend.DisplayRef.Height,
WindowWidth = (uint)RenderBackend.DisplayRef.Width,
};
GetContext.UpdateSubresource(ref m_PerFrameConstBuffer, PerFrameConstantBuffer);
SetVertexShader("CommonVS");
SetPixelShader("ForwardPlusPosTexPS");
GetContext.InputAssembler.InputLayout = GetSharedItems.StandardInputLayout;
SetRasterizerState(RasterizerStates.WireframeBackCull);
m_PerObjectConstBuffer.AlbedoColor = new Vector4(0.8f, 0.5f, 0.5f, 1.0f);
string MeshName = "";
foreach (var rendererData in frameData.RenderersList)
{
if (MeshName != rendererData.MeshName)
{
MeshName = rendererData.MeshName;
SetMesh(MeshName);
}
m_PerObjectConstBuffer.WorldMatrix = rendererData.TransformMatrix;
m_PerObjectConstBuffer.WorldViewMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].View;
m_PerObjectConstBuffer.WorldViewProjMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].ViewProjection;
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
RenderBackend.DrawIndexedWrapper(m_CachedMesh.IndexCount, 0, 0);
}
}
private void LightCullingPass(StandardFrameData frameData)
{
CurrentPass = Pass.LightCulling;
UpdateLights(frameData.LightsList);
m_PerFrameConstBuffer.NumLights = NonDirLightsCount;
m_PerFrameConstBuffer.DirLightsNum = DirLightsCount;
m_PerFrameConstBuffer.MaxNumLightsPerTile = (uint)GetMaxNumLightsPerTile();
GetContext.UpdateSubresource(ref m_PerFrameConstBuffer, PerFrameConstantBuffer);
m_PerObjectConstBuffer = new CommonStructs.ConstBufferPerObjectStruct()
{
WorldMatrix = Matrix.Identity,
WorldViewMatrix = Matrix.Identity * frameData.CamerasList[0].View,
WorldViewProjMatrix = Matrix.Identity * frameData.CamerasList[0].ViewProjection,
};
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
GetContext.ComputeShader.SetConstantBuffer(0, PerObjConstantBuffer);
GetContext.ComputeShader.SetConstantBuffer(1, PerFrameConstantBuffer);
GetContext.OutputMerger.SetRenderTargets(null, (RenderTargetView)null);
SetNullVertexShader();
SetNullPixelShader();
SetNullRasterizerState();
SetBlendState(BlendStates.Opaque);
GetContext.ComputeShader.Set(AssetsLoader.GetShader <ComputeShader>("LightCullingCS"));
GetContext.ComputeShader.SetShaderResource(0, LightCenterAndRadiusSRV);
GetContext.ComputeShader.SetShaderResource(1, GetDisplay.DepthStencilSRVRef);
GetContext.ComputeShader.SetUnorderedAccessView(0, LightIndexURV);
GetContext.Dispatch(GetNumTilesX(), GetNumTilesY(), 1);
GetContext.ComputeShader.Set(null);
GetContext.ComputeShader.SetShaderResource(0, null);
GetContext.ComputeShader.SetShaderResource(1, null);
GetContext.ComputeShader.SetUnorderedAccessView(0, null);
}
public SingletonFrameScene()
{
FrameData = new StandardFrameData();
}
private void ColourPass(StandardFrameData frameData, DepthStencilView depthStencilView, RenderTargetView renderTargetView)
{
CurrentPass = Pass.ColourPass;
// Setup targets and states
// renderTargetView
GetContext.OutputMerger.SetRenderTargets(depthStencilView, hdrRenderTargetView);
SetDepthStencilState(DepthStencilStates.EqualAndDisableWrite);
// Setup vertex shader
SetVertexShader("CommonVS");
GetContext.InputAssembler.InputLayout = GetSharedItems.StandardInputLayout;
// Bind buffers
m_PerFrameConstBuffer = new CommonStructs.ConstBufferPerFrameStruct()
{
Projection = frameData.CamerasList[0].Projection,
ProjectionInv = Matrix.Invert(frameData.CamerasList[0].Projection),
CameraPos = frameData.CamerasList[0].Position,
AlphaTest = 0.5f,
MaxNumLightsPerTile = (uint)0,
//TODO: provide lights number
NumLights = (uint)400,
WindowHeight = (uint)RenderBackend.DisplayRef.Height,
WindowWidth = (uint)RenderBackend.DisplayRef.Width,
};
int n = frameData.LightsList.Count;
n = n > 3 ? 3 : n;
// Lights buffer max x3
StandardFrameData.LightData light;
for (int i = 0; i < n; i++)
{
light = frameData.LightsList[i];
m_LightBuffer[i].viewProjMatrix = light.ViewProjection;
m_LightBuffer[i].lightTint = Vector4.One;
m_LightBuffer[i].type = (float)light.Type;
m_LightBuffer[i].position = light.Position;
m_LightBuffer[i].direction = light.Direction;
m_LightBuffer[i].distanceSqr = light.Radius * light.Radius;
}
GetContext.UpdateSubresource(ref m_PerFrameConstBuffer, PerFrameConstantBuffer);
GetContext.UpdateSubresource(m_LightBuffer, LightBuffer);
// Draw scene
string MeshName = "";
string MaterialName = "";
int MaterialQueue = -999999;
foreach (var rendererData in frameData.RenderersList)
{
if (MaterialName != rendererData.MaterialName)
{
MaterialName = rendererData.MaterialName;
SetMaterial(MaterialName, MaterialQueue != rendererData.MaterialQueue);
MaterialQueue = rendererData.MaterialQueue;
}
if (MeshName != rendererData.MeshName)
{
MeshName = rendererData.MeshName;
SetMesh(MeshName);
}
m_PerObjectConstBuffer.WorldMatrix = rendererData.TransformMatrix;
m_PerObjectConstBuffer.WorldViewMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].View;
m_PerObjectConstBuffer.WorldViewProjMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].ViewProjection;
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
RenderBackend.DrawIndexedWrapper(m_CachedMesh.IndexCount, 0, 0);
}
}
private void DepthPrePass(StandardFrameData frameData, DepthStencilView depthStencilView, RenderTargetView renderTargetView)
{
CurrentPass = Pass.DepthPrePass;
// Setup targets and states
GetContext.OutputMerger.SetTargets(depthStencilView, (RenderTargetView)null);
SetDepthStencilState(DepthStencilStates.Greater);
SetRasterizerState(RasterizerStates.SolidBackCull);
GetContext.InputAssembler.InputLayout = GetSharedItems.StandardInputLayout;
// Setup vertex shader
GetContext.VertexShader.Set(AssetsLoader.GetShader <VertexShader>("ForwardPlusPosOnlyVS"));
// Cleanup pixel shader
GetContext.PixelShader.Set(null);
for (int i = 0; i < 2; i++)
{
GetContext.PixelShader.SetShaderResources(0, i, (ShaderResourceView)null);
}
GetContext.PixelShader.SetSamplers(0, 1, (SamplerState)null);
m_PerFrameConstBuffer = new CommonStructs.ConstBufferPerFrameStruct()
{
Projection = frameData.CamerasList[0].Projection,
ProjectionInv = Matrix.Invert(frameData.CamerasList[0].Projection),
CameraPos = frameData.CamerasList[0].Position,
AlphaTest = 0.5f,
MaxNumLightsPerTile = (uint)0,
//TODO: provide lights number
NumLights = (uint)400,
WindowHeight = (uint)RenderBackend.DisplayRef.Height,
WindowWidth = (uint)RenderBackend.DisplayRef.Width,
};
GetContext.UpdateSubresource(ref m_PerFrameConstBuffer, PerFrameConstantBuffer);
string MeshName = "";
string MaterialName = "";
bool IsOpaquePass = true;
foreach (var rendererData in frameData.RenderersList)
{
if (MeshName != rendererData.MeshName)
{
MeshName = rendererData.MeshName;
SetMesh(MeshName);
}
if (MaterialName != rendererData.MaterialName)
{
MaterialName = rendererData.MaterialName;
SetMaterial(MaterialName, false);
if (IsOpaquePass)
{
if (CurrentMaterialInstance.MetaMaterial.blendMode == ShaderGraph.MetaMaterial.BlendMode.Masked)
{
GetContext.OutputMerger.SetTargets(depthStencilView, renderTargetView);
SetRasterizerState(RasterizerStates.SolidNoneCull);
GetContext.PixelShader.SetSampler(0,
GetSharedItems.GetSamplerState(SamplerType.AnisotropicWrap));
//if (msaa) DepthOnlyAlphaToCoverageState
SetBlendState(BlendStates.DepthOnlyAlphaTest);
GetContext.VertexShader.Set(AssetsLoader.GetShader <VertexShader>("ForwardPlusPosTexVS"));
GetContext.PixelShader.Set(AssetsLoader.GetShader <PixelShader>("ForwardPlusPosTexPS"));
GetContext.PixelShader.SetShaderResources(0, 1,
GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.AlbedoMapAsset));
GetContext.PixelShader.SetSamplers(0, 1,
GetSharedItems.GetSamplerState(SamplerType.BilinearClamp));
IsOpaquePass = false;
}
}
else
{
GetContext.PixelShader.SetShaderResources(0, 1,
GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.AlbedoMapAsset));
}
if (CurrentMaterialInstance.MetaMaterial.blendMode > ShaderGraph.MetaMaterial.BlendMode.Masked)
{
break; // Break on translucent objects
}
}
m_PerObjectConstBuffer.WorldMatrix = rendererData.TransformMatrix;
m_PerObjectConstBuffer.WorldViewMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].View;
m_PerObjectConstBuffer.WorldViewProjMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].ViewProjection;
m_PerObjectConstBuffer.textureTiling = CurrentMaterialInstance.PropetyBlock.Tile;
m_PerObjectConstBuffer.textureShift = CurrentMaterialInstance.PropetyBlock.Shift;
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
RenderBackend.DrawIndexedWrapper(m_CachedMesh.IndexCount, 0, 0);
}
}
private void DepthPrePassWithVelocity(StandardFrameData frameData, DepthStencilView depthStencilView)
{
CurrentPass = Pass.DepthPrePass;
// Setup targets and states
GetContext.OutputMerger.SetTargets(depthStencilView, (RenderTargetView)null);
SetDepthStencilState(DepthStencilStates.Greater);
GetContext.InputAssembler.InputLayout = DepthPassLayout;
// Setup vertex shader
SetVertexShader("ForwardPlusPosOnlyVS");
// Cleanup pixel shader
GetContext.PixelShader.Set(null);
for (int i = 0; i < 2; i++)
{
GetContext.PixelShader.SetShaderResources(0, i, (ShaderResourceView)null);
}
GetContext.PixelShader.SetSamplers(0, 1, (SamplerState)null);
// Draw opaque
string MeshName = "";
int MaterialQueue = -999999;
DynamicMeshes.Clear();
foreach (var rendererData in frameData.RenderersList)
{
if (rendererData.IsDynamic)
{
DynamicMeshes.Add(rendererData);
continue;
}
if (MaterialQueue != rendererData.MaterialQueue)
{
MaterialQueue = rendererData.MaterialQueue;
// TODO: correct changing
//SetMergerStates(AssetsLoader.LoadMaterial(rendererData.MaterialName).MetaMaterial);*/
//SetMergerStates(MaterialQueue);
}
if (MeshName != rendererData.MeshName)
{
MeshName = rendererData.MeshName;
SetMesh(MeshName);
}
m_PerObjectConstBuffer.WorldMatrix = rendererData.TransformMatrix;
m_PerObjectConstBuffer.WorldViewMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].View;
m_PerObjectConstBuffer.WorldViewProjMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].ViewProjection;
m_PerObjectConstBuffer.PreviousWorldViewProjMatrix = rendererData.PreviousTransformMatrix * frameData.CamerasList[0].PreviousViewProjection;
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
RenderBackend.DrawIndexedWrapper(m_CachedMesh.IndexCount, 0, 0);
}
GetContext.OutputMerger.SetTargets(depthStencilView, velocityRenderTargetView);
GetContext.ClearRenderTargetView(velocityRenderTargetView, Color.Yellow);
// Setup pixel shader
SetPixelShader("VelocityPS");
foreach (var rendererData in DynamicMeshes)
{
if (MaterialQueue != rendererData.MaterialQueue)
{
MaterialQueue = rendererData.MaterialQueue;
// TODO: correct changing
//SetMergerStates(AssetsLoader.LoadMaterial(rendererData.MaterialName).MetaMaterial);*/
//SetMergerStates(MaterialQueue);
}
if (MeshName != rendererData.MeshName)
{
MeshName = rendererData.MeshName;
SetMesh(MeshName);
}
m_PerObjectConstBuffer.WorldMatrix = rendererData.TransformMatrix;
m_PerObjectConstBuffer.WorldViewMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].View;
m_PerObjectConstBuffer.WorldViewProjMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].ViewProjection;
m_PerObjectConstBuffer.PreviousWorldViewProjMatrix = rendererData.PreviousTransformMatrix * frameData.CamerasList[0].PreviousViewProjection;
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
RenderBackend.DrawIndexedWrapper(m_CachedMesh.IndexCount, 0, 0);
}
//TODO: Alpha to coverage pre-pass
}
protected void ShadowMapsPass(StandardFrameData frameData)
{
CurrentPass = Pass.ShadowMapsPass;
GetContext.ClearRenderTargetView(ShadowMapsAtlasTarget.View, Color.White);
GetContext.ClearDepthStencilView(
ShadowMapsAtlasDepthTarget.View,
DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil,
1.0f, 0
);
GetContext.OutputMerger.SetTargets(ShadowMapsAtlasDepthTarget.View, ShadowMapsAtlasTarget.View);
SetDepthStencilState(DepthStencilStates.Less);
// TODO: select right cull mode
SetRasterizerState(RasterizerStates.SolidFrontCull);
Viewport atlasViewport = new Viewport(0, 0, ShadowAtlasSize, ShadowAtlasSize, 0.0f, 1.0f);
GetContext.Rasterizer.SetViewport(atlasViewport);
SetVertexShader("DepthShadowsVS");
GetContext.VertexShader.SetConstantBuffer(0, PerObjectShadowPassConstBuffer);
SetPixelShader("DepthShadowsPS");
//SetNullPixelShader();
string MeshName = "";
string MaterialName = "";
bool IsMaskedSubPass = false;
StandardFrameData.RendererData rendererData;
foreach (var light in frameData.LightsList)
{
if (!light.IsCastShadows)
{
continue;
}
foreach (int index in frameData.PerLightRenderersList[light.index])
{
rendererData = frameData.RenderersList[index];
if (MeshName != rendererData.MeshName)
{
MeshName = rendererData.MeshName;
SetMesh(MeshName);
}
if (MaterialName != rendererData.MaterialName)
{
MaterialName = rendererData.MaterialName;
SetMaterial(MaterialName);
/*
* if (!IsMaskedSubPass)
* {
* if (m_CachedMaterial.MetaMaterial.blendMode == ShaderGraph.MetaMaterial.BlendMode.Masked)
* {
* GetContext.OutputMerger.SetTargets(GetDisplay.DepthStencilViewRef, GetDisplay.RenderTargetViewRef);
* if (postProcessSettings.UsingMSAA) {
* SetBlendState(SharedRenderItemsStorage.BlendStates.DepthOnlyAlphaToCoverage);
* } else {
* SetBlendState(SharedRenderItemsStorage.BlendStates.DepthOnlyAlphaTest);
* }
* //DepthMaskedSubPath(false);
* IsMaskedSubPass = true;
* }
* }
* else
* {
* GetContext.PixelShader.SetShaderResource(0,
* GetSharedItems.LoadTextureSRV(m_CachedMaterial.AlbedoMapAsset));
* }
*/
if (m_CachedMaterial.MetaMaterial.blendMode > ShaderGraph.MetaMaterial.BlendMode.Masked)
{
break; // Break on translucent objects
}
}
m_PerObjectShadowPassConstBuffer.WorldMatrix = rendererData.TransformMatrix;
m_PerObjectShadowPassConstBuffer.ViewProjectionMatrix = light.ViewProjection;
GetContext.UpdateSubresource(ref m_PerObjectShadowPassConstBuffer, PerObjectShadowPassConstBuffer);
DX_DrawIndexed(m_CachedMesh.IndexCount, 0, 0);
}
break;
}
GetContext.Rasterizer.SetViewport(new Viewport(
0, 0,
GetDisplay.Width,
GetDisplay.Height,
0.0f, 1.0f
));
}
protected void DepthPrePass(StandardFrameData frameData)
{
CurrentPass = Pass.DepthPrePass;
GetContext.ClearRenderTargetView(GetDisplay.RenderTargetViewRef, Color.CornflowerBlue);
GetContext.ClearDepthStencilView(
GetDisplay.DepthStencilViewRef,
DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil,
0.0f, 0
);
GetContext.OutputMerger.SetTargets(GetDisplay.DepthStencilViewRef, (RenderTargetView)null);
SetDepthStencilState(DepthStencilStates.Greater);
SetRasterizerState(RasterizerStates.SolidBackCull);
SetVertexShader("ForwardPlusPosOnlyVS");
SetNullPixelShader();
GetContext.InputAssembler.InputLayout = GetSharedItems.StandardInputLayout;
m_PerFrameConstBuffer = new CommonStructs.ConstBufferPerFrameStruct()
{
Projection = frameData.CamerasList[0].Projection,
ProjectionInv = Matrix.Invert(frameData.CamerasList[0].Projection),
ViewInv = Matrix.Invert(frameData.CamerasList[0].View),
PreviousView = frameData.CamerasList[0].PreviousView,
CameraPos = frameData.CamerasList[0].Position,
CameraForward = new Vector4(frameData.CamerasList[0].Forward, 1),
AlphaTest = 0.5f,
WindowWidth = (uint)GetDisplay.Width,
WindowHeight = (uint)GetDisplay.Height,
CurrentFPS = (uint)(1.0f / RenderBackend.EngineRef.Time.DeltaTime),
};
GetContext.UpdateSubresource(ref m_PerFrameConstBuffer, PerFrameConstantBuffer);
GetContext.VertexShader.SetConstantBuffer(0, PerObjConstantBuffer);
GetContext.VertexShader.SetConstantBuffer(1, PerFrameConstantBuffer);
GetContext.PixelShader.SetConstantBuffer(0, PerObjConstantBuffer);
GetContext.PixelShader.SetConstantBuffer(1, PerFrameConstantBuffer);
//GetContext.PixelShader.SetConstantBuffer(2, LightsDataBuffer);
GetContext.PixelShader.SetConstantBuffer(3, ShadowLightsDataBuffer);
GetContext.UpdateSubresource(ref m_PerFrameConstBuffer, PerFrameConstantBuffer);
string MeshName = "";
string MaterialName = "";
bool IsMaskedSubPass = false;
if (postProcessSettings.MotionBlurEnabled)
{
GetContext.ClearRenderTargetView(VelocityTarget.View, Color.Yellow);
DynamicMeshes.Clear();
}
StandardFrameData.RendererData rendererData;
foreach (var index in frameData.PerCameraRenderersList[0])
{
rendererData = frameData.RenderersList[index];
if (postProcessSettings.MotionBlurEnabled && rendererData.IsDynamic)
{
DynamicMeshes.Add(rendererData);
continue;
}
if (MeshName != rendererData.MeshName)
{
MeshName = rendererData.MeshName;
SetMesh(MeshName);
}
if (MaterialName != rendererData.MaterialName)
{
MaterialName = rendererData.MaterialName;
SetMaterial(MaterialName);
if (!IsMaskedSubPass)
{
if (m_CachedMaterial.MetaMaterial.blendMode == ShaderGraph.MetaMaterial.BlendMode.Masked)
{
GetContext.OutputMerger.SetTargets(GetDisplay.DepthStencilViewRef, GetDisplay.RenderTargetViewRef);
if (EnabledMSAA)
{
SetBlendState(BlendStates.DepthOnlyAlphaToCoverage);
}
else
{
SetBlendState(BlendStates.DepthOnlyAlphaTest);
}
DepthMaskedSubPath(false);
IsMaskedSubPass = true;
}
}
else
{
GetContext.PixelShader.SetShaderResource(0,
GetSharedItems.LoadTextureSRV(m_CachedMaterial.AlbedoMapAsset));
}
if (m_CachedMaterial.MetaMaterial.blendMode > ShaderGraph.MetaMaterial.BlendMode.Masked)
{
break; // Break on translucent objects
}
}
m_PerObjectConstBuffer.WorldMatrix = rendererData.TransformMatrix;
m_PerObjectConstBuffer.WorldViewMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].View;
m_PerObjectConstBuffer.WorldViewProjMatrix = rendererData.TransformMatrix * frameData.CamerasList[0].ViewProjection;
m_PerObjectConstBuffer.textureTiling = m_CachedMaterial.PropetyBlock.Tile;
m_PerObjectConstBuffer.textureShift = m_CachedMaterial.PropetyBlock.Shift;
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
DX_DrawIndexed(m_CachedMesh.IndexCount, 0, 0);
}
if (!postProcessSettings.MotionBlurEnabled || DynamicMeshes.Count == 0)
{
return;
}
GetContext.OutputMerger.SetTargets(GetDisplay.DepthStencilViewRef, VelocityTarget.View);
SetBlendState(BlendStates.Opaque);
SetRasterizerState(RasterizerStates.SolidBackCull);
SetVertexShader("ForwardPlusPosOnlyVS");
SetPixelShader("VelocityPS");
IsMaskedSubPass = false;
foreach (var dRendererData in DynamicMeshes)
{
if (MeshName != dRendererData.MeshName)
{
MeshName = dRendererData.MeshName;
SetMesh(MeshName);
}
if (MaterialName != dRendererData.MaterialName)
{
MaterialName = dRendererData.MaterialName;
SetMaterial(MaterialName);
if (!IsMaskedSubPass)
{
if (m_CachedMaterial.MetaMaterial.blendMode == ShaderGraph.MetaMaterial.BlendMode.Masked)
{
DepthMaskedSubPath(true);
IsMaskedSubPass = true;
}
}
else
{
GetContext.PixelShader.SetShaderResource(0,
GetSharedItems.LoadTextureSRV(m_CachedMaterial.AlbedoMapAsset));
}
if (m_CachedMaterial.MetaMaterial.blendMode > ShaderGraph.MetaMaterial.BlendMode.Masked)
{
break; // Break on translucent objects
}
}
m_PerObjectConstBuffer.WorldMatrix = dRendererData.TransformMatrix;
m_PerObjectConstBuffer.WorldViewMatrix = dRendererData.TransformMatrix * frameData.CamerasList[0].View;
m_PerObjectConstBuffer.WorldViewProjMatrix = dRendererData.TransformMatrix * frameData.CamerasList[0].ViewProjection;
m_PerObjectConstBuffer.PreviousWorldViewProjMatrix = dRendererData.PreviousTransformMatrix * frameData.CamerasList[0].PreviousViewProjection;
GetContext.UpdateSubresource(ref m_PerObjectConstBuffer, PerObjConstantBuffer);
DX_DrawIndexed(m_CachedMesh.IndexCount, 0, 0);
}
}
