internal static void DisplayHistogram(RenderTargetView rtv) { RC.Context.PixelShader.SetShaderResource(0, m_histogram.ShaderView); RC.Context.PixelShader.Set(m_drawHistogram); RC.Context.OutputMerger.SetRenderTargets(rtv); MyScreenPass.DrawFullscreenQuad(new MyViewport(64, 64, 512, 64)); }
private static void DebugDraw(ISrvBindable src, IRtvBindable dst, MyViewport viewport) { RC.PixelShader.Set(m_copyPS); RC.SetRtv(dst); RC.PixelShader.SetSrv(0, src); MyScreenPass.DrawFullscreenQuad(viewport); }
static void DrawBlurYPS(IRtvBindable dst, MyViewport viewport) { RC.SetRtv(dst); RC.PixelShader.Set(m_blurYPS); RC.PixelShader.SetSrv(0, m_fullResAOZTexture); MyScreenPass.DrawFullscreenQuad(viewport); }
internal static void ResolveOIT(MyUnorderedAccessTexture accumTarget, MyUnorderedAccessTexture coverageTarget) { RC.SetBS(MyRender11.BlendInvTransparent); RC.SetPS(m_psResolve); RC.BindDepthRT(null, DepthStencilAccess.ReadOnly, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer)); RC.BindSRV(0, accumTarget); RC.BindSRV(1, coverageTarget); MyScreenPass.DrawFullscreenQuad(null); }
public static void DisplayHistogram(IRtvBindable output, ISrvBindable avgLumSrv, ISrvTexture histogram) { RC.PixelShader.SetSrvs(0, histogram, avgLumSrv); RC.PixelShader.Set(m_drawHistogram); RC.SetRtv(output); MyScreenPass.DrawFullscreenQuad(new MyViewport(64, 64, 512, 64)); //m_histogram.Release(); //m_histogram = null; }
static void DrawLinearDepthPS(ISrvBindable resolvedDepth, IRtvBindable rtv, MyViewport viewport) { RC.PixelShader.Set(m_linearizeDepthPS); //RC.SetRtv(m_fullResViewDepthTarget); RC.SetRtv(rtv); RC.PixelShader.SetSrv(0, resolvedDepth); MyScreenPass.DrawFullscreenQuad(viewport); RC.SetRtv(null); }
static void DrawBlurXPS(MyViewport viewport) { RC.SetRtv(m_fullResAOZTexture); RC.PixelShader.Set(m_blurXPS); RC.PixelShader.SetSrv(0, m_fullResAOZTexture2); RC.PixelShader.SetSamplers(0, MySamplerStateManager.Point); RC.PixelShader.SetSamplers(1, MySamplerStateManager.Linear); MyScreenPass.DrawFullscreenQuad(viewport); }
private static void ResolveOIT(ISrvBindable accumTarget, ISrvBindable coverageTarget) { RC.SetDepthStencilState(MyDepthStencilStateManager.IgnoreDepthStencil); RC.SetBlendState(MyBlendStateManager.BlendWeightedTransparencyResolve); RC.PixelShader.Set(m_psResolve); RC.SetRtv(MyGBuffer.Main.LBuffer); RC.PixelShader.SetSrv(0, accumTarget); RC.PixelShader.SetSrv(1, coverageTarget); MyScreenPass.DrawFullscreenQuad(null); }
internal static void DisplayHistogram(RenderTargetView rtv, ShaderResourceView avgLumSrv) { RC.DeviceContext.PixelShader.SetShaderResources(0, m_histogram.SRV, avgLumSrv); RC.DeviceContext.PixelShader.Set(m_drawHistogram); RC.DeviceContext.OutputMerger.SetRenderTargets(rtv); MyScreenPass.DrawFullscreenQuad(new MyViewport(64, 64, 512, 64)); RC.DeviceContext.PixelShader.Set(m_drawTonemapping); MyScreenPass.DrawFullscreenQuad(new MyViewport(64, 128, 512, 64)); }
internal static void Run(RenderTargetView renderTarget, RenderTargetView intermediateRenderTarget, ShaderResourceView intermediateResourceView, ShaderResourceView initialResourceView, int maxOffset = 5, MyBlurDensityFunctionType densityFunctionType = MyBlurDensityFunctionType.Gaussian, float WeightParameter = 1.5f, DepthStencilState depthStencilState = null, int stencilRef = 0x0, bool copyOnStencilFail = false, float depthDiscardThreshold = 0.0f, MyViewport?viewport = null) { ProfilerShort.Begin("MyBlur.Run"); MyGpuProfiler.IC_BeginBlock("MyBlur.Run"); Debug.Assert(initialResourceView != null); Debug.Assert(intermediateResourceView != null); Debug.Assert(intermediateRenderTarget != null); Debug.Assert(renderTarget != null); int shaderKey = InitShaders(densityFunctionType, maxOffset, copyOnStencilFail, depthDiscardThreshold); RC.DeviceContext.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 MyRender11.DeviceContext.ClearRenderTargetView(intermediateRenderTarget, Color4.White); RC.DeviceContext.OutputMerger.SetTargets(intermediateRenderTarget); RC.SetDS(depthStencilState, stencilRef); RC.DeviceContext.PixelShader.SetShaderResource(0, MyGBuffer.Main.DepthStencil.m_SRV_depth); RC.DeviceContext.PixelShader.SetShaderResource(4, MyGBuffer.Main.DepthStencil.m_SRV_stencil); RC.DeviceContext.PixelShader.SetShaderResource(5, initialResourceView); RC.SetPS(m_blurShaders[shaderKey].Item1); MyScreenPass.DrawFullscreenQuad(viewport); RC.DeviceContext.PixelShader.SetShaderResource(5, null); // Vertical pass MyRender11.DeviceContext.ClearRenderTargetView(renderTarget, Color4.White); RC.DeviceContext.OutputMerger.SetTargets(renderTarget); RC.SetDS(depthStencilState, stencilRef); RC.DeviceContext.PixelShader.SetShaderResource(0, MyGBuffer.Main.DepthStencil.m_SRV_depth); RC.DeviceContext.PixelShader.SetShaderResource(4, MyGBuffer.Main.DepthStencil.m_SRV_stencil); RC.DeviceContext.PixelShader.SetShaderResource(5, intermediateResourceView); RC.SetPS(m_blurShaders[shaderKey].Item2); MyScreenPass.DrawFullscreenQuad(viewport); RC.DeviceContext.PixelShader.SetShaderResource(0, null); RC.DeviceContext.PixelShader.SetShaderResource(4, null); RC.DeviceContext.PixelShader.SetShaderResource(5, null); MyGpuProfiler.IC_EndBlock(); ProfilerShort.End(); }
internal static void Run(IRtvBindable destination, ISrvBindable source) { RC.SetBlendState(null); RC.SetInputLayout(null); RC.PixelShader.Set(m_ps); RC.SetRtv(destination); RC.PixelShader.SetSrv(0, source); MyScreenPass.DrawFullscreenQuad(new MyViewport(destination.Size.X, destination.Size.Y)); }
internal static void ClearAlpha(IRtvBindable destination) { RC.SetBlendState(MyBlendStateManager.BlendAdditive); RC.SetInputLayout(null); RC.PixelShader.Set(m_clearAlphaPs); RC.SetRtv(destination); MyScreenPass.DrawFullscreenQuad(new MyViewport(destination.Size.X, destination.Size.Y)); RC.SetBlendState(null); }
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; }
static void Resolve(bool blur, IRtvBindable dst, MyViewport viewport) { RC.SetRtv(dst); RC.PixelShader.SetSrv(0, m_quarterResAOTextureArray); if (blur) { RC.PixelShader.Set(m_reinterleaveAOPS_PreBlur); RC.PixelShader.SetSrv(1, m_fullResViewDepthTarget); } else { RC.PixelShader.Set(m_reinterleaveAOPS); } RC.PixelShader.SetSamplers(0, MySamplerStateManager.PointHBAOClamp); MyScreenPass.DrawFullscreenQuad(viewport); }
internal static void Combine(RwTexId targetArray, MyShadowCascades firstCascades, MyShadowCascades secondCascades) { if (!MyRender11.Settings.EnableShadows) { return; } ProfilerShort.Begin("MyShadowCascadesPostProcess.Combine"); MyGpuProfiler.IC_BeginBlock("MyShadowCascadesPostProcess.Combine"); firstCascades.FillConstantBuffer(firstCascades.CascadeConstantBuffer); secondCascades.FillConstantBuffer(secondCascades.CascadeConstantBuffer); secondCascades.PostProcessor.MarkCascadesInStencil(secondCascades.CascadeInfo); MyRenderContext renderContext = MyRenderContext.Immediate; DeviceContext deviceContext = renderContext.DeviceContext; deviceContext.PixelShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants); deviceContext.PixelShader.SetConstantBuffer(10, firstCascades.CascadeConstantBuffer); deviceContext.PixelShader.SetConstantBuffer(11, secondCascades.CascadeConstantBuffer); deviceContext.PixelShader.SetConstantBuffer(12, m_inverseConstants); for (int subresourceIndex = 0; subresourceIndex < targetArray.Description2d.ArraySize; ++subresourceIndex) { renderContext.BindGBufferForRead(0, MyGBuffer.Main); deviceContext.OutputMerger.SetTargets((DepthStencilView)null, (RenderTargetView)targetArray.SubresourceRtv(subresourceIndex)); deviceContext.PixelShader.SetShaderResource(0, firstCascades.CascadeShadowmapArray.SubresourceSrv(subresourceIndex)); deviceContext.PixelShader.SetShaderResource(1, secondCascades.CascadeShadowmapArray.ShaderView); //deviceContext.PixelShader.SetShaderResource(4, MyGBuffer.Main.DepthStencil.m_SRV_stencil); renderContext.SetPS(m_combinePS); Matrix inverseCascadeMatrix = MatrixD.Transpose(MatrixD.Invert(firstCascades.CascadeInfo[subresourceIndex].CurrentLocalToProjection * MyMatrixHelpers.ClipspaceToTexture)); var mapping = MyMapping.MapDiscard(m_inverseConstants); mapping.WriteAndPosition(ref inverseCascadeMatrix); mapping.Unmap(); MyScreenPass.DrawFullscreenQuad(new MyViewport(0, 0, targetArray.Description2d.Width, targetArray.Description2d.Height)); } deviceContext.OutputMerger.SetTargets(null as DepthStencilView, null as RenderTargetView); deviceContext.PixelShader.SetShaderResource(0, null); deviceContext.PixelShader.SetShaderResource(1, null); deviceContext.PixelShader.SetShaderResource(2, null); MyGpuProfiler.IC_EndBlock(); ProfilerShort.End(); }
internal static void Run(MyBindableResource destination, MyBindableResource source) { var context = MyRender11.Context; context.OutputMerger.BlendState = null; //context.Rasterizer.SetViewport(0, 0, MyRender.ViewportResolution.X, MyRender.ViewportResolution.Y); context.InputAssembler.InputLayout = 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(new MyViewport(destination.GetSize().X, destination.GetSize().Y)); }
internal static unsafe void RunForwardPostprocess(IRtvBindable rt, IDsvBindable depthDsv, ISrvBindable depthSrv, ref Matrix viewMatrix, ref Matrix projMatrix) { MyGpuProfiler.IC_BeginBlock("Postprocess"); var viewMatrixT = Matrix.Transpose(viewMatrix); var projMatrixT = Matrix.Transpose(projMatrix); var mapping = MyMapping.MapDiscard(RC, TransformConstants); mapping.WriteAndPosition(ref viewMatrixT); mapping.WriteAndPosition(ref projMatrixT); mapping.WriteAndPosition(ref MyRender11.Environment.Data.EnvironmentLight.SunLightDirection); mapping.Unmap(); RC.AllShaderStages.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants); RC.AllShaderStages.SetConstantBuffer(MyCommon.OBJECT_SLOT, TransformConstants); RC.SetDepthStencilState(MyDepthStencilStateManager.IgnoreDepthStencil); RC.SetRtv(rt); RC.PixelShader.SetSrv(0, depthSrv); MyFileTextureManager texManager = MyManagers.FileTextures; RC.PixelShader.SetSrv(MyCommon.SKYBOX_SLOT, texManager.GetTexture(MyRender11.Environment.Data.Skybox, MyFileTextureEnum.CUBEMAP, true)); RC.PixelShader.SetSamplers(0, MySamplerStateManager.StandardSamplers); RC.PixelShader.Set(m_ps); MyScreenPass.DrawFullscreenQuad(new MyViewport(m_viewportSize, m_viewportSize)); MyGpuProfiler.IC_EndBlock(); var nearestAtmosphereId = MyAtmosphereRenderer.GetNearestAtmosphereId(); if (nearestAtmosphereId != null) { MyGpuProfiler.IC_BeginBlock("Atmosphere"); RC.PixelShader.SetSrv(0, depthSrv); var viewProj = viewMatrix * projMatrix; MyAtmosphereRenderer.RenderEnvProbe(MyRender11.Environment.Matrices.CameraPosition, ref viewProj, nearestAtmosphereId.Value); MyGpuProfiler.IC_EndBlock(); } RC.SetRtv(null); }
static void DrawDeinterleavedDepth(MyViewport viewport) { var qViewport = GetQuarterViewport(viewport); RC.PixelShader.Set(m_deinterleaveDepthPS); RC.PixelShader.SetSrv(0, m_fullResViewDepthTarget); var rtvs = new IRtvBindable[MAX_NUM_MRTS]; for (int sliceIndex = 0; sliceIndex < NUM_SLICES; sliceIndex += MAX_NUM_MRTS) { for (int i = 0; i < MAX_NUM_MRTS; i++) { rtvs[i] = m_quarterResViewDepthTextureArray.SubresourceRtv(sliceIndex + i); } RC.SetRtvs(rtvs); RC.PixelShader.SetConstantBuffer(1, m_perPassCBs[sliceIndex]); MyScreenPass.DrawFullscreenQuad(qViewport); } }
internal unsafe static void RunForwardPostprocess(RenderTargetView rt, ShaderResourceView depth, ref Matrix viewMatrix, uint?atmosphereId) { var mapping = MyMapping.MapDiscard(RC.Context, MyCommon.ProjectionConstants); mapping.stream.Write(Matrix.Transpose(viewMatrix)); mapping.Unmap(); RC.SetCB(MyCommon.FRAME_SLOT, MyCommon.FrameConstants); RC.SetCB(MyCommon.PROJECTION_SLOT, MyCommon.ProjectionConstants); RC.Context.OutputMerger.SetTargets(rt); RC.Context.PixelShader.SetShaderResource(0, depth); RC.Context.PixelShader.SetShaderResource(MyCommon.SKYBOX_SLOT, MyTextures.GetView(MyTextures.GetTexture(MyEnvironment.DaySkybox, MyTextureEnum.CUBEMAP, true))); RC.Context.PixelShader.SetShaderResource(MyCommon.SKYBOX2_SLOT, MyTextures.GetView(MyTextures.GetTexture(MyEnvironment.NightSkybox, MyTextureEnum.CUBEMAP, true))); RC.Context.PixelShader.SetSamplers(0, MyRender11.StandardSamplers); RC.Context.PixelShader.Set(m_ps); MyScreenPass.DrawFullscreenQuad(new MyViewport(256, 256)); RC.Context.OutputMerger.SetTargets(null as RenderTargetView); }
static void DisplayOverlappingHeatMap(IUavTexture accumTarget, IUavTexture coverageTarget, bool useGrayscale) { IBorrowedRtvTexture heatMap = MyManagers.RwTexturesPool.BorrowRtv("MyTransparentRendering.HeatMap", Format.R8G8B8A8_UNorm); RC.ClearRtv(heatMap, default(RawColor4)); RC.SetRtv(heatMap); RC.PixelShader.SetSrv(0, accumTarget); RC.PixelShader.Set(useGrayscale ? m_psOverlappingHeatMapInGrayscale : m_psOverlappingHeatMap); RC.SetBlendState(MyBlendStateManager.BlendAdditive); RC.SetDepthStencilState(MyDepthStencilStateManager.IgnoreDepthStencil); MyScreenPass.DrawFullscreenQuad(); RC.PixelShader.Set(null); RC.PixelShader.SetSrv(0, null); RC.SetRtv(null); SetupOIT(accumTarget, coverageTarget, false); MyDebugTextureDisplay.Select(heatMap); heatMap.Release(); }
static void DrawCoarseAO(MyGBuffer gbuffer, MyViewport viewport) { var qViewport = GetQuarterViewport(viewport); RC.PixelShader.Set(m_coarseAOPS); RC.PixelShader.SetSamplers(0, Params.DepthClampToEdge ? MySamplerStateManager.PointHBAOClamp : MySamplerStateManager.PointHBAOBorder); RC.PixelShader.SetSamplers(1, MySamplerStateManager.PointHBAOClamp); RC.PixelShader.SetSrv(1, gbuffer.GBuffer1); for (int sliceIndex = 0; sliceIndex < NUM_SLICES; ++sliceIndex) { RC.PixelShader.SetSrv(0, m_quarterResViewDepthTextureArray.SubresourceSrv(sliceIndex)); RC.PixelShader.SetConstantBuffer(1, m_perPassCBs[sliceIndex]); RC.GeometryShader.SetConstantBuffer(1, m_perPassCBs[sliceIndex]); RC.SetRtv(m_quarterResAOTextureArray.SubresourceRtv(sliceIndex)); MyScreenPass.DrawFullscreenQuad(qViewport); } RC.GeometryShader.Set(null); }
internal static void Run(IRtvBindable destination, ISrvBindable source, bool alphaBlended = false, MyViewport?customViewport = null) { if (alphaBlended) { RC.SetBlendState(MyBlendStateManager.BlendAlphaPremult); } else { RC.SetBlendState(null); } //context.Rasterizer.SetViewport(0, 0, MyRender.ViewportResolution.X, MyRender.ViewportResolution.Y); RC.SetInputLayout(null); RC.PixelShader.Set(m_copyPs); //context.OutputMerger.SetTargets(null as DepthStencilView, target); //context.PixelShader.SetShaderResource(0, resource); RC.SetRtv(destination); RC.PixelShader.SetSrv(0, source); MyScreenPass.DrawFullscreenQuad(customViewport ?? new MyViewport(destination.Size.X, destination.Size.Y)); }
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 static void Run() { // set resolved depth/ stencil // render all shit with proper depth-stencil state // bluuuur // blend to main target testing with stencil again MyOutlinePass.Instance.ViewProjection = MyEnvironment.ViewProjectionAt0; MyOutlinePass.Instance.Viewport = new MyViewport(MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y); MyOutlinePass.Instance.PerFrame(); MyOutlinePass.Instance.Begin(); RC.Clear(); RC.Context.VertexShader.SetShaderResources(0, null, null, null, null, null, null); RC.Context.GeometryShader.SetShaderResources(0, null, null, null, null, null, null); RC.Context.PixelShader.SetShaderResources(0, null, null, null, null, null, null); RC.Context.ComputeShader.SetShaderResources(0, null, null, null, null, null, null); if (MyRender11.MultisamplingEnabled) { RC.Context.ClearRenderTargetView(MyRender11.m_rgba8_ms.m_RTV, new SharpDX.Color4(0, 0, 0, 0)); RC.Context.OutputMerger.SetTargets(MyGBuffer.Main.DepthStencil.m_DSV, MyRender11.m_rgba8_ms.m_RTV); } else { RC.Context.ClearRenderTargetView(MyRender11.m_rgba8_1.m_RTV, new SharpDX.Color4(0, 0, 0, 0)); RC.Context.OutputMerger.SetTargets(MyGBuffer.Main.DepthStencil.m_DSV, MyRender11.m_rgba8_1.m_RTV); } OutlineConstantsLayout constants; foreach (var kv in m_outlines) { var r = MyIDTracker <MyActor> .FindByID(kv.Key).GetRenderable(); var renderLod = r.m_lods[r.m_lod]; var submeshes = MyMeshes.GetLodMesh(r.GetModel(), r.m_lod).Info.PartsNum; for (int i = 0; i < submeshes; i++) { var part = MyMeshes.GetMeshPart(r.GetModel(), r.m_lod, i); for (int j = 0; j < kv.Value.Count; ++j) { if (part.Info.Material.Info.Name == kv.Value[j].Material) { constants.Color = kv.Value[j].Color.ToVector4(); constants.WorldToVolume = kv.Value[j].WorldToVolume.HasValue ? kv.Value[j].WorldToVolume.Value : Matrix.Zero; var mapping = MyMapping.MapDiscard(MyCommon.OutlineConstants); mapping.stream.Write(constants); mapping.Unmap(); RC.BindShaders(renderLod.HighlightShaders[i]); MyOutlinePass.Instance.RecordCommands(renderLod.RenderableProxies[i]); } } } } MyOutlinePass.Instance.End(); RC.Context.OutputMerger.SetTargets(null as DepthStencilView, null as RenderTargetView); RC.SetBS(null); if (MyRender11.MultisamplingEnabled) { RC.Context.PixelShader.SetShaderResource(0, MyRender11.m_rgba8_ms.m_SRV); } else { RC.Context.PixelShader.SetShaderResource(0, MyRender11.m_rgba8_1.m_SRV); } RC.Context.OutputMerger.SetTargets(null as DepthStencilView, MyRender11.m_rgba8_2.m_RTV); RC.SetPS(m_blurH); MyScreenPass.DrawFullscreenQuad(); RC.Context.PixelShader.SetShaderResource(0, null); RC.Context.OutputMerger.SetTargets(null as DepthStencilView, MyRender11.m_rgba8_1.m_RTV); RC.Context.PixelShader.SetShaderResource(0, MyRender11.m_rgba8_2.m_SRV); RC.SetPS(m_blurV); MyScreenPass.DrawFullscreenQuad(); RC.Context.OutputMerger.SetTargets(null as DepthStencilView, null as RenderTargetView); RC.Context.PixelShader.SetShaderResource(0, null); }
internal unsafe static void RunForwardPostprocess(RenderTargetView rt, ShaderResourceView depth, ref Matrix viewMatrix, uint?atmosphereId) { var transpose = Matrix.Transpose(viewMatrix); var mapping = MyMapping.MapDiscard(RC.DeviceContext, MyCommon.ProjectionConstants); mapping.WriteAndPosition(ref transpose); mapping.Unmap(); RC.SetCB(MyCommon.FRAME_SLOT, MyCommon.FrameConstants); RC.SetCB(MyCommon.PROJECTION_SLOT, MyCommon.ProjectionConstants); RC.DeviceContext.OutputMerger.SetTargets(rt); RC.DeviceContext.PixelShader.SetShaderResource(0, depth); RC.DeviceContext.PixelShader.SetShaderResource(MyCommon.SKYBOX_SLOT, MyTextures.GetView(MyTextures.GetTexture(MyEnvironment.DaySkybox, MyTextureEnum.CUBEMAP, true))); RC.DeviceContext.PixelShader.SetShaderResource(MyCommon.SKYBOX2_SLOT, MyTextures.GetView(MyTextures.GetTexture(MyEnvironment.NightSkybox, MyTextureEnum.CUBEMAP, true))); RC.DeviceContext.PixelShader.SetSamplers(0, MyRender11.StandardSamplers); RC.DeviceContext.PixelShader.Set(m_ps); MyScreenPass.DrawFullscreenQuad(new MyViewport(256, 256)); if (atmosphereId != null) { var atmosphere = MyAtmosphereRenderer.GetAtmosphere(atmosphereId.Value); var constants = new AtmosphereConstants(); //TODO(AF) These values are computed in MyAtmosphere as well. Find a way to remove the duplication var worldMatrix = atmosphere.WorldMatrix; worldMatrix.Translation -= MyEnvironment.CameraPosition; double distance = worldMatrix.Translation.Length(); double atmosphereTop = atmosphere.AtmosphereRadius * atmosphere.Settings.AtmosphereTopModifier * atmosphere.PlanetScaleFactor * atmosphere.Settings.RayleighTransitionModifier; float rayleighHeight = atmosphere.Settings.RayleighHeight; float t = 0.0f; if (distance > atmosphereTop) { if (distance > atmosphereTop * 2.0f) { t = 1.0f; } else { t = (float)((distance - atmosphereTop) / atmosphereTop); } } rayleighHeight = MathHelper.Lerp(atmosphere.Settings.RayleighHeight, atmosphere.Settings.RayleighHeightSpace, t); constants.PlanetCentre = (Vector3)worldMatrix.Translation; constants.AtmosphereRadius = atmosphere.AtmosphereRadius * atmosphere.Settings.AtmosphereTopModifier; constants.GroundRadius = atmosphere.PlanetRadius * 1.01f * atmosphere.Settings.SeaLevelModifier; constants.BetaRayleighScattering = atmosphere.BetaRayleighScattering / atmosphere.Settings.RayleighScattering; constants.BetaMieScattering = atmosphere.BetaMieScattering / atmosphere.Settings.MieColorScattering; constants.HeightScaleRayleighMie = atmosphere.HeightScaleRayleighMie * new Vector2(rayleighHeight, atmosphere.Settings.MieHeight); constants.MieG = atmosphere.Settings.MieG; constants.PlanetScaleFactor = atmosphere.PlanetScaleFactor; constants.AtmosphereScaleFactor = atmosphere.AtmosphereScaleFactor; constants.Intensity = atmosphere.Settings.Intensity; constants.FogIntensity = atmosphere.Settings.FogIntensity; var cb = MyCommon.GetObjectCB(sizeof(AtmosphereConstants)); mapping = MyMapping.MapDiscard(RC.DeviceContext, cb); mapping.WriteAndPosition(ref constants); mapping.Unmap(); RC.SetBS(MyRender11.BlendAdditive); RC.SetCB(2, cb); RC.DeviceContext.PixelShader.SetShaderResource(2, MyAtmosphereRenderer.GetAtmosphereLuts(atmosphereId.Value).TransmittanceLut.ShaderView); RC.DeviceContext.PixelShader.Set(m_atmosphere); MyScreenPass.DrawFullscreenQuad(new MyViewport(MyEnvironmentProbe.CubeMapResolution, MyEnvironmentProbe.CubeMapResolution)); } RC.DeviceContext.OutputMerger.SetTargets(null as RenderTargetView); }
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(); } }
/// <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 unsafe static void RunForwardPostprocess(IRtvBindable rt, ISrvBindable depth, ref Matrix viewMatrix, uint?atmosphereId) { MyGpuProfiler.IC_BeginBlock("Postprocess"); var transpose = Matrix.Transpose(viewMatrix); var mapping = MyMapping.MapDiscard(RC, MyCommon.ProjectionConstants); mapping.WriteAndPosition(ref transpose); mapping.Unmap(); RC.AllShaderStages.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants); RC.AllShaderStages.SetConstantBuffer(MyCommon.PROJECTION_SLOT, MyCommon.ProjectionConstants); RC.SetDepthStencilState(MyDepthStencilStateManager.IgnoreDepthStencil); RC.SetRtv(rt); RC.PixelShader.SetSrv(0, depth); MyFileTextureManager texManager = MyManagers.FileTextures; RC.PixelShader.SetSrv(MyCommon.SKYBOX_SLOT, texManager.GetTexture(MyRender11.Environment.Data.Skybox, MyFileTextureEnum.CUBEMAP, true)); RC.PixelShader.SetSamplers(0, MySamplerStateManager.StandardSamplers); RC.PixelShader.Set(m_ps); MyScreenPass.DrawFullscreenQuad(new MyViewport(m_viewportSize, m_viewportSize)); MyGpuProfiler.IC_EndBlock(); MyGpuProfiler.IC_BeginBlock("Atmosphere"); if (atmosphereId != null) { var atmosphere = MyAtmosphereRenderer.GetAtmosphere(atmosphereId.Value); var constants = new AtmosphereConstants(); //TODO(AF) These values are computed in MyAtmosphere as well. Find a way to remove the duplication var worldMatrix = atmosphere.WorldMatrix; worldMatrix.Translation -= MyRender11.Environment.Matrices.CameraPosition; double distance = worldMatrix.Translation.Length(); double atmosphereTop = atmosphere.AtmosphereRadius * atmosphere.Settings.AtmosphereTopModifier * atmosphere.PlanetScaleFactor * atmosphere.Settings.RayleighTransitionModifier; float rayleighHeight = atmosphere.Settings.RayleighHeight; float t = 0.0f; if (distance > atmosphereTop) { if (distance > atmosphereTop * 2.0f) { t = 1.0f; } else { t = (float)((distance - atmosphereTop) / atmosphereTop); } } rayleighHeight = MathHelper.Lerp(atmosphere.Settings.RayleighHeight, atmosphere.Settings.RayleighHeightSpace, t); constants.PlanetCentre = (Vector3)worldMatrix.Translation; constants.AtmosphereRadius = atmosphere.AtmosphereRadius * atmosphere.Settings.AtmosphereTopModifier; constants.GroundRadius = atmosphere.PlanetRadius * 1.01f * atmosphere.Settings.SeaLevelModifier; constants.BetaRayleighScattering = atmosphere.BetaRayleighScattering / atmosphere.Settings.RayleighScattering; constants.BetaMieScattering = atmosphere.BetaMieScattering / atmosphere.Settings.MieColorScattering; constants.HeightScaleRayleighMie = atmosphere.HeightScaleRayleighMie * new Vector2(rayleighHeight, atmosphere.Settings.MieHeight); constants.MieG = atmosphere.Settings.MieG; constants.PlanetScaleFactor = atmosphere.PlanetScaleFactor; constants.AtmosphereScaleFactor = atmosphere.AtmosphereScaleFactor; constants.Intensity = atmosphere.Settings.Intensity; constants.FogIntensity = atmosphere.Settings.FogIntensity; var cb = MyCommon.GetObjectCB(sizeof(AtmosphereConstants)); mapping = MyMapping.MapDiscard(RC, cb); mapping.WriteAndPosition(ref constants); mapping.Unmap(); RC.SetBlendState(MyBlendStateManager.BlendAdditive); RC.PixelShader.SetConstantBuffer(2, cb); RC.PixelShader.SetSrv(2, MyAtmosphereRenderer.GetAtmosphereLuts(atmosphereId.Value).TransmittanceLut); RC.PixelShader.Set(m_atmosphere); MyScreenPass.DrawFullscreenQuad(new MyViewport(MyEnvironmentProbe.CubeMapResolution, MyEnvironmentProbe.CubeMapResolution)); } MyGpuProfiler.IC_EndBlock(); RC.SetRtv(null); }