private static void DebugDraw(ISrvBindable src, IRtvBindable dst, MyViewport viewport)
{
RC.PixelShader.Set(m_copyPS);
RC.SetRtv(dst);
RC.PixelShader.SetSrv(0, src);
MyScreenPass.DrawFullscreenQuad(viewport);
}
internal void Render()
{
var foliageComponents = MyFoliageComponents.ActiveComponents;
if (foliageComponents.Count <= 0)
{
return;
}
ViewProjection = MyRender11.Environment.Matrices.ViewProjectionAt0;
Viewport = new MyViewport(MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y);
PerFrame();
Begin();
var viewFrustum = new BoundingFrustumD(MyRender11.Environment.Matrices.ViewProjectionD);
foreach (var foliageComponent in foliageComponents)
{
var renderableComponent = foliageComponent.Owner.GetRenderable();
bool removeDitheringInProgress = renderableComponent.m_objectDithering > 0 && renderableComponent.m_objectDithering < 2;
if (!removeDitheringInProgress && foliageComponent.Owner.CalculateCameraDistance() < MyRender11.RenderSettings.FoliageDetails.GrassDrawDistance())
{
if (viewFrustum.Contains(foliageComponent.Owner.Aabb) != ContainmentType.Disjoint)
{
foliageComponent.Render(this);
}
}
}
End();
}
static void DrawBlurYPS(IRtvBindable dst, MyViewport viewport)
{
RC.SetRtv(dst);
RC.PixelShader.Set(m_blurYPS);
RC.PixelShader.SetSrv(0, m_fullResAOZTexture);
MyScreenPass.DrawFullscreenQuad(viewport);
}
static void DrawLinearDepthPS(ISrvBindable resolvedDepth, IRtvBindable rtv, MyViewport viewport)
{
RC.PixelShader.Set(m_linearizeDepthPS);
//RC.SetRtv(m_fullResViewDepthTarget);
RC.SetRtv(rtv);
RC.PixelShader.SetSrv(0, resolvedDepth);
MyScreenPass.DrawFullscreenQuad(viewport);
RC.SetRtv(null);
}
static MyViewport GetQuarterViewport(MyViewport viewport)
{
MyViewport qViewport;
qViewport.OffsetX = 0;
qViewport.OffsetY = 0;
qViewport.Width = DivUp((int)viewport.Width, 4);
qViewport.Height = DivUp((int)viewport.Height, 4);
return(qViewport);
}
private static void DrawSprites(IRtvBindable texture, MyViewport viewPort)
{
GetRenderProfiler().StartProfilingBlock("MySpritesRenderer.Draw");
MyStatsUpdater.Timestamps.Update(ref MyStatsUpdater.Timestamps.PreDrawSprites_Draw);
MyGpuProfiler.IC_BeginBlock("SpriteRenderer");
MySpritesRenderer.Draw(texture, viewPort);
MyGpuProfiler.IC_EndBlock();
MyStatsUpdater.Timestamps.Update(ref MyStatsUpdater.Timestamps.PostDrawSprites_Draw);
GetRenderProfiler().EndProfilingBlock();
}
static void DrawBlurXPS(MyViewport viewport)
{
RC.SetRtv(m_fullResAOZTexture);
RC.PixelShader.Set(m_blurXPS);
RC.PixelShader.SetSrv(0, m_fullResAOZTexture2);
RC.PixelShader.SetSamplers(0, MySamplerStateManager.Point);
RC.PixelShader.SetSamplers(1, MySamplerStateManager.Linear);
MyScreenPass.DrawFullscreenQuad(viewport);
}
static void Resolve(bool blur, IRtvBindable dst, MyViewport viewport)
{
RC.SetRtv(dst);
RC.PixelShader.SetSrv(0, m_quarterResAOTextureArray);
if (blur)
{
RC.PixelShader.Set(m_reinterleaveAOPS_PreBlur);
RC.PixelShader.SetSrv(1, m_fullResViewDepthTarget);
}
else
{
RC.PixelShader.Set(m_reinterleaveAOPS);
}
RC.PixelShader.SetSamplers(0, MySamplerStateManager.PointHBAOClamp);
MyScreenPass.DrawFullscreenQuad(viewport);
}
internal void AddMainViewPass(MyViewport viewport, MyGBuffer gbuffer)
{
int frustumMask = AddFrustum(ref MyRender11.Environment.ViewProjectionD);
FrustumCullQueries[Size - 1].Type = MyFrustumEnum.MainFrustum;
var pass = MyObjectPoolManager.Allocate <MyGBufferPass>();
pass.ProcessingMask = frustumMask;
pass.ViewProjection = MyRender11.Environment.ViewProjectionAt0;
pass.Viewport = viewport;
pass.GBuffer = gbuffer;
pass.PerFrame();
RenderingPasses[Size - 1] = pass;
}
internal virtual void Cleanup()
{
m_RC = null;
if (Locals != null)
{
Locals.Clear();
}
Stats.Clear();
m_joined = false;
m_currentProfilingBlock_renderableType = -1;
m_currentProfilingBlock_renderableMaterial = string.Empty;
m_isImmediate = false;
ViewProjection = default(Matrix);
Viewport = default(MyViewport);
DebugName = string.Empty;
ProcessingMask = 0;
}
static void DrawDeinterleavedDepth(MyViewport viewport)
{
var qViewport = GetQuarterViewport(viewport);
RC.PixelShader.Set(m_deinterleaveDepthPS);
RC.PixelShader.SetSrv(0, m_fullResViewDepthTarget);
var rtvs = new IRtvBindable[MAX_NUM_MRTS];
for (int sliceIndex = 0; sliceIndex < NUM_SLICES; sliceIndex += MAX_NUM_MRTS)
{
for (int i = 0; i < MAX_NUM_MRTS; i++)
{
rtvs[i] = m_quarterResViewDepthTextureArray.SubresourceRtv(sliceIndex + i);
}
RC.SetRtvs(rtvs);
RC.PixelShader.SetConstantBuffer(1, m_perPassCBs[sliceIndex]);
MyScreenPass.DrawFullscreenQuad(qViewport);
}
}
internal static void Run(IRtvTexture dst, MyGBuffer gbuffer, ISrvBindable resolvedDepth, MyViewport?viewport = null)
{
CompilePS();
if (!viewport.HasValue)
{
viewport = new MyViewport(0, 0, MyRender11.m_resolution.X, MyRender11.m_resolution.Y);
}
var data = InitConstantBuffer(viewport.Value);
var mapping = MyMapping.MapDiscard(m_dataCB);
mapping.WriteAndPosition(ref data);
mapping.Unmap();
RC.PixelShader.SetConstantBuffer(0, m_dataCB);
RC.PixelShader.SetSamplers(0, MySamplerStateManager.PointHBAOClamp);
RC.SetBlendState(null);
DrawLinearDepthPS(resolvedDepth, m_fullResViewDepthTarget, viewport.Value);
DrawDeinterleavedDepth(viewport.Value);
DrawCoarseAO(gbuffer, viewport.Value);
if (Params.BlurEnable)
{
Resolve(true, m_fullResAOZTexture2, viewport.Value);
DrawBlurXPS(viewport.Value);
DrawBlurYPS(dst, viewport.Value);
}
else
{
Resolve(false, dst, viewport.Value);
}
RC.SetRtv(null);
}
static void DrawCoarseAO(MyGBuffer gbuffer, MyViewport viewport)
{
var qViewport = GetQuarterViewport(viewport);
RC.PixelShader.Set(m_coarseAOPS);
RC.PixelShader.SetSamplers(0, Params.DepthClampToEdge ? MySamplerStateManager.PointHBAOClamp : MySamplerStateManager.PointHBAOBorder);
RC.PixelShader.SetSamplers(1, MySamplerStateManager.PointHBAOClamp);
RC.PixelShader.SetSrv(1, gbuffer.GBuffer1);
for (int sliceIndex = 0; sliceIndex < NUM_SLICES; ++sliceIndex)
{
RC.PixelShader.SetSrv(0, m_quarterResViewDepthTextureArray.SubresourceSrv(sliceIndex));
RC.PixelShader.SetConstantBuffer(1, m_perPassCBs[sliceIndex]);
RC.GeometryShader.SetConstantBuffer(1, m_perPassCBs[sliceIndex]);
RC.SetRtv(m_quarterResAOTextureArray.SubresourceRtv(sliceIndex));
MyScreenPass.DrawFullscreenQuad(qViewport);
}
RC.GeometryShader.Set(null);
}
// viewport, render target
internal unsafe static void Draw(RenderTargetView rtv, MyViewport viewport)
{
if (StackTop().m_internalBatch.Texture != null && StackTop().m_internalBatch.Count > 0)
{
StackTop().m_internalBatch.Commit();
}
StackTop().m_internalBatch = new MySpritesBatch();
RC.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip;
RC.SetIL(m_inputLayout);
//RC.SetupScreenViewport();
RC.DeviceContext.Rasterizer.SetViewport(viewport.OffsetX, viewport.OffsetY, viewport.Width, viewport.Height);
RC.SetVS(m_vs);
RC.SetCB(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.SetCB(MyCommon.PROJECTION_SLOT, MyCommon.GetObjectCB(64));
RC.SetPS(m_ps);
RC.DeviceContext.PixelShader.SetSamplers(0, MyRender11.StandardSamplers);
//RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, MyRender11.Backbuffer);
// to reset state
RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, null);
RC.DeviceContext.OutputMerger.SetRenderTargets(rtv);
RC.SetBS(MyRender11.BlendGui);
CheckBufferSize(StackTop().m_instances.Count);
RC.SetVB(0, m_VB.Buffer, m_VB.Stride);
var mapping = MyMapping.MapDiscard(m_VB.Buffer);
for (int i = 0; i < StackTop().m_instances.Count; i++)
{
var helper = StackTop().m_instances[i];
mapping.WriteAndPosition(ref helper);
}
mapping.Unmap();
mapping = MyMapping.MapDiscard(MyCommon.GetObjectCB(64));
var viewportSize = new Vector2(viewport.Width, viewport.Height);
mapping.WriteAndPosition(ref viewportSize);
mapping.Unmap();
foreach (var batch in StackTop().m_batches)
{
if (batch.ScissorRectangle.HasValue)
{
RC.SetRS(MyRender11.m_scissorTestRasterizerState);
var scissor = batch.ScissorRectangle.Value;
RC.DeviceContext.Rasterizer.SetScissorRectangle((int)scissor.X, (int)scissor.Y, (int)(scissor.X + scissor.Width), (int)(scissor.Y + scissor.Height));
}
else
{
RC.SetRS(MyRender11.m_nocullRasterizerState);
}
RC.BindRawSRV(0, batch.Texture);
RC.DeviceContext.DrawInstanced(4, batch.Count, 0, batch.Start);
}
RC.SetBS(null);
RC.SetRS(null);
StackTop().m_instances.Clear();
StackTop().m_batches.Clear();
}
internal static void AddShadowCaster(BoundingFrustumD frustum, Matrix viewProjectionLocal, MyViewport viewport, DepthStencilView depthTarget, bool isCascade, string debugName)
{
var frustumMask = m_cullQuery.AddFrustum(frustum);
MyDepthPass pass = new MyDepthPass();
pass.DebugName = debugName;
pass.Cleanup();
pass.ProcessingMask = frustumMask;
pass.ViewProjection = viewProjectionLocal;
pass.Viewport = viewport;
pass.DSV = depthTarget;
pass.DefaultRasterizer = isCascade ? MyRender11.m_cascadesRasterizerState : MyRender11.m_shadowRasterizerState;
pass.PerFrame();
m_wavefront.Add(pass);
}
internal static void AddForwardCamera(ref Matrix offsetedViewProjection, ref MatrixD viewProjection, MyViewport viewport, DepthStencilView dsv, RenderTargetView rtv)
{
var frustumMask = m_cullQuery.AddFrustum(new BoundingFrustumD(viewProjection));
MyForwardPass pass = new MyForwardPass();
pass.Cleanup();
pass.ProcessingMask = frustumMask;
pass.ViewProjection = offsetedViewProjection;
pass.Viewport = viewport;
pass.DSV = dsv;
pass.RTV = rtv;
pass.PerFrame();
m_wavefront.Add(pass);
}
internal static void AddCamera(ref MatrixD viewMatrix, ref MatrixD projectionMatrix, MyViewport viewport, MyGBuffer gbuffer)
{
var frustumMask = m_cullQuery.AddFrustum(new BoundingFrustumD(MyEnvironment.ViewProjectionD));
MyGBufferPass pass = new MyGBufferPass();
pass.Cleanup();
pass.ProcessingMask = frustumMask;
pass.ViewProjection = MyEnvironment.ViewProjectionAt0;
pass.Viewport = viewport;
pass.GBuffer = gbuffer;
pass.PerFrame();
m_wavefront.Add(pass);
}
// viewport, render target
internal unsafe static void Draw(IRtvBindable rtv, MyViewport viewport, IBlendState blendstate = null)
{
if (StackTop.m_internalBatch.Texture != null && StackTop.m_internalBatch.Count > 0)
{
StackTop.m_internalBatch.Commit();
}
StackTop.m_internalBatch = new MySpritesBatch();
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleStrip);
RC.SetInputLayout(m_inputLayout);
//RC.SetScreenViewport();
RC.SetViewport(viewport.OffsetX, viewport.OffsetY, viewport.Width, viewport.Height);
RC.VertexShader.Set(m_vs);
RC.AllShaderStages.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.AllShaderStages.SetConstantBuffer(MyCommon.PROJECTION_SLOT, MyCommon.GetObjectCB(64));
RC.PixelShader.Set(m_ps);
RC.PixelShader.SetSamplers(0, MySamplerStateManager.StandardSamplers);
//RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, MyRender11.Backbuffer);
// to reset state
RC.SetRtv(rtv);
RC.SetBlendState(blendstate == null ? MyBlendStateManager.BlendAlphaPremult : blendstate);
RC.SetDepthStencilState(MyDepthStencilStateManager.IgnoreDepthStencil, 0);
CheckBufferSize(StackTop.m_instances.Count);
RC.SetVertexBuffer(0, m_VB);
var mapping = MyMapping.MapDiscard(m_VB);
for (int i = 0; i < StackTop.m_instances.Count; i++)
{
var helper = StackTop.m_instances[i];
mapping.WriteAndPosition(ref helper);
}
mapping.Unmap();
mapping = MyMapping.MapDiscard(MyCommon.GetObjectCB(64));
var viewportSize = new Vector2(viewport.Width, viewport.Height);
mapping.WriteAndPosition(ref viewportSize);
mapping.Unmap();
foreach (var batch in StackTop.m_batches)
{
if (batch.ScissorRectangle.HasValue)
{
RC.SetRasterizerState(MyRasterizerStateManager.ScissorTestRasterizerState);
var scissor = batch.ScissorRectangle.Value;
RC.SetScissorRectangle((int)scissor.X, (int)scissor.Y, (int)(scissor.X + scissor.Width), (int)(scissor.Y + scissor.Height));
}
else
{
RC.SetRasterizerState(MyRasterizerStateManager.NocullRasterizerState);
}
RC.PixelShader.SetSrv(0, batch.Texture);
RC.DrawInstanced(4, batch.Count, 0, batch.Start);
}
RC.SetBlendState(null);
RC.SetRasterizerState(null);
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
StackTop.m_instances.Clear();
StackTop.m_batches.Clear();
}
internal void AddDepthPass(ref MatrixD worldToProjection, Matrix viewProjectionLocal, MyViewport viewport, DepthStencilView depthTarget, bool isCascade, string debugName)
{
int frustumMask = AddFrustum(ref worldToProjection);
MyDepthPass pass = MyObjectPoolManager.Allocate <MyDepthPass>();
pass.DebugName = debugName;
pass.ProcessingMask = frustumMask;
pass.ViewProjection = viewProjectionLocal;
pass.Viewport = viewport;
pass.DSV = depthTarget;
pass.DefaultRasterizer = isCascade ? MyRender11.m_cascadesRasterizerState : MyRender11.m_shadowRasterizerState;
pass.PerFrame();
RenderingPasses[Size - 1] = pass;
}
static GlobalConstantBuffer InitConstantBuffer(MyViewport viewport)
{
GlobalConstantBuffer m_Data = new GlobalConstantBuffer();
Matrix m = MyRender11.Environment.Matrices.Projection;
// ProjectionMatrixInfo
// In matrices generated with D3DXMatrixPerspectiveFovRH
// A = zf/(zn-zf)
// B = zn*zf/(zn-zf)
// C = -1
float A = m.M33;
float B = m.M43;
// Rely on INFs to be generated in case of any divisions by zero
float zNear = B / A;
float zFar = B / (A + 1);
// Some matrices may use negative m00 or m11 terms to flip X/Y axises
float tanHalfFovX = 1 / Math.Abs(m.M11);
float tanHalfFovY = 1 / Math.Abs(m.M22);
// SetDepthLinearizationConstants
const float EPSILON = 1e-6f;
float inverseZNear = Math.Max(1 / zNear, EPSILON);
float inverseZFar = Math.Max(1 / zFar, EPSILON);
m_Data.LinearizeDepthA = inverseZFar - inverseZNear;
m_Data.LinearizeDepthB = inverseZNear;
// SetViewportConstants
m_Data.InverseDepthRangeA = 1f;
m_Data.InverseDepthRangeB = 0f;
m_Data.InputViewportTopLeft.X = viewport.OffsetX;
m_Data.InputViewportTopLeft.Y = viewport.OffsetY;
// SetProjectionConstants
m_Data.UVToViewA.X = 2 * tanHalfFovX;
m_Data.UVToViewA.Y = -2 * tanHalfFovY;
m_Data.UVToViewB.X = -1 * tanHalfFovX;
m_Data.UVToViewB.Y = 1 * tanHalfFovY;
// SetResolutionConstants
m_Data.InvFullResolution.X = 1.0f / viewport.Width;
m_Data.InvFullResolution.Y = 1.0f / viewport.Height;
m_Data.InvQuarterResolution.X = 1.0f / DivUp((int)viewport.Width, 4);
m_Data.InvQuarterResolution.Y = 1.0f / DivUp((int)viewport.Height, 4);
// SetNormalData
m_Data.NormalMatrix = MyRender11.Environment.Matrices.ViewAt0;
m_Data.NormalDecodeScale = 2;
m_Data.NormalDecodeBias = -1;
// SetAORadiusConstants
float radiusInMeters = Math.Max(Params.Radius, EPSILON);
float r = radiusInMeters * METERS_TO_VIEW_SPACE_UNITS;
m_Data.R2 = r * r;
m_Data.NegInvR2 = -1 / m_Data.R2;
m_Data.RadiusToScreen = r * 0.5f / tanHalfFovY * viewport.Height;
float backgroundViewDepth = Math.Max(Params.BackgroundViewDepth, EPSILON);
m_Data.BackgroundAORadiusPixels = m_Data.RadiusToScreen / backgroundViewDepth;
float foregroundViewDepth = Math.Max(Params.ForegroundViewDepth, EPSILON);
m_Data.ForegroundAORadiusPixels = m_Data.RadiusToScreen / foregroundViewDepth;
// SetBlurConstants
float BaseSharpness = Math.Max(Params.BlurSharpness, 0);
BaseSharpness /= METERS_TO_VIEW_SPACE_UNITS;
if (Params.BlurSharpnessFunctionEnable)
{
m_Data.BlurViewDepth0 = Math.Max(Params.BlurSharpnessFunctionForegroundViewDepth, 0);
m_Data.BlurViewDepth1 = Math.Max(Params.BlurSharpnessFunctionBackgroundViewDepth, m_Data.BlurViewDepth0 + EPSILON);
m_Data.BlurSharpness0 = BaseSharpness * Math.Max(Params.BlurSharpnessFunctionForegroundScale, 0);
m_Data.BlurSharpness1 = BaseSharpness;
}
else
{
m_Data.BlurSharpness0 = BaseSharpness;
m_Data.BlurSharpness1 = BaseSharpness;
m_Data.BlurViewDepth0 = 0;
m_Data.BlurViewDepth1 = 1;
}
// SetDepthThresholdConstants
if (Params.DepthThresholdEnable)
{
m_Data.ViewDepthThresholdNegInv = -1 / Math.Max(Params.DepthThreshold, EPSILON);
m_Data.ViewDepthThresholdSharpness = Math.Max(Params.DepthThresholdSharpness, 0);
}
else
{
m_Data.ViewDepthThresholdNegInv = 0;
m_Data.ViewDepthThresholdSharpness = 1;
}
// SetAOParameters
m_Data.PowExponent = Math.Min(Math.Max(Params.PowerExponent, 1), 8);
m_Data.NDotVBias = Math.Min(Math.Max(Params.Bias, 0.0f), 0.5f);
float aoAmountScaleFactor = 1 / (1 - m_Data.NDotVBias);
m_Data.SmallScaleAOAmount = Math.Min(Math.Max(Params.SmallScaleAO, 0), 4) * aoAmountScaleFactor * 2;
m_Data.LargeScaleAOAmount = Math.Min(Math.Max(Params.LargeScaleAO, 0), 4) * aoAmountScaleFactor;
return(m_Data);
}
internal void AddForwardPass(int index, ref Matrix offsetedViewProjection, ref MatrixD viewProjection, MyViewport viewport, IDsvBindable dsv, IRtvBindable rtv)
{
int frustumMask = AddFrustum(ref viewProjection);
MyForwardPass pass = MyObjectPoolManager.Allocate <MyForwardPass>();
pass.DebugName = "EnvironmentProbe";
pass.ProcessingMask = frustumMask;
pass.ViewProjection = offsetedViewProjection;
pass.Viewport = viewport;
pass.FrustumIndex = index;
pass.Dsv = dsv;
pass.Rtv = rtv;
pass.PerFrame();
RenderingPasses[Size - 1] = pass;
}
internal void AddForwardPass(ref Matrix offsetedViewProjection, ref MatrixD viewProjection, MyViewport viewport, DepthStencilView dsv, RenderTargetView rtv)
{
int frustumMask = AddFrustum(ref viewProjection);
MyForwardPass pass = MyObjectPoolManager.Allocate <MyForwardPass>();
pass.ProcessingMask = frustumMask;
pass.ViewProjection = offsetedViewProjection;
pass.Viewport = viewport;
pass.DSV = dsv;
pass.RTV = rtv;
pass.PerFrame();
RenderingPasses[Size - 1] = pass;
}
