internal static void SSGrass(MyBindableResource destination,
MyBindableResource depth, MyBindableResource source, MyBindableResource gbuffer2)
{
var context = MyRender.Context;
var cbuffer = MyCommon.GetObjectBuffer(16);
var mapping = MyMapping.MapDiscard(cbuffer.Buffer);
mapping.stream.Write(MyRender.Settings.GrassPostprocessCloseDistance);
mapping.Unmap();
context.PixelShader.SetConstantBuffer(1, cbuffer.Buffer);
context.OutputMerger.BlendState = null;
context.Rasterizer.SetViewport(0, 0, MyRender.ViewportResolution.X, MyRender.ViewportResolution.Y);
context.VertexShader.Set(FullscreenShader.VertexShader);
context.PixelShader.Set(SSGrassShader.PixelShader);
//var array = new ShaderResourceView[] { depth, resource, MyRender.MainGbuffer.Gbuffers[2].ShaderView };
//context.OutputMerger.SetTargets(null as DepthStencilView, target);
//context.PixelShader.SetShaderResources(0, array);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, destination);
RC.BindSRV(0, depth, source, gbuffer2);
context.Draw(3, 0);
}
internal static void Run(MyBindableResource dst, MyBindableResource src, MyBindableResource avgLum, MyBindableResource bloom, bool enableTonemapping = true)
{
//Debug.Assert(src.GetSize() == dst.GetSize());
var mapping = MyMapping.MapDiscard(MyCommon.GetObjectCB(16));
mapping.stream.Write(MyRender11.Settings.MiddleGrey);
mapping.stream.Write(MyRender11.Settings.LuminanceExposure);
mapping.stream.Write(MyRender11.Settings.BloomExposure);
mapping.stream.Write(MyRender11.Settings.BloomMult);
mapping.Unmap();
RC.CSSetCB(0, MyCommon.FrameConstants);
RC.CSSetCB(1, MyCommon.GetObjectCB(16));
RC.BindUAV(0, dst);
RC.BindSRV(0, src, avgLum, bloom);
RC.Context.ComputeShader.SetSampler(0, MyRender11.m_defaultSamplerState);
if (enableTonemapping)
{
RC.SetCS(m_cs);
}
else
{
RC.SetCS(m_csSkip);
}
var size = dst.GetSize();
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
RC.SetCS(null);
}
internal static void Run(MyBindableResource depthRead)
{
// The maximum number of supported GPU particles
SharpDX.Direct3D11.ShaderResourceView textureArraySRV;
int emitterCount = MyGPUEmitters.Gather(m_emitterData, out textureArraySRV);
if (emitterCount == 0)
return;
// Unbind current targets while we run the compute stages of the system
//RC.DeviceContext.OutputMerger.SetTargets(null);
// global GPU particles setup
RC.SetDS(MyDepthStencilState.DefaultDepthState);
RC.SetRS(MyRender11.m_nocullRasterizerState);
RC.SetIL(null);
RC.CSSetCB(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.DeviceContext.ComputeShader.SetSamplers(0, SamplerStates.StandardSamplers);
RC.DeviceContext.PixelShader.SetSamplers(0, SamplerStates.StandardSamplers);
RC.SetCB(4, MyRender11.DynamicShadows.ShadowCascades.CascadeConstantBuffer);
RC.DeviceContext.VertexShader.SetSampler(MyCommon.SHADOW_SAMPLER_SLOT, SamplerStates.m_shadowmap);
RC.DeviceContext.VertexShader.SetShaderResource(MyCommon.CASCADES_SM_SLOT, MyRender11.DynamicShadows.ShadowCascades.CascadeShadowmapArray.SRV);
RC.DeviceContext.VertexShader.SetSamplers(0, SamplerStates.StandardSamplers);
// If we are resetting the particle system, then initialize the dead list
if (m_resetSystem)
{
ResetInternal();
m_resetSystem = false;
}
MyGpuProfiler.IC_BeginBlock("Emit");
// Emit particles into the system
Emit(emitterCount, m_emitterData);
MyGpuProfiler.IC_EndBlock();
// Run the simulation for this frame
MyGpuProfiler.IC_BeginBlock("Simulate");
Simulate(depthRead);
MyGpuProfiler.IC_EndBlock();
// Copy the atomic counter in the alive list UAV into a constant buffer for access by subsequent passes
RC.DeviceContext.CopyStructureCount(m_activeListConstantBuffer, 0, m_aliveIndexBuffer.m_UAV);
// Only read number of alive and dead particle back to the CPU in debug as we don't want to stall the GPU in release code
#if DEBUG
int numDeadParticlesAfterSimulation = ReadCounter( m_deadListBuffer );
int numActiveParticlesAfterSimulation = ReadCounter(m_aliveIndexBuffer);
int numSkippedParticlesAfterSimulation = ReadCounter(m_skippedParticleCountBuffer);
#endif
MyGpuProfiler.IC_BeginBlock("Render");
Render(textureArraySRV, depthRead);
MyGpuProfiler.IC_EndBlock();
RC.DeviceContext.ComputeShader.SetSamplers(0, SamplerStates.StandardSamplers);
#if DEBUG
MyRenderStats.Generic.WriteFormat("GPU particles live #: {0}", numActiveParticlesAfterSimulation, VRage.Stats.MyStatTypeEnum.CurrentValue, 300, 0);
MyRenderStats.Generic.WriteFormat("GPU particles dead #: {0}", numDeadParticlesAfterSimulation, VRage.Stats.MyStatTypeEnum.CurrentValue, 300, 0);
MyRenderStats.Generic.WriteFormat("GPU particles skipped #: {0}", numSkippedParticlesAfterSimulation, VRage.Stats.MyStatTypeEnum.CurrentValue, 300, 0);
#endif
}
internal static void Run(MyBindableResource dst, MyBindableResource src)
{
RC.SetPS(m_ps);
RC.BindDepthRT(dst, DepthStencilAccess.ReadWrite, null);
RC.BindSRV(0, src);
DrawFullscreenQuad();
}
internal static void Run(MyBindableResource destinationResource, MyBindableResource intermediateResource, MyBindableResource resourceToBlur)
{
var initialResourceView = resourceToBlur as IShaderResourceBindable;
var intermediateResourceView = intermediateResource as IShaderResourceBindable;
var intermediateTarget = intermediateResource as IRenderTargetBindable;
var destinationTarget = destinationResource as IRenderTargetBindable;
Run(destinationTarget.RTV, intermediateTarget.RTV, intermediateResourceView.SRV, initialResourceView.SRV);
}
internal static void RunFullscreenSampleFreq(MyBindableResource RT)
{
Debug.Assert(MyRender11.MultisamplingEnabled);
RC.SetDS(MyDepthStencilState.TestEdgeStencil, 0x80);
RC.BindDepthRT(MyGBuffer.Main.Get(MyGbufferSlot.DepthStencil), DepthStencilAccess.ReadOnly, RT);
DrawFullscreenQuad();
RC.SetDS(MyDepthStencilState.DefaultDepthState);
}
internal static void Run(MyBindableResource dst, MyBindableResource src, BlendState bs = null)
{
RC.SetBS(bs);
RC.SetRS(null);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, dst);
RC.BindSRV(0, src);
RC.SetPS(m_copyPixelShader);
DrawFullscreenQuad();
RC.SetBS(null);
}
internal static void Run(MyBindableResource dst, MyBindableResource src, MyBindableResource stencil)
{
RC.BindUAV(0, dst);
RC.BindSRV(0, src, stencil);
RC.SetCS(m_cs);
var size = dst.GetSize();
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
RC.SetCS(null);
}
internal static void RunWithStencil(MyBindableResource destinationResource, MyBindableResource sourceResource, BlendState blendState, DepthStencilState depthStencilState, int stencilMask)
{
RC.SetDS(depthStencilState, stencilMask);
RC.SetBS(blendState);
RC.SetRS(null);
RC.BindDepthRT(MyGBuffer.Main.DepthStencil, DepthStencilAccess.ReadOnly, destinationResource);
RC.BindSRV(0, sourceResource);
RC.SetPS(m_copyPixelShader);
DrawFullscreenQuad();
RC.SetBS(null);
}
internal static MyBindableResource Run(MyBindableResource src, MyBindableResource avgLum)
{
RC.CSSetCB(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.BindUAV(0, MyRender11.HalfScreenUavHDR);
RC.BindSRVs(0, src, avgLum);
RC.SetCS(m_bloomShader);
var size = MyRender11.HalfScreenUavHDR.GetSize();
VRageMath.Vector2I threadGroups = new VRageMath.Vector2I((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads);
RC.DeviceContext.Dispatch(threadGroups.X, threadGroups.Y, 1);
RC.SetCS(m_downscaleShader);
size = MyRender11.QuarterScreenUavHDR.GetSize();
threadGroups = new VRageMath.Vector2I((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads);
RC.BindUAV(0, MyRender11.QuarterScreenUavHDR);
RC.BindSRV(0, MyRender11.HalfScreenUavHDR);
RC.DeviceContext.Dispatch(threadGroups.X, threadGroups.Y, 1);
size = MyRender11.EighthScreenUavHDR.GetSize();
threadGroups = new VRageMath.Vector2I((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads);
RC.BindUAV(0, MyRender11.EighthScreenUavHDR);
RC.BindSRV(0, MyRender11.QuarterScreenUavHDR);
RC.DeviceContext.Dispatch(threadGroups.X, threadGroups.Y, 1);
RC.SetCS(m_blurV);
RC.BindUAV(0, MyRender11.EighthScreenUavHDRHelper);
RC.BindSRV(0, MyRender11.EighthScreenUavHDR);
RC.DeviceContext.Dispatch(threadGroups.X, threadGroups.Y, 1);
RC.SetCS(m_blurH);
RC.BindUAV(0, MyRender11.EighthScreenUavHDR);
RC.BindSRV(0, MyRender11.EighthScreenUavHDRHelper);
int nPasses = 1;
if (MyStereoRender.Enable)
{
threadGroups.X /= 2;
nPasses = 2;
}
for (int nPass = 0; nPass < nPasses; nPass++)
{
MyStereoRegion region = MyStereoRegion.FULLSCREEN;
if (MyStereoRender.Enable)
region = nPass == 0 ? MyStereoRegion.LEFT : MyStereoRegion.RIGHT;
RC.CSSetCB(1, GetCB_blurH(region, size));
RC.DeviceContext.Dispatch(threadGroups.X, threadGroups.Y, 1);
}
return MyRender11.EighthScreenUavHDR;
}
internal static void Run(MyBindableResource destination, MyBindableResource source)
{
var context = MyRender11.DeviceContext;
context.OutputMerger.BlendState = null;
RC.SetIL(null);
context.PixelShader.Set(m_ps);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, destination);
RC.BindSRV(0, source);
MyScreenPass.DrawFullscreenQuad(new MyViewport(destination.GetSize().X, destination.GetSize().Y));
}
internal static void ClearAlpha(MyBindableResource destination)
{
var context = MyRender11.DeviceContext;
context.OutputMerger.BlendState = MyRender11.BlendAdditive;
context.InputAssembler.InputLayout = null;
context.PixelShader.Set(m_clearAlphaPs);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, destination);
MyScreenPass.DrawFullscreenQuad(new MyViewport(destination.GetSize().X, destination.GetSize().Y));
context.OutputMerger.BlendState = null;
}
internal static void RunWithPixelStencilTest(MyBindableResource dst, MyBindableResource src, BlendState bs = null, bool inverseTest = false)
{
RC.SetDS(null);
RC.SetBS(bs);
RC.SetRS(null);
RC.BindDepthRT(null, DepthStencilAccess.ReadOnly, dst);
RC.BindSRV(0, src);
RC.BindSRV(1, MyGBuffer.Main.DepthStencil.Stencil);
if (!inverseTest)
RC.SetPS(m_stencilTestPixelShader);
else
RC.SetPS(m_stencilInverseTestPixelShader);
DrawFullscreenQuad();
RC.SetBS(null);
}
internal static void Run(MyBindableResource destination, MyBindableResource source, MyViewport? customViewport = null)
{
var context = MyRender11.DeviceContext;
context.OutputMerger.BlendState = null;
//context.Rasterizer.SetViewport(0, 0, MyRender.ViewportResolution.X, MyRender.ViewportResolution.Y);
RC.SetIL(null);
context.PixelShader.Set(m_copyPs);
//context.OutputMerger.SetTargets(null as DepthStencilView, target);
//context.PixelShader.SetShaderResource(0, resource);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, destination);
RC.BindSRV(0, source);
MyScreenPass.DrawFullscreenQuad(customViewport ?? new MyViewport(destination.GetSize().X, destination.GetSize().Y));
}
internal static MyBindableResource Run(MyBindableResource src, MyBindableResource avgLum)
{
var mapping = MyMapping.MapDiscard(MyCommon.GetObjectCB(16));
mapping.stream.Write(MyRender11.Settings.MiddleGrey);
mapping.stream.Write(MyRender11.Settings.LuminanceExposure);
mapping.stream.Write(MyRender11.Settings.BloomExposure);
mapping.stream.Write(MyRender11.Settings.BloomMult);
mapping.Unmap();
RC.CSSetCB(0, MyCommon.FrameConstants);
RC.CSSetCB(1, MyCommon.GetObjectCB(16));
RC.BindUAV(0, MyRender11.m_div2);
RC.BindSRV(0, src, avgLum);
RC.SetCS(m_bloomShader);
var size = MyRender11.m_div2.GetSize();
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
RC.SetCS(m_downscaleShader);
size = MyRender11.m_div4.GetSize();
RC.BindUAV(0, MyRender11.m_div4);
RC.BindSRV(0, MyRender11.m_div2);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
size = MyRender11.m_div8.GetSize();
RC.BindUAV(0, MyRender11.m_div8);
RC.BindSRV(0, MyRender11.m_div4);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
RC.SetCS(m_blurH);
RC.BindUAV(0, MyRender11.m_div8_1);
RC.BindSRV(0, MyRender11.m_div8);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
RC.SetCS(m_blurV);
RC.BindUAV(0, MyRender11.m_div8);
RC.BindSRV(0, MyRender11.m_div8_1);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
return MyRender11.m_div8;
}
internal static void Copy(MyBindableResource destination, MyBindableResource source)
{
var context = MyRender.Context;
context.OutputMerger.BlendState = null;
context.Rasterizer.SetViewport(0, 0, MyRender.ViewportResolution.X, MyRender.ViewportResolution.Y);
context.InputAssembler.InputLayout = null;
context.VertexShader.Set(FullscreenShader.VertexShader);
context.PixelShader.Set(CopyShader.PixelShader);
//context.OutputMerger.SetTargets(null as DepthStencilView, target);
//context.PixelShader.SetShaderResource(0, resource);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, destination);
RC.BindSRV(0, source);
context.Draw(3, 0);
}
internal void BindSRV(int slot, MyBindableResource bindable)
{
Array.Clear(State.m_SRVs, 0, State.m_SRVs.Length);
Debug.Assert(bindable as IShaderResourceBindable != null);
MyBinding binding;
State.m_bindings.TryGetValue(bindable.GetID(), out binding);
if (binding.WriteView == MyWriteBindingEnum.RTV || binding.WriteView == MyWriteBindingEnum.DSV)
{
DeviceContext.OutputMerger.ResetTargets();
ClearDsvRtvWriteBindings();
}
else if (binding.WriteView == MyWriteBindingEnum.UAV)
{
ComputeShaderId.TmpUav[0] = null;
DeviceContext.ComputeShader.SetUnorderedAccessViews(binding.UavSlot, ComputeShaderId.TmpUav, ComputeShaderId.TmpCount);
State.m_bindings.Remove(bindable.GetID());
List <int> keyList = State.m_slotToBindingKeys.GetList(slot);
if (keyList != null)
{
keyList.Remove(bindable.GetID());
if (keyList.Count == 0)
{
State.m_slotToBindingKeys.Remove(slot);
}
}
}
State.m_srvBindings.Add(bindable.GetID(), slot);
var bindableShaderResource = bindable as IShaderResourceBindable;
Debug.Assert(bindableShaderResource != null);
State.m_SRVs[0] = bindableShaderResource.SRV;
DeviceContext.VertexShader.SetShaderResource(slot, State.m_SRVs[0]);
DeviceContext.PixelShader.SetShaderResource(slot, State.m_SRVs[0]);
DeviceContext.ComputeShader.SetShaderResource(slot, State.m_SRVs[0]);
MyRender11.ProcessDebugOutput();
}
internal static void Run(MyBindableResource dst1, MyBindableResource dst2, MyBindableResource lightBuffer, MyGBuffer gbuffer)
{
if (!Settings.BlurEnabled || Settings.BlurAmount < 0.01f)
{
return;
}
RC.DeviceContext.ClearRenderTargetView((dst1 as IRenderTargetBindable).RTV, new SharpDX.Color4(0, 0, 0, 0));
RC.DeviceContext.ClearRenderTargetView((dst2 as IRenderTargetBindable).RTV, new SharpDX.Color4(0, 0, 0, 0));
float zero = 0f;
var mapping = MyMapping.MapDiscard(m_cb);
mapping.WriteAndPosition(ref Settings.BlurAmount);
mapping.WriteAndPosition(ref Settings.BlurDistance);
mapping.WriteAndPosition(ref Settings.BlurTransitionRatio);
mapping.WriteAndPosition(ref zero);
mapping.Unmap();
RC.SetCB(0, MyCommon.FrameConstants);
RC.SetCB(1, m_cb);
RC.SetPS(m_psH);
RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, dst1);
RC.BindGBufferForRead(0, gbuffer);
RC.BindSRV(5, lightBuffer);
DrawFullscreenQuad();
RC.SetPS(m_psV);
RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, dst2);
RC.BindSRV(5, dst1);
DrawFullscreenQuad();
// MyBlendTargets.Run(lightBuffer, MyScreenDependants.m_planetBlur2, MyRender11.BlendPlanetBlur);
// MyBlendTargets.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyScreenDependants.m_planetBlur2, MyRender11.BlendPlanetBlur);
}
internal static void Run(MyBindableResource dst1, MyBindableResource dst2, MyBindableResource lightBuffer, MyGBuffer gbuffer)
{
if (!Settings.BlurEnabled || Settings.BlurAmount < 0.01f)
{
return;
}
RC.DeviceContext.ClearRenderTargetView((dst1 as IRenderTargetBindable).RTV, new SharpDX.Color4(0, 0, 0, 0));
RC.DeviceContext.ClearRenderTargetView((dst2 as IRenderTargetBindable).RTV, new SharpDX.Color4(0, 0, 0, 0));
float zero = 0f;
var mapping = MyMapping.MapDiscard(m_cb);
mapping.WriteAndPosition(ref Settings.BlurAmount);
mapping.WriteAndPosition(ref Settings.BlurDistance);
mapping.WriteAndPosition(ref Settings.BlurTransitionRatio);
mapping.WriteAndPosition(ref zero);
mapping.Unmap();
RC.SetCB(0, MyCommon.FrameConstants);
RC.SetCB(1, m_cb);
RC.SetPS(m_psH);
RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, dst1);
RC.BindGBufferForRead(0, gbuffer);
RC.BindSRV(5, lightBuffer);
DrawFullscreenQuad();
RC.SetPS(m_psV);
RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, dst2);
RC.BindSRV(5, dst1);
DrawFullscreenQuad();
// MyBlendTargets.Run(lightBuffer, MyScreenDependants.m_planetBlur2, MyRender11.BlendPlanetBlur);
// MyBlendTargets.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyScreenDependants.m_planetBlur2, MyRender11.BlendPlanetBlur);
}
internal static void Run(MyBindableResource dst, MyBindableResource src, MyBindableResource avgLum, MyBindableResource bloom, bool enableTonemapping = true)
{
//Debug.Assert(src.GetSize() == dst.GetSize());
var buffer = MyCommon.GetObjectCB(16);
var mapping = MyMapping.MapDiscard(buffer);
mapping.WriteAndPosition(ref MyRender11.Settings.MiddleGrey);
mapping.WriteAndPosition(ref MyRender11.Settings.LuminanceExposure);
mapping.WriteAndPosition(ref MyRender11.Settings.BloomExposure);
mapping.WriteAndPosition(ref MyRender11.Settings.BloomMult);
mapping.Unmap();
RC.CSSetCB(0, MyCommon.FrameConstants);
RC.CSSetCB(1, MyCommon.GetObjectCB(16));
RC.BindUAV(0, dst);
RC.BindSRVs(0, src, avgLum, bloom);
RC.DeviceContext.ComputeShader.SetSampler(0, MyRender11.m_defaultSamplerState);
if (enableTonemapping)
{
RC.SetCS(m_cs);
}
else
{
RC.SetCS(m_csSkip);
}
var size = dst.GetSize();
RC.DeviceContext.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
ComputeShaderId.TmpUav[0] = null;
RC.DeviceContext.ComputeShader.SetUnorderedAccessViews(0, ComputeShaderId.TmpUav, ComputeShaderId.TmpCount);
RC.SetCS(null);
}
internal static void Run(MyBindableResource dst, MyGBuffer gbuffer, MyBindableResource resolvedDepth)
{
RC.DeviceContext.ClearRenderTargetView((dst as IRenderTargetBindable).RTV, new SharpDX.Color4(1, 1, 1, 1));
var paramsCB = MyCommon.GetObjectCB(16 * (2 + NUM_SAMPLES * 2));
var mapping = MyMapping.MapDiscard(paramsCB);
mapping.WriteAndPosition(ref Params);
FillRandomVectors(mapping);
mapping.Unmap();
RC.SetCB(0, MyCommon.FrameConstants);
RC.SetCB(1, paramsCB);
RC.SetPS(m_ps);
RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, dst);
RC.BindGBufferForRead(0, gbuffer);
RC.BindSRV(5, resolvedDepth);
DrawFullscreenQuad();
}
internal static void DrawSkybox(MyBindableResource destination)
{
var context = MyRender.Context;
context.OutputMerger.BlendState = null;
context.Rasterizer.SetViewport(0, 0, MyRender.ViewportResolution.X, MyRender.ViewportResolution.Y);
context.PixelShader.SetSamplers(0, MyRender.StandardSamplers);
context.VertexShader.Set(FullscreenShader.VertexShader);
context.PixelShader.Set(SkyboxShader.PixelShader);
//context.OutputMerger.SetTargets(null as DepthStencilView, target);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, destination);
RC.BindGBufferForRead(0, MyGBuffer.Main);
//context.PixelShader.SetShaderResources(0, MyRender.MainGbuffer.DepthGbufferViews);
context.PixelShader.SetShaderResource(MyCommon.SKYBOX_SLOT,
MyTextureManager.GetTexture(MyEnvironment.SkyboxTexture).ShaderView);
context.Draw(3, 0);
context.PixelShader.SetShaderResource(0, null);
}
internal static void DrawSkybox(MyBindableResource destination)
{
var context = MyRender.Context;
context.OutputMerger.BlendState = null;
context.Rasterizer.SetViewport(0, 0, MyRender.ViewportResolution.X, MyRender.ViewportResolution.Y);
context.PixelShader.SetSamplers(0, MyRender.StandardSamplers);
context.VertexShader.Set(FullscreenShader.VertexShader);
context.PixelShader.Set(SkyboxShader.PixelShader);
//context.OutputMerger.SetTargets(null as DepthStencilView, target);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, destination);
RC.BindGBufferForRead(0, MyGBuffer.Main);
//context.PixelShader.SetShaderResources(0, MyRender.MainGbuffer.DepthGbufferViews);
context.PixelShader.SetShaderResource(MyCommon.SKYBOX_SLOT,
MyTextureManager.GetTexture(MyEnvironment.SkyboxTexture).ShaderView);
context.Draw(3, 0);
context.PixelShader.SetShaderResource(0, null);
}
internal static void Run(MyBindableResource dst, MyBindableResource src, MyBindableResource avgLum, MyBindableResource bloom, bool enableTonemapping = true)
{
//Debug.Assert(src.GetSize() == dst.GetSize());
var buffer = MyCommon.GetObjectCB(16);
var mapping = MyMapping.MapDiscard(buffer);
mapping.WriteAndPosition(ref MyRender11.Settings.MiddleGrey);
mapping.WriteAndPosition(ref MyRender11.Settings.LuminanceExposure);
mapping.WriteAndPosition(ref MyRender11.Settings.BloomExposure);
mapping.WriteAndPosition(ref MyRender11.Settings.BloomMult);
mapping.Unmap();
RC.CSSetCB(0, MyCommon.FrameConstants);
RC.CSSetCB(1, MyCommon.GetObjectCB(16));
RC.BindUAV(0, dst);
RC.BindSRVs(0, src, avgLum, bloom);
RC.DeviceContext.ComputeShader.SetSampler(0, SamplerStates.m_default);
if (enableTonemapping)
{
RC.SetCS(m_cs);
}
else
{
RC.SetCS(m_csSkip);
}
var size = dst.GetSize();
RC.DeviceContext.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
ComputeShaderId.TmpUav[0] = null;
RC.DeviceContext.ComputeShader.SetUnorderedAccessViews(0, ComputeShaderId.TmpUav, ComputeShaderId.TmpCount);
RC.SetCS(null);
}
internal MySrvView(MyBindableResource from, Format fmt)
{
m_owner = from;
var desc = new ShaderResourceViewDescription
{
Format = fmt,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource { MipLevels = 1, MostDetailedMip = 0 }
};
m_srv = new ShaderResourceView(MyRender11.Device, m_owner.m_resource, desc);
}
private static void DrawGameScene(bool blitToBackbuffer)
{
ResetStats();
MyCommon.UpdateFrameConstants();
// todo: shouldn't be necessary
if (true)
{
MyImmediateRC.RC.Clear();
MyImmediateRC.RC.Context.ClearState();
}
MyRender11.GetRenderProfiler().StartProfilingBlock("MyGeometryRenderer.Render");
MyGpuProfiler.IC_BeginBlock("MyGeometryRenderer.Render");
MyGeometryRenderer.Render();
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
// cleanup context atfer deferred lists
if (MyRender11.DeferredContextsEnabled)
{
MyImmediateRC.RC.Clear();
}
// todo: shouldn't be necessary
if (true)
{
MyImmediateRC.RC.Clear();
MyImmediateRC.RC.Context.ClearState();
}
MyRender11.GetRenderProfiler().StartProfilingBlock("Render decals");
MyGpuProfiler.IC_BeginBlock("Render decals");
MyRender11.CopyGbufferToScratch();
MyScreenDecals.Draw();
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
MyRender11.GetRenderProfiler().StartProfilingBlock("Render foliage");
MyGpuProfiler.IC_BeginBlock("Render foliage");
MyFoliageRenderer.Render();
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
MySceneMaterials.MoveToGPU();
MyRender11.GetRenderProfiler().StartProfilingBlock("Postprocessing");
MyGpuProfiler.IC_BeginBlock("Postprocessing");
if (MultisamplingEnabled)
{
MyRender11.Context.ClearDepthStencilView(MyScreenDependants.m_resolvedDepth.m_DSV, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1, 0);
MyGpuProfiler.IC_BeginBlock("MarkAAEdges");
MyAAEdgeMarking.Run();
MyGpuProfiler.IC_EndBlock();
MyDepthResolve.Run(MyScreenDependants.m_resolvedDepth, MyGBuffer.Main.DepthStencil.Depth);
}
MyGpuProfiler.IC_BeginBlock("MarkCascades");
MyShadows.MarkCascadesInStencil();
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("Shadows resolve");
MyShadowsResolve.Run();
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("SSAO");
if (Postprocess.EnableSsao)
{
MySSAO.Run(MyScreenDependants.m_ambientOcclusion, MyGBuffer.Main, MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth.Depth : MyGBuffer.Main.DepthStencil.Depth);
}
else
{
MyRender11.Context.ClearRenderTargetView(MyScreenDependants.m_ambientOcclusion.m_RTV, Color4.White);
}
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("Lights");
MyLightRendering.Render();
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().StartProfilingBlock("Billboards");
MyGpuProfiler.IC_BeginBlock("Billboards");
MyRender11.Context.ClearRenderTargetView((MyScreenDependants.m_particlesRT as IRenderTargetBindable).RTV, new Color4(0, 0, 0, 0));
if (MyRender11.MultisamplingEnabled)
{
MyBillboardRenderer.Render(MyScreenDependants.m_particlesRT, MyScreenDependants.m_resolvedDepth, MyScreenDependants.m_resolvedDepth.Depth);
}
else
{
MyBillboardRenderer.Render(MyScreenDependants.m_particlesRT, MyGBuffer.Main.DepthStencil, MyGBuffer.Main.DepthStencil.Depth);
}
MyBlendTargets.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyScreenDependants.m_particlesRT, MyRender11.BlendAlphaPremult);
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
MyAtmosphereRenderer.Render();
MyGpuProfiler.IC_BeginBlock("Luminance reduction");
MyBindableResource avgLum = null;
if (MyRender11.MultisamplingEnabled)
{
//MyLBufferResolve.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBufferResolved), MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyGBuffer.Main.DepthStencil.Stencil);
MyImmediateRC.RC.Context.ResolveSubresource(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer).m_resource, 0, MyGBuffer.Main.Get(MyGbufferSlot.LBufferResolved).m_resource, 0, SharpDX.DXGI.Format.R11G11B10_Float);
}
if (m_resetEyeAdaptation)
{
MyImmediateRC.RC.Context.ClearUnorderedAccessView(m_prevLum.m_UAV, Int4.Zero);
m_resetEyeAdaptation = false;
}
avgLum = MyLuminanceAverage.Run(m_reduce0, m_reduce1, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), m_prevLum, m_localLum);
MyGpuProfiler.IC_EndBlock();
if (MyRender11.Settings.DispalyHdrDebug)
{
var src = MyGBuffer.Main.Get(MyGbufferSlot.LBuffer) as MyRenderTarget;
MyHdrDebugTools.CreateHistogram(src.m_SRV, src.m_resolution, src.m_samples.X);
}
MyGpuProfiler.IC_BeginBlock("Bloom");
var bloom = MyBloom.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum);
MyGpuProfiler.IC_EndBlock();
MyBindableResource tonemapped;
if (MyRender11.FxaaEnabled)
{
tonemapped = m_rgba8_linear;
}
else
{
tonemapped = m_uav3;
}
MyGpuProfiler.IC_BeginBlock("Tone mapping");
MyToneMapping.Run(tonemapped, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum, bloom, MyRender11.Settings.EnableTonemapping && Postprocess.EnableTonemapping && MyRender11.RenderSettings.TonemappingEnabled);
MyGpuProfiler.IC_EndBlock();
MyBindableResource renderedImage;
if (MyRender11.FxaaEnabled)
{
MyGpuProfiler.IC_BeginBlock("FXAA");
MyFXAA.Run(m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm, View = MyViewEnum.RtvView
}), tonemapped);
MyGpuProfiler.IC_EndBlock();
renderedImage = m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView
});
}
else
{
//renderedImage = (tonemapped as MyCustomTexture).GetView(new MyViewKey { Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView });
renderedImage = tonemapped;
}
if (MyOutline.AnyOutline())
{
MyOutline.Run();
if (MyRender11.FxaaEnabled)
{
MyBlendTargets.RunWithStencil(m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}), MyRender11.m_rgba8_1, MyRender11.BlendAdditive);
}
else
{
if (MyRender11.MultisamplingEnabled)
{
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendAdditive);
}
else
{
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendAdditive);
}
}
}
m_finalImage = renderedImage;
if (blitToBackbuffer)
{
MyCopyToRT.Run(Backbuffer, renderedImage);
}
if (MyRender11.Settings.DispalyHdrDebug)
{
MyHdrDebugTools.DisplayHistogram(Backbuffer.m_RTV, (avgLum as IShaderResourceBindable).SRV);
}
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
}
private unsafe static byte[] GetScreenData(Vector2I resolution, byte[] screenData = null)
{
const uint headerPadding = 256; // Need to allocate some space for the bitmap headers
const uint bytesPerPixel = 4;
uint imageSizeInBytes = (uint)(resolution.Size() * bytesPerPixel);
uint dataSizeInBytes = imageSizeInBytes + headerPadding;
byte[] returnData = null;
if (screenData == null)
{
screenData = new byte[imageSizeInBytes];
}
else if (screenData.Length != imageSizeInBytes)
{
Debug.Fail("Preallocated buffer for GetScreenData incorrect size: " + imageSizeInBytes.ToString() + " expected, " + screenData.Length * bytesPerPixel + " received");
return(returnData);
}
MyBindableResource imageSource = Backbuffer;
if (imageSource == null)
{
return(returnData);
}
if (imageSizeInBytes > int.MaxValue)
{
Debug.Fail("Image size too large to read!");
return(returnData);
}
MyBindableResource imageResource = imageSource;
if (resolution.X != imageResource.GetSize().X || resolution.Y != imageResource.GetSize().Y)
{
imageResource = m_lastScreenDataResource;
if (imageResource == null || (imageResource.GetSize().X != resolution.X || imageResource.GetSize().Y != resolution.Y))
{
if (m_lastScreenDataResource != null && m_lastScreenDataResource != Backbuffer)
{
m_lastScreenDataResource.Release();
}
m_lastScreenDataResource = null;
imageResource = new MyRenderTarget(resolution.X, resolution.Y, MyRender11Constants.DX11_BACKBUFFER_FORMAT, 0, 0);
}
MyCopyToRT.Run(imageResource, imageSource, new MyViewport(resolution));
}
m_lastScreenDataResource = imageResource;
Stream dataStream = m_lastDataStream;
if (m_lastDataStream == null || m_lastDataStream.Length != dataSizeInBytes)
{
if (m_lastDataStream != null)
{
m_lastDataStream.Dispose();
m_lastDataStream = null;
}
dataStream = new DataStream((int)dataSizeInBytes, true, true);
}
m_lastDataStream = dataStream;
Resource.ToStream(MyRenderContext.Immediate.DeviceContext, imageResource.m_resource, ImageFileFormat.Bmp, dataStream);
if (!(dataStream.CanRead && dataStream.CanSeek))
{
Debug.Fail("Screen data stream does not support the necessary operations to get the data");
return(returnData);
}
fixed(byte *dataPointer = screenData)
{
GetBmpDataFromStream(dataStream, dataPointer, imageSizeInBytes);
}
returnData = screenData;
if (m_lastDataStream != null)
{
m_lastDataStream.Seek(0, SeekOrigin.Begin);
}
return(returnData);
}
internal static void SSGrass(MyBindableResource destination,
MyBindableResource depth, MyBindableResource source, MyBindableResource gbuffer2)
{
var context = MyRender.Context;
var cbuffer = MyCommon.GetObjectBuffer(16);
var mapping = MyMapping.MapDiscard(cbuffer.Buffer);
mapping.stream.Write(MyRender.Settings.GrassPostprocessCloseDistance);
mapping.Unmap();
context.PixelShader.SetConstantBuffer(1, cbuffer.Buffer);
context.OutputMerger.BlendState = null;
context.Rasterizer.SetViewport(0, 0, MyRender.ViewportResolution.X, MyRender.ViewportResolution.Y);
context.VertexShader.Set(FullscreenShader.VertexShader);
context.PixelShader.Set(SSGrassShader.PixelShader);
//var array = new ShaderResourceView[] { depth, resource, MyRender.MainGbuffer.Gbuffers[2].ShaderView };
//context.OutputMerger.SetTargets(null as DepthStencilView, target);
//context.PixelShader.SetShaderResources(0, array);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, destination);
RC.BindSRV(0, depth, source, gbuffer2);
context.Draw(3, 0);
}
internal static void Draw(MyBindableResource renderTarget)
{
var context = RC.DeviceContext;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.Rasterizer.SetViewport(0, 0, MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y);
context.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, renderTarget);
RC.BindGBufferForRead(0, MyGBuffer.Main);
//context.OutputMerger.SetTargets(null as DepthStencilView, MyRender.Backbuffer.RenderTarget);
//context.PixelShader.SetShaderResources(0, MyRender.MainGbuffer.DepthGbufferViews);
context.OutputMerger.BlendState = null;
RC.SetVS(null);
RC.DeviceContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding());
RC.DeviceContext.InputAssembler.InputLayout = null;
if(MyRender11.Settings.DisplayGbufferColor)
{
context.PixelShader.Set(m_baseColorShader);
MyScreenPass.DrawFullscreenQuad();
}
if (MyRender11.Settings.DisplayGbufferColorLinear)
{
context.PixelShader.Set(m_baseColorLinearShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferNormal)
{
context.PixelShader.Set(m_normalShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferGlossiness)
{
context.PixelShader.Set(m_glossinessShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferMetalness)
{
context.PixelShader.Set(m_metalnessShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferMaterialID)
{
context.PixelShader.Set(m_matIDShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferAO)
{
context.PixelShader.Set(m_aoShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayEmissive)
{
context.PixelShader.Set(m_emissiveShader);
MyScreenPass.DrawFullscreenQuad();
}
else if(MyRender11.Settings.DisplayAmbientDiffuse)
{
context.PixelShader.Set(m_ambientDiffuseShader);
MyScreenPass.DrawFullscreenQuad();
}
else if(MyRender11.Settings.DisplayAmbientSpecular)
{
context.PixelShader.Set(m_ambientSpecularShader);
MyScreenPass.DrawFullscreenQuad();
}
else if(MyRender11.Settings.DisplayEdgeMask)
{
context.PixelShader.Set(m_edgeDebugShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayShadowsWithDebug)
{
context.PixelShader.Set(m_shadowsDebugShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayNDotL)
{
context.PixelShader.Set(m_NDotLShader);
MyScreenPass.DrawFullscreenQuad();
}
else if(MyRender11.Settings.DisplayDepth)
{
context.PixelShader.Set(m_depthShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayStencil)
{
context.PixelShader.Set(m_stencilShader);
MyScreenPass.DrawFullscreenQuad();
}
//DrawEnvProbe();
//DrawAtmosphereTransmittance(MyAtmosphereRenderer.AtmosphereLUT.Keys.ToArray()[0]);
//DrawAtmosphereInscatter(MyAtmosphereRenderer.AtmosphereLUT.Keys.ToArray()[0]);
if (MyRender11.Settings.DrawCascadeTextures)
{
DrawCascades(MyRender11.DynamicShadows.ShadowCascades, 100, 100, 200);
if (MyScene.SeparateGeometry)
{
DrawCascades(MyRender11.StaticShadows.ShadowCascades, 100, 300, 200);
DrawCombinedCascades(100, 500, 200);
}
}
if (MyRender11.Settings.DisplayIDs || MyRender11.Settings.DisplayAabbs)
{
DrawHierarchyDebug();
}
if (false)
{
var batch = MyLinesRenderer.CreateBatch();
foreach (var light in MyLightRendering.VisiblePointlights)
{
batch.AddSphereRing(new BoundingSphere(light.PointPosition, 0.5f), Color.White, Matrix.Identity);
}
batch.Commit();
}
// draw terrain lods
if (MyRender11.Settings.DebugRenderClipmapCells)
{
//var batch = MyLinesRenderer.CreateBatch();
//foreach (var renderable in MyComponentFactory<MyRenderableComponent>.GetAll().Where(x => (MyMeshes.IsVoxelMesh(x.Mesh))))
//{
// if (renderable.IsVisible)
// {
// if (renderable.m_lod >= LOD_COLORS.Length)
// return;
// BoundingBox bb = new BoundingBox(renderable.m_owner.Aabb.Min - MyEnvironment.CameraPosition,renderable.m_owner.Aabb.Max - MyEnvironment.CameraPosition);
// batch.AddBoundingBox(bb, new Color(LOD_COLORS[renderable.m_voxelLod]));
// if (renderable.m_lods != null && renderable.m_voxelLod != renderable.m_lods[0].RenderableProxies[0].ObjectData.CustomAlpha)
// {
// }
// }
//}
//batch.Commit();
MyClipmap.DebugDrawClipmaps();
}
if (MyRender11.Settings.EnableVoxelMerging && MyRender11.Settings.DebugRenderMergedCells)
MyClipmap.DebugDrawMergedCells();
//if(true)
//{
// var batch = MyLinesRenderer.CreateBatch();
// foreach(var id in MyLights.DirtySpotlights)
// {
// var info = MyLights.Spotlights[id.Index];
// if(info.ApertureCos > 0)
// {
// var D = info.Direction * info.Range;
// //batch.AddCone(MyLights.Lights.Data[id.Index].Position + D, -D, info.Up.Cross(info.Direction) * info.BaseRatio * info.Range, 32, Color.OrangeRed);
// //var bb = MyLights.AabbFromCone(info.Direction, info.ApertureCos, info.Range).Transform(Matrix.CreateLookAt(MyLights.Lights.Data[id.Index].Position, info.Direction, info.Up));
// //batch.AddBoundingBox(bb, Color.Green);
// batch.AddCone(MyLights.Lights.Data[id.Index].Position + D, -D, info.Up.Cross(info.Direction) * info.BaseRatio * info.Range, 32, Color.OrangeRed);
// var bb = MyLights.AabbFromCone(info.Direction, info.ApertureCos, info.Range, MyLights.Lights.Data[id.Index].Position, info.Up);
// batch.AddBoundingBox(bb, Color.Green);
// }
// }
// batch.Commit();
//}
// draw lods
if(false)
{
var batch = MyLinesRenderer.CreateBatch();
//foreach (var renderable in MyComponentFactory<MyRenderableComponent>.GetAll().Where(x => ((x.GetMesh() as MyVoxelMesh) == null)))
//{
// if (renderable.CurrentLodNum >= LOD_COLORS.Length || renderable.m_lods.Length == 1)
// continue;
// batch.AddBoundingBox(renderable.m_owner.Aabb, new Color(LOD_COLORS[renderable.CurrentLodNum]));
//}
batch.Commit();
}
}
internal unsafe static void Render(MyBindableResource dst, MyBindableResource depth, MyBindableResource depthRead)
{
MyRender11.GetRenderProfiler().StartProfilingBlock("Gather");
Gather();
MyRender11.GetRenderProfiler().EndProfilingBlock();
MyRender11.GetRenderProfiler().StartProfilingBlock("Draw");
TransferData();
RC.SetupScreenViewport();
RC.BindDepthRT(depth, DepthStencilAccess.ReadOnly, dst);
RC.SetBS(MyRender11.BlendAlphaPremult);
RC.SetRS(MyRender11.m_nocullRasterizerState);
RC.BindRawSRV(104, m_SB.Srv);
RC.BindSRV(1, depthRead);
RC.SetCB(2, MyCommon.GetObjectCB(sizeof(Matrix) * MaxCustomProjections));
RC.SetDS(MyDepthStencilState.DefaultDepthState);
RC.SetCB(4, MyShadows.m_csmConstants);
RC.Context.VertexShader.SetSampler(MyCommon.SHADOW_SAMPLER_SLOT, MyRender11.m_shadowmapSamplerState);
RC.Context.VertexShader.SetShaderResource(MyCommon.CASCADES_SM_SLOT, MyShadows.m_cascadeShadowmapArray.ShaderView);
RC.Context.VertexShader.SetSamplers(0, MyRender11.StandardSamplers);
RC.Context.VertexShader.SetShaderResource(MyCommon.SKYBOX_IBL_SLOT, MyTextures.GetView(MyTextures.GetTexture(MyEnvironment.DaySkyboxPrefiltered, MyTextureEnum.CUBEMAP, true)));
RC.Context.PixelShader.SetShaderResource(MyCommon.SKYBOX2_IBL_SLOT, MyTextures.GetView(MyTextures.GetTexture(MyEnvironment.NightSkyboxPrefiltered, MyTextureEnum.CUBEMAP, true)));
RC.SetVB(0, m_VB.Buffer, m_VB.Stride);
RC.SetIB(m_IB.Buffer, m_IB.Format);
RC.SetIL(m_inputLayout);
for (int i = 0; i < m_batches.Count; i++)
{
// first part of batches contain sorted billboards and they read depth
// second part of batches contain unsorted billboards and they ignore depth
// switch here:
if (m_batches[i].Offset == m_sortedBillboardsNum)
{
//RC.BindDepthRT(null, DepthStencilAccess.ReadOnly, dst);
}
if (m_batches[i].Lit)
{
RC.SetVS(m_vsLit);
RC.SetPS(m_psLit);
}
else
{
RC.SetVS(m_vs);
RC.SetPS(m_ps);
}
RC.BindRawSRV(0, m_batches[i].Texture);
RC.Context.DrawIndexed(m_batches[i].Num * 6, m_batches[i].Offset * 6, 0);
}
RC.SetRS(null);
m_batches.Clear();
MyRender11.GetRenderProfiler().EndProfilingBlock();
}
internal override void Release()
{
if (m_rtv != null)
{
m_rtv.Dispose();
}
m_owner = null;
base.Release();
}
private static void Render(SharpDX.Direct3D11.ShaderResourceView textureArraySRV, MyBindableResource depthRead)
{
RC.SetVS(m_vs);
if (MyRender11.DebugOverrides.OIT)
{
RC.SetPS(m_psOIT);
}
else
{
RC.SetPS(m_ps);
}
RC.SetVB(0, null, 0);
RC.SetIB(m_ib.Buffer, SharpDX.DXGI.Format.R32_UInt);
RC.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
RC.SetCB(1, m_activeListConstantBuffer);
RC.BindSRV(0, depthRead);
RC.DeviceContext.PixelShader.SetShaderResources(1, textureArraySRV);
RC.VSBindRawSRV(0, m_particleBuffer);
RC.VSBindRawSRV(1, m_aliveIndexBuffer);
RC.VSBindRawSRV(2, m_emitterStructuredBuffer);
RC.DeviceContext.VertexShader.SetShaderResource(MyCommon.SKYBOX_IBL_SLOT,
MyRender11.IsIntelBrokenCubemapsWorkaround ? Resources.MyTextures.GetView(Resources.MyTextures.IntelFallbackCubeTexId) : MyEnvironmentProbe.Instance.cubemapPrefiltered.SRV);
RC.DeviceContext.VertexShader.SetShaderResource(MyCommon.SKYBOX2_IBL_SLOT,
Resources.MyTextures.GetView(Resources.MyTextures.GetTexture(MyEnvironment.NightSkyboxPrefiltered, Resources.MyTextureEnum.CUBEMAP, true)));
// bind render target?
RC.DeviceContext.DrawIndexedInstancedIndirect(m_indirectDrawArgsBuffer.Buffer, 0);
MyRender11.ProcessDebugOutput();
RC.DeviceContext.PixelShader.SetShaderResource(MyCommon.SKYBOX_IBL_SLOT, null);
RC.DeviceContext.PixelShader.SetShaderResource(MyCommon.SKYBOX2_IBL_SLOT, null);
}
internal static void Draw(MyBindableResource renderTarget, MyBindableResource depth)
{
RC.SetupScreenViewport();
RC.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
RC.SetIL(m_inputLayout);
RC.SetRS(MyRender11.m_nocullRasterizerState);
RC.SetDS(MyDepthStencilState.DefaultDepthState);
RC.SetVS(m_vs);
RC.SetPS(m_ps);
RC.BindDepthRT(depth, DepthStencilAccess.ReadOnly, renderTarget);
RC.SetCB(MyCommon.PROJECTION_SLOT, MyCommon.ProjectionConstants);
RC.SetBS(MyRender11.BlendTransparent);
SortTransparent();
var transpose = Matrix.Transpose(MyRender11.Environment.ViewProjectionAt0);
var mapping = MyMapping.MapDiscard(MyCommon.ProjectionConstants);
mapping.WriteAndPosition(ref transpose);
mapping.Unmap();
CheckBufferSize(m_vertexList.Count);
RC.SetVB(0, m_VB.Buffer, m_VB.Stride);
if (m_vertexList.Count > 0)
{
mapping = MyMapping.MapDiscard(m_VB.Buffer);
mapping.WriteAndPosition(m_vertexList.GetInternalArray(), 0, m_vertexList.Count);
mapping.Unmap();
}
RC.DeviceContext.Draw(m_vertexList.Count, 0);
if (m_debugMeshes.Count > 0)
{
var transposeViewProj = Matrix.Transpose(MyRender11.Environment.ViewProjection);
mapping = MyMapping.MapDiscard(MyCommon.ProjectionConstants);
mapping.WriteAndPosition(ref transposeViewProj);
mapping.Unmap();
}
foreach (var mesh in m_debugMeshes.Values)
{
if (mesh.depth)
RC.BindDepthRT(depth, DepthStencilAccess.ReadWrite, MyRender11.Backbuffer);
else
RC.BindDepthRT(null, DepthStencilAccess.ReadOnly, null);
if (mesh.edges)
{
RC.SetRS(MyRender11.m_nocullWireframeRasterizerState);
}
else
{
RC.SetRS(MyRender11.m_nocullRasterizerState);
}
RC.SetVB(0, mesh.vbuffer.Buffer, mesh.vbuffer.Stride);
RC.DeviceContext.Draw(mesh.vbuffer.Capacity, 0);
}
RC.SetBS(null);
m_vertexList.Clear();
m_postSortVertexList.Clear();
m_triangleSortDistance.Clear();
m_sortedIndices.Clear();
}
internal void BindDepthRT(MyBindableResource depthStencil, DepthStencilAccess dsAccess, MyBindableResource bindable0, MyBindableResource bindable1)
{
m_tmpBinds2[0] = bindable0;
m_tmpBinds2[1] = bindable1;
BindDepthRTInternal(depthStencil, dsAccess, m_tmpBinds2);
Array.Clear(m_tmpBinds2, 0, m_tmpBinds2.Length);
}
internal unsafe static void Render(MyBindableResource dst, MyBindableResource depth, MyBindableResource depthRead)
{
if (!MyRender11.DebugOverrides.BillboardsDynamic)
{
OnFrameStart();
}
m_stats.Clear();
MyRender11.GetRenderProfiler().StartProfilingBlock("Gather");
Gather();
MyRender11.GetRenderProfiler().EndProfilingBlock();
MyRender11.GetRenderProfiler().StartProfilingBlock("Draw");
TransferData();
RC.SetupScreenViewport();
RC.BindDepthRT(depth, DepthStencilAccess.ReadOnly, dst);
RC.SetBS(MyRender11.BlendAlphaPremult);
RC.SetRS(MyRender11.m_nocullRasterizerState);
RC.BindRawSRV(104, m_SB);
RC.BindSRV(1, depthRead);
RC.SetCB(2, MyCommon.GetObjectCB(sizeof(Matrix) * MaxCustomProjections));
RC.SetDS(MyDepthStencilState.DefaultDepthState);
RC.SetCB(4, MyRender11.DynamicShadows.ShadowCascades.CascadeConstantBuffer);
RC.DeviceContext.VertexShader.SetSampler(MyCommon.SHADOW_SAMPLER_SLOT, SamplerStates.m_shadowmap);
RC.DeviceContext.VertexShader.SetShaderResource(MyCommon.CASCADES_SM_SLOT, MyRender11.DynamicShadows.ShadowCascades.CascadeShadowmapArray.SRV);
RC.DeviceContext.VertexShader.SetSamplers(0, SamplerStates.StandardSamplers);
RC.DeviceContext.VertexShader.SetShaderResource(MyCommon.SKYBOX_IBL_SLOT,
MyRender11.IsIntelBrokenCubemapsWorkaround ? MyTextures.GetView(MyTextures.IntelFallbackCubeTexId) : MyEnvironmentProbe.Instance.cubemapPrefiltered.SRV);
RC.DeviceContext.VertexShader.SetShaderResource(MyCommon.SKYBOX2_IBL_SLOT,
MyTextures.GetView(MyTextures.GetTexture(MyEnvironment.NightSkyboxPrefiltered, MyTextureEnum.CUBEMAP, true)));
RC.SetVB(0, m_VB.Buffer, m_VB.Stride);
RC.SetIB(m_IB.Buffer, m_IB.Format);
RC.SetIL(m_inputLayout);
for (int i = 0; i < m_batches.Count; i++)
{
// first part of batches contain sorted billboards and they read depth
// second part of batches contain unsorted billboards and they ignore depth
// switch here:
if (m_batches[i].Offset == m_sortedBillboardsNum)
{
//RC.BindDepthRT(null, DepthStencilAccess.ReadOnly, dst);
}
if (m_batches[i].Lit)
{
RC.SetVS(m_vsLit);
if (m_batches[i].AlphaCutout)
{
RC.SetPS(m_psAlphaCutoutAndLit);
}
else
{
RC.SetPS(m_psLit);
}
}
else
if (m_batches[i].AlphaCutout)
{
RC.SetVS(m_vs);
RC.SetPS(m_psAlphaCutout);
}
else
{
RC.SetVS(m_vs);
RC.SetPS(m_ps);
}
RC.BindRawSRV(0, m_batches[i].Texture);
RC.DeviceContext.DrawIndexed(m_batches[i].Num * 6, m_batches[i].Offset * 6, 0);
++RC.Stats.BillboardDrawIndexed;
}
m_stats.Billboards += m_sorted + m_unsorted;
RC.SetRS(null);
RC.SetBS(null);
m_batches.Clear();
MyRender11.GatherStats(m_stats);
MyRender11.GetRenderProfiler().EndProfilingBlock();
}
// Returns the final image and copies it to renderTarget if non-null
private static MyBindableResource DrawGameScene(MyBindableResource renderTarget)
{
ProfilerShort.Begin("DrawGameScene");
PrepareGameScene();
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear");
MyRenderContext.Immediate.Clear();
MyRenderContext.Immediate.DeviceContext.ClearState();
ProfilerShort.End();
}
Debug.Assert(m_commandLists.Count == 0, "Not all command lists executed last frame!");
DynamicGeometryRenderer.Render(m_commandLists, true);
if (MyScene.SeparateGeometry)
{
StaticGeometryRenderer.Render(m_commandLists, false);
}
SendGlobalOutputMessages();
ExecuteCommandLists(m_commandLists);
MyEnvironmentProbe.FinalizeEnvProbes();
// cleanup context atfer deferred lists
if (MyRender11.DeferredContextsEnabled)
{
ProfilerShort.Begin("Clear2");
MyRenderContext.Immediate.Clear();
ProfilerShort.End();
}
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear3");
MyRenderContext.Immediate.Clear();
MyRenderContext.Immediate.DeviceContext.ClearState();
ProfilerShort.End();
}
ProfilerShort.Begin("Render decals");
MyGpuProfiler.IC_BeginBlock("Render decals");
MyRender11.CopyGbufferToScratch();
MyScreenDecals.Draw();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Render foliage");
MyGpuProfiler.IC_BeginBlock("Render foliage");
m_foliageRenderer.Render();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("MySceneMaterials.MoveToGPU");
MySceneMaterials.MoveToGPU();
ProfilerShort.BeginNextBlock("Postprocessing");
MyGpuProfiler.IC_BeginBlock("Postprocessing");
if (MultisamplingEnabled)
{
MyRender11.DeviceContext.ClearDepthStencilView(MyScreenDependants.m_resolvedDepth.m_DSV, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1, 0);
MyGpuProfiler.IC_BeginBlock("MarkAAEdges");
MyAAEdgeMarking.Run();
MyGpuProfiler.IC_EndBlock();
MyDepthResolve.Run(MyScreenDependants.m_resolvedDepth, MyGBuffer.Main.DepthStencil.Depth);
}
if (MyScene.SeparateGeometry)
{
MyShadowCascadesPostProcess.Combine(MyShadowCascades.CombineShadowmapArray, DynamicShadows.ShadowCascades, StaticShadows.ShadowCascades);
DynamicShadows.ShadowCascades.PostProcess(MyRender11.PostProcessedShadows, MyShadowCascades.CombineShadowmapArray);
}
else
{
DynamicShadows.ShadowCascades.PostProcess(MyRender11.PostProcessedShadows, DynamicShadows.ShadowCascades.CascadeShadowmapArray);
}
MyGpuProfiler.IC_BeginBlock("SSAO");
if (Postprocess.EnableSsao)
{
MySSAO.Run(MyScreenDependants.m_ambientOcclusion, MyGBuffer.Main, MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth.Depth : MyGBuffer.Main.DepthStencil.Depth);
if (MySSAO.UseBlur)
{
MyBlur.Run(MyScreenDependants.m_ambientOcclusion, MyScreenDependants.m_ambientOcclusionHelper, MyScreenDependants.m_ambientOcclusion);
}
}
else
{
MyRender11.DeviceContext.ClearRenderTargetView(MyScreenDependants.m_ambientOcclusion.m_RTV, Color4.White);
}
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("Lights");
MyLightRendering.Render();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginBlock("Billboards");
if (MyRender11.MultisamplingEnabled)
{
MyBillboardRenderer.Render(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyScreenDependants.m_resolvedDepth, MyScreenDependants.m_resolvedDepth.Depth);
}
else
{
MyBillboardRenderer.Render(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyGBuffer.Main.DepthStencil, MyGBuffer.Main.DepthStencil.Depth);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Atmosphere");
MyGpuProfiler.IC_BeginBlock("Atmosphere");
MyAtmosphereRenderer.Render();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Clouds");
MyGpuProfiler.IC_BeginBlock("Clouds");
MyCloudRenderer.Render();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
MyGpuProfiler.IC_BeginBlock("Luminance reduction");
MyBindableResource avgLum = null;
if (MyRender11.MultisamplingEnabled)
{
MyRenderContext.Immediate.DeviceContext.ResolveSubresource(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer).m_resource, 0, MyGBuffer.Main.Get(MyGbufferSlot.LBufferResolved).m_resource, 0, SharpDX.DXGI.Format.R11G11B10_Float);
}
if (m_resetEyeAdaptation)
{
MyRenderContext.Immediate.DeviceContext.ClearUnorderedAccessView(m_prevLum.m_UAV, Int4.Zero);
m_resetEyeAdaptation = false;
}
avgLum = MyLuminanceAverage.Run(m_reduce0, m_reduce1, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), m_prevLum);
MyGpuProfiler.IC_EndBlock();
if (MyRender11.Settings.DisplayHdrDebug)
{
var src = MyGBuffer.Main.Get(MyGbufferSlot.LBuffer) as MyRenderTarget;
MyHdrDebugTools.CreateHistogram(src.m_SRV, src.m_resolution, src.m_samples.X);
}
MyGpuProfiler.IC_BeginBlock("Bloom");
var bloom = MyBloom.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum);
MyGpuProfiler.IC_EndBlock();
MyBindableResource tonemapped;
if (MyRender11.FxaaEnabled)
{
tonemapped = m_rgba8_linear;
}
else
{
tonemapped = m_uav3;
}
MyGpuProfiler.IC_BeginBlock("Tone mapping");
MyToneMapping.Run(tonemapped, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum, bloom, Postprocess.EnableTonemapping);
MyGpuProfiler.IC_EndBlock();
MyBindableResource renderedImage;
if (MyRender11.FxaaEnabled)
{
MyGpuProfiler.IC_BeginBlock("FXAA");
MyFXAA.Run(m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm, View = MyViewEnum.RtvView
}), tonemapped);
MyGpuProfiler.IC_EndBlock();
renderedImage = m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView
});
}
else
{
//renderedImage = (tonemapped as MyCustomTexture).GetView(new MyViewKey { Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView });
renderedImage = tonemapped;
}
ProfilerShort.Begin("Outline");
if (MyOutline.AnyOutline())
{
MyOutline.Run();
MyGpuProfiler.IC_BeginBlock("Outline Blending");
ProfilerShort.Begin("Outline Blending");
if (MyRender11.FxaaEnabled)
{
MyBlendTargets.RunWithStencil(
m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}),
MyRender11.m_rgba8_1,
MyRender11.BlendAdditive,
MyDepthStencilState.TestOutlineMeshStencil,
0x40);
MyBlendTargets.RunWithStencil(
m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}),
MyRender11.m_rgba8_1,
MyRender11.BlendTransparent,
MyDepthStencilState.TestHighlightMeshStencil,
0x40);
}
else
{
if (MyRender11.MultisamplingEnabled)
{
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_ms, MyRender11.BlendAdditive);
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_ms, MyRender11.BlendTransparent, true);
}
else
{
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendAdditive, MyDepthStencilState.TestOutlineMeshStencil, 0x40);
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendTransparent, MyDepthStencilState.TestHighlightMeshStencil, 0x40);
}
}
ProfilerShort.End();
MyGpuProfiler.IC_EndBlock();
}
ProfilerShort.End();
if (renderTarget != null)
{
MyCopyToRT.Run(renderTarget, renderedImage);
}
if (MyRender11.Settings.DisplayHdrDebug)
{
MyHdrDebugTools.DisplayHistogram((renderTarget as IRenderTargetBindable).RTV, (avgLum as IShaderResourceBindable).SRV);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
return(renderedImage);
}
internal static void Run(MyBindableResource dst, MyBindableResource src)
{
//RC.SetBS(MyRender.BlendStateAdditive);
RC.SetBS(MyRender11.BlendAlphaPremult);
RC.SetRS(null);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, dst);
RC.BindSRV(0, src);
RC.SetPS(m_ps);
DrawFullscreenQuad();
RC.SetBS(null);
}
internal MyUavView(MyBindableResource from, Format fmt)
{
m_owner = from;
var desc = new UnorderedAccessViewDescription
{
Format = fmt,
Dimension = UnorderedAccessViewDimension.Texture2D,
Texture2D = new UnorderedAccessViewDescription.Texture2DResource { MipSlice = 0 }
};
m_uav = new UnorderedAccessView(MyRender11.Device, m_owner.m_resource, desc);
}
internal static void Draw(MyBindableResource renderTarget, MyBindableResource depth)
{
RC.SetupScreenViewport();
RC.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
RC.SetIL(m_inputLayout);
RC.SetRS(MyRender11.m_nocullRasterizerState);
RC.SetDS(MyDepthStencilState.DefaultDepthState);
RC.SetVS(m_vs);
RC.SetPS(m_ps);
RC.BindDepthRT(depth, DepthStencilAccess.ReadOnly, renderTarget);
RC.SetCB(MyCommon.PROJECTION_SLOT, MyCommon.ProjectionConstants);
RC.SetBS(MyRender11.BlendTransparent);
SortTransparent();
var transpose = Matrix.Transpose(MyRender11.Environment.ViewProjectionAt0);
var mapping = MyMapping.MapDiscard(MyCommon.ProjectionConstants);
mapping.WriteAndPosition(ref transpose);
mapping.Unmap();
CheckBufferSize(m_vertexList.Count);
RC.SetVB(0, m_VB.Buffer, m_VB.Stride);
if (m_vertexList.Count > 0)
{
mapping = MyMapping.MapDiscard(m_VB.Buffer);
mapping.WriteAndPosition(m_vertexList.GetInternalArray(), 0, m_vertexList.Count);
mapping.Unmap();
}
RC.DeviceContext.Draw(m_vertexList.Count, 0);
if (m_debugMeshes.Count > 0)
{
var transposeViewProj = Matrix.Transpose(MyRender11.Environment.ViewProjection);
mapping = MyMapping.MapDiscard(MyCommon.ProjectionConstants);
mapping.WriteAndPosition(ref transposeViewProj);
mapping.Unmap();
}
foreach (var mesh in m_debugMeshes.Values)
{
if (mesh.depth)
{
RC.BindDepthRT(depth, DepthStencilAccess.ReadWrite, MyRender11.Backbuffer);
}
else
{
RC.BindDepthRT(null, DepthStencilAccess.ReadOnly, null);
}
if (mesh.edges)
{
RC.SetRS(MyRender11.m_nocullWireframeRasterizerState);
}
else
{
RC.SetRS(MyRender11.m_nocullRasterizerState);
}
RC.SetVB(0, mesh.vbuffer.Buffer, mesh.vbuffer.Stride);
RC.DeviceContext.Draw(mesh.vbuffer.Capacity, 0);
}
RC.SetBS(null);
m_vertexList.Clear();
m_postSortVertexList.Clear();
m_triangleSortDistance.Clear();
m_sortedIndices.Clear();
}
internal MyRtvView(MyBindableResource from, Format fmt)
{
m_owner = from;
var desc = new RenderTargetViewDescription
{
Format = fmt,
Dimension = RenderTargetViewDimension.Texture2D,
Texture2D = new RenderTargetViewDescription.Texture2DResource { MipSlice = 0 }
};
m_rtv = new RenderTargetView(MyRender11.Device, m_owner.m_resource, desc);
}
internal void BindSRVs(int slot, MyBindableResource bindable0, MyBindableResource bindable1, MyBindableResource bindable2)
{
m_tmpBinds3[0] = bindable0;
m_tmpBinds3[1] = bindable1;
m_tmpBinds3[2] = bindable2;
BindSRVsInternal(slot, m_tmpBinds3);
Array.Clear(m_tmpBinds3, 0, m_tmpBinds3.Length);
}
internal static MyBindableResource Run(MyBindableResource uav0, MyBindableResource uav1, MyBindableResource src,
MyBindableResource prevLum, MyBindableResource localAvgLum)
{
var size = src.GetSize();
var texelsNum = size.X * size.Y;
var mapping = MyMapping.MapDiscard(MyCommon.GetObjectCB(16));
mapping.stream.Write((uint)size.X);
mapping.stream.Write((uint)size.Y);
mapping.stream.Write(texelsNum);
mapping.Unmap();
RC.CSSetCB(0, MyCommon.FrameConstants);
RC.CSSetCB(1, MyCommon.GetObjectCB(16));
RC.BindUAV(0, uav0);
RC.BindSRV(0, src);
RC.SetCS(m_initialShader);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
RC.SetCS(m_sumShader);
int i = 0;
while (true)
{
size.X = (size.X + m_numthreads - 1) / m_numthreads;
size.Y = (size.Y + m_numthreads - 1) / m_numthreads;
if (size.X <= 8 && size.Y <= 8)
break;
//mapping = MyMapping.MapDiscard(MyCommon.GetObjectBuffer(16).Buffer);
//mapping.stream.Write(new Vector2I(size.X, size.Y));
//mapping.Unmap();
RC.BindUAV(0, (i % 2 == 0) ? uav1 : uav0);
RC.BindSRV(0, (i % 2 == 0) ? uav0 : uav1);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
//might not be exactly correct if we skip this
var dirty = (i % 2 == 0) ? uav0 : uav1;
RC.Context.ClearUnorderedAccessView((dirty as IUnorderedAccessBindable).UAV, new SharpDX.Int4(0, 0, 0, 0));
i++;
}
RC.SetCS(m_finalShader);
//mapping = MyMapping.MapDiscard(MyCommon.GetObjectBuffer(16).Buffer);
//mapping.stream.Write(new Vector2I(size.X, size.Y));
//mapping.stream.Write(texelsNum);
//mapping.Unmap();
RC.BindUAV(0, (i % 2 == 0) ? uav1 : uav0);
RC.BindSRV(0, (i % 2 == 0) ? uav0 : uav1, prevLum);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
RC.SetCS(null);
var output = (i % 2 == 0) ? uav1 : uav0;
RC.Context.CopySubresourceRegion(output.m_resource, 0, new ResourceRegion(0, 0, 0, 1, 1, 1), prevLum.m_resource, 0);
return output;
}
internal static MyBindableResource Run(MyBindableResource uav0, MyBindableResource uav1, MyBindableResource src,
MyBindableResource prevLum)
{
Vector3I size = src.GetSize();
int texelsNum = size.X * size.Y;
uint sizeX = (uint)size.X;
uint sizeY = (uint)size.Y;
float adaptationFactor = MyRender11.Postprocess.EnableEyeAdaptation ? -1.0f : MyRender11.Postprocess.ConstantLuminance;
var buffer = MyCommon.GetObjectCB(16);
var mapping = MyMapping.MapDiscard(buffer);
mapping.WriteAndPosition(ref sizeX);
mapping.WriteAndPosition(ref sizeY);
mapping.WriteAndPosition(ref texelsNum);
mapping.WriteAndPosition(ref adaptationFactor);
mapping.Unmap();
RC.CSSetCB(0, MyCommon.FrameConstants);
RC.CSSetCB(1, MyCommon.GetObjectCB(16));
RC.SetCS(m_initialShader);
MyBindableResource output = uav0;
MyBindableResource input = src;
RC.BindUAV(0, output);
RC.BindSRV(0, input);
int threadGroupCountX = ComputeGroupCount(size.X);
int threadGroupCountY = ComputeGroupCount(size.Y);
RC.DeviceContext.Dispatch(threadGroupCountX, threadGroupCountY, 1);
RC.SetCS(m_sumShader);
int i = 0;
while (true)
{
size.X = threadGroupCountX;
size.Y = threadGroupCountY;
if (size.X <= NUM_THREADS && size.Y <= NUM_THREADS)
break;
output = (i % 2 == 0) ? uav1 : uav0;
input = (i % 2 == 0) ? uav0 : uav1;
RC.BindUAV(0, output);
RC.BindSRV(0, input);
threadGroupCountX = ComputeGroupCount(size.X);
threadGroupCountY = ComputeGroupCount(size.Y);
RC.DeviceContext.Dispatch(threadGroupCountX, threadGroupCountY, 1);
i++;
}
RC.SetCS(m_finalShader);
output = (i % 2 == 0) ? uav1 : uav0;
input = (i % 2 == 0) ? uav0 : uav1;
RC.BindUAV(0, output);
RC.BindSRVs(0, input, prevLum);
threadGroupCountX = ComputeGroupCount(size.X);
threadGroupCountY = ComputeGroupCount(size.Y);
RC.DeviceContext.Dispatch(threadGroupCountX, threadGroupCountY, 1);
RC.SetCS(null);
// Backup the result for later process
RC.DeviceContext.CopySubresourceRegion(output.m_resource, 0, new ResourceRegion(0, 0, 0, 1, 1, 1), prevLum.m_resource, 0);
return output;
}
internal static void DrawParticles(MyBindableResource particleRenderTarget, int quadStartX, int quadStartY, int quadSize)
{
RC.DeviceContext.PixelShader.Set(m_blitTextureShader);
RC.BindSRV(0, particleRenderTarget);
RC.SetBS(MyRender11.BlendAlphaPremult);
DrawQuad(quadStartX, quadStartY, quadSize, quadSize * MyRender11.ViewportResolution.Y / MyRender11.ViewportResolution.X);
RC.SetBS(null);
RC.DeviceContext.PixelShader.SetShaderResource(0, null);
}
internal static MyBindableResource Run(MyBindableResource uav0, MyBindableResource uav1, MyBindableResource src,
MyBindableResource prevLum)
{
Vector3I size = src.GetSize();
int texelsNum = size.X * size.Y;
uint sizeX = (uint)size.X;
uint sizeY = (uint)size.Y;
float adaptationFactor = MyRender11.Postprocess.EnableEyeAdaptation ? -1.0f : MyRender11.Postprocess.ConstantLuminance;
var buffer = MyCommon.GetObjectCB(16);
var mapping = MyMapping.MapDiscard(buffer);
mapping.WriteAndPosition(ref sizeX);
mapping.WriteAndPosition(ref sizeY);
mapping.WriteAndPosition(ref texelsNum);
mapping.WriteAndPosition(ref adaptationFactor);
mapping.Unmap();
RC.CSSetCB(0, MyCommon.FrameConstants);
RC.CSSetCB(1, MyCommon.GetObjectCB(16));
RC.SetCS(m_initialShader);
MyBindableResource output = uav0;
MyBindableResource input = src;
RC.BindUAV(0, output);
RC.BindSRV(0, input);
int threadGroupCountX = ComputeGroupCount(size.X);
int threadGroupCountY = ComputeGroupCount(size.Y);
RC.DeviceContext.Dispatch(threadGroupCountX, threadGroupCountY, 1);
RC.SetCS(m_sumShader);
int i = 0;
while (true)
{
size.X = threadGroupCountX;
size.Y = threadGroupCountY;
if (size.X <= NUM_THREADS && size.Y <= NUM_THREADS)
{
break;
}
output = (i % 2 == 0) ? uav1 : uav0;
input = (i % 2 == 0) ? uav0 : uav1;
RC.BindUAV(0, output);
RC.BindSRV(0, input);
threadGroupCountX = ComputeGroupCount(size.X);
threadGroupCountY = ComputeGroupCount(size.Y);
RC.DeviceContext.Dispatch(threadGroupCountX, threadGroupCountY, 1);
i++;
}
RC.SetCS(m_finalShader);
output = (i % 2 == 0) ? uav1 : uav0;
input = (i % 2 == 0) ? uav0 : uav1;
RC.BindUAV(0, output);
RC.BindSRVs(0, input, prevLum);
threadGroupCountX = ComputeGroupCount(size.X);
threadGroupCountY = ComputeGroupCount(size.Y);
RC.DeviceContext.Dispatch(threadGroupCountX, threadGroupCountY, 1);
RC.SetCS(null);
// Backup the result for later process
RC.DeviceContext.CopySubresourceRegion(output.m_resource, 0, new ResourceRegion(0, 0, 0, 1, 1, 1), prevLum.m_resource, 0);
return(output);
}
internal static void Run(MyBindableResource depthRead)
{
// The maximum number of supported GPU particles
SharpDX.Direct3D11.ShaderResourceView textureArraySRV;
int emitterCount = MyGPUEmitters.Gather(m_emitterData, out textureArraySRV);
if (emitterCount == 0)
{
return;
}
// Unbind current targets while we run the compute stages of the system
//RC.DeviceContext.OutputMerger.SetTargets(null);
// global GPU particles setup
RC.SetDS(MyDepthStencilState.DefaultDepthState);
RC.SetRS(MyRender11.m_nocullRasterizerState);
RC.SetIL(null);
RC.CSSetCB(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.DeviceContext.ComputeShader.SetSamplers(0, SamplerStates.StandardSamplers);
RC.DeviceContext.PixelShader.SetSamplers(0, SamplerStates.StandardSamplers);
RC.SetCB(4, MyRender11.DynamicShadows.ShadowCascades.CascadeConstantBuffer);
RC.DeviceContext.VertexShader.SetSampler(MyCommon.SHADOW_SAMPLER_SLOT, SamplerStates.m_shadowmap);
RC.DeviceContext.VertexShader.SetShaderResource(MyCommon.CASCADES_SM_SLOT, MyRender11.DynamicShadows.ShadowCascades.CascadeShadowmapArray.SRV);
RC.DeviceContext.VertexShader.SetSamplers(0, SamplerStates.StandardSamplers);
// If we are resetting the particle system, then initialize the dead list
if (m_resetSystem)
{
ResetInternal();
m_resetSystem = false;
}
MyGpuProfiler.IC_BeginBlock("Emit");
// Emit particles into the system
Emit(emitterCount, m_emitterData);
MyGpuProfiler.IC_EndBlock();
// Run the simulation for this frame
MyGpuProfiler.IC_BeginBlock("Simulate");
Simulate(depthRead);
MyGpuProfiler.IC_EndBlock();
// Copy the atomic counter in the alive list UAV into a constant buffer for access by subsequent passes
RC.DeviceContext.CopyStructureCount(m_activeListConstantBuffer, 0, m_aliveIndexBuffer.m_UAV);
// Only read number of alive and dead particle back to the CPU in debug as we don't want to stall the GPU in release code
#if DEBUG
m_numDeadParticlesAfterSimulation = ReadCounter(m_deadListBuffer);
m_numActiveParticlesAfterSimulation = ReadCounter(m_aliveIndexBuffer);
#endif
MyGpuProfiler.IC_BeginBlock("Render");
Render(textureArraySRV, depthRead);
MyGpuProfiler.IC_EndBlock();
RC.DeviceContext.ComputeShader.SetSamplers(0, SamplerStates.StandardSamplers);
/*Debug.WriteLine(string.Format("dead particles @ start {0} dead after emit {1} dead after sim {2} active after sim {3}",
* m_numDeadParticlesOnInit, m_numDeadParticlesAfterEmit,
* m_numDeadParticlesAfterSimulation, m_numActiveParticlesAfterSimulation));*/
}
// Returns the final image and copies it to renderTarget if non-null
private static MyBindableResource DrawGameScene(MyBindableResource renderTarget)
{
MyGpuProfiler.IC_BeginBlock("Clear & Geometry Render");
PrepareGameScene();
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear");
MyRenderContext.Immediate.Clear();
MyRenderContext.Immediate.DeviceContext.ClearState();
ProfilerShort.End();
}
if (MyStereoRender.Enable && MyStereoRender.EnableUsingStencilMask)
{
ProfilerShort.Begin("MyStereoStencilMask.Draw");
MyGpuProfiler.IC_BeginBlock("MyStereoStencilMask.Draw");
MyStereoStencilMask.Draw();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
}
MyGpuProfiler.IC_BeginBlock("MyGeometryRenderer.Render");
Debug.Assert(m_commandLists.Count == 0, "Not all command lists executed last frame!");
ProfilerShort.Begin("DynamicGeometryRenderer");
DynamicGeometryRenderer.Render(m_commandLists, true);
ProfilerShort.End(); // End function block
if (MyScene.SeparateGeometry)
{
ProfilerShort.Begin("StaticGeometryRenderer");
StaticGeometryRenderer.Render(m_commandLists, false);
ProfilerShort.End(); // End function block
}
SendGlobalOutputMessages();
ExecuteCommandLists(m_commandLists);
MyGpuProfiler.IC_EndBlock();
#if !UNSHARPER_TMP
MyEnvironmentProbe.FinalizeEnvProbes();
#endif
// cleanup context atfer deferred lists
if (MyRender11.DeferredContextsEnabled)
{
ProfilerShort.Begin("Clear2");
MyRenderContext.Immediate.Clear();
ProfilerShort.End();
}
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear3");
MyRenderContext.Immediate.Clear();
MyRenderContext.Immediate.DeviceContext.ClearState();
ProfilerShort.End();
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.Begin("Render decals - Opaque");
MyGpuProfiler.IC_BeginBlock("Render decals - Opaque");
MyRender11.CopyGbufferToScratch();
MyScreenDecals.Draw(false);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Render foliage");
MyGpuProfiler.IC_BeginBlock("Render foliage");
m_foliageRenderer.Render();
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("GBuffer Resolve");
ProfilerShort.BeginNextBlock("MySceneMaterials.MoveToGPU");
MySceneMaterials.MoveToGPU();
int nPasses = MyStereoRender.Enable ? 2 : 1;
for (int i = 0; i < nPasses; i++)
{
if (MyStereoRender.Enable)
{
MyStereoRender.RenderRegion = i == 0 ? MyStereoRegion.LEFT : MyStereoRegion.RIGHT;
}
if (MultisamplingEnabled)
{
MyRender11.DeviceContext.ClearDepthStencilView(MyScreenDependants.m_resolvedDepth.m_DSV, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1, 0);
MyGpuProfiler.IC_BeginBlock("MarkAAEdges");
MyAAEdgeMarking.Run();
MyGpuProfiler.IC_EndBlock();
MyDepthResolve.Run(MyScreenDependants.m_resolvedDepth, MyGBuffer.Main.DepthStencil.Depth);
}
ProfilerShort.BeginNextBlock("Shadows");
MyGpuProfiler.IC_BeginBlock("Shadows");
if (MyScene.SeparateGeometry)
{
MyShadowCascadesPostProcess.Combine(MyShadowCascades.CombineShadowmapArray, DynamicShadows.ShadowCascades, StaticShadows.ShadowCascades);
DynamicShadows.ShadowCascades.PostProcess(MyRender11.PostProcessedShadows, MyShadowCascades.CombineShadowmapArray);
}
else
{
DynamicShadows.ShadowCascades.PostProcess(MyRender11.PostProcessedShadows, DynamicShadows.ShadowCascades.CascadeShadowmapArray);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("SSAO");
MyGpuProfiler.IC_BeginBlock("SSAO");
if (Postprocess.EnableSsao && m_debugOverrides.Postprocessing && m_debugOverrides.SSAO)
{
MySSAO.Run(MyScreenDependants.m_ambientOcclusion, MyGBuffer.Main, MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth.Depth : MyGBuffer.Main.DepthStencil.Depth);
if (MySSAO.UseBlur)
{
MyBlur.Run(MyScreenDependants.m_ambientOcclusion, MyScreenDependants.m_ambientOcclusionHelper, MyScreenDependants.m_ambientOcclusion);
}
}
else
{
MyRender11.DeviceContext.ClearRenderTargetView(MyScreenDependants.m_ambientOcclusion.m_RTV, Color4.White);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Lights");
MyGpuProfiler.IC_BeginBlock("Lights");
if (m_debugOverrides.Lighting)
{
MyLightRendering.Render();
}
MyGpuProfiler.IC_EndBlock();
if (MyRender11.DebugOverrides.Flares)
{
MyLightRendering.DrawFlares();
}
}
MyStereoRender.RenderRegion = MyStereoRegion.FULLSCREEN;
MyGpuProfiler.IC_EndBlock();
// Rendering for VR is solved inside of Transparent rendering
ProfilerShort.BeginNextBlock("Transparent Pass");
MyGpuProfiler.IC_BeginBlock("Transparent Pass");
if (m_debugOverrides.Transparent)
{
MyTransparentRendering.Render(m_transparencyAccum, m_transparencyCoverage);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("PostProcess");
MyGpuProfiler.IC_BeginBlock("PostProcess");
MyGpuProfiler.IC_BeginBlock("Luminance reduction");
MyBindableResource avgLum = null;
if (m_resetEyeAdaptation)
{
MyRenderContext.Immediate.DeviceContext.ClearUnorderedAccessView(m_prevLum.m_UAV, Int4.Zero);
m_resetEyeAdaptation = false;
}
avgLum = MyLuminanceAverage.Run(m_reduce0, m_reduce1, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), m_prevLum);
MyGpuProfiler.IC_EndBlock();
if (MyRender11.Settings.DisplayHdrDebug)
{
var src = MyGBuffer.Main.Get(MyGbufferSlot.LBuffer) as MyRenderTarget;
MyHdrDebugTools.CreateHistogram(src.m_SRV, src.m_resolution, src.m_samples.X);
}
MyGpuProfiler.IC_BeginBlock("Bloom");
MyBindableResource bloom;
if (m_debugOverrides.Postprocessing && m_debugOverrides.Bloom)
{
bloom = MyBloom.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum);
}
else
{
MyRender11.DeviceContext.ClearRenderTargetView(MyRender11.EighthScreenUavHDR.m_RTV, Color4.Black);
bloom = MyRender11.EighthScreenUavHDR;
}
MyGpuProfiler.IC_EndBlock();
MyBindableResource tonemapped;
bool fxaa = MyRender11.FxaaEnabled;
if (fxaa)
{
tonemapped = m_rgba8_linear;
}
else
{
tonemapped = m_uav3;
}
MyGpuProfiler.IC_BeginBlock("Tone mapping");
if (m_debugOverrides.Postprocessing && m_debugOverrides.Tonemapping)
{
MyToneMapping.Run(tonemapped, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum, bloom, Postprocess.EnableTonemapping);
}
else
{
tonemapped = MyGBuffer.Main.Get(MyGbufferSlot.LBuffer);
//MyRender11.DeviceContext.CopyResource(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer).m_resource, tonemapped.m_resource);
}
MyGpuProfiler.IC_EndBlock();
MyBindableResource renderedImage;
if (fxaa)
{
MyGpuProfiler.IC_BeginBlock("FXAA");
MyFXAA.Run(m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm, View = MyViewEnum.RtvView
}), tonemapped);
MyGpuProfiler.IC_EndBlock();
renderedImage = m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView
});
}
else
{
//renderedImage = (tonemapped as MyCustomTexture).GetView(new MyViewKey { Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView });
renderedImage = tonemapped;
}
ProfilerShort.Begin("Outline");
if (MyOutline.AnyOutline())
{
MyOutline.Run();
MyGpuProfiler.IC_BeginBlock("Outline Blending");
ProfilerShort.Begin("Outline Blending");
if (fxaa)
{
MyBlendTargets.RunWithStencil(
m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}),
MyRender11.m_rgba8_1,
MyRender11.BlendAdditive,
MyDepthStencilState.TestOutlineMeshStencil,
0x40);
MyBlendTargets.RunWithStencil(
m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}),
MyRender11.m_rgba8_1,
MyRender11.BlendTransparent,
MyDepthStencilState.TestHighlightMeshStencil,
0x40);
}
else
{
if (MyRender11.MultisamplingEnabled)
{
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_ms, MyRender11.BlendAdditive);
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_ms, MyRender11.BlendTransparent, true);
}
else
{
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendAdditive, MyDepthStencilState.TestOutlineMeshStencil, 0x40);
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendTransparent, MyDepthStencilState.TestHighlightMeshStencil, 0x40);
}
}
ProfilerShort.End();
MyGpuProfiler.IC_EndBlock();
}
ProfilerShort.End();
if (renderTarget != null)
{
MyCopyToRT.Run(renderTarget, renderedImage);
}
if (MyRender11.Settings.DisplayHdrDebug)
{
var target = renderTarget as IRenderTargetBindable;
var lum = avgLum as IShaderResourceBindable;
if (target != null && lum != null)
{
MyHdrDebugTools.DisplayHistogram(target.RTV, lum.SRV);
}
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
return(renderedImage);
}
internal void BindDepthRT(MyBindableResource depthStencil, DepthStencilAccess dsAccess, MyBindableResource bindable0, MyBindableResource bindable1, MyBindableResource bindable2)
{
m_tmpBinds3[0] = bindable0;
m_tmpBinds3[1] = bindable1;
m_tmpBinds3[2] = bindable2;
BindDepthRTInternal(depthStencil, dsAccess, m_tmpBinds3);
Array.Clear(m_tmpBinds3, 0, m_tmpBinds3.Length);
}
internal static MyBindableResource Run(MyBindableResource uav0, MyBindableResource uav1, MyBindableResource src,
MyBindableResource prevLum, MyBindableResource localAvgLum)
{
var size = src.GetSize();
var texelsNum = size.X * size.Y;
var mapping = MyMapping.MapDiscard(MyCommon.GetObjectCB(16));
mapping.stream.Write((uint)size.X);
mapping.stream.Write((uint)size.Y);
mapping.stream.Write(texelsNum);
mapping.stream.Write(MyRender11.Postprocess.EnableEyeAdaptation ? -1.0f : MyRender11.Postprocess.ConstantLuminance);
mapping.Unmap();
RC.CSSetCB(0, MyCommon.FrameConstants);
RC.CSSetCB(1, MyCommon.GetObjectCB(16));
RC.BindUAV(0, uav0);
RC.BindSRV(0, src);
RC.SetCS(m_initialShader);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
RC.SetCS(m_sumShader);
int i = 0;
while (true)
{
size.X = (size.X + m_numthreads - 1) / m_numthreads;
size.Y = (size.Y + m_numthreads - 1) / m_numthreads;
if (size.X <= 8 && size.Y <= 8)
{
break;
}
//mapping = MyMapping.MapDiscard(MyCommon.GetObjectBuffer(16).Buffer);
//mapping.stream.Write(new Vector2I(size.X, size.Y));
//mapping.Unmap();
RC.BindUAV(0, (i % 2 == 0) ? uav1 : uav0);
RC.BindSRV(0, (i % 2 == 0) ? uav0 : uav1);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
//might not be exactly correct if we skip this
var dirty = (i % 2 == 0) ? uav0 : uav1;
RC.Context.ClearUnorderedAccessView((dirty as IUnorderedAccessBindable).UAV, new SharpDX.Int4(0, 0, 0, 0));
i++;
}
RC.SetCS(m_finalShader);
//mapping = MyMapping.MapDiscard(MyCommon.GetObjectBuffer(16).Buffer);
//mapping.stream.Write(new Vector2I(size.X, size.Y));
//mapping.stream.Write(texelsNum);
//mapping.Unmap();
RC.BindUAV(0, (i % 2 == 0) ? uav1 : uav0);
RC.BindSRV(0, (i % 2 == 0) ? uav0 : uav1, prevLum);
RC.Context.Dispatch((size.X + m_numthreads - 1) / m_numthreads, (size.Y + m_numthreads - 1) / m_numthreads, 1);
RC.SetCS(null);
var output = (i % 2 == 0) ? uav1 : uav0;
RC.Context.CopySubresourceRegion(output.m_resource, 0, new ResourceRegion(0, 0, 0, 1, 1, 1), prevLum.m_resource, 0);
return(output);
}
internal unsafe static void Render(MyBindableResource dst, MyBindableResource depth, MyBindableResource depthRead)
{
MyRender11.GetRenderProfiler().StartProfilingBlock("Gather");
Gather();
MyRender11.GetRenderProfiler().EndProfilingBlock();
MyRender11.GetRenderProfiler().StartProfilingBlock("Draw");
TransferData();
RC.SetupScreenViewport();
RC.BindDepthRT(depth, DepthStencilAccess.ReadOnly, dst);
RC.SetBS(MyRender11.BlendAlphaPremult);
RC.SetRS(MyRender11.m_nocullRasterizerState);
RC.BindRawSRV(104, m_SB.Srv);
RC.BindSRV(1, depthRead);
RC.SetCB(2, MyCommon.GetObjectCB(sizeof(Matrix) * MaxCustomProjections));
RC.SetDS(MyDepthStencilState.DefaultDepthState);
RC.SetCB(4, MyShadows.m_csmConstants);
RC.Context.VertexShader.SetSampler(MyCommon.SHADOW_SAMPLER_SLOT, MyRender11.m_shadowmapSamplerState);
RC.Context.VertexShader.SetShaderResource(MyCommon.CASCADES_SM_SLOT, MyShadows.m_cascadeShadowmapArray.ShaderView);
RC.Context.VertexShader.SetSamplers(0, MyRender11.StandardSamplers);
RC.Context.VertexShader.SetShaderResource(MyCommon.SKYBOX_IBL_SLOT, MyTextures.GetView(MyTextures.GetTexture(MyEnvironment.DaySkyboxPrefiltered, MyTextureEnum.CUBEMAP, true)));
RC.Context.PixelShader.SetShaderResource(MyCommon.SKYBOX2_IBL_SLOT, MyTextures.GetView(MyTextures.GetTexture(MyEnvironment.NightSkyboxPrefiltered, MyTextureEnum.CUBEMAP, true)));
RC.SetVB(0, m_VB.Buffer, m_VB.Stride);
RC.SetIB(m_IB.Buffer, m_IB.Format);
RC.SetIL(m_inputLayout);
for(int i=0; i<m_batches.Count; i++)
{
// first part of batches contain sorted billboards and they read depth
// second part of batches contain unsorted billboards and they ignore depth
// switch here:
if (m_batches[i].Offset == m_sortedBillboardsNum)
{
//RC.BindDepthRT(null, DepthStencilAccess.ReadOnly, dst);
}
if(m_batches[i].Lit)
{
RC.SetVS(m_vsLit);
RC.SetPS(m_psLit);
}
else
{
RC.SetVS(m_vs);
RC.SetPS(m_ps);
}
RC.BindRawSRV(0, m_batches[i].Texture);
RC.Context.DrawIndexed(m_batches[i].Num * 6, m_batches[i].Offset * 6, 0);
}
RC.SetRS(null);
m_batches.Clear();
MyRender11.GetRenderProfiler().EndProfilingBlock();
}
private void BindDepthRTInternal(MyBindableResource depthStencil, DepthStencilAccess dsAccess, params MyBindableResource[] RTs)
{
DepthStencilView dsv = null;
if (depthStencil != null)
{
var ds = depthStencil as MyDepthStencil;
Debug.Assert(ds != null);
// check conflicts
if (dsAccess == DepthStencilAccess.ReadWrite)
{
// for both
// check reads
UnbindSRVRead(ds.Depth.GetID());
UnbindSRVRead(ds.Stencil.GetID());
dsv = ds.m_DSV;
}
else if (dsAccess == DepthStencilAccess.DepthReadOnly)
{
// check reads
UnbindSRVRead(ds.Depth.GetID());
dsv = (ds.Depth as IDepthStencilBindable).DSV;
}
else if (dsAccess == DepthStencilAccess.StencilReadOnly)
{
// check reads
UnbindSRVRead(ds.Stencil.GetID());
dsv = (ds.Stencil as IDepthStencilBindable).DSV;
}
else if (dsAccess == DepthStencilAccess.ReadOnly)
{
dsv = ds.m_DSV_ro;
}
}
Array.Clear(State.m_RTVs, 0, State.m_RTVs.Length);
if (RTs != null)
{
for (int i = 0; i < RTs.Length; i++)
{
if (RTs[i] != null)
{
Debug.Assert(RTs[i] as IRenderTargetBindable != null);
UnbindSRVRead(RTs[i].GetID());
State.m_RTVs[i] = (RTs[i] as IRenderTargetBindable).RTV;
}
else
{
State.m_RTVs[i] = null;
}
}
}
DeviceContext.OutputMerger.SetTargets(
dsv,
State.m_RTVs);
ClearDsvRtvWriteBindings();
if (depthStencil != null)
{
var ds = depthStencil as MyDepthStencil;
if (dsAccess == DepthStencilAccess.ReadWrite)
{
var binding = new MyBinding(MyWriteBindingEnum.DSV);
State.m_bindings[ds.Depth.GetID()] = binding;
State.m_slotToBindingKeys.Add(binding.UavSlot, ds.Depth.GetID());
State.m_bindings[ds.Stencil.GetID()] = binding;
State.m_slotToBindingKeys.Add(binding.UavSlot, ds.Stencil.GetID());
}
else if (dsAccess == DepthStencilAccess.DepthReadOnly)
{
var depthBinding = new MyBinding(true);
State.m_bindings[ds.Depth.GetID()] = depthBinding;
State.m_slotToBindingKeys.Add(depthBinding.UavSlot, ds.Depth.GetID());
var stencilBinding = new MyBinding(MyWriteBindingEnum.DSV);
State.m_bindings[ds.Stencil.GetID()] = stencilBinding;
State.m_slotToBindingKeys.Add(stencilBinding.UavSlot, ds.Stencil.GetID());
}
else if (dsAccess == DepthStencilAccess.StencilReadOnly)
{
var depthBinding = new MyBinding(MyWriteBindingEnum.DSV);
State.m_bindings[ds.Depth.GetID()] = depthBinding;
State.m_slotToBindingKeys.Add(depthBinding.UavSlot, ds.Depth.GetID());
var stencilBinding = new MyBinding(true);
State.m_bindings[ds.Stencil.GetID()] = stencilBinding;
State.m_slotToBindingKeys.Add(stencilBinding.UavSlot, ds.Stencil.GetID());
}
else if (dsAccess == DepthStencilAccess.ReadOnly)
{
var binding = new MyBinding(true);
State.m_bindings[ds.Depth.GetID()] = binding;
State.m_bindings[ds.Stencil.GetID()] = binding;
State.m_slotToBindingKeys.Add(binding.UavSlot, ds.Depth.GetID());
State.m_slotToBindingKeys.Add(binding.UavSlot, ds.Stencil.GetID());
}
}
if (RTs != null)
{
for (int i = 0; i < RTs.Length; i++)
{
if (RTs[i] != null)
{
var binding = new MyBinding(MyWriteBindingEnum.RTV);
State.m_bindings[RTs[i].GetID()] = binding;
State.m_slotToBindingKeys.Add(binding.UavSlot, RTs[i].GetID());
}
}
}
}
internal static void Run(MyBindableResource destinationResource, MyBindableResource intermediateResource, MyBindableResource resourceToBlur)
{
var initialResourceView = resourceToBlur as IShaderResourceBindable;
var intermediateResourceView = intermediateResource as IShaderResourceBindable;
var intermediateTarget = intermediateResource as IRenderTargetBindable;
var destinationTarget = destinationResource as IRenderTargetBindable;
Run(destinationTarget.RTV, intermediateTarget.RTV, intermediateResourceView.SRV, initialResourceView.SRV);
}
private unsafe static byte[] GetScreenData(Vector2I resolution, byte[] screenData = null)
{
const uint headerPadding = 256; // Need to allocate some space for the bitmap headers
const uint bytesPerPixel = 4;
uint imageSizeInBytes = (uint)(resolution.Size() * bytesPerPixel);
uint dataSizeInBytes = imageSizeInBytes + headerPadding;
byte[] returnData = null;
if (screenData == null)
{
screenData = new byte[imageSizeInBytes];
}
else if (screenData.Length != imageSizeInBytes)
{
Debug.Fail("Preallocated buffer for GetScreenData incorrect size: " + imageSizeInBytes.ToString() + " expected, " + screenData.Length + " received");
return(returnData);
}
MyBindableResource imageSource = Backbuffer;
MyBindableResource imageSourceResourceView = null;
if (imageSource != null && (resolution.X != imageSource.GetSize().X || resolution.Y != imageSource.GetSize().Y))
{
MyViewKey viewKey = new MyViewKey {
View = MyViewEnum.SrvView, Fmt = MyRender11Constants.DX11_BACKBUFFER_FORMAT
};
if (m_backbufferCopyResource == null)
{
m_backbufferCopyResource = new MyCustomTexture(m_resolution.X, m_resolution.Y, BindFlags.ShaderResource, MyRender11Constants.DX11_BACKBUFFER_FORMAT);
m_backbufferCopyResource.AddView(viewKey);
}
MyRenderContext.Immediate.DeviceContext.CopyResource(imageSource.m_resource, m_backbufferCopyResource.m_resource);
imageSource = m_backbufferCopyResource;
imageSourceResourceView = m_backbufferCopyResource.GetView(viewKey);
}
if (imageSource == null)
{
return(returnData);
}
if (imageSizeInBytes > int.MaxValue)
{
Debug.Fail("Image size too large to read!");
return(returnData);
}
MyBindableResource imageResource = imageSource;
bool shouldResize = imageSourceResourceView != null;
if (shouldResize)
{
imageResource = m_lastScreenDataResource;
if (imageResource == null || (imageResource.GetSize().X != resolution.X || imageResource.GetSize().Y != resolution.Y))
{
if (m_lastScreenDataResource != null && (m_lastScreenDataResource != m_backbufferCopyResource && m_lastScreenDataResource != Backbuffer))
{
m_lastScreenDataResource.Release();
}
m_lastScreenDataResource = null;
imageResource = new MyRenderTarget(resolution.X, resolution.Y, MyRender11Constants.DX11_BACKBUFFER_FORMAT, 1, 0);
}
var RC = MyRenderContext.Immediate;
var deviceContext = RC.DeviceContext;
deviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
deviceContext.Rasterizer.SetViewport(0, 0, resolution.X, resolution.Y);
deviceContext.PixelShader.Set(MyDebugRenderer.BlitTextureShader);
deviceContext.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, imageResource);
RC.BindSRV(0, imageSourceResourceView);
MyDebugRenderer.DrawQuad(0, 0, resolution.X, resolution.Y, MyScreenPass.QuadVS);
//MyCopyToRT.Run(imageResource, imageSourceResourceView, new MyViewport(resolution));
}
m_lastScreenDataResource = imageResource;
Stream dataStream = m_lastDataStream;
if (m_lastDataStream == null || m_lastDataStream.Length != dataSizeInBytes)
{
if (m_lastDataStream != null)
{
m_lastDataStream.Dispose();
m_lastDataStream = null;
}
dataStream = new DataStream((int)dataSizeInBytes, true, true);
dataStream.Seek(0, SeekOrigin.Begin);
}
m_lastDataStream = dataStream;
Resource.ToStream(MyRenderContext.Immediate.DeviceContext, imageResource.m_resource, ImageFileFormat.Bmp, dataStream);
if (!(dataStream.CanRead && dataStream.CanSeek))
{
Debug.Fail("Screen data stream does not support the necessary operations to get the data");
return(returnData);
}
fixed(byte *dataPointer = screenData)
{
GetBmpDataFromStream(dataStream, dataPointer, imageSizeInBytes);
}
returnData = screenData;
if (m_lastDataStream != null)
{
m_lastDataStream.Seek(0, SeekOrigin.Begin);
}
return(returnData);
}
internal static unsafe void Draw(MyBindableResource renderTarget, MyBindableResource depth)
{
RC.SetupScreenViewport();
RC.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.LineList;
RC.SetIL(m_inputLayout);
RC.SetRS(MyRender11.m_linesRasterizerState);
RC.SetVS(m_vs);
RC.SetPS(m_ps);
RC.SetDS(MyDepthStencilState.DefaultDepthState);
CheckBufferSize(m_vertices.Count);
RC.SetVB(0, m_VB.Buffer, m_VB.Stride);
RC.BindDepthRT(depth, DepthStencilAccess.ReadOnly, renderTarget);
RC.SetCB(MyCommon.PROJECTION_SLOT, MyCommon.ProjectionConstants);
if (m_batches.Count > 0)
{
var mapping = MyMapping.MapDiscard(m_VB.Buffer);
mapping.WriteAndPosition(m_vertices.GetInternalArray(), 0, m_vertices.Count);
mapping.Unmap();
Matrix prevMatrix = Matrix.Zero;
foreach (var batch in m_batches)
{
Matrix matrix;
if (batch.CustomViewProjection.HasValue)
{
matrix = batch.CustomViewProjection.Value;
}
else
{
matrix = MyEnvironment.ViewProjectionAt0;
}
if (prevMatrix != matrix)
{
prevMatrix = matrix;
var transpose = Matrix.Transpose(matrix);
mapping = MyMapping.MapDiscard(MyCommon.ProjectionConstants);
mapping.WriteAndPosition(ref transpose);
mapping.Unmap();
}
if (batch.IgnoreDepth)
{
RC.SetDS(MyDepthStencilState.IgnoreDepthStencil);
}
else
{
RC.SetDS(MyDepthStencilState.DefaultDepthState);
}
RC.DeviceContext.Draw(batch.VertexCount, batch.StartVertex);
}
}
RC.SetDS(null);
RC.SetRS(null);
m_vertices.Clear();
foreach (var batch in m_batches)
{
m_batchesPool.Deallocate(batch);
}
m_batches.Clear();
}
internal void BindDepthRT(MyBindableResource depthStencil, DepthStencilAccess dsAccess, MyBindableResource RT)
{
m_tmpBinds1[0] = RT;
BindDepthRTInternal(depthStencil, dsAccess, m_tmpBinds1);
Array.Clear(m_tmpBinds1, 0, m_tmpBinds1.Length);
}
internal static void Draw(MyBindableResource renderTarget)
{
var context = RC.DeviceContext;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.Rasterizer.SetViewport(0, 0, MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y);
context.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, renderTarget);
RC.BindGBufferForRead(0, MyGBuffer.Main);
//context.OutputMerger.SetTargets(null as DepthStencilView, MyRender.Backbuffer.RenderTarget);
//context.PixelShader.SetShaderResources(0, MyRender.MainGbuffer.DepthGbufferViews);
context.OutputMerger.BlendState = null;
RC.SetVS(null);
RC.DeviceContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding());
RC.DeviceContext.InputAssembler.InputLayout = null;
if (MyRender11.Settings.DisplayGbufferColor)
{
context.PixelShader.Set(m_baseColorShader);
MyScreenPass.DrawFullscreenQuad();
}
if (MyRender11.Settings.DisplayGbufferColorLinear)
{
context.PixelShader.Set(m_baseColorLinearShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferNormal)
{
context.PixelShader.Set(m_normalShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferGlossiness)
{
context.PixelShader.Set(m_glossinessShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferMetalness)
{
context.PixelShader.Set(m_metalnessShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferMaterialID)
{
context.PixelShader.Set(m_matIDShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferAO)
{
context.PixelShader.Set(m_aoShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayEmissive)
{
context.PixelShader.Set(m_emissiveShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayAmbientDiffuse)
{
context.PixelShader.Set(m_ambientDiffuseShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayAmbientSpecular)
{
context.PixelShader.Set(m_ambientSpecularShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayEdgeMask)
{
context.PixelShader.Set(m_edgeDebugShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayShadowsWithDebug)
{
context.PixelShader.Set(m_shadowsDebugShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayNDotL)
{
context.PixelShader.Set(m_NDotLShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayStencil)
{
context.PixelShader.SetShaderResource(4, MyGBuffer.Main.DepthStencil.m_SRV_stencil);
context.PixelShader.Set(m_stencilShader);
MyScreenPass.DrawFullscreenQuad();
}
//DrawEnvProbe();
//DrawAtmosphereTransmittance(MyAtmosphereRenderer.AtmosphereLUT.Keys.ToArray()[0]);
//DrawAtmosphereInscatter(MyAtmosphereRenderer.AtmosphereLUT.Keys.ToArray()[0]);
if (MyRender11.Settings.DrawCascadeTextures)
{
DrawCascades(MyRender11.DynamicShadows.ShadowCascades, 100, 100, 200);
if (MyScene.SeparateGeometry)
{
DrawCascades(MyRender11.StaticShadows.ShadowCascades, 100, 300, 200);
DrawCombinedCascades(100, 500, 200);
}
}
if (MyRender11.Settings.DisplayIDs || MyRender11.Settings.DisplayAabbs)
{
DrawHierarchyDebug();
}
if (false)
{
var batch = MyLinesRenderer.CreateBatch();
foreach (var light in MyLightRendering.VisiblePointlights)
{
batch.AddSphereRing(new BoundingSphere(light.Position, 0.5f), Color.White, Matrix.Identity);
}
batch.Commit();
}
// draw terrain lods
if (MyRender11.Settings.DebugRenderClipmapCells)
{
//var batch = MyLinesRenderer.CreateBatch();
//foreach (var renderable in MyComponentFactory<MyRenderableComponent>.GetAll().Where(x => (MyMeshes.IsVoxelMesh(x.Mesh))))
//{
// if (renderable.IsVisible)
// {
// if (renderable.m_lod >= LOD_COLORS.Length)
// return;
// BoundingBox bb = new BoundingBox(renderable.m_owner.Aabb.Min - MyEnvironment.CameraPosition,renderable.m_owner.Aabb.Max - MyEnvironment.CameraPosition);
// batch.AddBoundingBox(bb, new Color(LOD_COLORS[renderable.m_voxelLod]));
// if (renderable.m_lods != null && renderable.m_voxelLod != renderable.m_lods[0].RenderableProxies[0].ObjectData.CustomAlpha)
// {
// }
// }
//}
//batch.Commit();
MyClipmap.DebugDrawClipmaps();
}
if (MyRender11.Settings.EnableVoxelMerging && MyRender11.Settings.DebugRenderMergedCells)
{
MyClipmap.DebugDrawMergedCells();
}
//if(true)
//{
// var batch = MyLinesRenderer.CreateBatch();
// foreach(var id in MyLights.DirtySpotlights)
// {
// var info = MyLights.Spotlights[id.Index];
// if(info.ApertureCos > 0)
// {
// var D = info.Direction * info.Range;
// //batch.AddCone(MyLights.Lights.Data[id.Index].Position + D, -D, info.Up.Cross(info.Direction) * info.BaseRatio * info.Range, 32, Color.OrangeRed);
// //var bb = MyLights.AabbFromCone(info.Direction, info.ApertureCos, info.Range).Transform(Matrix.CreateLookAt(MyLights.Lights.Data[id.Index].Position, info.Direction, info.Up));
// //batch.AddBoundingBox(bb, Color.Green);
// batch.AddCone(MyLights.Lights.Data[id.Index].Position + D, -D, info.Up.Cross(info.Direction) * info.BaseRatio * info.Range, 32, Color.OrangeRed);
// var bb = MyLights.AabbFromCone(info.Direction, info.ApertureCos, info.Range, MyLights.Lights.Data[id.Index].Position, info.Up);
// batch.AddBoundingBox(bb, Color.Green);
// }
// }
// batch.Commit();
//}
// draw lods
if (false)
{
var batch = MyLinesRenderer.CreateBatch();
//foreach (var renderable in MyComponentFactory<MyRenderableComponent>.GetAll().Where(x => ((x.GetMesh() as MyVoxelMesh) == null)))
//{
// if (renderable.CurrentLodNum >= LOD_COLORS.Length || renderable.m_lods.Length == 1)
// continue;
// batch.AddBoundingBox(renderable.m_owner.Aabb, new Color(LOD_COLORS[renderable.CurrentLodNum]));
//}
batch.Commit();
}
}
internal unsafe static void Render(MyBindableResource depthRead)
{
if (!MyRender11.DebugOverrides.BillboardsDynamic && !MyRender11.DebugOverrides.BillboardsStatic)
{
return;
}
m_stats.Clear();
MyRender11.GetRenderProfiler().StartProfilingBlock("Gather");
Gather();
MyRender11.GetRenderProfiler().EndProfilingBlock();
if (m_batches.Count == 0)
{
return;
}
MyRender11.GetRenderProfiler().StartProfilingBlock("Draw");
TransferDataCustomProjections();
TransferDataBillboards(BillboardCountSafe, ref m_arrayDataBillboards);
RC.BindSRV(1, depthRead);
BindResourcesCommon();
for (int i = 0; i < m_batches.Count; i++)
{
// first part of batches contain sorted billboards and they read depth
// second part of batches contain unsorted billboards and they ignore depth
// switch here:
if (m_batches[i].Offset == m_sortedCount)
{
//RC.BindDepthRT(null, DepthStencilAccess.ReadOnly, dst);
}
if (m_batches[i].Lit)
{
RC.SetVS(m_vsLit);
if (m_batches[i].AlphaCutout)
{
RC.SetPS(MyRender11.DebugOverrides.OIT ? m_psAlphaCutoutAndLitOIT : m_psAlphaCutoutAndLit);
}
else
{
RC.SetPS(MyRender11.DebugOverrides.OIT ? m_psLitOIT : m_psLit);
}
}
else if (m_batches[i].AlphaCutout)
{
RC.SetVS(m_vs);
RC.SetPS(MyRender11.DebugOverrides.OIT ? m_psAlphaCutoutOIT : m_psAlphaCutout);
}
else
{
RC.SetVS(m_vs);
RC.SetPS(MyRender11.DebugOverrides.OIT ? m_psOIT : m_ps);
}
RC.BindRawSRV(0, m_batches[i].Texture);
if (!MyStereoRender.Enable)
{
RC.DeviceContext.DrawIndexed(m_batches[i].Num * 6, m_batches[i].Offset * 6, 0);
}
else
{
MyStereoRender.DrawIndexedBillboards(RC, m_batches[i].Num * 6, m_batches[i].Offset * 6, 0);
}
++RC.Stats.BillboardDrawIndexed;
}
m_stats.Billboards += BillboardCountSafe;
RC.SetRS(null);
MyRender11.GatherStats(m_stats);
MyRender11.GetRenderProfiler().EndProfilingBlock();
}