internal void Resize(int width, int height, int samplesNum, int samplesQuality)
{
Release();
m_samplesCount = samplesNum;
m_samplesQuality = samplesQuality;
MyDepthStencilManager dsManager = MyManagers.DepthStencils;
m_depthStencil = dsManager.CreateDepthStencil("MyGBuffer.DepthStencil", width, height, samplesCount: samplesNum, samplesQuality: samplesQuality);
if (MyRender11.MultisamplingEnabled)
{
m_resolvedDepthStencil = dsManager.CreateDepthStencil("MyGBuffer.ResolvedDepth", width, height);
}
MyRwTextureManager rwManager = MyManagers.RwTextures;
m_gbuffer0 = rwManager.CreateRtv("MyGBuffer.GBuffer0", width, height, Format.R8G8B8A8_UNorm_SRgb,
samplesNum, samplesQuality);
m_gbuffer1 = rwManager.CreateRtv("MyGBuffer.GBuffer1", width, height, Format.R10G10B10A2_UNorm,
samplesNum, samplesQuality);
m_gbuffer2 = rwManager.CreateRtv("MyGBuffer.GBuffer2", width, height, Format.R8G8B8A8_UNorm,
samplesNum, samplesQuality);
m_lbuffer = rwManager.CreateRtv("MyGBuffer.LBuffer", width, height, LBufferFormat,
samplesNum, samplesQuality);
}
/// <param name="visibleRenderIDs">Optional list of visible render object IDs</param>
internal static void Draw(IRtvTexture gbuffer1Copy, bool transparent, HashSet <uint> visibleRenderIDs = null, float squaredDistanceMax = VISIBLE_DECALS_SQ_TH)
{
if (m_decals.Count == 0)
{
return;
}
uint sinceStartTs = GetTimeStampSinceStart();
MyDecalFlags targetFlag = transparent ? MyDecalFlags.Transparent : MyDecalFlags.None;
bool visibleDecals;
if (visibleRenderIDs == null || visibleRenderIDs.Count > m_decals.Count)
{
visibleDecals = IterateDecals(visibleRenderIDs, targetFlag, squaredDistanceMax, sinceStartTs);
}
else
{
visibleDecals = IterateVisibleRenderIDs(visibleRenderIDs, targetFlag, squaredDistanceMax, sinceStartTs);
}
if (!visibleDecals)
{
return;
}
DrawInternal(gbuffer1Copy, transparent, sinceStartTs);
}
public void Create()
{
int width = MyRender11.ResolutionI.X;
int height = MyRender11.ResolutionI.Y;
int samples = MyRender11.RenderSettings.AntialiasingMode.SamplesCount();
Gbuffer1Copy = MyManagers.RwTextures.CreateRtv("MyRender11.Gbuffer1Copy", width, height, Format.R10G10B10A2_UNorm, samples);
}
public void Create()
{
int width = MyRender11.ResolutionI.X;
int height = MyRender11.ResolutionI.Y;
int samples = MyRender11.RenderSettings.AntialiasingMode.SamplesCount();
Gbuffer1Copy = MyManagers.RwTextures.CreateRtv("MyRender11.Gbuffer1Copy", width, height, Format.R10G10B10A2_UNorm, samples);
}
unsafe static void DrawInternal(IRtvTexture gbuffer1Copy, bool transparent, uint sinceStartTs)
{
var RC = MyImmediateRC.RC;
int nPasses = MyStereoRender.Enable ? 2 : 1;
for (int i = 0; i < nPasses; i++)
{
if (!MyStereoRender.Enable)
{
RC.AllShaderStages.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.SetViewport(0, 0, MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y);
}
else
{
MyStereoRender.RenderRegion = i == 0 ? MyStereoRegion.LEFT : MyStereoRegion.RIGHT;
MyStereoRender.BindRawCB_FrameConstants(RC);
MyStereoRender.SetViewport(RC);
}
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
RC.SetIndexBuffer(m_IB);
RC.SetInputLayout(null);
RC.VertexShader.Set(m_vs);
RC.SetDepthStencilState(MyDepthStencilStateManager.DepthTestReadOnly);
RC.PixelShader.SetSamplers(0, MySamplerStateManager.StandardSamplers);
var decalCb = MyCommon.GetObjectCB(sizeof(MyDecalConstants) * DECAL_BATCH_SIZE);
RC.AllShaderStages.SetConstantBuffer(2, decalCb);
foreach (var pair in m_materialsToDraw)
{
PrepareMaterialBatches(RC, pair.Value, sinceStartTs);
DrawBatches(RC, gbuffer1Copy, pair.Key.Material, pair.Key.Index, transparent);
m_jobs.Clear();
}
}
// Clear materials to draw outside eye rendering passes
foreach (var pair in m_materialsToDraw)
{
pair.Value.Clear();
}
RC.SetBlendState(null);
RC.PixelShader.SetSrv(0, null);
if (MyStereoRender.Enable)
{
RC.AllShaderStages.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.SetViewport(0, 0, MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y);
MyStereoRender.RenderRegion = MyStereoRegion.FULLSCREEN;
}
}
void DisposeTexture(MyBorrowedRtvTexture rtv)
{
IRtvTexture rtvTexture = rtv.RtvTexture;
MyManagers.RwTextures.DisposeTex(ref rtvTexture);
MyBorrowedTextureKey key = rtv.Key;
m_dictionaryRtvTextures[key].Remove(rtv);
m_objectPoolRtv.Deallocate(rtv);
}
public void DrawCoverage(IRtvTexture outTex, IDepthStencil depthStencil)
{
MyRenderContext RC = MyRender11.RC;
RC.SetBlendState(null);
RC.SetRtv(outTex);
RC.PixelShader.Set(m_psDrawCoverage);
RC.PixelShader.SetSrv(1, depthStencil.SrvStencil);
MyScreenPass.DrawFullscreenQuad();
RC.ResetTargets();
}
public static void Deselect()
{
m_selRtvTexture = null;
m_selUavTexture = null;
if (m_selBorrowedRtvTexture != null)
{
m_selBorrowedRtvTexture.Release();
m_selBorrowedRtvTexture = null;
}
if (m_selBorrowedUavTexture != null)
{
m_selBorrowedUavTexture.Release();
m_selBorrowedUavTexture = null;
}
}
public static void Deselect()
{
m_selRtvTexture = null;
m_selUavTexture = null;
if (m_selBorrowedRtvTexture != null)
{
m_selBorrowedRtvTexture.Release();
m_selBorrowedRtvTexture = null;
}
if (m_selBorrowedUavTexture != null)
{
m_selBorrowedUavTexture.Release();
m_selBorrowedUavTexture = null;
}
}
private static void RenderPointlightsTiled(IRtvTexture ambientOcclusion)
{
RC.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.PixelShader.SetSrv(MyCommon.TILE_LIGHT_INDICES_SLOT, m_tileIndices);
RC.AllShaderStages.SetSrv(MyCommon.POINTLIGHT_SLOT, m_pointlightCullHwBuffer);
RC.PixelShader.SetSrv(MyCommon.AO_SLOT, ambientOcclusion);
RC.PixelShader.Set(m_pointlightsTiledPixel);
MyScreenPass.RunFullscreenPixelFreq(MyGBuffer.Main.LBuffer);
if (MyRender11.MultisamplingEnabled)
{
RC.PixelShader.Set(m_pointlightsTiledSample);
MyScreenPass.RunFullscreenSampleFreq(MyGBuffer.Main.LBuffer);
}
}
public void DisposeTex(ref IRtvTexture texture)
{
if (texture == null)
{
return;
}
MyRtvTexture textureInternal = (MyRtvTexture)texture;
if (m_isDeviceInit)
{
textureInternal.OnDeviceEnd();
}
m_rtvTextures.Deallocate(textureInternal);
texture = null;
}
public void Draw(IRtvTexture outTex, IDepthStencil stencil, ICascadeShadowMap csm, ref MyShadowsSettings settings)
{
MyRenderContext RC = MyRender11.RC;
RC.SetBlendState(null);
RC.SetRtv(outTex);
RC.PixelShader.Set(m_ps);
RC.PixelShader.SetSrv(0, stencil.SrvDepth);
RC.PixelShader.SetSrv(1, stencil.SrvStencil);
RC.PixelShader.SetSrv(2, csm.DepthArrayTexture);
RC.PixelShader.SetSrv(3, MyGBuffer.Main.GBuffer1);
RC.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.PixelShader.SetConstantBuffer(1, GetShadowConstants(csm, ref settings));
RC.PixelShader.SetSampler(6, MySamplerStateManager.Shadowmap);
MyScreenPass.DrawFullscreenQuad();
RC.ResetTargets();
}
internal static void Resize(int width, int height, int samplesNum, int samplesQuality)
{
MyDepthStencilManager dsManager = MyManagers.DepthStencils;
dsManager.DisposeTex(ref m_resolvedDepth);
m_resolvedDepth = dsManager.CreateDepthStencil("MyScreenDependants.ResolvedDepth", width, height);
MyRwTextureManager texManager = MyManagers.RwTextures;
texManager.DisposeTex(ref m_ambientOcclusionHelper);
m_ambientOcclusionHelper = texManager.CreateRtv("MyScreenDependants.AmbientOcclusionHelper", width, height, Format.R8_UNorm, 1, 0);
texManager.DisposeTex(ref m_ambientOcclusion);
m_ambientOcclusion = texManager.CreateRtv("MyScreenDependants.AmbientOcclusion", width, height, Format.R8_UNorm, 1, 0);
TilesX = (width + MyLightRendering.TILE_SIZE - 1) / MyLightRendering.TILE_SIZE;
TilesY = ((height + MyLightRendering.TILE_SIZE - 1) / MyLightRendering.TILE_SIZE);
TilesNum = TilesX * TilesY;
if (m_tileIndices != null)
m_tileIndices.Release();
m_tileIndices = new MyRWStructuredBuffer(TilesNum + TilesNum * MyRender11Constants.MAX_POINT_LIGHTS, sizeof(uint), MyRWStructuredBuffer.UavType.Default, true, "MyScreenDependants::tileIndices");
}
public void Draw(IRtvTexture outTex, IDepthStencil stencil, ICascadeShadowMap csm, ref MyShadowsSettings settings)
{
MyRenderContext RC = MyRender11.RC;
RC.SetBlendState(null);
RC.SetRtv(outTex);
RC.PixelShader.Set(m_ps);
RC.PixelShader.SetSrv(0, stencil.SrvDepth);
RC.PixelShader.SetSrv(1, stencil.SrvStencil);
RC.PixelShader.SetSrv(2, csm.DepthArrayTexture);
RC.PixelShader.SetSrv(3, MyGBuffer.Main.GBuffer1);
RC.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.PixelShader.SetConstantBuffer(1, GetShadowConstants(csm, ref settings));
RC.PixelShader.SetSampler(6, MySamplerStateManager.Shadowmap);
MyScreenPass.DrawFullscreenQuad();
RC.ResetTargets();
}
internal void Resize(int width, int height, int samplesNum, int samplesQuality)
{
Release();
m_samplesCount = samplesNum;
m_samplesQuality = samplesQuality;
MyDepthStencilManager dsManager = MyManagers.DepthStencils;
m_depthStencil = dsManager.CreateDepthStencil("MyGBuffer.DepthStencil", width, height, samplesCount: samplesNum, samplesQuality: samplesQuality);
MyRwTextureManager rwManager = MyManagers.RwTextures;
m_gbuffer0 = rwManager.CreateRtv("MyGBuffer.GBuffer0", width, height, Format.R8G8B8A8_UNorm_SRgb,
samplesNum, samplesQuality);
m_gbuffer1 = rwManager.CreateRtv("MyGBuffer.GBuffer1", width, height, Format.R10G10B10A2_UNorm,
samplesNum, samplesQuality);
m_gbuffer2 = rwManager.CreateRtv("MyGBuffer.GBuffer2", width, height, Format.R8G8B8A8_UNorm,
samplesNum, samplesQuality);
m_lbuffer = rwManager.CreateRtv("MyGBuffer.LBuffer", width, height, LBufferFormat,
samplesNum, samplesQuality);
}
internal static void InitScreenResources()
{
MyRwTextureManager rwManager = MyManagers.RwTextures;
m_fullResViewDepthTarget = rwManager.CreateRtv("MyHBAO.FullResViewDepthTarget", MyRender11.m_resolution.X, MyRender11.m_resolution.Y,
SharpDX.DXGI.Format.R32_Float, 1, 0);
m_fullResNormalTexture = rwManager.CreateRtv("MyHBAO.FullResNormalTexture", MyRender11.m_resolution.X, MyRender11.m_resolution.Y,
SharpDX.DXGI.Format.R8G8B8A8_UNorm, 1, 0);
m_fullResAOZTexture = rwManager.CreateRtv("MyHBAO.FullResAOZTexture", MyRender11.m_resolution.X, MyRender11.m_resolution.Y,
SharpDX.DXGI.Format.R16G16_Float, 1, 0);
m_fullResAOZTexture2 = rwManager.CreateRtv("MyHBAO.FullResAOZTexture2", MyRender11.m_resolution.X, MyRender11.m_resolution.Y,
SharpDX.DXGI.Format.R16G16_Float, 1, 0);
MyArrayTextureManager arrayManager = MyManagers.ArrayTextures;
m_quarterResViewDepthTextureArray = arrayManager.CreateRtvArray("MyHBAO.QuarterResViewDepthTextureArray",
DivUp(MyRender11.m_resolution.X, 4), DivUp(MyRender11.m_resolution.Y, 4), NUM_SLICES, SharpDX.DXGI.Format.R16_Float);
m_quarterResAOTextureArray = arrayManager.CreateRtvArray("MyHBAO.QuarterResAOTextureArray",
DivUp(MyRender11.m_resolution.X, 4), DivUp(MyRender11.m_resolution.Y, 4), NUM_SLICES, SharpDX.DXGI.Format.R8_UNorm);
}
public void ApplyPostprocess(MyPostprocessShadows.Type type, IRtvTexture outTex, IDepthStencil stencil, ICascadeShadowMap csm,
ref MyShadowsSettings settings)
{
MyPostprocessShadows postprocess = null;
switch (type)
{
case MyPostprocessShadows.Type.HARD:
postprocess = m_postprocessHardShadows;
break;
case MyPostprocessShadows.Type.SIMPLE:
postprocess = m_postprocessSimpleShadows;
break;
default:
MyRenderProxy.Assert(false);
break;
}
postprocess.Draw(outTex, stencil, csm, ref settings);
}
internal static void Run(IRtvTexture dst, MyGBuffer gbuffer, ISrvBindable resolvedDepth, MyViewport?viewport = null)
{
CompilePS();
if (!viewport.HasValue)
{
viewport = new MyViewport(0, 0, MyRender11.m_resolution.X, MyRender11.m_resolution.Y);
}
var data = InitConstantBuffer(viewport.Value);
var mapping = MyMapping.MapDiscard(m_dataCB);
mapping.WriteAndPosition(ref data);
mapping.Unmap();
RC.PixelShader.SetConstantBuffer(0, m_dataCB);
RC.PixelShader.SetSamplers(0, MySamplerStateManager.PointHBAOClamp);
RC.SetBlendState(null);
DrawLinearDepthPS(resolvedDepth, m_fullResViewDepthTarget, viewport.Value);
DrawDeinterleavedDepth(viewport.Value);
DrawCoarseAO(gbuffer, viewport.Value);
if (Params.BlurEnable)
{
Resolve(true, m_fullResAOZTexture2, viewport.Value);
DrawBlurXPS(viewport.Value);
DrawBlurYPS(dst, viewport.Value);
}
else
{
Resolve(false, dst, viewport.Value);
}
RC.SetRtv(null);
}
internal static void Resize(int width, int height, int samplesNum, int samplesQuality)
{
MyDepthStencilManager dsManager = MyManagers.DepthStencils;
dsManager.DisposeTex(ref m_resolvedDepth);
m_resolvedDepth = dsManager.CreateDepthStencil("MyScreenDependants.ResolvedDepth", width, height);
MyRwTextureManager texManager = MyManagers.RwTextures;
texManager.DisposeTex(ref m_ambientOcclusionHelper);
m_ambientOcclusionHelper = texManager.CreateRtv("MyScreenDependants.AmbientOcclusionHelper", width, height, Format.R8_UNorm, 1, 0);
texManager.DisposeTex(ref m_ambientOcclusion);
m_ambientOcclusion = texManager.CreateRtv("MyScreenDependants.AmbientOcclusion", width, height, Format.R8_UNorm, 1, 0);
TilesX = (width + MyLightRendering.TILE_SIZE - 1) / MyLightRendering.TILE_SIZE;
TilesY = ((height + MyLightRendering.TILE_SIZE - 1) / MyLightRendering.TILE_SIZE);
TilesNum = TilesX * TilesY;
if (m_tileIndices != null)
{
m_tileIndices.Release();
}
m_tileIndices = new MyRWStructuredBuffer(TilesNum + TilesNum * MyRender11Constants.MAX_POINT_LIGHTS, sizeof(uint), MyRWStructuredBuffer.UavType.Default, true, "MyScreenDependants::tileIndices");
}
public void DisposeTex(ref IRtvTexture texture)
{
if (texture == null)
return;
MyRtvTexture textureInternal = (MyRtvTexture) texture;
if (m_isDeviceInit)
textureInternal.OnDeviceEnd();
m_rtvTextures.Deallocate(textureInternal);
texture = null;
}
public void DrawCoverage(IRtvTexture outTex, IDepthStencil depthStencil)
{
MyRenderContext RC = MyRender11.RC;
RC.SetBlendState(null);
RC.SetRtv(outTex);
RC.PixelShader.Set(m_psDrawCoverage);
RC.PixelShader.SetSrv(1, depthStencil.SrvStencil);
MyScreenPass.DrawFullscreenQuad();
RC.ResetTargets();
}
static void RenderPointlightsTiled(IRtvTexture ambientOcclusion)
{
RC.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.PixelShader.SetSrv(MyCommon.TILE_LIGHT_INDICES_SLOT, MyScreenDependants.TileIndices);
RC.AllShaderStages.SetSrv(MyCommon.POINTLIGHT_SLOT, m_pointlightCullHwBuffer);
RC.PixelShader.SetSrv(MyCommon.AO_SLOT, ambientOcclusion);
RC.PixelShader.Set(PointlightsTiled_Pixel);
MyScreenPass.RunFullscreenPixelFreq(MyGBuffer.Main.LBuffer);
if (MyRender11.MultisamplingEnabled)
{
RC.PixelShader.Set(PointlightsTiled_Sample);
MyScreenPass.RunFullscreenSampleFreq(MyGBuffer.Main.LBuffer);
}
}
public void DrawCoverage(IRtvTexture outTex, IDepthStencil depthStencil)
{
m_markCascades.DrawCoverage(outTex, depthStencil);
}
public void ApplyPostprocess(MyPostprocessShadows.Type type, IRtvTexture outTex, IDepthStencil stencil, ICascadeShadowMap csm,
ref MyShadowsSettings settings)
{
MyPostprocessShadows postprocess = null;
switch (type)
{
case MyPostprocessShadows.Type.HARD:
postprocess = m_postprocessHardShadows;
break;
case MyPostprocessShadows.Type.SIMPLE:
postprocess = m_postprocessSimpleShadows;
break;
default:
MyRenderProxy.Assert(false);
break;
}
postprocess.Draw(outTex, stencil, csm, ref settings);
}
internal static void Run(IRtvTexture dst, MyGBuffer gbuffer, MyViewport? viewport = null)
{
CompilePS();
if (!viewport.HasValue)
{
viewport = new MyViewport(0, 0, MyRender11.m_resolution.X, MyRender11.m_resolution.Y);
}
var data = InitConstantBuffer(viewport.Value);
var mapping = MyMapping.MapDiscard(m_dataCB);
mapping.WriteAndPosition(ref data);
mapping.Unmap();
RC.PixelShader.SetConstantBuffer(0, m_dataCB);
RC.PixelShader.SetSamplers(0, MySamplerStateManager.PointHBAOClamp);
RC.SetBlendState(null);
RC.SetDepthStencilState(MyDepthStencilStateManager.IgnoreDepthStencil);
DrawLinearDepthPS(gbuffer.ResolvedDepthStencil.SrvDepth, m_fullResViewDepthTarget, viewport.Value);
DrawDeinterleavedDepth(viewport.Value);
DrawCoarseAO(gbuffer, viewport.Value);
if (Params.BlurEnable)
{
Resolve(true, m_fullResAOZTexture2, viewport.Value);
DrawBlurXPS(viewport.Value);
DrawBlurYPS(dst, viewport.Value);
}
else Resolve(false, dst, viewport.Value);
RC.SetRtv(null);
}
private static void RenderDirectionalEnvironmentLight(ISrvTexture postProcessedShadows, IRtvTexture ambientOcclusion)
{
PixelShaderId directionalPixelShader;
MyShadowsQuality shadowsQuality = MyRender11.Settings.User.ShadowQuality.GetShadowsQuality();
if (!MyRender11.Settings.EnableShadows || !MyRender11.DebugOverrides.Shadows || shadowsQuality == MyShadowsQuality.DISABLED)
{
if (m_directionalEnvironmentLightNoShadow == PixelShaderId.NULL)
{
m_directionalEnvironmentLightNoShadow = MyShaders.CreatePs("Lighting/LightDir.hlsl", new[] { new ShaderMacro("NO_SHADOWS", null) });
}
directionalPixelShader = m_directionalEnvironmentLightNoShadow;
}
else
{
directionalPixelShader = m_directionalEnvironmentLightPixel;
}
//context.VertexShader.Set(MyCommon.FullscreenShader.VertexShader);
RC.PixelShader.Set(directionalPixelShader);
RC.AllShaderStages.SetConstantBuffer(4, MyRender11.DynamicShadows.ShadowCascades.CascadeConstantBuffer);
RC.PixelShader.SetSampler(MyCommon.SHADOW_SAMPLER_SLOT, MySamplerStateManager.Shadowmap);
MyFileTextureManager texManager = MyManagers.FileTextures;
RC.PixelShader.SetSrv(MyCommon.SKYBOX_SLOT, texManager.GetTexture(MyRender11.Environment.Data.Skybox, MyFileTextureEnum.CUBEMAP, true));
ISrvBindable skybox = MyRender11.IsIntelBrokenCubemapsWorkaround
? MyGeneratedTextureManager.IntelFallbackCubeTex
: (ISrvBindable)MyManagers.EnvironmentProbe.Cubemap;
RC.PixelShader.SetSrv(MyCommon.SKYBOX_IBL_SLOT, skybox);
RC.PixelShader.SetSrv(MyCommon.CASCADES_SM_SLOT, MyRender11.DynamicShadows.ShadowCascades.CascadeShadowmapArray);
RC.PixelShader.SetSrv(MyCommon.SHADOW_SLOT, postProcessedShadows);
RC.PixelShader.SetSrv(MyCommon.AMBIENT_BRDF_LUT_SLOT,
MyCommon.GetAmbientBrdfLut());
RC.PixelShader.SetSrv(MyCommon.AO_SLOT, ambientOcclusion);
MyScreenPass.RunFullscreenPixelFreq(MyGBuffer.Main.LBuffer);
if (MyRender11.MultisamplingEnabled)
{
RC.PixelShader.Set(m_directionalEnvironmentLightSample);
MyScreenPass.RunFullscreenSampleFreq(MyGBuffer.Main.LBuffer);
}
RC.PixelShader.SetSrv(MyCommon.SHADOW_SLOT, null);
}
internal static void Render(IRtvTexture gbuffer1Copy)
{
IBorrowedUavTexture accumTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.AccumTarget", Format.R16G16B16A16_Float);
IBorrowedUavTexture coverageTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.CoverageTarget", Format.R16_UNorm);
ProfilerShort.Begin("Atmosphere");
MyGpuProfiler.IC_BeginBlock("Atmosphere");
if (MyRender11.DebugOverrides.Atmosphere)
MyAtmosphereRenderer.Render();
ProfilerShort.BeginNextBlock("Clouds");
MyGpuProfiler.IC_BeginNextBlock("Clouds");
if (MyRender11.DebugOverrides.Clouds)
MyCloudRenderer.Render();
MyGpuProfiler.IC_EndBlock();
var depthResource = MyGBuffer.Main.ResolvedDepthStencil;
// setup weighted blended OIT targets + blend states
SetupTargets(accumTarget, coverageTarget, true);
ProfilerShort.BeginNextBlock("Static glass");
MyGpuProfiler.IC_BeginBlock("Static glass");
m_glassWithDecals.Clear();
MyStaticGlassRenderer.Render(HandleGlass);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginBlock("Billboards");
bool resetBindings = MyBillboardRenderer.Gather();
if (resetBindings)
SetupTargets(accumTarget, coverageTarget, false);
MyBillboardRenderer.Render(depthResource.SrvDepth);
ProfilerShort.BeginNextBlock("GPU Particles");
MyGpuProfiler.IC_BeginNextBlock("GPU Particles");
if (MyRender11.DebugOverrides.GPUParticles)
MyGPUParticleRenderer.Run(depthResource.SrvDepth, MyGBuffer.Main.GBuffer1);
MyGpuProfiler.IC_EndBlock();
// Render decals on transparent surfaces in 2 steps: first far, second proximity
float intervalMax = MyScreenDecals.VISIBLE_DECALS_SQ_TH;
for (int it = 0; it < m_distances.Length; it++)
{
float intervalMin = m_distances[it];
ProfilerShort.BeginNextBlock("Glass - Depth Only");
MyGpuProfiler.IC_BeginBlock("Glass - Depth Only");
bool glassFound = MyStaticGlassRenderer.RenderGlassDepthOnly(depthResource, gbuffer1Copy, intervalMin, intervalMax);
MyGpuProfiler.IC_EndBlock();
if (glassFound)
{
SetupTargets(accumTarget, coverageTarget, false);
ProfilerShort.BeginNextBlock("Render decals - Transparent");
MyGpuProfiler.IC_BeginBlock("Render decals - Transparent");
MyScreenDecals.Draw(gbuffer1Copy, true, m_glassWithDecals);
MyGpuProfiler.IC_EndBlock();
}
intervalMax = intervalMin;
}
if (IsUsedOverlappingHeatMap())
DisplayOverlappingHeatMap(accumTarget, coverageTarget, MyRender11.Settings.DisplayTransparencyHeatMapInGrayscale);
MyGpuProfiler.IC_BeginBlock("OIT Resolve");
// resolve weighted blended OIT in accum / coverage to LBuffer
if (MyRender11.DebugOverrides.OIT)
ResolveOIT(accumTarget, coverageTarget);
else RC.SetRtv(null);
MyGpuProfiler.IC_EndBlock();
coverageTarget.Release();
accumTarget.Release();
ProfilerShort.End();
}
public static void Select(IRtvTexture tex)
{
Deselect();
m_selRtvTexture = tex;
}
internal static void Render(IRtvTexture gbuffer1Copy)
{
IBorrowedUavTexture accumTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.AccumTarget", Format.R16G16B16A16_Float);
IBorrowedUavTexture coverageTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.CoverageTarget", Format.R16_UNorm);
ProfilerShort.Begin("Atmosphere");
MyGpuProfiler.IC_BeginBlock("Atmosphere");
if (MyRender11.DebugOverrides.Atmosphere)
{
MyAtmosphereRenderer.RenderGBuffer();
}
ProfilerShort.BeginNextBlock("Clouds");
MyGpuProfiler.IC_BeginNextBlock("Clouds");
if (MyRender11.DebugOverrides.Clouds)
{
MyCloudRenderer.Render();
}
var depthResource = MyGBuffer.Main.ResolvedDepthStencil;
// setup weighted blended OIT targets + blend states
if (MyRender11.Settings.DrawBillboards)
{
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginNextBlock("Billboards");
MyBillboardRenderer.Gather();
MyBillboardRenderer.RenderAdditveBottom(depthResource.SrvDepth);
SetupTargets(accumTarget, coverageTarget, true);
MyBillboardRenderer.RenderStandard(depthResource.SrvDepth);
}
else
{
SetupTargets(accumTarget, coverageTarget, true);
}
ProfilerShort.BeginNextBlock("GPU Particles");
MyGpuProfiler.IC_BeginNextBlock("GPU Particles");
if (MyRender11.DebugOverrides.GPUParticles)
{
MyGPUParticleRenderer.Run(depthResource.SrvDepth, MyGBuffer.Main.GBuffer1);
}
// Render decals on transparent surfaces in 2 steps: first far, second proximity
if (MyRender11.Settings.DrawGlass)
{
ProfilerShort.BeginNextBlock("Static glass");
MyGpuProfiler.IC_BeginNextBlock("Static glass");
m_glassWithDecals.Clear();
MyStaticGlassRenderer.Render(HandleGlass);
float intervalMax = MyScreenDecals.VISIBLE_DECALS_SQ_TH;
for (int it = 0; it < m_distances.Length; it++)
{
float intervalMin = m_distances[it];
ProfilerShort.BeginNextBlock("Glass - Depth Only");
MyGpuProfiler.IC_BeginNextBlock("Glass - Depth Only");
//TODO: This code should properly render glass decals, that they are visible when looking through window on another window
// Anyway, it is italian code and it doesnt work. Solve after Beta
bool glassFound = MyStaticGlassRenderer.RenderGlassDepthOnly(depthResource, gbuffer1Copy, intervalMin, intervalMax);
// if (glassFound)
{
SetupTargets(accumTarget, coverageTarget, false);
ProfilerShort.BeginNextBlock("Render decals - Transparent");
MyGpuProfiler.IC_BeginNextBlock("Render decals - Transparent");
MyScreenDecals.Draw(gbuffer1Copy, true /*, m_glassWithDecals*/);
}
intervalMax = intervalMin;
}
}
if (IsUsedOverlappingHeatMap())
{
DisplayOverlappingHeatMap(accumTarget, coverageTarget, MyRender11.Settings.DisplayTransparencyHeatMapInGrayscale);
}
MyGpuProfiler.IC_BeginNextBlock("OIT Resolve");
// resolve weighted blended OIT in accum / coverage to LBuffer
if (MyRender11.DebugOverrides.OIT)
{
ResolveOIT(accumTarget, coverageTarget);
}
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginNextBlock("Billboards");
if (MyRender11.Settings.DrawBillboards)
{
MyBillboardRenderer.RenderAdditveTop(depthResource.SrvDepth);
}
RC.SetRtv(null);
MyGpuProfiler.IC_EndBlock();
coverageTarget.Release();
accumTarget.Release();
ProfilerShort.End();
}
protected override void CreateTextureInternal(ref MyBorrowedTextureKey key)
{
RtvTexture = MyManagers.RwTextures.CreateRtv(NamesGenerator.GetUniqueName(), key.Width, key.Height,
key.Format, key.SamplesCount, key.SamplesQuality);
}
public static void Select(IRtvTexture tex)
{
Deselect();
m_selRtvTexture = tex;
}
static void RenderDirectionalEnvironmentLight(ISrvTexture postProcessedShadows, IRtvTexture ambientOcclusion)
{
PixelShaderId directionalPixelShader;
MyShadowsQuality shadowsQuality = MyRender11.RenderSettings.ShadowQuality.GetShadowsQuality();
if (!MyRender11.Settings.EnableShadows || !MyRender11.DebugOverrides.Shadows || shadowsQuality == MyShadowsQuality.DISABLED)
{
if (DirectionalEnvironmentLight_NoShadow == PixelShaderId.NULL)
DirectionalEnvironmentLight_NoShadow = MyShaders.CreatePs("Lighting/LightDir.hlsl", new[] { new ShaderMacro("NO_SHADOWS", null) });
directionalPixelShader = DirectionalEnvironmentLight_NoShadow;
}
else
directionalPixelShader = DirectionalEnvironmentLight_Pixel;
//context.VertexShader.Set(MyCommon.FullscreenShader.VertexShader);
RC.PixelShader.Set(directionalPixelShader);
RC.AllShaderStages.SetConstantBuffer(4, MyRender11.DynamicShadows.ShadowCascades.CascadeConstantBuffer);
RC.PixelShader.SetSampler(MyCommon.SHADOW_SAMPLER_SLOT, MySamplerStateManager.Shadowmap);
MyFileTextureManager texManager = MyManagers.FileTextures;
RC.PixelShader.SetSrv(MyCommon.SKYBOX_SLOT, texManager.GetTexture(MyRender11.Environment.Data.Skybox, MyFileTextureEnum.CUBEMAP, true));
ISrvBindable skybox = MyRender11.IsIntelBrokenCubemapsWorkaround
? MyGeneratedTextureManager.IntelFallbackCubeTex
: (ISrvBindable)MyManagers.EnvironmentProbe.Cubemap;
RC.PixelShader.SetSrv(MyCommon.SKYBOX_IBL_SLOT, skybox);
RC.PixelShader.SetSrv(MyCommon.CASCADES_SM_SLOT, MyRender11.DynamicShadows.ShadowCascades.CascadeShadowmapArray);
RC.PixelShader.SetSrv(MyCommon.SHADOW_SLOT, postProcessedShadows);
RC.PixelShader.SetSrv(MyCommon.AMBIENT_BRDF_LUT_SLOT,
MyCommon.GetAmbientBrdfLut());
RC.PixelShader.SetSrv(MyCommon.AO_SLOT, ambientOcclusion);
MyScreenPass.RunFullscreenPixelFreq(MyGBuffer.Main.LBuffer);
if (MyRender11.MultisamplingEnabled)
{
RC.PixelShader.Set(DirectionalEnvironmentLight_Sample);
MyScreenPass.RunFullscreenSampleFreq(MyGBuffer.Main.LBuffer);
}
RC.PixelShader.SetSrv(MyCommon.SHADOW_SLOT, null);
}
internal static void Render(ISrvTexture postProcessedShadows, IRtvTexture ambientOcclusion)
{
ProfilerShort.Begin("PreparePointLights");
MyGpuProfiler.IC_BeginBlock("Map lights to tiles");
if (MyRender11.DebugOverrides.PointLights)
{
PreparePointLights();
}
MyGpuProfiler.IC_BeginNextBlock("Apply point lights");
ProfilerShort.End();
ProfilerShort.Begin("RenderPointlightsTiled");
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
if (!MyStereoRender.Enable)
{
RC.ComputeShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
}
else
{
MyStereoRender.CSBindRawCB_FrameConstants(RC);
MyStereoRender.PSBindRawCB_FrameConstants(RC);
}
RC.PixelShader.SetSrvs(0, MyGBuffer.Main);
RC.AllShaderStages.SetSrv(MyCommon.MATERIAL_BUFFER_SLOT, MySceneMaterials.m_buffer);
RC.SetBlendState(MyBlendStateManager.BlendAdditive);
RC.SetDepthStencilState(!MyStereoRender.Enable ? MyDepthStencilStateManager.IgnoreDepthStencil : MyDepthStencilStateManager.StereoIgnoreDepthStencil);
RC.PixelShader.SetSamplers(0, MySamplerStateManager.StandardSamplers);
if (MyRender11.DebugOverrides.PointLights)
{
RenderPointlightsTiled(ambientOcclusion);
}
ProfilerShort.End();
ProfilerShort.Begin("RenderSpotlights");
MyGpuProfiler.IC_BeginNextBlock("Apply spotlights");
if (MyRender11.DebugOverrides.SpotLights)
{
RenderSpotlights();
}
ProfilerShort.End();
ProfilerShort.Begin("RenderDirectionalEnvironmentLight");
MyGpuProfiler.IC_BeginNextBlock("Apply directional light");
if (MyRender11.DebugOverrides.EnvLight)
{
RenderDirectionalEnvironmentLight(postProcessedShadows, ambientOcclusion);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
// Because of BindGBufferForRead:
RC.AllShaderStages.SetSrv(0, null);
RC.AllShaderStages.SetSrv(1, null);
RC.AllShaderStages.SetSrv(2, null);
RC.AllShaderStages.SetSrv(3, null);
RC.AllShaderStages.SetSrv(4, null);
RC.SetBlendState(null);
RC.SetRtv(null);
}
static unsafe void DrawBatches(MyRenderContext rc, IRtvTexture gbuffer1Copy, MyStringId material, int matIndex, bool transparent)
{
if (m_jobs.Count == 0)
{
return;
}
var matDesc = m_materials[material][matIndex];
rc.PixelShader.SetSrv(0, MyGBuffer.Main.DepthStencil.SrvDepth);
rc.PixelShader.SetSrv(1, gbuffer1Copy);
if (transparent)
{
rc.PixelShader.Set(m_psColorMapTransparent);
}
else
{
rc.SetRtvs(MyGBuffer.Main, MyDepthStencilAccess.ReadOnly);
MyFileTextureEnum type = matDesc.DecalType;
switch (type)
{
case MyFileTextureEnum.NORMALMAP_GLOSS:
rc.PixelShader.Set(m_psNormalMap);
break;
case MyFileTextureEnum.COLOR_METAL:
rc.PixelShader.Set(m_psColorMap);
break;
case MyFileTextureEnum.COLOR_METAL | MyFileTextureEnum.NORMALMAP_GLOSS:
rc.PixelShader.Set(m_psNormalColorMap);
break;
case MyFileTextureEnum.COLOR_METAL | MyFileTextureEnum.NORMALMAP_GLOSS | MyFileTextureEnum.EXTENSIONS:
rc.PixelShader.Set(m_psNormalColorExtMap);
break;
default:
throw new Exception("Unknown decal type");
}
MyMeshMaterials1.BindMaterialTextureBlendStates(rc, type, true);
}
// factor 1 makes overwriting of gbuffer color & subtracting from ao
rc.PixelShader.SetSrv(3, matDesc.AlphamaskTexture);
rc.PixelShader.SetSrv(4, matDesc.ColorMetalTexture);
rc.PixelShader.SetSrv(5, matDesc.NormalmapTexture);
rc.PixelShader.SetSrv(6, matDesc.ExtensionsTexture);
var decalCb = MyCommon.GetObjectCB(sizeof(MyDecalConstants) * DECAL_BATCH_SIZE);
int batchCount = m_jobs.Count / DECAL_BATCH_SIZE + 1;
int offset = 0;
for (int i1 = 0; i1 < batchCount; i1++)
{
var mapping = MyMapping.MapDiscard(decalCb);
int leftDecals = m_jobs.Count - offset;
int decalCount = leftDecals > DECAL_BATCH_SIZE ? DECAL_BATCH_SIZE : leftDecals;
for (int i2 = 0; i2 < decalCount; ++i2)
{
MyDecalConstants constants = new MyDecalConstants();
EncodeJobConstants(i2 + offset, ref constants);
mapping.WriteAndPosition(ref constants);
}
mapping.Unmap();
// Draw a box without buffer: 36 vertices -> 12 triangles. 2 triangles per face -> 6 faces
MyImmediateRC.RC.DrawIndexed(36 * decalCount, 0, 0);
offset += DECAL_BATCH_SIZE;
}
}
internal static void RenderColoredTextures(List <renderColoredTextureProperties> texturesToRender)
{
if (texturesToRender.Count == 0)
{
return;
}
if (!m_initialized)
{
Init();
}
const int RENDER_TEXTURE_RESOLUTION = 512;
RC.SetBlendState(null);
RC.SetInputLayout(null);
RC.PixelShader.Set(m_ps);
RC.AllShaderStages.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.AllShaderStages.SetConstantBuffer(1, m_cb);
Dictionary <Vector2I, IRtvTexture> createdRenderTextureTargets = new Dictionary <Vector2I, IRtvTexture>();
MyRwTextureManager rwTexManager = MyManagers.RwTextures;
MyFileTextureManager fileTexManager = MyManagers.FileTextures;
foreach (var texture in texturesToRender)
{
ISrvBindable tex = fileTexManager.GetTexture(texture.TextureName, MyFileTextureEnum.COLOR_METAL, true);
if (tex == null)
{
continue;
}
Vector2 texSize = tex.Size;
Vector2I renderTargetResolution = new Vector2I(RENDER_TEXTURE_RESOLUTION, RENDER_TEXTURE_RESOLUTION);
if (texSize.Y > 0)
{
if (texSize.Y < RENDER_TEXTURE_RESOLUTION)
{
renderTargetResolution.X = (int)texSize.X;
renderTargetResolution.Y = (int)texSize.Y;
}
else
{
renderTargetResolution.X *= (int)(texSize.X / texSize.Y);
}
}
MyViewport viewport = new MyViewport(renderTargetResolution.X, renderTargetResolution.Y);
IRtvTexture renderTexture = null;
if (!createdRenderTextureTargets.TryGetValue(renderTargetResolution, out renderTexture))
{
renderTexture = rwTexManager.CreateRtv("MySaveExportedTextures.RenderColoredTextures",
renderTargetResolution.X, renderTargetResolution.Y, SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, 1, 0);
createdRenderTextureTargets[renderTargetResolution] = renderTexture;
}
RC.SetRtv(renderTexture);
// Set color
var mapping = MyMapping.MapDiscard(m_cb);
Vector4 color = new Vector4(texture.ColorMaskHSV, 1);
mapping.WriteAndPosition(ref color);
mapping.Unmap();
// Set texture
RC.PixelShader.SetSrv(0, tex);
// Draw
MyScreenPass.DrawFullscreenQuad(viewport);
// Save to file
MyTextureData.ToFile(renderTexture.Resource, texture.PathToSave, ImageFileFormat.Png);
}
texturesToRender.Clear();
foreach (var tex in createdRenderTextureTargets)
{
IRtvTexture _tex = tex.Value;
rwTexManager.DisposeTex(ref _tex);
}
createdRenderTextureTargets.Clear();
RC.SetRtv(null);
RC.PixelShader.SetSrvs(0, MyGBuffer.Main);
}
internal static void InitScreenResources()
{
MyRwTextureManager rwManager = MyManagers.RwTextures;
m_fullResViewDepthTarget = rwManager.CreateRtv("MyHBAO.FullResViewDepthTarget", MyRender11.m_resolution.X, MyRender11.m_resolution.Y,
SharpDX.DXGI.Format.R32_Float, 1, 0);
m_fullResNormalTexture = rwManager.CreateRtv("MyHBAO.FullResNormalTexture", MyRender11.m_resolution.X, MyRender11.m_resolution.Y,
SharpDX.DXGI.Format.R8G8B8A8_UNorm, 1, 0);
m_fullResAOZTexture = rwManager.CreateRtv("MyHBAO.FullResAOZTexture", MyRender11.m_resolution.X, MyRender11.m_resolution.Y,
SharpDX.DXGI.Format.R16G16_Float, 1, 0);
m_fullResAOZTexture2 = rwManager.CreateRtv("MyHBAO.FullResAOZTexture2", MyRender11.m_resolution.X, MyRender11.m_resolution.Y,
SharpDX.DXGI.Format.R16G16_Float, 1, 0);
MyArrayTextureManager arrayManager = MyManagers.ArrayTextures;
m_quarterResViewDepthTextureArray = arrayManager.CreateRtvArray("MyHBAO.QuarterResViewDepthTextureArray",
DivUp(MyRender11.m_resolution.X, 4), DivUp(MyRender11.m_resolution.Y, 4), NUM_SLICES, SharpDX.DXGI.Format.R16_Float);
m_quarterResAOTextureArray = arrayManager.CreateRtvArray("MyHBAO.QuarterResAOTextureArray",
DivUp(MyRender11.m_resolution.X, 4), DivUp(MyRender11.m_resolution.Y, 4), NUM_SLICES, SharpDX.DXGI.Format.R8_UNorm);
}
internal static void Render(IRtvTexture gbuffer1Copy)
{
IBorrowedUavTexture accumTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.AccumTarget", Format.R16G16B16A16_Float);
IBorrowedUavTexture coverageTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.CoverageTarget", Format.R16_UNorm);
ProfilerShort.Begin("Atmosphere");
MyGpuProfiler.IC_BeginBlock("Atmosphere");
if (MyRender11.DebugOverrides.Atmosphere)
{
MyAtmosphereRenderer.Render();
}
ProfilerShort.BeginNextBlock("Clouds");
MyGpuProfiler.IC_BeginNextBlock("Clouds");
if (MyRender11.DebugOverrides.Clouds)
{
MyCloudRenderer.Render();
}
MyGpuProfiler.IC_EndBlock();
var depthResource = MyGBuffer.Main.ResolvedDepthStencil;
// setup weighted blended OIT targets + blend states
SetupTargets(accumTarget, coverageTarget, true);
ProfilerShort.BeginNextBlock("Static glass");
MyGpuProfiler.IC_BeginBlock("Static glass");
m_glassWithDecals.Clear();
MyStaticGlassRenderer.Render(HandleGlass);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginBlock("Billboards");
bool resetBindings = MyBillboardRenderer.Gather();
if (resetBindings)
{
SetupTargets(accumTarget, coverageTarget, false);
}
MyBillboardRenderer.Render(depthResource.SrvDepth);
ProfilerShort.BeginNextBlock("GPU Particles");
MyGpuProfiler.IC_BeginNextBlock("GPU Particles");
if (MyRender11.DebugOverrides.GPUParticles)
{
MyGPUParticleRenderer.Run(depthResource.SrvDepth, MyGBuffer.Main.GBuffer1);
}
MyGpuProfiler.IC_EndBlock();
// Render decals on transparent surfaces in 2 steps: first far, second proximity
float intervalMax = MyScreenDecals.VISIBLE_DECALS_SQ_TH;
for (int it = 0; it < m_distances.Length; it++)
{
float intervalMin = m_distances[it];
ProfilerShort.BeginNextBlock("Glass - Depth Only");
MyGpuProfiler.IC_BeginBlock("Glass - Depth Only");
bool glassFound = MyStaticGlassRenderer.RenderGlassDepthOnly(depthResource, gbuffer1Copy, intervalMin, intervalMax);
MyGpuProfiler.IC_EndBlock();
if (glassFound)
{
SetupTargets(accumTarget, coverageTarget, false);
ProfilerShort.BeginNextBlock("Render decals - Transparent");
MyGpuProfiler.IC_BeginBlock("Render decals - Transparent");
MyScreenDecals.Draw(gbuffer1Copy, true, m_glassWithDecals);
MyGpuProfiler.IC_EndBlock();
}
intervalMax = intervalMin;
}
if (IsUsedOverlappingHeatMap())
{
DisplayOverlappingHeatMap(accumTarget, coverageTarget, MyRender11.Settings.DisplayTransparencyHeatMapInGrayscale);
}
MyGpuProfiler.IC_BeginBlock("OIT Resolve");
// resolve weighted blended OIT in accum / coverage to LBuffer
if (MyRender11.DebugOverrides.OIT)
{
ResolveOIT(accumTarget, coverageTarget);
}
else
{
RC.SetRtv(null);
}
MyGpuProfiler.IC_EndBlock();
coverageTarget.Release();
accumTarget.Release();
ProfilerShort.End();
}
public void DrawCoverage(IRtvTexture outTex, IDepthStencil depthStencil)
{
m_markCascades.DrawCoverage(outTex, depthStencil);
}
/// <param name="clearColor">Color used to clear render targets. Defaults to black</param>
internal static void Run(IRtvBindable renderTarget, IRtvTexture intermediate, ISrvBindable initialResourceView,
int maxOffset = 5, MyBlurDensityFunctionType densityFunctionType = MyBlurDensityFunctionType.Gaussian, float WeightParameter = 1.5f,
IDepthStencilState depthStencilState = null, int stencilRef = 0x0, Color4 clearColor = default(Color4),
float depthDiscardThreshold = 0.0f, MyViewport?viewport = null)
{
ProfilerShort.Begin("MyBlur.Run");
MyGpuProfiler.IC_BeginBlock("MyBlur.Run");
Debug.Assert(initialResourceView != null);
Debug.Assert(intermediate != null);
Debug.Assert(renderTarget != null);
int shaderKey = InitShaders(densityFunctionType, maxOffset, depthDiscardThreshold);
RC.PixelShader.SetConstantBuffer(5, m_blurConstantBuffer);
BlurConstants constants = new BlurConstants
{
DistributionWeight = WeightParameter,
StencilRef = stencilRef,
};
var mapping = MyMapping.MapDiscard(m_blurConstantBuffer);
mapping.WriteAndPosition(ref constants);
mapping.Unmap();
// Horizontal pass
// NOTE: DepthStencilState is not used here because the resulted target
// would not be usable to perform vertical pass. DepthStencil is stil
// bindinded as SRV since it is sampled in the shader
RC.ClearRtv(intermediate, clearColor);
RC.SetRtv(intermediate);
RC.PixelShader.SetSrv(0, MyGBuffer.Main.DepthStencil.SrvDepth);
RC.PixelShader.SetSrv(4, MyGBuffer.Main.DepthStencil.SrvStencil);
RC.SetDepthStencilState(MyDepthStencilStateManager.IgnoreDepthStencil);
RC.PixelShader.SetSrv(5, initialResourceView);
RC.PixelShader.Set(m_blurShaders[shaderKey].Item1);
MyScreenPass.DrawFullscreenQuad(viewport);
RC.PixelShader.SetSrv(5, null);
// Vertical pass
RC.ClearRtv(renderTarget, clearColor);
if (depthStencilState == null)
{
RC.SetRtv(renderTarget);
}
else
{
RC.SetDepthStencilState(depthStencilState, stencilRef);
RC.SetRtv(MyGBuffer.Main.DepthStencil, MyDepthStencilAccess.ReadOnly, renderTarget);
}
RC.PixelShader.SetSrv(5, intermediate);
RC.PixelShader.Set(m_blurShaders[shaderKey].Item2);
MyScreenPass.DrawFullscreenQuad(viewport);
RC.PixelShader.SetSrv(0, null);
RC.PixelShader.SetSrv(4, null);
RC.PixelShader.SetSrv(5, null);
RC.SetRtv(null);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
}
/// <param name="clearColor">Color used to clear render targets. Defaults to black</param>
internal static void Run(IRtvBindable renderTarget, IRtvTexture intermediate, ISrvBindable initialResourceView,
int maxOffset = 5, MyBlurDensityFunctionType densityFunctionType = MyBlurDensityFunctionType.Gaussian, float WeightParameter = 1.5f,
IDepthStencilState depthStencilState = null, int stencilRef = 0x0, Color4 clearColor = default(Color4),
float depthDiscardThreshold = 0.0f, MyViewport? viewport = null)
{
ProfilerShort.Begin("MyBlur.Run");
MyGpuProfiler.IC_BeginBlock("MyBlur.Run");
Debug.Assert(initialResourceView != null);
Debug.Assert(intermediate != null);
Debug.Assert(renderTarget != null);
int shaderKey = InitShaders(densityFunctionType, maxOffset, depthDiscardThreshold);
RC.PixelShader.SetConstantBuffer(5, m_blurConstantBuffer);
BlurConstants constants = new BlurConstants
{
DistributionWeight = WeightParameter,
StencilRef = stencilRef,
};
var mapping = MyMapping.MapDiscard(m_blurConstantBuffer);
mapping.WriteAndPosition(ref constants);
mapping.Unmap();
// Horizontal pass
// NOTE: DepthStencilState is not used here because the resulted target
// would not be usable to perform vertical pass. DepthStencil is stil
// bindinded as SRV since it is sampled in the shader
RC.ClearRtv(intermediate, clearColor);
RC.SetRtv(intermediate);
RC.PixelShader.SetSrv(0, MyGBuffer.Main.DepthStencil.SrvDepth);
RC.PixelShader.SetSrv(4, MyGBuffer.Main.DepthStencil.SrvStencil);
RC.SetDepthStencilState(MyDepthStencilStateManager.IgnoreDepthStencil);
RC.PixelShader.SetSrv(5, initialResourceView);
RC.PixelShader.Set(m_blurShaders[shaderKey].Item1);
MyScreenPass.DrawFullscreenQuad(viewport);
RC.PixelShader.SetSrv(5, null);
// Vertical pass
RC.ClearRtv(renderTarget, clearColor);
if (depthStencilState == null)
{
RC.SetRtv(renderTarget);
}
else
{
RC.SetDepthStencilState(depthStencilState, stencilRef);
RC.SetRtv(MyGBuffer.Main.DepthStencil, MyDepthStencilAccess.ReadOnly, renderTarget);
}
RC.PixelShader.SetSrv(5, intermediate);
RC.PixelShader.Set(m_blurShaders[shaderKey].Item2);
MyScreenPass.DrawFullscreenQuad(viewport);
RC.PixelShader.SetSrv(0, null);
RC.PixelShader.SetSrv(4, null);
RC.PixelShader.SetSrv(5, null);
RC.SetRtv(null);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
}
internal static void Draw(IRtvBindable renderTarget, IRtvTexture ambientOcclusion)
{
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
RC.SetViewport(0, 0, MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y);
RC.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.SetRtv(renderTarget);
RC.PixelShader.SetSrvs(0, MyGBuffer.Main);
RC.SetBlendState(null);
if (MyRender11.Settings.DisplayGbufferColor)
{
RC.PixelShader.Set(m_baseColorShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferAlbedo)
{
RC.PixelShader.Set(m_albedoShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferNormal)
{
RC.PixelShader.Set(m_normalShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferNormalView)
{
RC.PixelShader.Set(m_normalViewShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferGlossiness)
{
RC.PixelShader.Set(m_glossinessShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferMetalness)
{
RC.PixelShader.Set(m_metalnessShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferAO)
{
RC.PixelShader.Set(m_aoShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayEmissive)
{
RC.PixelShader.Set(m_emissiveShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayAmbientDiffuse)
{
RC.PixelShader.Set(m_ambientDiffuseShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayAmbientSpecular)
{
RC.PixelShader.Set(m_ambientSpecularShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayEdgeMask)
{
RC.PixelShader.Set(m_edgeDebugShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayShadowsWithDebug)
{
RC.PixelShader.Set(m_shadowsDebugShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayNDotL)
{
RC.PixelShader.Set(m_NDotLShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferLOD)
{
RC.PixelShader.Set(m_LODShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayDepth)
{
RC.PixelShader.Set(m_depthShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayStencil)
{
RC.PixelShader.Set(m_stencilShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayAO)
{
RC.PixelShader.SetSrv(0, ambientOcclusion);
RC.PixelShader.SetSampler(0, MySamplerStateManager.Linear);
RC.PixelShader.Set(m_rtShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayEnvProbe)
{
DrawEnvProbe();
}
//DrawEnvProbe();
//DrawAtmosphereTransmittance(MyAtmosphereRenderer.AtmosphereLUT.Keys.ToArray()[0]);
//DrawAtmosphereInscatter(MyAtmosphereRenderer.AtmosphereLUT.Keys.ToArray()[0]);
if (MyRender11.Settings.DrawCascadeTextures)
{
//DrawDepthArrayTexture(MyManagers.Shadow.GetCsmForGbuffer(), 100, 100, 200);
DrawDepthArrayTexture(MyRender11.DynamicShadows.ShadowCascades.CascadeShadowmapArray, 100, 100, 200);
if (MyScene.SeparateGeometry)
{
DrawDepthArrayTexture(MyRender11.StaticShadows.ShadowCascades.CascadeShadowmapArray, 100, 300, 200);
DrawDepthArrayTexture(MyShadowCascades.CombineShadowmapArray, 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 - MyRender11.Environment.CameraPosition,renderable.m_owner.Aabb.Max - MyRender11.Environment.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 static void Draw(IRtvBindable renderTarget, IRtvTexture ambientOcclusion)
{
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
RC.SetViewport(0, 0, MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y);
RC.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.SetRtv(renderTarget);
RC.PixelShader.SetSrvs(0, MyGBuffer.Main);
RC.SetBlendState(null);
if (MyRender11.Settings.DisplayGbufferColor)
{
RC.PixelShader.Set(m_baseColorShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferAlbedo)
{
RC.PixelShader.Set(m_albedoShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferNormal)
{
RC.PixelShader.Set(m_normalShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferNormalView)
{
RC.PixelShader.Set(m_normalViewShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferGlossiness)
{
RC.PixelShader.Set(m_glossinessShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferMetalness)
{
RC.PixelShader.Set(m_metalnessShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferAO)
{
RC.PixelShader.Set(m_aoShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayEmissive)
{
RC.PixelShader.Set(m_emissiveShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayAmbientDiffuse)
{
RC.PixelShader.Set(m_ambientDiffuseShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayAmbientSpecular)
{
RC.PixelShader.Set(m_ambientSpecularShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayEdgeMask)
{
RC.PixelShader.Set(m_edgeDebugShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayShadowsWithDebug)
{
RC.PixelShader.Set(m_shadowsDebugShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayNDotL)
{
RC.PixelShader.Set(m_NDotLShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayGbufferLOD)
{
RC.PixelShader.Set(m_LODShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayMipmap)
{
RC.PixelShader.Set(m_baseColorShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayDepth)
{
RC.PixelShader.Set(m_depthShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayReprojectedDepth)
{
var dst = MyManagers.RwTexturesPool.BorrowUav("DebugRender.DepthReprojection", Format.R32_Float);
MyRender11.RC.ClearUav(dst, SharpDX.Int4.Zero);
RC.ComputeShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.ComputeShader.SetSrv(0, MyGBuffer.Main.DepthStencil.SrvDepth);
RC.ComputeShader.SetUav(0, dst);
RC.ComputeShader.Set(m_depthReprojectionShader);
int numThreadGroupsX = align(MyRender11.ResolutionI.X, 32) / 32;
int numThreadGroupsY = align(MyRender11.ResolutionI.Y, 32) / 32;
RC.Dispatch(numThreadGroupsX, numThreadGroupsY, 1);
RC.ComputeShader.SetSrv(0, null);
RC.ComputeShader.SetUav(0, null);
RC.PixelShader.SetSrv(0, dst);
RC.PixelShader.Set(m_depthShader);
MyScreenPass.DrawFullscreenQuad();
RC.PixelShader.SetSrv(0, MyGBuffer.Main.DepthStencil.SrvDepth);
}
else if (MyRender11.Settings.DisplayStencil)
{
RC.PixelShader.Set(m_stencilShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayAO)
{
RC.PixelShader.SetSrv(0, ambientOcclusion);
RC.PixelShader.SetSampler(0, MySamplerStateManager.Linear);
RC.PixelShader.Set(m_rtShader);
MyScreenPass.DrawFullscreenQuad();
}
else if (MyRender11.Settings.DisplayEnvProbe)
{
DrawEnvProbe();
}
//DrawEnvProbe();
//DrawAtmosphereTransmittance(MyAtmosphereRenderer.AtmosphereLUT.Keys.ToArray()[0]);
//DrawAtmosphereInscatter(MyAtmosphereRenderer.AtmosphereLUT.Keys.ToArray()[0]);
if (MyRender11.Settings.DrawCascadeTextures)
{
//DrawDepthArrayTexture(MyManagers.Shadow.GetCsmForGbuffer(), 100, 100, 200);
DrawDepthArrayTexture(MyRender11.DynamicShadows.ShadowCascades.CascadeShadowmapArray, 100, 100, 200);
if (MyScene.SeparateGeometry)
{
DrawDepthArrayTexture(MyRender11.StaticShadows.ShadowCascades.CascadeShadowmapArray, 100, 300, 200);
DrawDepthArrayTexture(MyShadowCascades.CombineShadowmapArray, 100, 500, 200);
}
}
if (MyRender11.Settings.DisplayIDs || MyRender11.Settings.DisplayAabbs)
{
DrawHierarchyDebug();
}
if (false)
{
var batch = MyLinesRenderer.CreateBatch();
foreach (var light in MyLightsRendering.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 - MyRender11.Environment.CameraPosition,renderable.m_owner.Aabb.Max - MyRender11.Environment.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(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 static void Render(ISrvTexture postProcessedShadows, IRtvTexture ambientOcclusion)
{
MyLights.Update();
MyGpuProfiler.IC_BeginBlock("Map lights to tiles");
if (MyRender11.DebugOverrides.PointLights)
PreparePointLights();
MyGpuProfiler.IC_BeginNextBlock("Apply point lights");
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
if (!MyStereoRender.Enable)
{
RC.ComputeShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
}
else
{
MyStereoRender.CSBindRawCB_FrameConstants(RC);
MyStereoRender.PSBindRawCB_FrameConstants(RC);
}
RC.PixelShader.SetSrvs(0, MyGBuffer.Main);
RC.AllShaderStages.SetSrv(MyCommon.MATERIAL_BUFFER_SLOT, MySceneMaterials.m_buffer);
RC.SetBlendState(MyBlendStateManager.BlendAdditive);
if (!MyStereoRender.Enable)
RC.SetDepthStencilState(MyDepthStencilStateManager.IgnoreDepthStencil);
else
RC.SetDepthStencilState(MyDepthStencilStateManager.StereoIgnoreDepthStencil);
RC.PixelShader.SetSamplers(0, MySamplerStateManager.StandardSamplers);
if (MyRender11.DebugOverrides.PointLights)
RenderPointlightsTiled(ambientOcclusion);
MyGpuProfiler.IC_BeginNextBlock("Apply spotlights");
if (MyRender11.DebugOverrides.SpotLights)
RenderSpotlights();
MyGpuProfiler.IC_BeginNextBlock("Apply directional light");
if (MyRender11.DebugOverrides.EnvLight)
RenderDirectionalEnvironmentLight(postProcessedShadows, ambientOcclusion);
MyGpuProfiler.IC_EndBlock();
// Because of BindGBufferForRead:
RC.AllShaderStages.SetSrv(0, null);
RC.AllShaderStages.SetSrv(1, null);
RC.AllShaderStages.SetSrv(2, null);
RC.AllShaderStages.SetSrv(3, null);
RC.AllShaderStages.SetSrv(4, null);
RC.SetBlendState(null);
RC.SetRtv(null);
}
