protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { ShaderPass pass = MaterialVariables.GetPass(RenderType, context); if (pass.IsNULL) { return; } MaterialVariables.UpdateMaterialStruct(deviceContext, ref modelStruct); pass.BindShader(deviceContext); pass.BindStates(deviceContext, DefaultStateBinding); if (!materialVariables.BindMaterial(context, deviceContext, pass)) { return; } DynamicReflector?.BindCubeMap(deviceContext); DrawIndexed(deviceContext, GeometryBuffer.IndexBuffer, InstanceBuffer); DynamicReflector?.UnBindCubeMap(deviceContext); if (RenderWireframe && !WireframePass.IsNULL) { if (RenderType == RenderType.Transparent && context.IsOITPass) { pass = WireframeOITPass; } else { pass = WireframePass; } pass.BindShader(deviceContext, false); pass.BindStates(deviceContext, DefaultStateBinding); deviceContext.SetRasterState(RasterStateWireframe); DrawIndexed(deviceContext, GeometryBuffer.IndexBuffer, InstanceBuffer); } }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { ShaderPass pass = MaterialVariables.GetPass(this, context); if (pass.IsNULL) { return; } pass.BindShader(deviceContext); pass.BindStates(deviceContext, DefaultStateBinding); if (!BindMaterialTextures(deviceContext, pass)) { return; } if (context.RenderHost.IsShadowMapEnabled) { pass.PixelShader.BindTexture(deviceContext, shadowMapSlot, context.SharedResource.ShadowView); } DynamicReflector?.BindCubeMap(deviceContext); OnDraw(deviceContext, InstanceBuffer); DynamicReflector?.UnBindCubeMap(deviceContext); if (RenderWireframe && WireframePass != ShaderPass.NullPass) { if (RenderType == RenderType.Transparent && context.IsOITPass) { pass = WireframeOITPass; } else { pass = WireframePass; } pass.BindShader(deviceContext, false); pass.BindStates(deviceContext, DefaultStateBinding); deviceContext.SetRasterState(RasterStateWireframe); OnDraw(deviceContext, InstanceBuffer); } }
private void DrawOutline(RenderContext context, DeviceContextProxy deviceContext, ShaderResourceViewProxy depthStencilBuffer, ShaderResourceViewProxy renderTargetFull) { var buffer = context.RenderHost.RenderBuffer; #region Do Blur Pass BindTarget(null, blurCore.CurrentRTV, deviceContext, blurCore.Width, blurCore.Height, true); blurPassVertical.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); blurPassVertical.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.NextSRV); blurPassVertical.BindShader(deviceContext); blurPassVertical.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); deviceContext.Draw(4, 0); blurCore.Run(deviceContext, NumberOfBlurPass, 1, 0);//Already blur once on vertical, pass 1 as initial index. #endregion #region Draw back with stencil test BindTarget(depthStencilBuffer, renderTargetFull, deviceContext, buffer.TargetWidth, buffer.TargetHeight); screenQuadPass.PixelShader.BindTexture(deviceContext, textureSlot, blurCore.CurrentSRV); screenQuadPass.BindShader(deviceContext); screenQuadPass.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); deviceContext.Draw(4, 0); #endregion #region Draw outline onto original target BindTarget(null, buffer.FullResPPBuffer.CurrentRTV, deviceContext, buffer.TargetWidth, buffer.TargetHeight, false); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.NextSRV); screenOutlinePass.BindShader(deviceContext); screenOutlinePass.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); deviceContext.Draw(4, 0); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, null); #endregion }
public override void Render(RenderContext context, DeviceContextProxy deviceContext) { var buffer = context.RenderHost.RenderBuffer; #region Do Bloom Pass modelCB.Upload(deviceContext, ref modelStruct); //Extract bloom samples deviceContext.SetRenderTarget(buffer.FullResPPBuffer.NextRTV, buffer.TargetWidth, buffer.TargetHeight); screenQuadPass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.CurrentSRV); screenQuadPass.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); screenQuadPass.BindShader(deviceContext); screenQuadPass.BindStates(deviceContext, StateType.All); deviceContext.Draw(4, 0); // Down sampling for (int i = 0; i < numberOfBlurPass; ++i) { blurCore.Run(context, deviceContext, buffer.FullResPPBuffer.NextRTV, buffer.TargetWidth, buffer.TargetHeight, PostEffectBlurCore.BlurDepth.Two, ref modelStruct); } #endregion #region Draw outline onto original target BindTarget(null, buffer.FullResPPBuffer.CurrentRTV, deviceContext, buffer.TargetWidth, buffer.TargetHeight, false); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.NextSRV); screenOutlinePass.BindShader(deviceContext); screenOutlinePass.BindStates(deviceContext, StateType.All); deviceContext.Draw(4, 0); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, null); #endregion }
/// <summary> /// Runs the specified device context. /// </summary> /// <param name="deviceContext">The device context.</param> /// <param name="iteration">The iteration.</param> /// <param name="initVerticalIter">The initialize vertical iter.</param> /// <param name="initHorizontalIter">The initialize horizontal iter.</param> public virtual void Run(DeviceContextProxy deviceContext, int iteration, int initVerticalIter = 0, int initHorizontalIter = 0) { deviceContext.SetSampler(PixelShader.Type, samplerSlot, sampler); if (!screenBlurPassVertical.IsNULL) { screenBlurPassVertical.BindShader(deviceContext); screenBlurPassVertical.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); for (int i = initVerticalIter; i < iteration; ++i) { SwapTargets(); BindTarget(null, renderTargetBlur[0], deviceContext, texture2DDesc.Width, texture2DDesc.Height); screenBlurPassVertical.PixelShader.BindTexture(deviceContext, textureSlot, renderTargetBlur[1]); deviceContext.Draw(4, 0); } } if (!screenBlurPassHorizontal.IsNULL) { screenBlurPassHorizontal.BindShader(deviceContext); screenBlurPassHorizontal.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); for (int i = initHorizontalIter; i < iteration; ++i) { SwapTargets(); BindTarget(null, renderTargetBlur[0], deviceContext, texture2DDesc.Width, texture2DDesc.Height); screenBlurPassHorizontal.PixelShader.BindTexture(deviceContext, textureSlot, renderTargetBlur[1]); deviceContext.Draw(4, 0); } } deviceContext.SetShaderResource(PixelShader.Type, textureSlot, null); }
/// <summary> /// Runs the specified device context. /// </summary> /// <param name="deviceContext">The device context.</param> /// <param name="iteration">The iteration.</param> /// <param name="initVerticalIter">The initialize vertical iter.</param> /// <param name="initHorizontalIter">The initialize horizontal iter.</param> public virtual void Run(DeviceContextProxy deviceContext, int iteration, int initVerticalIter = 0, int initHorizontalIter = 0) { deviceContext.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip; deviceContext.DeviceContext.PixelShader.SetSampler(samplerSlot, sampler); if (!screenBlurPassVertical.IsNULL) { screenBlurPassVertical.BindShader(deviceContext); screenBlurPassVertical.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); for (int i = initVerticalIter; i < iteration; ++i) { SwapTargets(); BindTarget(null, renderTargetBlur[0], deviceContext, texture2DDesc.Width, texture2DDesc.Height); screenBlurPassVertical.GetShader(ShaderStage.Pixel).BindTexture(deviceContext, textureSlot, renderTargetBlur[1].TextureView); deviceContext.DeviceContext.Draw(4, 0); } } if (!screenBlurPassHorizontal.IsNULL) { screenBlurPassHorizontal.BindShader(deviceContext); screenBlurPassHorizontal.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); for (int i = initHorizontalIter; i < iteration; ++i) { SwapTargets(); BindTarget(null, renderTargetBlur[0], deviceContext, texture2DDesc.Width, texture2DDesc.Height); screenBlurPassHorizontal.GetShader(ShaderStage.Pixel).BindTexture(deviceContext, textureSlot, renderTargetBlur[1].TextureView); deviceContext.DeviceContext.Draw(4, 0); } } deviceContext.DeviceContext.PixelShader.SetShaderResource(textureSlot, null); }
protected override void OnRender(RenderContext renderContext, DeviceContextProxy deviceContext) { base.OnRender(renderContext, deviceContext); // Draw backface into stencil buffer DepthStencilView dsView; var renderTargets = deviceContext.DeviceContext.OutputMerger.GetRenderTargets(1, out dsView); if (dsView == null) { return; } deviceContext.DeviceContext.ClearDepthStencilView(dsView, DepthStencilClearFlags.Stencil, 0, 0); deviceContext.DeviceContext.OutputMerger.SetRenderTargets(dsView, new RenderTargetView[0]);//Remove render target deviceContext.SetRasterState(backfaceRasterState); drawBackfacePass.BindShader(deviceContext); drawBackfacePass.BindStates(deviceContext, StateType.BlendState); deviceContext.SetDepthStencilState(drawBackfacePass.DepthStencilState, 1); //Draw backface onto stencil buffer, set value to 1 OnDraw(deviceContext, InstanceBuffer); //Draw full screen quad to fill cross section deviceContext.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip; deviceContext.SetRasterState(RasterState); drawScreenQuadPass.BindShader(deviceContext); drawScreenQuadPass.BindStates(deviceContext, StateType.BlendState); deviceContext.DeviceContext.OutputMerger.SetRenderTargets(dsView, renderTargets); //Rebind render target deviceContext.SetDepthStencilState(drawScreenQuadPass.DepthStencilState, 1); //Only pass stencil buffer test if value is 1 deviceContext.DeviceContext.Draw(4, 0); //Decrement ref count. See OutputMerger.GetRenderTargets remarks dsView.Dispose(); foreach (var t in renderTargets) { t.Dispose(); } }
public override void Render(RenderContext context, DeviceContextProxy deviceContext) { if (Buffer == null || TextureView == null || spritePass.IsNULL) { return; } int slot = 0; if (!Buffer.AttachBuffers(deviceContext, ref slot, EffectTechnique.EffectsManager)) { return; } var globalTrans = context.GlobalTransform; globalTrans.Projection = ProjectionMatrix; globalTransformCB.Upload(deviceContext, ref globalTrans); spritePass.BindShader(deviceContext); spritePass.BindStates(deviceContext, StateType.All); spritePass.PixelShader.BindTexture(deviceContext, texSlot, TextureView); spritePass.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); deviceContext.SetViewport(0, 0, (float)context.ActualWidth, (float)context.ActualHeight); deviceContext.SetScissorRectangle(0, 0, (int)context.ActualWidth, (int)context.ActualHeight); deviceContext.DrawIndexed(Buffer.IndexBuffer.ElementCount, 0, 0); RaiseInvalidateRender(); }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { RenderCount = 0; if (CreateTextureResources(context, deviceContext)) { InvalidateRenderer(); return; // Skip this frame if texture resized to reduce latency. } Bind(context, deviceContext); var frustum = context.BoundingFrustum; int count = context.RenderHost.PerFrameTransparentNodes.Count; context.IsOITPass = true; for (int i = 0; i < count; ++i) { var renderable = context.RenderHost.PerFrameTransparentNodes[i]; if (context.EnableBoundingFrustum && !renderable.TestViewFrustum(ref frustum)) { continue; } renderable.RenderCore.Render(context, deviceContext); ++RenderCount; } context.IsOITPass = false; UnBind(context, deviceContext); screenQuadPass.BindShader(deviceContext); screenQuadPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState | StateType.RasterState); screenQuadPass.GetShader(ShaderStage.Pixel).BindTexture(deviceContext, colorTexIndex, colorTargetNoMSAA); screenQuadPass.GetShader(ShaderStage.Pixel).BindTexture(deviceContext, alphaTexIndex, alphaTargetNoMSAA); screenQuadPass.GetShader(ShaderStage.Pixel).BindSampler(deviceContext, samplerIndex, targetSampler); deviceContext.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip; deviceContext.DeviceContext.Draw(4, 0); }
/// <summary> /// Runs the blur procedure /// </summary> /// <param name="context">The context.</param> /// <param name="deviceContext">The device context.</param> /// <param name="source">The source.</param> /// <param name="depth">The depth.</param> /// <param name="sourceViewport"></param> /// <param name="modelStruct"></param> public virtual void Run(RenderContext context, DeviceContextProxy deviceContext, ShaderResourceViewProxy source, ref ViewportF sourceViewport, BlurDepth depth, ref BorderEffectStruct modelStruct) { deviceContext.SetSampler(PixelShader.Type, samplerSlot, sampler); if ((depth & BlurDepth.One) != 0) { using (var target1 = context.GetOffScreenRT(OffScreenTextureSize.Half, global::SharpDX.DXGI.Format.R8G8B8A8_UNorm, out var width, out var height)) { modelStruct.ViewportScale = (int)OffScreenTextureSize.Half; modelCB.Upload(deviceContext, ref modelStruct); //Full -> Half Vertical deviceContext.SetRenderTarget(target1); deviceContext.SetViewport(0, 0, width, height); deviceContext.SetScissorRectangle(0, 0, width, height); screenBlurPassVertical.BindShader(deviceContext); screenBlurPassVertical.BindStates(deviceContext, StateType.All); screenBlurPassVertical.PixelShader.BindTexture(deviceContext, textureSlot, source); deviceContext.Draw(4, 0); if ((depth & BlurDepth.Two) != 0) { using (var target2 = context.GetOffScreenRT(OffScreenTextureSize.Quarter, global::SharpDX.DXGI.Format.R8G8B8A8_UNorm, out var width2, out var height2)) { // Half to Quater Vertical modelStruct.ViewportScale = (int)OffScreenTextureSize.Quarter; modelCB.Upload(deviceContext, ref modelStruct); deviceContext.SetRenderTarget(target2); deviceContext.SetViewport(0, 0, width2, height2); deviceContext.SetScissorRectangle(0, 0, width2, height2); screenBlurPassVertical.BindShader(deviceContext); screenBlurPassVertical.PixelShader.BindTexture(deviceContext, textureSlot, target1); deviceContext.Draw(4, 0); // Quater to Half Horizontal modelStruct.ViewportScale = (int)OffScreenTextureSize.Half; modelCB.Upload(deviceContext, ref modelStruct); deviceContext.SetRenderTarget(target1); deviceContext.SetViewport(0, 0, width, height); deviceContext.SetScissorRectangle(0, 0, width, height); screenBlurPassHorizontal.BindShader(deviceContext); screenBlurPassHorizontal.PixelShader.BindTexture(deviceContext, textureSlot, target2); deviceContext.Draw(4, 0); } } // Half to Full Horizontal modelStruct.ViewportScale = (int)OffScreenTextureSize.Full; modelCB.Upload(deviceContext, ref modelStruct); deviceContext.SetRenderTarget(source); deviceContext.SetViewport(ref sourceViewport); deviceContext.SetScissorRectangle(ref sourceViewport); screenBlurPassHorizontal.BindShader(deviceContext); screenBlurPassHorizontal.PixelShader.BindTexture(deviceContext, textureSlot, target1); deviceContext.Draw(4, 0); } } }
/// <summary> /// Called when [render]. /// </summary> /// <param name="context">The context.</param> /// <param name="deviceContext">The device context.</param> protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { context.SharedResource.EnvironementMap = cubeTextureRes; DefaultShaderPass.BindShader(deviceContext); DefaultShaderPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState); DefaultShaderPass.PixelShader.BindTexture(deviceContext, cubeTextureSlot, cubeTextureRes); DefaultShaderPass.PixelShader.BindSampler(deviceContext, textureSamplerSlot, textureSampler); deviceContext.DrawIndexed(GeometryBuffer.IndexBuffer.ElementCount, 0, 0); }
private void DrawOutline(RenderContext context, DeviceContextProxy deviceContext, ShaderResourceViewProxy depthStencilBuffer, ShaderResourceViewProxy source) { var buffer = context.RenderHost.RenderBuffer; var sourceViewport = new ViewportF(0, 0, buffer.FullResPPBuffer.Width, buffer.FullResPPBuffer.Height); deviceContext.SetViewport(ref sourceViewport); deviceContext.SetScissorRectangle(ref sourceViewport); #region Do Blur Pass if (useBlurCore) { for (var i = 0; i < numberOfBlurPass; ++i) { blurCore.Run(context, deviceContext, source, ref sourceViewport, PostEffectBlurCore.BlurDepth.One, ref modelStruct); } } else { blurPassHorizontal.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); for (var i = 0; i < numberOfBlurPass; ++i) { deviceContext.SetRenderTarget(context.RenderHost.RenderBuffer.FullResPPBuffer.NextRTV); blurPassHorizontal.PixelShader.BindTexture(deviceContext, textureSlot, source); blurPassHorizontal.BindShader(deviceContext); blurPassHorizontal.BindStates(deviceContext, StateType.All); deviceContext.Draw(4, 0); deviceContext.SetRenderTarget(source); blurPassVertical.PixelShader.BindTexture(deviceContext, textureSlot, context.RenderHost.RenderBuffer.FullResPPBuffer.NextRTV); blurPassVertical.BindShader(deviceContext); blurPassVertical.BindStates(deviceContext, StateType.All); deviceContext.Draw(4, 0); } } #region Draw back with stencil test deviceContext.SetRenderTarget(depthStencilBuffer, context.RenderHost.RenderBuffer.FullResPPBuffer.NextRTV, true, global::SharpDX.Color.Transparent, false); screenQuadPass.PixelShader.BindTexture(deviceContext, textureSlot, source); screenQuadPass.BindShader(deviceContext); screenQuadPass.BindStates(deviceContext, StateType.All); deviceContext.Draw(4, 0); #endregion #region Draw outline onto original target deviceContext.SetRenderTarget(buffer.FullResPPBuffer.CurrentRTV); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, context.RenderHost.RenderBuffer.FullResPPBuffer.NextRTV); screenOutlinePass.BindShader(deviceContext); screenOutlinePass.BindStates(deviceContext, StateType.All); deviceContext.Draw(4, 0); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, null); #endregion #endregion }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { modelCB.Upload(deviceContext, ref modelStruct); DefaultShaderPass.BindShader(deviceContext); DefaultShaderPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState | StateType.RasterState); if (RenderShadowMap && context.SharedResource.ShadowView != null) { DefaultShaderPass.PixelShader.BindTexture(deviceContext, shadowMapSlot, context.SharedResource.ShadowView); DefaultShaderPass.PixelShader.BindSampler(deviceContext, samplerSlot, shadowSampler); } deviceContext.Draw(4, 0); }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { ShaderPass pass = DefaultShaderPass; if (RenderType == RenderType.Transparent && context.IsOITPass) { pass = TransparentPass; } pass.BindShader(deviceContext); pass.BindStates(deviceContext, DefaultStateBinding); BindBillboardTexture(deviceContext, pass.PixelShader); OnDraw(deviceContext, InstanceBuffer); }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { var buffer = context.RenderHost.RenderBuffer; buffer.SetDefaultRenderTargets(deviceContext, false); FXAAPass.BindShader(deviceContext); FXAAPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState | StateType.RasterState); FXAAPass.GetShader(ShaderStage.Pixel).BindTexture(deviceContext, textureSlot, buffer.ColorBuffer); FXAAPass.GetShader(ShaderStage.Pixel).BindSampler(deviceContext, samplerSlot, sampler); deviceContext.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip; deviceContext.DeviceContext.Draw(4, 0); FXAAPass.GetShader(ShaderStage.Pixel).BindTexture(deviceContext, textureSlot, null); }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { ShaderPass pass = DefaultShaderPass; if (RenderType == RenderType.Transparent && context.IsOITPass) { pass = TransparentPass; } modelCB.Upload(deviceContext, ref modelStruct); pass.BindShader(deviceContext); pass.BindStates(deviceContext, DefaultStateBinding); BindBillboardTexture(deviceContext, pass.PixelShader); DrawPoints(deviceContext, GeometryBuffer.VertexBuffer[0], InstanceBuffer); }
public override void Render(RenderContext context, DeviceContextProxy deviceContext) { if (pass.IsNULL) { return; } ModelStruct.mWorld = ModelMatrix; modelCB.Upload(deviceContext, ref ModelStruct); pass.BindShader(deviceContext); pass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState | StateType.RasterState); pass.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); pass.PixelShader.BindTexture(deviceContext, textureSlot, textureProxy); deviceContext.Draw(4, 0); }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { ShaderPass pass = MaterialVariables.GetPass(RenderType, context); if (pass.IsNULL) { return; } OnUpdatePerModelStruct(context); if (!materialVariables.UpdateMaterialStruct(deviceContext, ref modelStruct, ModelStruct.SizeInBytes)) { return; } pass.BindShader(deviceContext); pass.BindStates(deviceContext, DefaultStateBinding); if (!materialVariables.BindMaterialResources(context, deviceContext, pass)) { return; } DynamicReflector?.BindCubeMap(deviceContext); materialVariables.Draw(deviceContext, GeometryBuffer, InstanceBuffer.ElementCount); DynamicReflector?.UnBindCubeMap(deviceContext); if (RenderWireframe) { pass = materialVariables.GetWireframePass(RenderType, context); if (pass.IsNULL) { return; } pass.BindShader(deviceContext, false); pass.BindStates(deviceContext, DefaultStateBinding); deviceContext.SetRasterState(RasterStateWireframe); materialVariables.Draw(deviceContext, GeometryBuffer, InstanceBuffer.ElementCount); } }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { RenderCount = 0; if (context.RenderHost.PerFrameTransparentNodes.Count == 0) { return; } else if (CreateTextureResources(context, deviceContext)) { InvalidateRenderer(); return; // Skip this frame if texture resized to reduce latency. } Bind(context, deviceContext); context.IsOITPass = true; var parameter = ExternRenderParameter; if (!parameter.ScissorRegion.IsEmpty) { parameter.RenderTargetView = new RenderTargetView[] { colorTarget, alphaTarget }; RenderCount = context.RenderHost.Renderer.RenderOpaque(context, context.RenderHost.PerFrameTransparentNodes, ref parameter); } else { var frustum = context.BoundingFrustum; int count = context.RenderHost.PerFrameTransparentNodes.Count; for (int i = 0; i < count; ++i) { var renderable = context.RenderHost.PerFrameTransparentNodes[i]; if (context.EnableBoundingFrustum && !renderable.TestViewFrustum(ref frustum)) { continue; } renderable.RenderCore.Render(context, deviceContext); ++RenderCount; } } context.IsOITPass = false; UnBind(context, deviceContext); screenQuadPass.BindShader(deviceContext); screenQuadPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState | StateType.RasterState); screenQuadPass.PixelShader.BindTexture(deviceContext, colorTexIndex, colorTargetNoMSAA); screenQuadPass.PixelShader.BindTexture(deviceContext, alphaTexIndex, alphaTargetNoMSAA); screenQuadPass.PixelShader.BindSampler(deviceContext, samplerIndex, targetSampler); deviceContext.Draw(4, 0); }
public override void Render(RenderContext context, DeviceContextProxy deviceContext) { if (CreateRenderTargets((int)context.ActualWidth, (int)context.ActualHeight)) { RaiseInvalidateRender(); return; } var buffer = context.RenderHost.RenderBuffer; var hasMSAA = buffer.ColorBufferSampleDesc.Count > 1; var nonMSAADepthBuffer = hasMSAA ? context.RenderHost.RenderBuffer.DepthStencilBufferNoMSAA : null; var depthStencilView = hasMSAA ? nonMSAADepthBuffer : ExternRenderParameter.DepthStencilView; RenderCount = 0; InitializeMinMaxRenderTarget(deviceContext); context.OITRenderStage = OITRenderStage.DepthPeelingInitMinMaxZ; deviceContext.SetRenderTarget(depthStencilView, minMaxZTargets[0]); DrawMesh(context, deviceContext); context.OITRenderStage = OITRenderStage.DepthPeeling; var currId = 0; for (var layer = 1; layer < PeelingIteration; ++layer) { currId = layer % 2; var prevId = 1 - currId; var color = new Color4(-1, -1, 0, 0); deviceContext.ClearRenderTargetView(minMaxZTargets[currId], color); targets[0] = minMaxZTargets[currId]; targets[1] = frontBlendingTarget; targets[2] = backBlendingTarget; deviceContext.SetRenderTargets(depthStencilView, targets); deviceContext.SetShaderResource(new PixelShaderType(), 100, minMaxZTargets[prevId]); DrawMesh(context, deviceContext); deviceContext.SetShaderResource(new PixelShaderType(), 100, null); } context.OITRenderStage = OITRenderStage.None; finalSRVs[0] = minMaxZTargets[currId]; finalSRVs[1] = frontBlendingTarget; finalSRVs[2] = backBlendingTarget; finalPass.BindShader(deviceContext); finalPass.BindStates(deviceContext, StateType.All); deviceContext.SetRenderTargets(null, ExternRenderParameter.RenderTargetView); deviceContext.SetShaderResources(new PixelShaderType(), 100, finalSRVs); deviceContext.Draw(4, 0); }
protected override void OnRender(RenderContext renderContext, DeviceContextProxy deviceContext) { if (needsAssignVariables) { lock (clipParamCB) { if (needsAssignVariables) { clipParamCB.WriteValueByName(ClipPlaneStruct.CuttingOperationStr, (int)cuttingOperation); clipParamCB.WriteValueByName(ClipPlaneStruct.CrossSectionColorStr, sectionColor); clipParamCB.WriteValueByName(ClipPlaneStruct.EnableCrossPlaneStr, planeEnabled); clipParamCB.WriteValueByName(ClipPlaneStruct.EnableCrossPlane5To8Str, plane5To8Enabled); clipParamCB.WriteValueByName(ClipPlaneStruct.CrossPlane1ParamsStr, plane1Params); clipParamCB.WriteValueByName(ClipPlaneStruct.CrossPlane2ParamsStr, plane2Params); clipParamCB.WriteValueByName(ClipPlaneStruct.CrossPlane3ParamsStr, plane3Params); clipParamCB.WriteValueByName(ClipPlaneStruct.CrossPlane4ParamsStr, plane4Params); clipParamCB.WriteValueByName(ClipPlaneStruct.CrossPlane5ParamsStr, plane5Params); clipParamCB.WriteValueByName(ClipPlaneStruct.CrossPlane6ParamsStr, plane6Params); clipParamCB.WriteValueByName(ClipPlaneStruct.CrossPlane7ParamsStr, plane7Params); clipParamCB.WriteValueByName(ClipPlaneStruct.CrossPlane8ParamsStr, plane8Params); needsAssignVariables = false; } } } clipParamCB.Upload(deviceContext); base.OnRender(renderContext, deviceContext); // Draw backface into stencil buffer var dsView = renderContext.RenderHost.DepthStencilBufferView; deviceContext.ClearDepthStencilView(dsView, DepthStencilClearFlags.Stencil, 0, 0); deviceContext.SetDepthStencil(dsView);//Remove render target deviceContext.SetRasterState(backfaceRasterState); drawBackfacePass.BindShader(deviceContext); drawBackfacePass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState); DrawIndexed(deviceContext, GeometryBuffer.IndexBuffer, InstanceBuffer); //Draw full screen quad to fill cross section deviceContext.SetRasterState(RasterState); drawScreenQuadPass.BindShader(deviceContext); drawScreenQuadPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState); renderContext.RenderHost.SetDefaultRenderTargets(false);//Rebind render target deviceContext.Draw(4, 0); }
public override void Render(RenderContext context, DeviceContextProxy deviceContext) { var buffer = context.RenderHost.RenderBuffer; deviceContext.SetRenderTarget(buffer.FullResPPBuffer.NextRTV, buffer.TargetWidth, buffer.TargetHeight); OnUpdatePerModelStruct(context); modelCB.Upload(deviceContext, ref modelStruct); LUMAPass.BindShader(deviceContext); LUMAPass.BindStates(deviceContext, StateType.All); LUMAPass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.CurrentSRV); LUMAPass.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); deviceContext.Draw(4, 0); deviceContext.SetRenderTargetOnly(buffer.FullResPPBuffer.CurrentRTV); FXAAPass.BindShader(deviceContext); FXAAPass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.NextSRV); deviceContext.Draw(4, 0); FXAAPass.PixelShader.BindTexture(deviceContext, textureSlot, null); }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { var buffer = context.RenderHost.RenderBuffer; deviceContext.SetRenderTargets(null, new RenderTargetView[] { buffer.FullResPPBuffer.NextRTV }); deviceContext.SetViewport(0, 0, buffer.TargetWidth, buffer.TargetHeight, 0.0f, 1.0f); deviceContext.SetScissorRectangle(0, 0, buffer.TargetWidth, buffer.TargetHeight); LUMAPass.BindShader(deviceContext); LUMAPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState | StateType.RasterState); LUMAPass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.CurrentSRV); LUMAPass.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); deviceContext.Draw(4, 0); deviceContext.SetRenderTargets(null, new RenderTargetView[] { buffer.FullResPPBuffer.CurrentRTV }); FXAAPass.BindShader(deviceContext); FXAAPass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.NextSRV); deviceContext.Draw(4, 0); FXAAPass.PixelShader.BindTexture(deviceContext, textureSlot, null); }
protected override void OnRender(RenderContext renderContext, DeviceContextProxy deviceContext) { base.OnRender(renderContext, deviceContext); // Draw backface into stencil buffer var dsView = renderContext.RenderHost.DepthStencilBufferView; deviceContext.ClearDepthStencilView(dsView, DepthStencilClearFlags.Stencil, 0, 0); deviceContext.SetDepthStencilOnly(dsView);//Remove render target deviceContext.SetRasterState(backfaceRasterState); drawBackfacePass.BindShader(deviceContext); drawBackfacePass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState); OnDraw(deviceContext, InstanceBuffer); //Draw full screen quad to fill cross section deviceContext.SetRasterState(RasterState); drawScreenQuadPass.BindShader(deviceContext); drawScreenQuadPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState); renderContext.RenderHost.SetDefaultRenderTargets(false);//Rebind render target deviceContext.Draw(4, 0); }
/// <summary> /// Called when [render]. /// </summary> /// <param name="context">The context.</param> /// <param name="deviceContext">The device context.</param> protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { perFrameCB.UploadDataToBuffer(deviceContext, ref FrameVariables); // Clear binding updatePass.ComputeShader.BindUAV(deviceContext, currentStateSlot, null); updatePass.ComputeShader.BindUAV(deviceContext, newStateSlot, null); // Render existing particles renderPass.BindShader(deviceContext); renderPass.BindStates(deviceContext, StateType.RasterState | StateType.DepthStencilState); renderPass.VertexShader.BindTexture(deviceContext, renderStateSlot, BufferProxies[0]); renderPass.PixelShader.BindTexture(deviceContext, textureSlot, textureView); renderPass.PixelShader.BindSampler(deviceContext, samplerSlot, textureSampler); deviceContext.InputLayout = VertexLayout; int firstSlot = 0; InstanceBuffer?.AttachBuffer(deviceContext, ref firstSlot); deviceContext.SetBlendState(blendState, blendFactor, sampleMask); deviceContext.DrawInstancedIndirect(particleCountGSIABuffer.Buffer, 0); InvalidateRenderer();//Since particle is running all the time. Invalidate once finished rendering }
public override void Render(RenderContext context, DeviceContextProxy deviceContext) { var buffer = context.RenderHost.RenderBuffer; deviceContext.SetRenderTarget(buffer.FullResPPBuffer.NextRTV); var viewport = context.Viewport; deviceContext.SetViewport(ref viewport); deviceContext.SetScissorRectangle(ref viewport); OnUpdatePerModelStruct(context); modelCB.Upload(deviceContext, ref modelStruct); LUMAPass.BindShader(deviceContext); LUMAPass.BindStates(deviceContext, StateType.All); LUMAPass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.CurrentSRV); LUMAPass.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); deviceContext.Draw(4, 0); deviceContext.SetRenderTarget(buffer.FullResPPBuffer.CurrentRTV); FXAAPass.BindShader(deviceContext); FXAAPass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.NextSRV); deviceContext.Draw(4, 0); FXAAPass.PixelShader.BindTexture(deviceContext, textureSlot, null); }
/// <summary> /// Called when [render]. /// </summary> /// <param name="context">The context.</param> /// <param name="deviceContext">The device context.</param> protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { perFrameCB.UploadDataToBuffer(deviceContext, ref FrameVariables); // Clear binding updatePass.GetShader(ShaderStage.Compute).BindUAV(deviceContext, currentStateSlot, null); updatePass.GetShader(ShaderStage.Compute).BindUAV(deviceContext, newStateSlot, null); // Render existing particles renderPass.BindShader(deviceContext); renderPass.BindStates(deviceContext, StateType.RasterState | StateType.DepthStencilState); renderPass.GetShader(ShaderStage.Vertex).BindTexture(deviceContext, renderStateSlot, BufferProxies[0].SRV); renderPass.GetShader(ShaderStage.Pixel).BindTexture(deviceContext, textureSlot, textureView); renderPass.GetShader(ShaderStage.Pixel).BindSampler(deviceContext, samplerSlot, textureSampler); deviceContext.DeviceContext.InputAssembler.InputLayout = VertexLayout; deviceContext.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList; int firstSlot = 0; InstanceBuffer?.AttachBuffer(deviceContext, ref firstSlot); deviceContext.DeviceContext.OutputMerger.SetBlendState(blendState, null, 0xFFFFFFFF); deviceContext.DeviceContext.DrawInstancedIndirect(particleCountGSIABuffer.Buffer, 0); InvalidateRenderer();//Since particle is running all the time. Invalidate once finished rendering }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { #region Initialize textures var buffer = context.RenderHost.RenderBuffer; if (depthdesc.Width != buffer.TargetWidth || depthdesc.Height != buffer.TargetHeight) { depthdesc.Width = buffer.TargetWidth; depthdesc.Height = buffer.TargetHeight; blurCore.Resize(deviceContext, depthdesc.Width / downSamplingScale, depthdesc.Height / downSamplingScale); //Skip this frame to avoid performance hit due to texture creation InvalidateRenderer(); return; } #endregion var depthStencilBuffer = buffer.FullResDepthStencilPool.Get(depthdesc.Format); #region Render objects onto offscreen texture var renderTargetFull = buffer.FullResPPBuffer.NextRTV; deviceContext.ClearDepthStencilView(depthStencilBuffer, DepthStencilClearFlags.Stencil, 0, 0); BindTarget(depthStencilBuffer, renderTargetFull, deviceContext, buffer.TargetWidth, buffer.TargetHeight); var frustum = context.BoundingFrustum; context.IsCustomPass = true; bool hasMesh = false; for (int i = 0; i < context.RenderHost.PerFrameNodesWithPostEffect.Count; ++i) { var mesh = context.RenderHost.PerFrameNodesWithPostEffect[i]; if (context.EnableBoundingFrustum && !mesh.TestViewFrustum(ref frustum)) { continue; } if (mesh.TryGetPostEffect(EffectName, out IEffectAttributes effect)) { object attribute; var color = Color; if (effect.TryGetAttribute(EffectAttributeNames.ColorAttributeName, out attribute) && attribute is string colorStr) { color = colorStr.ToColor4(); } if (modelStruct.Color != color) { modelStruct.Color = color; OnUploadPerModelConstantBuffers(deviceContext); } context.CustomPassName = DefaultPassNames.EffectOutlineP1; var pass = mesh.EffectTechnique[DefaultPassNames.EffectOutlineP1]; if (pass.IsNULL) { continue; } pass.BindShader(deviceContext); pass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState); mesh.Render(context, deviceContext); hasMesh = true; } } context.IsCustomPass = false; #endregion if (hasMesh) { #region Do Blur Pass BindTarget(null, blurCore.CurrentRTV, deviceContext, blurCore.Width, blurCore.Height, true); blurPassVertical.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); blurPassVertical.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.NextSRV); blurPassVertical.BindShader(deviceContext); blurPassVertical.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); deviceContext.Draw(4, 0); blurCore.Run(deviceContext, NumberOfBlurPass, 1, 0);//Already blur once on vertical, pass 1 as initial index. #endregion #region Draw back with stencil test BindTarget(depthStencilBuffer, renderTargetFull, deviceContext, buffer.TargetWidth, buffer.TargetHeight); screenQuadPass.PixelShader.BindTexture(deviceContext, textureSlot, blurCore.CurrentSRV); screenQuadPass.BindShader(deviceContext); screenQuadPass.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); deviceContext.Draw(4, 0); #endregion #region Draw outline onto original target BindTarget(null, buffer.FullResPPBuffer.CurrentRTV, deviceContext, buffer.TargetWidth, buffer.TargetHeight, false); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, buffer.FullResPPBuffer.NextSRV); screenOutlinePass.BindShader(deviceContext); screenOutlinePass.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); deviceContext.Draw(4, 0); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, null); #endregion } buffer.FullResDepthStencilPool.Put(depthdesc.Format, depthStencilBuffer); }
public override void Render(RenderContext context, DeviceContextProxy deviceContext) { EnsureTextureResources((int)context.ActualWidth, (int)context.ActualHeight, deviceContext); int texScale = (int)offScreenTextureSize; var viewport = context.Viewport; using (var ds = context.GetOffScreenDS(offScreenTextureSize, DEPTHFORMAT)) { using (var rt0 = context.GetOffScreenRT(offScreenTextureSize, RENDERTARGETFORMAT)) { using (var rt1 = context.GetOffScreenRT(offScreenTextureSize, SSAOTARGETFORMAT)) { var w = (int)(context.ActualWidth / texScale);// Make sure to set correct viewport width/height by quality var h = (int)(context.ActualHeight / texScale); deviceContext.SetRenderTarget(ds, rt0, true, new Color4(0, 0, 0, 1), true, DepthStencilClearFlags.Depth); deviceContext.SetViewport(0, 0, w, h); deviceContext.SetScissorRectangle(0, 0, w, h); IRenderTechnique currTechnique = null; var ssaoPass1 = ShaderPass.NullPass; var frustum = context.BoundingFrustum; for (var i = 0; i < context.RenderHost.PerFrameOpaqueNodesInFrustum.Count; ++i) { var node = context.RenderHost.PerFrameOpaqueNodesInFrustum[i]; if (currTechnique != node.EffectTechnique) { currTechnique = node.EffectTechnique; ssaoPass1 = currTechnique[DefaultPassNames.MeshSSAOPass]; } if (ssaoPass1.IsNULL) { continue; } node.RenderDepth(context, deviceContext, ssaoPass1); } var invProjection = context.ProjectionMatrix.Inverted(); ssaoParam.InvProjection = invProjection; ssaoParam.NoiseScale = new Vector2(w / 4f, h / 4f); ssaoParam.Radius = radius; ssaoParam.TextureScale = texScale; ssaoCB.ModelConstBuffer.UploadDataToBuffer(deviceContext, (dataBox) => { Debug.Assert(UnsafeHelper.SizeOf(kernels) + UnsafeHelper.SizeOf(ref ssaoParam) <= ssaoCB.ModelConstBuffer.bufferDesc.SizeInBytes); var nextPtr = UnsafeHelper.Write(dataBox.DataPointer, kernels, 0, kernels.Length); UnsafeHelper.Write(nextPtr, ref ssaoParam); }); deviceContext.SetRenderTarget(rt1); ssaoPass.BindShader(deviceContext); ssaoPass.BindStates(deviceContext, StateType.All); ssaoPass.PixelShader.BindTexture(deviceContext, ssaoTexSlot, rt0); ssaoPass.PixelShader.BindTexture(deviceContext, noiseTexSlot, ssaoNoiseView); ssaoPass.PixelShader.BindTexture(deviceContext, depthSlot, ds); ssaoPass.PixelShader.BindSampler(deviceContext, surfaceSampleSlot, surfaceSampler); ssaoPass.PixelShader.BindSampler(deviceContext, noiseSamplerSlot, noiseSampler); deviceContext.Draw(4, 0); ssaoPass.PixelShader.BindTexture(deviceContext, depthSlot, null); deviceContext.SetRenderTarget(ssaoView); deviceContext.SetViewport(ref viewport); deviceContext.SetScissorRectangle(ref viewport); ssaoBlur.BindShader(deviceContext); ssaoBlur.BindStates(deviceContext, StateType.All); ssaoBlur.PixelShader.BindTexture(deviceContext, ssaoTexSlot, rt1); ssaoBlur.PixelShader.BindSampler(deviceContext, surfaceSampleSlot, blurSampler); deviceContext.Draw(4, 0); context.SharedResource.SSAOMap = ssaoView; context.RenderHost.SetDefaultRenderTargets(false); deviceContext.SetShaderResource(PixelShader.Type, ssaoTexSlot, ssaoView); } } } }
public override void Render(RenderContext context, DeviceContextProxy deviceContext) { if (Buffer == null || TextureView == null || spritePass.IsNULL) { return; } var io = ImGui.GetIO(); ImGui.Render(); if (!UpdateBuffer(deviceContext)) { return; } ProjectionMatrix = Matrix.OrthoOffCenterRH( 0f, io.DisplaySize.X / context.DpiScale, io.DisplaySize.Y / context.DpiScale, 0.0f, -1.0f, 1.0f); int slot = 0; if (!Buffer.AttachBuffers(deviceContext, ref slot, EffectTechnique.EffectsManager)) { return; } var globalTrans = context.GlobalTransform; globalTrans.Projection = ProjectionMatrix; globalTransformCB.Upload(deviceContext, ref globalTrans); spritePass.BindShader(deviceContext); spritePass.BindStates(deviceContext, StateType.All); spritePass.PixelShader.BindTexture(deviceContext, texSlot, TextureView); spritePass.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); deviceContext.SetViewport(0, 0, io.DisplaySize.X, io.DisplaySize.Y); #region Render unsafe { var draw_data = ImGui.GetDrawData(); draw_data.ScaleClipRects(new System.Numerics.Vector2(context.DpiScale, context.DpiScale)); int idx_offset = 0; int vtx_offset = 0; for (int n = 0; n < draw_data.CmdListsCount; n++) { var cmd_list = draw_data.CmdListsRange[n]; for (int cmd_i = 0; cmd_i < cmd_list.CmdBuffer.Size; cmd_i++) { var pcmd = &(((ImDrawCmd *)cmd_list.CmdBuffer.Data)[cmd_i]); if (pcmd->UserCallback != IntPtr.Zero) { } else { deviceContext.SetScissorRectangle( (int)pcmd->ClipRect.X, (int)pcmd->ClipRect.Y, (int)(pcmd->ClipRect.Z), (int)(pcmd->ClipRect.W)); deviceContext.DrawIndexed((int)pcmd->ElemCount, idx_offset, vtx_offset); } idx_offset += (int)pcmd->ElemCount; } vtx_offset += cmd_list.VtxBuffer.Size; } #endregion } RaiseInvalidateRender(); }