void BuildGPULightList(RenderGraph renderGraph, HDCamera hdCamera, RenderGraphResource depthStencilBuffer, RenderGraphResource stencilBufferCopy, GBufferOutput gBuffer)
{
using (var builder = renderGraph.AddRenderPass <BuildGPULightListPassData>("Build Light List", out var passData))
{
builder.EnableAsyncCompute(hdCamera.frameSettings.BuildLightListRunsAsync());
passData.lightDataGlobalParameters = PrepareLightDataGlobalParameters(hdCamera);
passData.shadowGlobalParameters = PrepareShadowGlobalParameters(hdCamera);
passData.lightLoopGlobalParameters = PrepareLightLoopGlobalParameters(hdCamera);
passData.buildGPULightListParameters = PrepareBuildGPULightListParameters(hdCamera);
// TODO: Move this inside the render function onces compute buffers are RenderGraph ready
passData.buildGPULightListResources = PrepareBuildGPULightListResources(m_TileAndClusterData, null, null);
passData.depthBuffer = builder.ReadTexture(depthStencilBuffer);
passData.stencilTexture = builder.ReadTexture(stencilBufferCopy);
if (passData.buildGPULightListParameters.computeMaterialVariants && passData.buildGPULightListParameters.enableFeatureVariants)
{
for (int i = 0; i < gBuffer.gBufferCount; ++i)
{
passData.gBuffer[i] = builder.ReadTexture(gBuffer.mrt[i]);
}
passData.gBufferCount = gBuffer.gBufferCount;
}
builder.SetRenderFunc(
(BuildGPULightListPassData data, RenderGraphContext context) =>
{
bool tileFlagsWritten = false;
data.buildGPULightListResources.depthBuffer = context.resources.GetTexture(data.depthBuffer);
data.buildGPULightListResources.stencilTexture = context.resources.GetTexture(data.stencilTexture);
if (passData.buildGPULightListParameters.computeMaterialVariants && passData.buildGPULightListParameters.enableFeatureVariants)
{
data.buildGPULightListResources.gBuffer = context.renderGraphPool.GetTempArray <RTHandle>(data.gBufferCount);
for (int i = 0; i < data.gBufferCount; ++i)
{
data.buildGPULightListResources.gBuffer[i] = context.resources.GetTexture(data.gBuffer[i]);
}
}
GenerateLightsScreenSpaceAABBs(data.buildGPULightListParameters, data.buildGPULightListResources, context.cmd);
BigTilePrepass(data.buildGPULightListParameters, data.buildGPULightListResources, context.cmd);
BuildPerTileLightList(data.buildGPULightListParameters, data.buildGPULightListResources, ref tileFlagsWritten, context.cmd);
VoxelLightListGeneration(data.buildGPULightListParameters, data.buildGPULightListResources, context.cmd);
BuildDispatchIndirectArguments(data.buildGPULightListParameters, data.buildGPULightListResources, tileFlagsWritten, context.cmd);
// WARNING: Note that the three set of variables are bound here, but it should be handled differently.
PushLightDataGlobalParams(data.lightDataGlobalParameters, context.cmd);
PushShadowGlobalParams(data.shadowGlobalParameters, context.cmd);
PushLightLoopGlobalParams(data.lightLoopGlobalParameters, context.cmd);
});
}
}
internal void PushCameraTexture(
RenderGraph renderGraph,
AOVBuffers aovBufferId,
HDCamera camera,
RenderGraphResource source,
List <RTHandle> targets
)
{
if (!isValid)
{
return;
}
Assert.IsNotNull(m_RequestedAOVBuffers);
Assert.IsNotNull(targets);
var index = Array.IndexOf(m_RequestedAOVBuffers, aovBufferId);
if (index == -1)
{
return;
}
using (var builder = renderGraph.AddRenderPass <PushCameraTexturePassData>("Push AOV Camera Texture", out var passData))
{
passData.requestIndex = index;
passData.source = builder.ReadTexture(source);
passData.targets = targets;
builder.SetRenderFunc(
(PushCameraTexturePassData data, RenderGraphContext ctx) =>
{
HDUtils.BlitCameraTexture(ctx.cmd, ctx.resources.GetTexture(data.source), data.targets[data.requestIndex]);
});
}
}
LightingOutput RenderDeferredLighting(RenderGraph renderGraph,
HDCamera hdCamera,
RenderGraphMutableResource colorBuffer,
RenderGraphResource depthStencilBuffer,
RenderGraphResource depthPyramidTexture,
in LightingBuffers lightingBuffers,
RenderGraphResource CopyStencilBufferIfNeeded(RenderGraph renderGraph, HDCamera hdCamera, RenderGraphResource depthStencilBuffer, Material copyStencil, Material copyStencilForSSR)
{
// TODO: Move early out outside of the rendering function, otherwise we adds a pass for nothing.
using (var builder = renderGraph.AddRenderPass <CopyStencilBufferPassData>("Copy Stencil", out var passData))
{
passData.hdCamera = hdCamera;
passData.depthStencilBuffer = builder.ReadTexture(depthStencilBuffer);
passData.stencilBufferCopy = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R8_UNorm, enableRandomWrite = true, name = "CameraStencilCopy"
}));
passData.copyStencil = copyStencil;
passData.copyStencilForSSR = copyStencilForSSR;
builder.SetRenderFunc(
(CopyStencilBufferPassData data, RenderGraphContext context) =>
{
RTHandle depthBuffer = context.resources.GetTexture(data.depthStencilBuffer);
RTHandle stencilCopy = context.resources.GetTexture(data.stencilBufferCopy);
CopyStencilBufferIfNeeded(context.cmd, data.hdCamera, depthBuffer, stencilCopy, data.copyStencil, data.copyStencilForSSR);
});
return(passData.stencilBufferCopy);
}
}
public RenderGraphResource Render(RenderGraph renderGraph, HDCamera hdCamera, RenderGraphResource depthPyramid, RenderGraphResource motionVectors, int frameCount)
{
var settings = hdCamera.volumeStack.GetComponent <AmbientOcclusion>();
RenderGraphResource result;
// AO has side effects (as it uses an imported history buffer)
// So we can't rely on automatic pass stripping. This is why we have to be explicit here.
if (IsActive(hdCamera, settings))
{
{
EnsureRTSize(settings, hdCamera);
var aoParameters = PrepareRenderAOParameters(hdCamera, renderGraph.rtHandleProperties, frameCount);
var currentHistory = renderGraph.ImportTexture(hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.AmbientOcclusion));
var outputHistory = renderGraph.ImportTexture(hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.AmbientOcclusion));
var packedData = RenderAO(renderGraph, aoParameters, depthPyramid);
result = DenoiseAO(renderGraph, aoParameters, motionVectors, packedData, currentHistory, outputHistory);
}
}
else
{
result = renderGraph.ImportTexture(TextureXR.GetBlackTexture(), HDShaderIDs._AmbientOcclusionTexture);
}
return(result);
}
internal RenderGraphResource RenderShadows(RenderGraph renderGraph, CullingResults cullResults, FrameSettings frameSettings, string shadowPassName)
{
RenderGraphResource result = new RenderGraphResource();
if (m_ShadowRequests.Count == 0)
{
return(result);
}
using (var builder = renderGraph.AddRenderPass <RenderShadowsPassData>(shadowPassName, out var passData, CustomSamplerId.RenderShadowMaps.GetSampler()))
{
passData.parameters = PrepareRenderShadowsParameters();
// TODO: Get rid of this and refactor to use the same kind of API than RendererList
passData.shadowDrawSettings = new ShadowDrawingSettings(cullResults, 0);
passData.shadowDrawSettings.useRenderingLayerMaskTest = frameSettings.IsEnabled(FrameSettingsField.LightLayers);
passData.atlasTexture = builder.WriteTexture(
renderGraph.CreateTexture(new TextureDesc(width, height)
{
filterMode = m_FilterMode, depthBufferBits = m_DepthBufferBits, isShadowMap = true, name = m_Name, clearBuffer = passData.parameters.debugClearAtlas
}, passData.parameters.atlasShaderID));
result = passData.atlasTexture;
if (passData.parameters.blurAlgorithm == BlurAlgorithm.EVSM)
{
passData.momentAtlasTexture1 = builder.WriteTexture(AllocateMomentAtlas(renderGraph, string.Format("{0}Moment", m_Name), passData.parameters.momentAtlasShaderID));
passData.momentAtlasTexture2 = builder.WriteTexture(AllocateMomentAtlas(renderGraph, string.Format("{0}MomentCopy", m_Name)));
result = passData.momentAtlasTexture1;
}
else if (passData.parameters.blurAlgorithm == BlurAlgorithm.IM)
{
passData.momentAtlasTexture1 = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(width, height)
{
colorFormat = GraphicsFormat.R32G32B32A32_SFloat, name = string.Format("{0}Moment", m_Name), enableRandomWrite = true
}, passData.parameters.momentAtlasShaderID));
passData.intermediateSummedAreaTexture = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(width, height)
{
colorFormat = GraphicsFormat.R32G32B32A32_SInt, name = string.Format("{0}IntermediateSummedArea", m_Name), enableRandomWrite = true
}, passData.parameters.momentAtlasShaderID));
passData.summedAreaTexture = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(width, height)
{
colorFormat = GraphicsFormat.R32G32B32A32_SInt, name = string.Format("{0}SummedArea", m_Name), enableRandomWrite = true
}, passData.parameters.momentAtlasShaderID));
result = passData.momentAtlasTexture1;
}
builder.SetRenderFunc(
(RenderShadowsPassData data, RenderGraphContext context) =>
{
RTHandle atlasTexture = context.resources.GetTexture(data.atlasTexture);
RenderShadows(data.parameters,
atlasTexture,
data.shadowDrawSettings,
context.renderContext, context.cmd);
if (data.parameters.blurAlgorithm == BlurAlgorithm.EVSM)
{
RTHandle[] momentTextures = context.renderGraphPool.GetTempArray <RTHandle>(2);
momentTextures[0] = context.resources.GetTexture(data.momentAtlasTexture1);
momentTextures[1] = context.resources.GetTexture(data.momentAtlasTexture2);
EVSMBlurMoments(data.parameters, atlasTexture, momentTextures, context.cmd);
}
else if (data.parameters.blurAlgorithm == BlurAlgorithm.IM)
{
RTHandle momentAtlas = context.resources.GetTexture(data.momentAtlasTexture1);
RTHandle intermediateSummedArea = context.resources.GetTexture(data.intermediateSummedAreaTexture);
RTHandle summedArea = context.resources.GetTexture(data.summedAreaTexture);
IMBlurMoment(data.parameters, atlasTexture, momentAtlas, intermediateSummedArea, summedArea, context.cmd);
}
});
return(result);
}
}
