protected void SetMesh(string meshName)
{
m_CachedMesh = GetSharedItems.GetMesh(meshName);
GetContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(m_CachedMesh.vertexBuffer, 96, 0));
GetContext.InputAssembler.SetIndexBuffer(m_CachedMesh.indexBuffer, Format.R32_UInt, 0);
GetContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
}
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);
}
protected void SetSamplerState(int slot, SamplerType sampler)
{
if (CurrentSamplerState[slot] == (int)sampler)
{
return;
}
GetContext.PixelShader.SetSampler(slot, GetSharedItems.GetSamplerState(sampler));
CurrentSamplerState[slot] = (int)sampler;
}
protected void SetRasterizerState(RasterizerStates state)
{
if (CurrentRasterizerState == (int)state)
{
return;
}
GetContext.Rasterizer.State = GetSharedItems.GetRasterizerState(state);
CurrentRasterizerState = (int)state;
}
protected void SetDepthStencilState(DepthStencilStates state)
{
if (CurrentDepthStencilState == (int)state)
{
return;
}
GetContext.OutputMerger.SetDepthStencilState(
GetSharedItems.GetDepthStencilState(state), 0x00);
CurrentDepthStencilState = (int)state;
}
protected void SetBlendState(BlendStates state)
{
if (CurrentBlendMode == (int)state)
{
return;
}
GetContext.OutputMerger.SetBlendState(GetSharedItems.GetBlendState(state),
GetSharedItems.BlendFactor, 0xFFFFFFFF);
CurrentBlendMode = (int)state;
}
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 DepthMaskedSubPath(bool isVelocityPass)
{
SetRasterizerState(RasterizerStates.SolidNoneCull);
GetContext.PixelShader.SetSampler(0,
GetSharedItems.GetSamplerState(SamplerType.AnisotropicWrap));
SetVertexShader("ForwardPlusPosTexVS");
if (!isVelocityPass)
{
SetPixelShader("ForwardPlusPosTexPS");
}
else
{
SetPixelShader("MaskedVelocityPS");
}
GetContext.PixelShader.SetShaderResource(0,
GetSharedItems.LoadTextureSRV(m_CachedMaterial.AlbedoMapAsset));
GetContext.PixelShader.SetSampler(0,
GetSharedItems.GetSamplerState(SamplerType.BilinearClamp));
}
private int ShadowAtlasSize = 2048;//8192;
protected virtual void InitTargets(int samples)
{
if (EnabledHDR)
{
ScreenQuadTarget = GetSharedItems.CreateRenderTarget("ScreenQuadHDR",
GetDisplay.Width, GetDisplay.Height, Format.R16G16B16A16_Float, samples);
}
else
{
ScreenQuadTarget = GetSharedItems.CreateRenderTarget("ScreenQuadLDR",
GetDisplay.Width, GetDisplay.Height, Format.R8G8B8A8_UNorm, samples);
}
if (postProcessSettings.MotionBlurEnabled)
{
VelocityTarget = GetSharedItems.CreateRenderTarget("Velocity",
GetDisplay.Width, GetDisplay.Height, Format.R16G16_Float, samples);
}
ShadowMapsAtlasTarget = GetSharedItems.CreateRenderTarget("ShadowMapsAtlas",
ShadowAtlasSize, ShadowAtlasSize, Format.R32G32B32A32_Float, 1);
ShadowMapsAtlasDepthTarget = GetSharedItems.CreateDepthRenderTarget("ShadowMapsAtlas",
ShadowAtlasSize, ShadowAtlasSize, 1);
}
private void SetMaterial(string materialName, bool changeMergerStates)
{
if (materialName == "SkySphereMaterial")
{
CurrentMaterialInstance = Material.GetSkySphereMaterial();
}
else
{
CurrentMaterialInstance = AssetsLoader.LoadMaterial(materialName);
}
if (changeMergerStates)
{
SetMergerStates(CurrentMaterialInstance.MetaMaterial);
}
// TODO: shader selector
m_PerObjectConstBuffer = new CommonStructs.ConstBufferPerObjectStruct
{
textureTiling = CurrentMaterialInstance.PropetyBlock.Tile,
textureShift = CurrentMaterialInstance.PropetyBlock.Shift,
AlbedoColor = new Vector4(CurrentMaterialInstance.PropetyBlock.AlbedoColor, CurrentMaterialInstance.PropetyBlock.AlphaValue),
RoughnessValue = CurrentMaterialInstance.PropetyBlock.RoughnessValue,
MetallicValue = CurrentMaterialInstance.PropetyBlock.MetallicValue,
optionsMask0 = floatMaskVal(CurrentMaterialInstance.HasAlbedoMap, CurrentMaterialInstance.HasNormalMap, CurrentMaterialInstance.HasRoughnessMap, CurrentMaterialInstance.HasMetallicMap),
optionsMask1 = floatMaskVal(CurrentMaterialInstance.HasOcclusionMap, false, false, false),
/*renderer.SpecificType == Renderer.SpecificTypeEnum.SkySphere || renderer.SpecificType == Renderer.SpecificTypeEnum.Unlit
|| renderer.SpecificType == Renderer.SpecificTypeEnum.Wireframe,
|| renderer.SpecificType == Renderer.SpecificTypeEnum.SkySphere, false),*/
filler = Vector2.Zero,
};
if (materialName == "SkySphereMaterial")
{
m_PerObjectConstBuffer.optionsMask1 = floatMaskVal(CurrentMaterialInstance.HasOcclusionMap, true, true, false);
}
// TODO: Change textures binding
if (CurrentMaterialInstance.HasSampler)
{
GetContext.PixelShader.SetSampler(0, GetSharedItems.GetSamplerState(CurrentMaterialInstance.GetSamplerType));
ShaderResourceView[] textures = new ShaderResourceView[]
{
CurrentMaterialInstance.HasAlbedoMap?GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.AlbedoMapAsset) : null,
CurrentMaterialInstance.HasNormalMap ? GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.NormalMapAsset) : null,
CurrentMaterialInstance.HasRoughnessMap ? GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.RoughnessMapAsset) : null,
CurrentMaterialInstance.HasMetallicMap ? GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.MetallicMapAsset) : null,
CurrentMaterialInstance.HasOcclusionMap ? GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.OcclusionMapAsset) : null,
};
GetContext.PixelShader.SetShaderResources(0, 5, textures);
}
else
{
GetContext.PixelShader.SetSampler(0, null);
GetContext.PixelShader.SetShaderResources(0, 5, (ShaderResourceView[])null);
}
// PreFiltered
GetContext.PixelShader.SetShaderResource(5, GetSharedItems.PreFilteredMap);
// Irradiance
GetContext.PixelShader.SetShaderResource(6, RenderBackend.SharedRenderItems.IrradianceMap);
//Shadow maps
/*GetContext.PixelShader.SetSampler(1,
* Engine.Instance.MainLight.SamplerState);
* GetContext.PixelShader.SetShaderResource(7,
* Engine.Instance.MainLight.ShaderResourceView);*/
if (materialName == "SkySphereMaterial")
{
SetPixelShader("FwdSkySpherePS");
}
else if (CurrentMaterialInstance.MetaMaterial.blendMode == ShaderGraph.MetaMaterial.BlendMode.Translucent)
{
SetPixelShader("TestShader");
}
else
{
SetPixelShader("PBRForwardPS");
}
}
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 SetMaterial(string materialName, bool changeStates = false)
{
if (materialName == "SkySphereMaterial")
{
CurrentMaterialInstance = Material.GetSkySphereMaterial();
}
else
{
CurrentMaterialInstance = AssetsLoader.LoadMaterial(materialName);
}
if (CurrentPass == Pass.DepthPrePass)
{
return;
}
m_PerObjectConstBuffer = new CommonStructs.ConstBufferPerObjectStruct
{
textureTiling = CurrentMaterialInstance.PropetyBlock.Tile,
textureShift = CurrentMaterialInstance.PropetyBlock.Shift,
AlbedoColor = new Vector4(CurrentMaterialInstance.PropetyBlock.AlbedoColor, CurrentMaterialInstance.PropetyBlock.AlphaValue),
RoughnessValue = CurrentMaterialInstance.PropetyBlock.RoughnessValue,
MetallicValue = CurrentMaterialInstance.PropetyBlock.MetallicValue,
optionsMask0 = floatMaskVal(CurrentMaterialInstance.HasAlbedoMap, CurrentMaterialInstance.HasNormalMap, CurrentMaterialInstance.HasRoughnessMap, CurrentMaterialInstance.HasMetallicMap),
optionsMask1 = floatMaskVal(CurrentMaterialInstance.HasOcclusionMap, false, false, false),
/*renderer.SpecificType == Renderer.SpecificTypeEnum.SkySphere || renderer.SpecificType == Renderer.SpecificTypeEnum.Unlit
|| renderer.SpecificType == Renderer.SpecificTypeEnum.Wireframe,
|| renderer.SpecificType == Renderer.SpecificTypeEnum.SkySphere, false),*/
filler = Vector2.Zero,
};
if (changeStates)
{
SetMergerStates(CurrentMaterialInstance.MetaMaterial);
}
if (materialName == "SkySphereMaterial")
{
m_PerObjectConstBuffer.optionsMask1 = floatMaskVal(CurrentMaterialInstance.HasOcclusionMap, true, true, false);
}
if (CurrentMaterialInstance.HasSampler)
{
GetContext.PixelShader.SetSampler(0, GetSharedItems.GetSamplerState(CurrentMaterialInstance.GetSamplerType));
ShaderResourceView[] textures = new ShaderResourceView[]
{
CurrentMaterialInstance.HasAlbedoMap?GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.AlbedoMapAsset) : null,
CurrentMaterialInstance.HasNormalMap ? GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.NormalMapAsset) : null,
CurrentMaterialInstance.HasRoughnessMap ? GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.RoughnessMapAsset) : null,
CurrentMaterialInstance.HasMetallicMap ? GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.MetallicMapAsset) : null,
CurrentMaterialInstance.HasOcclusionMap ? GetSharedItems.LoadTextureSRV(CurrentMaterialInstance.OcclusionMapAsset) : null,
};
GetContext.PixelShader.SetShaderResources(0, 5, textures);
}
else
{
GetContext.PixelShader.SetSampler(0, null);
GetContext.PixelShader.SetShaderResources(0, 5, (ShaderResourceView[])null);
}
if (materialName == "SkySphereMaterial")
{
SetPixelShader("FwdSkySpherePS");
}
else
{
if (CurrentMaterialInstance.MetaMaterial.blendMode >= ShaderGraph.MetaMaterial.BlendMode.Translucent)
{
SetPixelShader("TestShader");
}
else
{
SetPixelShader("ForwardPlusScenePS");
}
}
}
protected void SetMaterial(string materialName, bool changeStates = false)
{
if (materialName == "SkySphereMaterial")
{
m_CachedMaterial = Material.GetSkySphereMaterial();
}
else
{
m_CachedMaterial = AssetsLoader.LoadMaterial(materialName);
}
if (CurrentPass == Pass.DepthPrePass || CurrentPass == Pass.ShadowMapsPass)
{
return;
}
if (changeStates)
{
SetMergerStates(m_CachedMaterial.MetaMaterial);
}
// TODO: setup shader from material meta. bind buffers and textures by shader.
if (materialName == "SkySphereMaterial")
{
SetPixelShader("FwdSkySpherePS");
}
else
{
if (m_CachedMaterial.MetaMaterial.blendMode >= ShaderGraph.MetaMaterial.BlendMode.Translucent)
{
SetPixelShader("TestShader");
}
else
{
if (SetPixelShader("PBRForwardPS"))
{
GetContext.PixelShader.SetShaderResource(5, GetSharedItems.PreFilteredMap);
GetContext.PixelShader.SetShaderResource(6, GetSharedItems.IrradianceMap);
GetContext.PixelShader.SetShaderResource(7, ShadowMapsAtlasTarget.ResourceView);
GetContext.PixelShader.SetSampler(1, GetSharedItems.GetSamplerState(SamplerType.ShadowMap));
}
}
}
m_PerObjectConstBuffer = new CommonStructs.ConstBufferPerObjectStruct
{
textureTiling = m_CachedMaterial.PropetyBlock.Tile,
textureShift = m_CachedMaterial.PropetyBlock.Shift,
AlbedoColor = new Vector4(m_CachedMaterial.PropetyBlock.AlbedoColor, m_CachedMaterial.PropetyBlock.AlphaValue),
RoughnessValue = m_CachedMaterial.PropetyBlock.RoughnessValue,
MetallicValue = m_CachedMaterial.PropetyBlock.MetallicValue,
optionsMask0 = CommonStructs.FloatMaskValue(
m_CachedMaterial.HasAlbedoMap, m_CachedMaterial.HasNormalMap,
m_CachedMaterial.HasRoughnessMap, m_CachedMaterial.HasMetallicMap),
optionsMask1 = CommonStructs.FloatMaskValue(
m_CachedMaterial.HasOcclusionMap, false, false, false),
filler = Vector2.Zero,
};
if (materialName == "SkySphereMaterial")
{
m_PerObjectConstBuffer.optionsMask1 = CommonStructs.FloatMaskValue(
m_CachedMaterial.HasOcclusionMap, true, true, false);
}
if (m_CachedMaterial.HasSampler)
{
GetContext.PixelShader.SetSampler(0, GetSharedItems.GetSamplerState(m_CachedMaterial.GetSamplerType));
ShaderResourceView[] textures = new ShaderResourceView[]
{
m_CachedMaterial.HasAlbedoMap?GetSharedItems.LoadTextureSRV(m_CachedMaterial.AlbedoMapAsset) : null,
m_CachedMaterial.HasNormalMap ? GetSharedItems.LoadTextureSRV(m_CachedMaterial.NormalMapAsset) : null,
m_CachedMaterial.HasRoughnessMap ? GetSharedItems.LoadTextureSRV(m_CachedMaterial.RoughnessMapAsset) : null,
m_CachedMaterial.HasMetallicMap ? GetSharedItems.LoadTextureSRV(m_CachedMaterial.MetallicMapAsset) : null,
m_CachedMaterial.HasOcclusionMap ? GetSharedItems.LoadTextureSRV(m_CachedMaterial.OcclusionMapAsset) : null,
};
GetContext.PixelShader.SetShaderResources(0, 5, textures);
}
else
{
GetContext.PixelShader.SetSampler(0, null);
GetContext.PixelShader.SetShaderResources(0, 5, new ShaderResourceView[5] {
null, null, null, null, null
});
}
}
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);
}
}
