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;
}
