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); } }
/// <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 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.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); }
/// <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); }
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); }
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 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(); } }
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; #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> /// /// </summary> /// <param name="context"></param> /// <param name="deviceContext"></param> protected override void OnUpdate(RenderContext context, DeviceContextProxy deviceContext) { UpdateTime(context, ref totalElapsed); //Set correct instance count from instance buffer drawArgument.InstanceCount = InstanceBuffer == null || !InstanceBuffer.HasElements ? 1 : (uint)InstanceBuffer.Buffer.ElementCount; //Upload the draw argument particleCountGSIABuffer.UploadDataToBuffer(deviceContext, ref drawArgument); updatePass.BindShader(deviceContext); updatePass.GetShader(ShaderStage.Compute).BindUAV(deviceContext, currentStateSlot, BufferProxies[0].UAV); updatePass.GetShader(ShaderStage.Compute).BindUAV(deviceContext, newStateSlot, BufferProxies[1].UAV); if (isRestart) { FrameVariables.NumParticles = 0; perFrameCB.UploadDataToBuffer(deviceContext, ref FrameVariables); // Call ComputeShader to add initial particles deviceContext.DeviceContext.Dispatch(1, 1, 1); isRestart = false; } else { #region Get consume buffer count // Get consume buffer count. //Due to some intel integrated graphic card having issue copy structure count directly into constant buffer. //Has to use staging buffer to read and pass into constant buffer FrameVariables.NumParticles = (uint)ReadCount("", deviceContext, BufferProxies[0]); perFrameCB.UploadDataToBuffer(deviceContext, ref FrameVariables); #endregion deviceContext.DeviceContext.Dispatch(Math.Max(1, (int)Math.Ceiling((double)FrameVariables.NumParticles / 512)), 1, 1); // Get append buffer count BufferProxies[1].CopyCount(deviceContext, particleCountGSIABuffer.Buffer, 0); } #if OUTPUTDEBUGGING ReadCount("UAV 0", deviceContext, BufferProxies[0].UAV); #endif if (totalElapsed > InsertElapseThrottle) { insertCB.UploadDataToBuffer(deviceContext, ref InsertVariables); // Add more particles insertPass.BindShader(deviceContext); insertPass.GetShader(ShaderStage.Compute).BindUAV(deviceContext, newStateSlot, BufferProxies[1].UAV); deviceContext.DeviceContext.Dispatch(1, 1, 1); totalElapsed = 0; #if OUTPUTDEBUGGING ReadCount("UAV 1", deviceContext, BufferProxies[1].UAV); #endif } // Swap UAV buffers for next frame var bproxy = BufferProxies[0]; BufferProxies[0] = BufferProxies[1]; BufferProxies[1] = bproxy; }
/// <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) { 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; } pass.BindShader(deviceContext); pass.BindStates(deviceContext, DefaultStateBinding); BindBillboardTexture(deviceContext, pass.PixelShader); OnDraw(deviceContext, 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 = 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); }
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); }
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 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 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); }
/// <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 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; }