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