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 }
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 }
/// <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 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); } } }
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 }
/// <summary> /// Draw call /// </summary> /// <param name="context"></param> /// <param name="instanceModel"></param> protected virtual void OnDraw(DeviceContextProxy context, IElementsBufferModel instanceModel) { if (GeometryBuffer.IndexBuffer != null) { if (instanceModel == null || !instanceModel.HasElements) { context.DrawIndexed(GeometryBuffer.IndexBuffer.ElementCount, GeometryBuffer.IndexBuffer.Offset, 0); } else { context.DrawIndexedInstanced(GeometryBuffer.IndexBuffer.ElementCount, instanceModel.Buffer.ElementCount, GeometryBuffer.IndexBuffer.Offset, 0, instanceModel.Buffer.Offset); } } else if (GeometryBuffer.VertexBuffer.Length > 0) { if (instanceModel == null || !instanceModel.HasElements) { context.Draw(GeometryBuffer.VertexBuffer[0].ElementCount, 0); } else { context.DrawInstanced(GeometryBuffer.VertexBuffer[0].ElementCount, instanceModel.Buffer.ElementCount, 0, instanceModel.Buffer.Offset); } } }
protected override void OnUpdate(RenderContext context, DeviceContextProxy deviceContext) { //Skip if not ready if (preComputeBoneSkinPass.IsNULL || preComputeBoneBuffer == null || !preComputeBoneBuffer.CanPreCompute) { return; } //Skip if not necessary if (!matricsChanged && !mtChanged) { return; } var boneBuffer = sharedBoneBuffer ?? internalBoneBuffer; if (boneBuffer.BoneMatrices.Length == 0 && !mtChanged) { preComputeBoneBuffer.ResetSkinnedVertexBuffer(deviceContext); } else { GeometryBuffer.UpdateBuffers(deviceContext, EffectTechnique.EffectsManager); preComputeBoneBuffer.BindSkinnedVertexBufferToOutput(deviceContext); boneBuffer.Update(context, deviceContext); internalMTBuffer.Update(context, deviceContext); preComputeBoneSkinPass.BindShader(deviceContext); boneBuffer.BindBuffer(deviceContext, boneSkinSBSlot); internalMTBuffer.BindBuffers(deviceContext, mtWeightsBSlot, mtDeltasBSlot, mtOffsetsBSlot); deviceContext.Draw(GeometryBuffer.VertexBuffer[0].ElementCount, 0); preComputeBoneBuffer.UnBindSkinnedVertexBufferToOutput(deviceContext); } matricsChanged = false; }
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); }
public static void DrawPoints(DeviceContextProxy context, IElementsBufferProxy vertexBuffer, IElementsBufferModel instanceModel) { if (!instanceModel.HasElements) { context.Draw(vertexBuffer.ElementCount, 0); } else { context.DrawInstanced(vertexBuffer.ElementCount, instanceModel.Buffer.ElementCount, 0, 0); } }
public static void DrawPoints(DeviceContextProxy context, int vertexCount, int instanceCount) { if (instanceCount <= 0) { context.Draw(vertexCount, 0); } else { context.DrawInstanced(vertexCount, instanceCount, 0, 0); } }
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); }
private void DrawCursor(ref PointerInfo pointer, DeviceContextProxy deviceContext) { if (!pointer.Visible || frameProcessor.PointerResource == null) { return; } CursorShaderPass.PixelShader.BindTexture(deviceContext, textureBindSlot, frameProcessor.PointerResource); CursorShaderPass.BindShader(deviceContext); CursorShaderPass.BindStates(deviceContext, StateType.DepthStencilState | StateType.RasterState | StateType.BlendState); //deviceContext.DeviceContext.OutputMerger.SetBlendState(CursorShaderPass.BlendState, new RawColor4(0, 0, 0, 0)); //Set special blend factor deviceContext.Draw(4, 0); }
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); }
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 OnDraw(DeviceContextProxy context, IElementsBufferModel instanceModel) { if (GeometryBuffer.VertexBuffer.Length > 0) { if (instanceModel == null || !instanceModel.HasElements) { context.Draw(GeometryBuffer.VertexBuffer[0].ElementCount, 0); } else { context.DrawInstanced(GeometryBuffer.VertexBuffer[0].ElementCount, instanceModel.Buffer.ElementCount, 0, 0); } } }
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) { if (context.Camera.CreateLeftHandSystem && RasterDescription.IsFrontCounterClockwise) { var desc = RasterDescription; desc.IsFrontCounterClockwise = false; RasterDescription = desc; InvalidateRenderer(); return; } DefaultShaderPass.BindShader(deviceContext); DefaultShaderPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState); DefaultShaderPass.PixelShader.BindTexture(deviceContext, cubeTextureSlot, cubeTextureRes); DefaultShaderPass.PixelShader.BindSampler(deviceContext, textureSamplerSlot, textureSampler); deviceContext.Draw(GeometryBuffer.VertexBuffer[0].ElementCount, 0); }
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); }
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); }
protected override void OnUpdate(RenderContext context, DeviceContextProxy deviceContext) { if (preComputeBoneSkinPass.IsNULL || preComputeBoneBuffer == null || !preComputeBoneBuffer.CanPreCompute || !matricsChanged) { return; } var buffer = sharedBoneBuffer ?? internalBoneBuffer; if (buffer.BoneMatrices.Length == 0) { preComputeBoneBuffer.ResetSkinnedVertexBuffer(deviceContext); } else { GeometryBuffer.UpdateBuffers(deviceContext, EffectTechnique.EffectsManager); preComputeBoneBuffer.BindSkinnedVertexBufferToOutput(deviceContext); buffer.Update(context, deviceContext); preComputeBoneSkinPass.BindShader(deviceContext); buffer.BindBuffer(deviceContext, boneSkinSBSlot); deviceContext.Draw(GeometryBuffer.VertexBuffer[0].ElementCount, 0); preComputeBoneBuffer.UnBindSkinnedVertexBufferToOutput(deviceContext); } matricsChanged = false; }
/// <summary> /// Called when [render]. /// </summary> /// <param name="context">The context.</param> /// <param name="deviceContext">The device context.</param> public override void Render(RenderContext context, DeviceContextProxy deviceContext) { var succ = duplicationResource.Initialize(); if (!succ) { RaiseInvalidateRender(); return; } context.RenderHost.RenderConfiguration = config; if (duplicationResource.GetFrame(Output, out var data, ref pointer, out var isTimeOut, out var accessLost)) { if (data.FrameInfo.TotalMetadataBufferSize > 0) { frameProcessor.ProcessFrame(ref data, deviceContext); } invalidRender = true; } if (frameProcessor.SharedTexture != null && !accessLost) { if (clearTarget) { clearTarget = false; context.RenderHost.ClearRenderTarget(deviceContext, true, false); } var cursorValid = false; if (pointer.Visible) { if (frameProcessor.ProcessCursor(ref pointer, deviceContext, out var rect)) { GetCursorVertexBound((int)context.ActualWidth, (int)context.ActualHeight, frameProcessor.TextureWidth, frameProcessor.TextureHeight, ref rect); invalidRender = true; cursorValid = true; } } if (invalidRender) { OnUpdatePerModelStruct(context); modelCB.Upload(deviceContext, ref modelStruct); DefaultShaderPass.BindShader(deviceContext); DefaultShaderPass.BindStates(deviceContext, StateType.BlendState | StateType.DepthStencilState | StateType.RasterState); DefaultShaderPass.PixelShader.BindSampler(deviceContext, samplerBindSlot, textureSampler); var left = (int)(context.ActualWidth * Math.Abs(modelStruct.TopLeft.X + 1) / 2); var top = (int)(context.ActualHeight * Math.Abs(modelStruct.TopLeft.Y - 1) / 2); deviceContext.SetScissorRectangle(left, top, (int)context.ActualWidth - left, (int)context.ActualHeight - top); using (var textureView = new global::SharpDX.Direct3D11.ShaderResourceView(deviceContext, frameProcessor.SharedTexture)) { deviceContext.SetShaderResource(PixelShader.Type, textureBindSlot, textureView); deviceContext.Draw(4, 0); } if (ShowMouseCursor && cursorValid) { DrawCursor(ref pointer, deviceContext); } invalidRender = false; } } if (isTimeOut) { } else if (accessLost) { throw new SharpDXException(ResultCode.AccessLost); } else { duplicationResource.ReleaseFrame(); } RaiseInvalidateRender(); }
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); }
protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext) { var buffer = context.RenderHost.RenderBuffer; #region Initialize textures if (offScreenRenderTargets.Count == 0 || width != (int)(context.ActualWidth) || height != (int)(context.ActualHeight)) { width = (int)(context.ActualWidth); height = (int)(context.ActualHeight); for (int i = 0; i < offScreenRenderTargets.Count; ++i) { var target = offScreenRenderTargets[i]; RemoveAndDispose(ref target); } offScreenRenderTargets.Clear(); int w = width; int h = height; int count = 0; while (w > 1 && h > 1 && count < Math.Max(0, MaximumDownSamplingStep) + 1) { var target = Collect(new PostEffectBlurCore(global::SharpDX.DXGI.Format.B8G8R8A8_UNorm, blurPassVertical, blurPassHorizontal, textureSlot, samplerSlot, DefaultSamplers.LinearSamplerClampAni1, EffectTechnique.EffectsManager)); target.Resize(Device, w, h); offScreenRenderTargets.Add(target); w >>= 2; h >>= 2; ++count; } //Skip this frame to avoid performance hit due to texture creation InvalidateRenderer(); return; } #endregion #region Render objects onto offscreen texture using (var resource2 = offScreenRenderTargets[0].CurrentRTV.Resource) { deviceContext.CopyResource(buffer.FullResPPBuffer.CurrentTexture, resource2); } #endregion #region Do Bloom Pass modelCB.Upload(deviceContext, ref modelStruct); //Extract bloom samples BindTarget(null, offScreenRenderTargets[0].NextRTV, deviceContext, offScreenRenderTargets[0].Width, offScreenRenderTargets[0].Height, false); screenQuadPass.PixelShader.BindTexture(deviceContext, textureSlot, offScreenRenderTargets[0].CurrentSRV); screenQuadPass.PixelShader.BindSampler(deviceContext, samplerSlot, sampler); screenQuadPass.BindShader(deviceContext); screenQuadPass.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); deviceContext.Draw(4, 0); offScreenRenderTargets[0].SwapTargets(); // Down sampling screenQuadCopy.BindShader(deviceContext); screenQuadCopy.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); for (int i = 1; i < offScreenRenderTargets.Count; ++i) { BindTarget(null, offScreenRenderTargets[i].CurrentRTV, deviceContext, offScreenRenderTargets[i].Width, offScreenRenderTargets[i].Height, false); screenQuadCopy.PixelShader.BindTexture(deviceContext, textureSlot, offScreenRenderTargets[i - 1].CurrentSRV); deviceContext.Draw(4, 0); } for (int i = offScreenRenderTargets.Count - 1; i >= 1; --i) { //Run blur pass offScreenRenderTargets[i].Run(deviceContext, NumberOfBlurPass); //Up sampling screenOutlinePass.BindShader(deviceContext); screenOutlinePass.BindStates(deviceContext, StateType.BlendState | StateType.RasterState | StateType.DepthStencilState); BindTarget(null, offScreenRenderTargets[i - 1].CurrentRTV, deviceContext, offScreenRenderTargets[i - 1].Width, offScreenRenderTargets[i - 1].Height, false); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, offScreenRenderTargets[i].CurrentSRV); deviceContext.Draw(4, 0); } offScreenRenderTargets[0].Run(deviceContext, NumberOfBlurPass); #endregion #region Draw outline onto original target BindTarget(null, buffer.FullResPPBuffer.CurrentRTV, deviceContext, buffer.TargetWidth, buffer.TargetHeight, false); screenOutlinePass.PixelShader.BindTexture(deviceContext, textureSlot, offScreenRenderTargets[0].CurrentSRV); 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) { 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); } } } }