static void RTReflectionDirectionGeneration(CommandBuffer cmd, RTReflectionDirGenParameters rtrDirGenParams, RTReflectionDirGenResources rtrDirGenResources)
{
// TODO: check if this is required, i do not think so
CoreUtils.SetRenderTarget(cmd, rtrDirGenResources.outputBuffer, ClearFlag.Color, clearColor: Color.black);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(cmd, rtrDirGenParams.ditheredTextureSet);
// Bind all the required scalars to the CB
rtrDirGenParams.shaderVariablesRayTracingCB._RaytracingReflectionMinSmoothness = rtrDirGenParams.minSmoothness;
ConstantBuffer.PushGlobal(cmd, rtrDirGenParams.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Bind all the required textures
cmd.SetComputeTextureParam(rtrDirGenParams.directionGenCS, rtrDirGenParams.dirGenKernel, HDShaderIDs._DepthTexture, rtrDirGenResources.depthBuffer);
cmd.SetComputeTextureParam(rtrDirGenParams.directionGenCS, rtrDirGenParams.dirGenKernel, HDShaderIDs._NormalBufferTexture, rtrDirGenResources.normalBuffer);
cmd.SetComputeTextureParam(rtrDirGenParams.directionGenCS, rtrDirGenParams.dirGenKernel, HDShaderIDs._SsrClearCoatMaskTexture, rtrDirGenResources.clearCoatMaskTexture);
cmd.SetComputeIntParam(rtrDirGenParams.directionGenCS, HDShaderIDs._SsrStencilBit, (int)StencilUsage.TraceReflectionRay);
cmd.SetComputeTextureParam(rtrDirGenParams.directionGenCS, rtrDirGenParams.dirGenKernel, HDShaderIDs._StencilTexture, rtrDirGenResources.stencilBuffer, 0, RenderTextureSubElement.Stencil);
// Bind the output buffers
cmd.SetComputeTextureParam(rtrDirGenParams.directionGenCS, rtrDirGenParams.dirGenKernel, HDShaderIDs._RaytracingDirectionBuffer, rtrDirGenResources.outputBuffer);
// Evaluate the dispatch parameters
int numTilesX = (rtrDirGenParams.texWidth + (rtReflectionsComputeTileSize - 1)) / rtReflectionsComputeTileSize;
int numTilesY = (rtrDirGenParams.texHeight + (rtReflectionsComputeTileSize - 1)) / rtReflectionsComputeTileSize;
// Compute the directions
cmd.DispatchCompute(rtrDirGenParams.directionGenCS, rtrDirGenParams.dirGenKernel, numTilesX, numTilesY, rtrDirGenParams.viewCount);
}
static public void TraceAO(CommandBuffer cmd, AmbientOcclusionTraceParameters aoTraceParameters, AmbientOcclusionTraceResources aoTraceResources)
{
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(aoTraceParameters.aoShaderRT, "VisibilityDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(aoTraceParameters.aoShaderRT, HDShaderIDs._RaytracingAccelerationStructureName, aoTraceResources.rayTracingAccelerationStructure);
// Inject the ray generation data (be careful of the global constant buffer limitation)
aoTraceParameters.raytracingCB._RaytracingRayMaxLength = aoTraceParameters.rayLength;
aoTraceParameters.raytracingCB._RaytracingNumSamples = aoTraceParameters.sampleCount;
ConstantBuffer.PushGlobal(cmd, aoTraceParameters.raytracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Set the data for the ray generation
cmd.SetRayTracingTextureParam(aoTraceParameters.aoShaderRT, HDShaderIDs._DepthTexture, aoTraceResources.depthStencilBuffer);
cmd.SetRayTracingTextureParam(aoTraceParameters.aoShaderRT, HDShaderIDs._NormalBufferTexture, aoTraceResources.normalBuffer);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(cmd, aoTraceResources.ditheredTextureSet);
// Set the output textures
cmd.SetRayTracingTextureParam(aoTraceParameters.aoShaderRT, HDShaderIDs._RayCountTexture, aoTraceResources.rayCountTexture);
cmd.SetRayTracingTextureParam(aoTraceParameters.aoShaderRT, HDShaderIDs._AmbientOcclusionTextureRW, aoTraceResources.outputTexture);
// Run the computation
cmd.DispatchRays(aoTraceParameters.aoShaderRT, m_RayGenShaderName, (uint)aoTraceParameters.actualWidth, (uint)aoTraceParameters.actualHeight, (uint)aoTraceParameters.viewCount);
}
void RenderReflectionsQuality(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount, bool transparent)
{
// Fetch the shaders that we will be using
ComputeShader reflectionFilter = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
RayTracingShader reflectionShader = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
// Request the buffers we shall be using
RTHandle intermediateBuffer0 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA0);
RTHandle intermediateBuffer1 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA1);
var settings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = hdCamera.volumeStack.GetComponent <LightCluster>();
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingIntegrateReflection)))
{
// Bind all the required data for ray tracing
BindRayTracedReflectionData(cmd, hdCamera, reflectionShader, settings, lightClusterSettings, intermediateBuffer0, intermediateBuffer1);
// Only use the shader variant that has multi bounce if the bounce count > 1
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", settings.bounceCount.value > 1);
// We are not in the diffuse only case
m_ShaderVariablesRayTracingCB._RayTracingDiffuseLightingOnly = 0;
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Run the computation
cmd.DispatchRays(reflectionShader, transparent ? m_RayGenIntegrationTransparentName : m_RayGenIntegrationName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, (uint)hdCamera.viewCount);
// Disable multi-bounce
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", false);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingFilterReflection)))
{
if (settings.denoise.value && !transparent)
{
// Grab the history buffer
RTHandle reflectionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
float historyValidity = 1.0f;
#if UNITY_HDRP_DXR_TESTS_DEFINE
if (Application.isPlaying)
{
historyValidity = 0.0f;
}
else
#endif
// We need to check if something invalidated the history buffers
historyValidity *= ValidRayTracingHistory(hdCamera) ? 1.0f : 0.0f;
HDReflectionDenoiser reflectionDenoiser = GetReflectionDenoiser();
reflectionDenoiser.DenoiseBuffer(cmd, hdCamera, settings.denoiserRadius.value, intermediateBuffer0, reflectionHistory, outputTexture, historyValidity: historyValidity);
}
else
{
HDUtils.BlitCameraTexture(cmd, intermediateBuffer0, outputTexture);
}
}
}
static void AdjustWeightRTReflections(CommandBuffer cmd, RTRAdjustWeightParameters parameters, RTRAdjustWeightResources resources)
{
// Bind all the required scalars to the CB
parameters.shaderVariablesRayTracingCB._RaytracingReflectionMinSmoothness = parameters.minSmoothness;
parameters.shaderVariablesRayTracingCB._RaytracingReflectionSmoothnessFadeStart = parameters.smoothnessFadeStart;
ConstantBuffer.PushGlobal(cmd, parameters.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Source input textures
cmd.SetComputeTextureParam(parameters.reflectionFilterCS, parameters.adjustWeightKernel, HDShaderIDs._DepthTexture, resources.depthStencilBuffer);
cmd.SetComputeTextureParam(parameters.reflectionFilterCS, parameters.adjustWeightKernel, HDShaderIDs._SsrClearCoatMaskTexture, resources.clearCoatMaskTexture);
cmd.SetComputeTextureParam(parameters.reflectionFilterCS, parameters.adjustWeightKernel, HDShaderIDs._NormalBufferTexture, resources.normalBuffer);
cmd.SetComputeTextureParam(parameters.reflectionFilterCS, parameters.adjustWeightKernel, HDShaderIDs._DirectionPDFTexture, resources.directionTexture);
// Lighting textures
cmd.SetComputeTextureParam(parameters.reflectionFilterCS, parameters.adjustWeightKernel, HDShaderIDs._SsrLightingTextureRW, resources.lightingTexture);
// Output texture
cmd.SetComputeTextureParam(parameters.reflectionFilterCS, parameters.adjustWeightKernel, HDShaderIDs._RaytracingReflectionTexture, resources.outputTexture);
// Compute the texture
int numTilesXHR = (parameters.texWidth + (rtReflectionsComputeTileSize - 1)) / rtReflectionsComputeTileSize;
int numTilesYHR = (parameters.texHeight + (rtReflectionsComputeTileSize - 1)) / rtReflectionsComputeTileSize;
cmd.DispatchCompute(parameters.reflectionFilterCS, parameters.adjustWeightKernel, numTilesXHR, numTilesYHR, parameters.viewCount);
}
private void SetupGlobalParamsForCubemapInternal(CommandBuffer cmd, HDCamera hdCamera, int cubemapSize, ref ShaderVariablesGlobal cb, out Matrix4x4 proj)
{
var gpuView = hdCamera.camera.worldToCameraMatrix;
if (ShaderConfig.s_CameraRelativeRendering != 0)
{
gpuView.SetColumn(3, new Vector4(0, 0, 0, 1));
}
var cubeProj = Matrix4x4.Perspective(90.0f, 1.0f, hdCamera.camera.nearClipPlane, hdCamera.camera.farClipPlane);
proj = cubeProj;
var gpuProj = GL.GetGPUProjectionMatrix(cubeProj, false);
var vp = gpuProj * gpuView;
cb._ViewMatrix = gpuView;
cb._InvViewMatrix = gpuView.inverse;
cb._ProjMatrix = gpuProj;
cb._InvProjMatrix = gpuProj.inverse;
cb._ViewProjMatrix = vp;
cb._InvViewProjMatrix = vp.inverse;
cb._CameraViewProjMatrix = vp;
cb._ScreenSize = new Vector4(cubemapSize, cubemapSize, 1f / cubemapSize, 1f / cubemapSize);
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesGlobalCB, HDShaderIDs._ShaderVariablesGlobal);
}
TextureHandle UpscaleSSGI(RenderGraph renderGraph, HDCamera hdCamera, GlobalIllumination giSettings, HDUtils.PackedMipChainInfo info, TextureHandle depthPyramid, TextureHandle inputBuffer)
{
using (var builder = renderGraph.AddRenderPass <UpscaleSSGIPassData>("Upscale SSGI", out var passData, ProfilingSampler.Get(HDProfileId.SSGIUpscale)))
{
builder.EnableAsyncCompute(false);
// Set the camera parameters
passData.texWidth = hdCamera.actualWidth;
passData.texHeight = hdCamera.actualHeight;
passData.viewCount = hdCamera.viewCount;
passData.shaderVariablesBilateralUpsampleCB._HalfScreenSize = new Vector4(passData.texWidth / 2, passData.texHeight / 2, 1.0f / (passData.texWidth * 0.5f), 1.0f / (passData.texHeight * 0.5f));
unsafe
{
for (int i = 0; i < 16; ++i)
{
passData.shaderVariablesBilateralUpsampleCB._DistanceBasedWeights[i] = BilateralUpsample.distanceBasedWeights_2x2[i];
}
for (int i = 0; i < 32; ++i)
{
passData.shaderVariablesBilateralUpsampleCB._TapOffsets[i] = BilateralUpsample.tapOffsets_2x2[i];
}
}
// Grab the right kernel
passData.bilateralUpsampleCS = m_Asset.renderPipelineResources.shaders.bilateralUpsampleCS;
passData.upscaleKernel = m_BilateralUpSampleColorKernel;
passData.depthTexture = builder.ReadTexture(depthPyramid);
passData.inputBuffer = builder.ReadTexture(inputBuffer);
passData.outputBuffer = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.B10G11R11_UFloatPack32, enableRandomWrite = true, name = "SSGI Final"
}));
builder.SetRenderFunc(
(UpscaleSSGIPassData data, RenderGraphContext ctx) =>
{
// Re-evaluate the dispatch parameters (we are evaluating the upsample in full resolution)
int ssgiTileSize = 8;
int numTilesXHR = (data.texWidth + (ssgiTileSize - 1)) / ssgiTileSize;
int numTilesYHR = (data.texHeight + (ssgiTileSize - 1)) / ssgiTileSize;
ConstantBuffer.PushGlobal(ctx.cmd, data.shaderVariablesBilateralUpsampleCB, HDShaderIDs._ShaderVariablesBilateralUpsample);
// Inject all the input buffers
ctx.cmd.SetComputeTextureParam(data.bilateralUpsampleCS, data.upscaleKernel, HDShaderIDs._DepthTexture, data.depthTexture);
ctx.cmd.SetComputeTextureParam(data.bilateralUpsampleCS, data.upscaleKernel, HDShaderIDs._LowResolutionTexture, data.inputBuffer);
// Inject the output textures
ctx.cmd.SetComputeTextureParam(data.bilateralUpsampleCS, data.upscaleKernel, HDShaderIDs._OutputUpscaledTexture, data.outputBuffer);
// Upscale the buffer to full resolution
ctx.cmd.DispatchCompute(data.bilateralUpsampleCS, data.upscaleKernel, numTilesXHR, numTilesYHR, data.viewCount);
});
return(passData.outputBuffer);
}
}
TextureHandle AdjustWeightRTR(RenderGraph renderGraph, HDCamera hdCamera, ScreenSpaceReflection settings,
TextureHandle depthPyramid, TextureHandle normalBuffer, TextureHandle clearCoatTexture, TextureHandle lightingTexture, TextureHandle directionTexture)
{
using (var builder = renderGraph.AddRenderPass <AdjustWeightRTRPassData>("Adjust Weight RTR", out var passData, ProfilingSampler.Get(HDProfileId.RaytracingReflectionAdjustWeight)))
{
builder.EnableAsyncCompute(false);
passData.texWidth = settings.fullResolution ? hdCamera.actualWidth : hdCamera.actualWidth / 2;
passData.texHeight = settings.fullResolution ? hdCamera.actualHeight : hdCamera.actualHeight / 2;
passData.viewCount = hdCamera.viewCount;
// Requires parameters
passData.minSmoothness = settings.minSmoothness;
passData.smoothnessFadeStart = settings.smoothnessFadeStart;
// Other parameters
passData.reflectionFilterCS = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
passData.adjustWeightKernel = settings.fullResolution ? m_ReflectionAdjustWeightKernel : m_ReflectionRescaleAndAdjustWeightKernel;
passData.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
passData.depthStencilBuffer = builder.ReadTexture(depthPyramid);
passData.normalBuffer = builder.ReadTexture(normalBuffer);
passData.clearCoatMaskTexture = builder.ReadTexture(clearCoatTexture);
passData.lightingTexture = builder.ReadTexture(lightingTexture);
passData.directionTexture = builder.ReadTexture(directionTexture);
passData.outputTexture = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Reflection Ray Reflections"
}));
builder.SetRenderFunc(
(AdjustWeightRTRPassData data, RenderGraphContext ctx) =>
{
// Bind all the required scalars to the CB
data.shaderVariablesRayTracingCB._RaytracingReflectionMinSmoothness = data.minSmoothness;
data.shaderVariablesRayTracingCB._RaytracingReflectionSmoothnessFadeStart = data.smoothnessFadeStart;
ConstantBuffer.PushGlobal(ctx.cmd, data.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Source input textures
ctx.cmd.SetComputeTextureParam(data.reflectionFilterCS, data.adjustWeightKernel, HDShaderIDs._DepthTexture, data.depthStencilBuffer);
ctx.cmd.SetComputeTextureParam(data.reflectionFilterCS, data.adjustWeightKernel, HDShaderIDs._SsrClearCoatMaskTexture, data.clearCoatMaskTexture);
ctx.cmd.SetComputeTextureParam(data.reflectionFilterCS, data.adjustWeightKernel, HDShaderIDs._NormalBufferTexture, data.normalBuffer);
ctx.cmd.SetComputeTextureParam(data.reflectionFilterCS, data.adjustWeightKernel, HDShaderIDs._DirectionPDFTexture, data.directionTexture);
// Lighting textures
ctx.cmd.SetComputeTextureParam(data.reflectionFilterCS, data.adjustWeightKernel, HDShaderIDs._SsrLightingTextureRW, data.lightingTexture);
// Output texture
ctx.cmd.SetComputeTextureParam(data.reflectionFilterCS, data.adjustWeightKernel, HDShaderIDs._RaytracingReflectionTexture, data.outputTexture);
// Compute the texture
int numTilesXHR = (data.texWidth + (rtReflectionsComputeTileSize - 1)) / rtReflectionsComputeTileSize;
int numTilesYHR = (data.texHeight + (rtReflectionsComputeTileSize - 1)) / rtReflectionsComputeTileSize;
ctx.cmd.DispatchCompute(data.reflectionFilterCS, data.adjustWeightKernel, numTilesXHR, numTilesYHR, data.viewCount);
});
return(passData.outputTexture);
}
}
// For both precomputation and runtime lighting passes.
void UpdateGlobalConstantBuffer(CommandBuffer cmd, BuiltinSkyParameters builtinParams)
{
var pbrSky = builtinParams.skySettings as PhysicallyBasedSky;
float R = pbrSky.GetPlanetaryRadius();
float D = pbrSky.GetMaximumAltitude();
float airH = pbrSky.GetAirScaleHeight();
float aerH = pbrSky.GetAerosolScaleHeight();
float aerA = pbrSky.GetAerosolAnisotropy();
float iMul = GetSkyIntensity(pbrSky, builtinParams.debugSettings);
Vector2 expParams = ComputeExponentialInterpolationParams(pbrSky.horizonZenithShift.value);
m_ConstantBuffer._PlanetaryRadius = R;
m_ConstantBuffer._RcpPlanetaryRadius = 1.0f / R;
m_ConstantBuffer._AtmosphericDepth = D;
m_ConstantBuffer._RcpAtmosphericDepth = 1.0f / D;
m_ConstantBuffer._AtmosphericRadius = R + D;
m_ConstantBuffer._AerosolAnisotropy = aerA;
m_ConstantBuffer._AerosolPhasePartConstant = CornetteShanksPhasePartConstant(aerA);
m_ConstantBuffer._Unused = 0.0f; // Warning fix
m_ConstantBuffer._Unused2 = 0.0f; // Warning fix
m_ConstantBuffer._AirDensityFalloff = 1.0f / airH;
m_ConstantBuffer._AirScaleHeight = airH;
m_ConstantBuffer._AerosolDensityFalloff = 1.0f / aerH;
m_ConstantBuffer._AerosolScaleHeight = aerH;
m_ConstantBuffer._AirSeaLevelExtinction = pbrSky.GetAirExtinctionCoefficient();
m_ConstantBuffer._AerosolSeaLevelExtinction = pbrSky.GetAerosolExtinctionCoefficient();
m_ConstantBuffer._AirSeaLevelScattering = pbrSky.GetAirScatteringCoefficient();
m_ConstantBuffer._IntensityMultiplier = iMul;
m_ConstantBuffer._AerosolSeaLevelScattering = pbrSky.GetAerosolScatteringCoefficient();
m_ConstantBuffer._ColorSaturation = pbrSky.colorSaturation.value;
Vector3 groundAlbedo = new Vector3(pbrSky.groundTint.value.r, pbrSky.groundTint.value.g, pbrSky.groundTint.value.b);
m_ConstantBuffer._GroundAlbedo = groundAlbedo;
m_ConstantBuffer._AlphaSaturation = pbrSky.alphaSaturation.value;
m_ConstantBuffer._PlanetCenterPosition = pbrSky.GetPlanetCenterPosition(builtinParams.worldSpaceCameraPos);
m_ConstantBuffer._AlphaMultiplier = pbrSky.alphaMultiplier.value;
Vector3 horizonTint = new Vector3(pbrSky.horizonTint.value.r, pbrSky.horizonTint.value.g, pbrSky.horizonTint.value.b);
m_ConstantBuffer._HorizonTint = horizonTint;
m_ConstantBuffer._HorizonZenithShiftPower = expParams.x;
Vector3 zenithTint = new Vector3(pbrSky.zenithTint.value.r, pbrSky.zenithTint.value.g, pbrSky.zenithTint.value.b);
m_ConstantBuffer._ZenithTint = zenithTint;
m_ConstantBuffer._HorizonZenithShiftScale = expParams.y;
ConstantBuffer.PushGlobal(cmd, m_ConstantBuffer, m_ShaderVariablesPhysicallyBasedSkyID);
}
static void ExecuteSSGITrace(CommandBuffer cmd, SSGITraceParameters parameters, SSGITraceResources resources)
{
int ssgiTileSize = 8;
int numTilesXHR = (parameters.texWidth + (ssgiTileSize - 1)) / ssgiTileSize;
int numTilesYHR = (parameters.texHeight + (ssgiTileSize - 1)) / ssgiTileSize;
// Inject all the input scalars
float n = parameters.nearClipPlane;
float f = parameters.farClipPlane;
float thicknessScale = 1.0f / (1.0f + parameters.thickness);
float thicknessBias = -n / (f - n) * (parameters.thickness * thicknessScale);
cmd.SetComputeFloatParam(parameters.ssGICS, HDShaderIDs._IndirectDiffuseThicknessScale, thicknessScale);
cmd.SetComputeFloatParam(parameters.ssGICS, HDShaderIDs._IndirectDiffuseThicknessBias, thicknessBias);
cmd.SetComputeIntParam(parameters.ssGICS, HDShaderIDs._IndirectDiffuseSteps, parameters.raySteps);
cmd.SetComputeFloatParam(parameters.ssGICS, HDShaderIDs._IndirectDiffuseMaximalRadius, parameters.maximalRadius);
// Inject half screen size if required
if (!parameters.fullResolutionSS)
{
cmd.SetComputeVectorParam(parameters.ssGICS, HDShaderIDs._HalfScreenSize, parameters.halfScreenSize);
}
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(cmd, parameters.ditheredTextureSet);
// Inject all the input textures/buffers
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.traceKernel, HDShaderIDs._DepthTexture, resources.depthTexture);
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.traceKernel, HDShaderIDs._NormalBufferTexture, resources.normalBuffer);
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.traceKernel, HDShaderIDs._IndirectDiffuseHitPointTextureRW, resources.hitPointBuffer);
cmd.SetComputeBufferParam(parameters.ssGICS, parameters.traceKernel, HDShaderIDs._DepthPyramidMipLevelOffsets, parameters.offsetBuffer);
// Do the ray marching
cmd.DispatchCompute(parameters.ssGICS, parameters.traceKernel, numTilesXHR, numTilesYHR, parameters.viewCount);
// Update global constant buffer.
// This should probably be a shader specific uniform instead of reusing the global constant buffer one since it's the only one updated here.
parameters.shaderVariablesRayTracingCB._RaytracingIntensityClamp = parameters.clampValueSS;
ConstantBuffer.PushGlobal(cmd, parameters.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Inject all the input scalars
cmd.SetComputeVectorParam(parameters.ssGICS, HDShaderIDs._ColorPyramidUvScaleAndLimitPrevFrame, parameters.colorPyramidUvScaleAndLimitPrevFrame);
// Bind all the input buffers
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.projectKernel, HDShaderIDs._DepthTexture, resources.depthTexture);
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.projectKernel, HDShaderIDs._NormalBufferTexture, resources.normalBuffer);
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.projectKernel, HDShaderIDs._CameraMotionVectorsTexture, resources.motionVectorsBuffer);
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.projectKernel, HDShaderIDs._IndirectDiffuseHitPointTexture, resources.hitPointBuffer);
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.projectKernel, HDShaderIDs._ColorPyramidTexture, resources.colorPyramid);
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.projectKernel, HDShaderIDs._HistoryDepthTexture, resources.historyDepth);
cmd.SetComputeBufferParam(parameters.ssGICS, parameters.projectKernel, HDShaderIDs._DepthPyramidMipLevelOffsets, parameters.offsetBuffer);
// Bind the output texture
cmd.SetComputeTextureParam(parameters.ssGICS, parameters.projectKernel, HDShaderIDs._IndirectDiffuseTextureRW, resources.outputBuffer);
// Do the reprojection
cmd.DispatchCompute(parameters.ssGICS, parameters.projectKernel, numTilesXHR, numTilesYHR, parameters.viewCount);
}
static void RenderQualityRayTracedReflections(CommandBuffer cmd, RTRQualityRenderingParameters rtrQRenderingParameters, RTRQualityRenderingResources rtrQRenderingResources)
{
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(rtrQRenderingParameters.reflectionShader, "IndirectDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(rtrQRenderingParameters.reflectionShader, HDShaderIDs._RaytracingAccelerationStructureName, rtrQRenderingParameters.accelerationStructure);
// Global reflection parameters
rtrQRenderingParameters.shaderVariablesRayTracingCB._RaytracingIntensityClamp = rtrQRenderingParameters.clampValue;
rtrQRenderingParameters.shaderVariablesRayTracingCB._RaytracingIncludeSky = rtrQRenderingParameters.reflectSky;
// Inject the ray generation data
rtrQRenderingParameters.shaderVariablesRayTracingCB._RaytracingRayMaxLength = rtrQRenderingParameters.rayLength;
rtrQRenderingParameters.shaderVariablesRayTracingCB._RaytracingNumSamples = rtrQRenderingParameters.sampleCount;
// Set the number of bounces for reflections
rtrQRenderingParameters.shaderVariablesRayTracingCB._RaytracingMaxRecursion = rtrQRenderingParameters.bounceCount;
ConstantBuffer.PushGlobal(cmd, rtrQRenderingParameters.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(cmd, rtrQRenderingParameters.ditheredTextureSet);
// Set the data for the ray generation
cmd.SetRayTracingTextureParam(rtrQRenderingParameters.reflectionShader, HDShaderIDs._SsrLightingTextureRW, rtrQRenderingResources.outputTexture);
cmd.SetRayTracingTextureParam(rtrQRenderingParameters.reflectionShader, HDShaderIDs._DepthTexture, rtrQRenderingResources.depthStencilBuffer);
cmd.SetRayTracingTextureParam(rtrQRenderingParameters.reflectionShader, HDShaderIDs._NormalBufferTexture, rtrQRenderingResources.normalBuffer);
cmd.SetGlobalTexture(HDShaderIDs._StencilTexture, rtrQRenderingResources.depthStencilBuffer, RenderTextureSubElement.Stencil);
cmd.SetRayTracingIntParams(rtrQRenderingParameters.reflectionShader, HDShaderIDs._SsrStencilBit, (int)StencilUsage.TraceReflectionRay);
// Set ray count texture
cmd.SetRayTracingTextureParam(rtrQRenderingParameters.reflectionShader, HDShaderIDs._RayCountTexture, rtrQRenderingResources.rayCountTexture);
// Bind the lightLoop data
rtrQRenderingParameters.lightCluster.BindLightClusterData(cmd);
// Note: Just in case, we rebind the directional light data (in case they were not)
cmd.SetGlobalBuffer(HDShaderIDs._DirectionalLightDatas, rtrQRenderingResources.directionalLightData);
// Evaluate the clear coat mask texture based on the lit shader mode
cmd.SetRayTracingTextureParam(rtrQRenderingParameters.reflectionShader, HDShaderIDs._SsrClearCoatMaskTexture, rtrQRenderingResources.clearCoatMaskTexture);
// Set the data for the ray miss
cmd.SetRayTracingTextureParam(rtrQRenderingParameters.reflectionShader, HDShaderIDs._SkyTexture, rtrQRenderingParameters.skyTexture);
// Only use the shader variant that has multi bounce if the bounce count > 1
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", rtrQRenderingParameters.bounceCount > 1);
// We are not in the diffuse only case
rtrQRenderingParameters.shaderVariablesRayTracingCB._RayTracingDiffuseLightingOnly = 0;
ConstantBuffer.PushGlobal(cmd, rtrQRenderingParameters.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Run the computation
cmd.DispatchRays(rtrQRenderingParameters.reflectionShader, rtrQRenderingParameters.transparent ? m_RayGenIntegrationTransparentName : m_RayGenIntegrationName, (uint)rtrQRenderingParameters.texWidth, (uint)rtrQRenderingParameters.texHeight, (uint)rtrQRenderingParameters.viewCount);
// Disable multi-bounce
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", false);
}
void UpdateShaderVariablesRaytracingLightLoopCB(HDCamera hdCamera, CommandBuffer cmd)
{
m_ShaderVariablesRaytracingLightLoopCB._MinClusterPos = m_RayTracingLightCluster.GetMinClusterPos();
m_ShaderVariablesRaytracingLightLoopCB._LightPerCellCount = (uint)m_RayTracingLightCluster.GetLightPerCellCount();
m_ShaderVariablesRaytracingLightLoopCB._MaxClusterPos = m_RayTracingLightCluster.GetMaxClusterPos();
m_ShaderVariablesRaytracingLightLoopCB._PunctualLightCountRT = (uint)m_RayTracingLightCluster.GetPunctualLightCount();
m_ShaderVariablesRaytracingLightLoopCB._AreaLightCountRT = (uint)m_RayTracingLightCluster.GetAreaLightCount();
m_ShaderVariablesRaytracingLightLoopCB._EnvLightCountRT = (uint)m_RayTracingLightCluster.GetEnvLightCount();
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRaytracingLightLoopCB, HDShaderIDs._ShaderVariablesRaytracingLightLoop);
}
void BindRayTracedReflectionData(CommandBuffer cmd, HDCamera hdCamera, RayTracingShader reflectionShader, ScreenSpaceReflection settings, LightCluster lightClusterSettings,
RTHandle outputLightingBuffer, RTHandle outputHitPointBuffer)
{
// Grab the acceleration structures and the light cluster to use
RayTracingAccelerationStructure accelerationStructure = RequestAccelerationStructure();
HDRaytracingLightCluster lightCluster = RequestLightCluster();
BlueNoise blueNoise = GetBlueNoiseManager();
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(reflectionShader, "IndirectDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(reflectionShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure);
// Global reflection parameters
m_ShaderVariablesRayTracingCB._RaytracingIntensityClamp = settings.clampValue.value;
m_ShaderVariablesRayTracingCB._RaytracingIncludeSky = settings.reflectSky.value ? 1 : 0;
// Inject the ray generation data
m_ShaderVariablesRayTracingCB._RaytracingRayMaxLength = settings.rayLength.value;
m_ShaderVariablesRayTracingCB._RaytracingNumSamples = settings.sampleCount.value;
// Set the number of bounces for reflections
m_ShaderVariablesRayTracingCB._RaytracingMaxRecursion = settings.bounceCount.value;
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Inject the ray-tracing sampling data
blueNoise.BindDitheredRNGData8SPP(cmd);
// Set the data for the ray generation
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrLightingTextureRW, outputLightingBuffer);
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrHitPointTexture, outputHitPointBuffer);
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetGlobalTexture(HDShaderIDs._StencilTexture, sharedRTManager.GetDepthStencilBuffer(), RenderTextureSubElement.Stencil);
cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._SsrStencilBit, (int)StencilUsage.TraceReflectionRay);
// Set ray count tex
RayCountManager rayCountManager = GetRayCountManager();
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._RayCountTexture, rayCountManager.GetRayCountTexture());
// Bind the lightLoop data
lightCluster.BindLightClusterData(cmd);
// Note: Just in case, we rebind the directional light data (in case they were not)
cmd.SetGlobalBuffer(HDShaderIDs._DirectionalLightDatas, m_LightLoopLightData.directionalLightData);
// Evaluate the clear coat mask texture based on the lit shader mode
RenderTargetIdentifier clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Set the data for the ray miss
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SkyTexture, m_SkyManager.GetSkyReflection(hdCamera));
}
/// <summary>
/// Update the constant buffer used by Probe Volumes in shaders.
/// </summary>
/// <param name="cmd">A command buffer used to perform the data update.</param>
/// <param name="normalBias">Normal bias to apply to the position used to sample probe volumes.</param>
public void UpdateConstantBuffer(CommandBuffer cmd, float normalBias)
{
ShaderVariablesProbeVolumes shaderVars;
shaderVars._WStoRS = Matrix4x4.Inverse(m_Transform.refSpaceToWS);
shaderVars._IndexDim = m_Index.GetIndexDimension();
shaderVars._NormalBias = normalBias;
shaderVars._PoolDim = m_Pool.GetPoolDimensions();
shaderVars.pad0 = 0;
ConstantBuffer.PushGlobal(cmd, shaderVars, m_CBShaderID);
}
void PushGlobalCameraParams(RenderGraph renderGraph, HDCamera hdCamera)
{
using (var builder = renderGraph.AddRenderPass <PushGlobalCameraParamPassData>("Push Global Camera Parameters", out var passData))
{
passData.hdCamera = hdCamera;
passData.frameCount = m_FrameCount;
passData.globalCB = m_ShaderVariablesGlobalCB;
builder.SetRenderFunc(
(PushGlobalCameraParamPassData data, RenderGraphContext context) =>
{
data.hdCamera.UpdateShaderVariableGlobalCB(ref data.globalCB, data.frameCount);
data.hdCamera.SetupGlobalParams(context.cmd, data.frameCount);
ConstantBuffer.PushGlobal(context.cmd, data.globalCB, HDShaderIDs._ShaderVariablesGlobal);
});
}
}
static void RenderQualityRayTracedIndirectDiffuse(CommandBuffer cmd, QualityRTIndirectDiffuseParameters qrtidParameters, QualityRTIndirectDiffuseResources qrtidResources)
{
// Define the shader pass to use for the indirect diffuse pass
cmd.SetRayTracingShaderPass(qrtidParameters.indirectDiffuseRT, "IndirectDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(qrtidParameters.indirectDiffuseRT, HDShaderIDs._RaytracingAccelerationStructureName, qrtidParameters.accelerationStructure);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(cmd, qrtidParameters.ditheredTextureSet);
// Set the data for the ray generation
cmd.SetRayTracingTextureParam(qrtidParameters.indirectDiffuseRT, HDShaderIDs._IndirectDiffuseTextureRW, qrtidResources.outputBuffer);
cmd.SetRayTracingTextureParam(qrtidParameters.indirectDiffuseRT, HDShaderIDs._DepthTexture, qrtidResources.depthBuffer);
cmd.SetRayTracingTextureParam(qrtidParameters.indirectDiffuseRT, HDShaderIDs._NormalBufferTexture, qrtidResources.normalBuffer);
// Set ray count texture
cmd.SetRayTracingTextureParam(qrtidParameters.indirectDiffuseRT, HDShaderIDs._RayCountTexture, qrtidResources.rayCountTexture);
// LightLoop data
qrtidParameters.lightCluster.BindLightClusterData(cmd);
// Set the data for the ray miss
cmd.SetRayTracingTextureParam(qrtidParameters.indirectDiffuseRT, HDShaderIDs._SkyTexture, qrtidParameters.skyTexture);
// Update global constant buffer
qrtidParameters.shaderVariablesRayTracingCB._RaytracingIntensityClamp = qrtidParameters.clampValue;
qrtidParameters.shaderVariablesRayTracingCB._RaytracingIncludeSky = 1;
qrtidParameters.shaderVariablesRayTracingCB._RaytracingRayMaxLength = qrtidParameters.rayLength;
qrtidParameters.shaderVariablesRayTracingCB._RaytracingNumSamples = qrtidParameters.sampleCount;
qrtidParameters.shaderVariablesRayTracingCB._RaytracingMaxRecursion = qrtidParameters.bounceCount;
qrtidParameters.shaderVariablesRayTracingCB._RayTracingDiffuseLightingOnly = 1;
ConstantBuffer.PushGlobal(cmd, qrtidParameters.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Only use the shader variant that has multi bounce if the bounce count > 1
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", qrtidParameters.bounceCount > 1);
// Run the computation
cmd.DispatchRays(qrtidParameters.indirectDiffuseRT, m_RayGenIndirectDiffuseIntegrationName, (uint)qrtidParameters.texWidth, (uint)qrtidParameters.texHeight, (uint)qrtidParameters.viewCount);
// Disable the keywords we do not need anymore
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", false);
}
void BindRayTracedIndirectDiffuseData(CommandBuffer cmd, HDCamera hdCamera
, RayTracingShader indirectDiffuseShader
, GlobalIllumination settings, LightCluster lightClusterSettings
, RTHandle outputLightingBuffer, RTHandle outputHitPointBuffer)
{
// Grab the acceleration structures and the light cluster to use
RayTracingAccelerationStructure accelerationStructure = RequestAccelerationStructure();
HDRaytracingLightCluster lightCluster = RequestLightCluster();
BlueNoise blueNoise = GetBlueNoiseManager();
// Define the shader pass to use for the indirect diffuse pass
cmd.SetRayTracingShaderPass(indirectDiffuseShader, "IndirectDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(indirectDiffuseShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure);
// Inject the ray-tracing sampling data
blueNoise.BindDitheredRNGData8SPP(cmd);
// Set the data for the ray generation
cmd.SetRayTracingTextureParam(indirectDiffuseShader, HDShaderIDs._IndirectDiffuseTextureRW, outputLightingBuffer);
cmd.SetRayTracingTextureParam(indirectDiffuseShader, HDShaderIDs._IndirectDiffuseHitPointTextureRW, outputHitPointBuffer);
cmd.SetRayTracingTextureParam(indirectDiffuseShader, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetRayTracingTextureParam(indirectDiffuseShader, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
// Set ray count texture
RayCountManager rayCountManager = GetRayCountManager();
cmd.SetRayTracingTextureParam(indirectDiffuseShader, HDShaderIDs._RayCountTexture, rayCountManager.GetRayCountTexture());
// LightLoop data
lightCluster.BindLightClusterData(cmd);
// Set the data for the ray miss
cmd.SetRayTracingTextureParam(indirectDiffuseShader, HDShaderIDs._SkyTexture, m_SkyManager.GetSkyReflection(hdCamera));
// Update global constant buffer
m_ShaderVariablesRayTracingCB._RaytracingRayMaxLength = settings.rayLength.value;
m_ShaderVariablesRayTracingCB._RaytracingNumSamples = settings.sampleCount.value;
m_ShaderVariablesRayTracingCB._RaytracingIntensityClamp = settings.clampValue.value;
m_ShaderVariablesRayTracingCB._RaytracingMaxRecursion = settings.bounceCount.value;
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
}
static void ExecuteRecursiveRendering(CommandBuffer cmd, RecursiveRendererParameters rrParams, RecursiveRendererResources rrResources)
{
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(rrParams.recursiveRenderingRT, "ForwardDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(rrParams.recursiveRenderingRT, HDShaderIDs._RaytracingAccelerationStructureName, rrParams.accelerationStructure);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(cmd, rrParams.ditheredTextureSet);
// Update Global Constant Buffer.
rrParams.shaderVariablesRayTracingCB._RaytracingRayMaxLength = rrParams.rayLength;
rrParams.shaderVariablesRayTracingCB._RaytracingMaxRecursion = rrParams.maxDepth;
rrParams.shaderVariablesRayTracingCB._RaytracingReflectionMinSmoothness = rrParams.minSmoothness;
ConstantBuffer.PushGlobal(cmd, rrParams.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Fecth the temporary buffers we shall be using
cmd.SetRayTracingTextureParam(rrParams.recursiveRenderingRT, HDShaderIDs._RaytracingFlagMask, rrResources.flagMask);
cmd.SetRayTracingTextureParam(rrParams.recursiveRenderingRT, HDShaderIDs._DepthTexture, rrResources.depthStencilBuffer);
cmd.SetRayTracingTextureParam(rrParams.recursiveRenderingRT, HDShaderIDs._CameraColorTextureRW, rrResources.outputBuffer);
// Set ray count texture
cmd.SetRayTracingTextureParam(rrParams.recursiveRenderingRT, HDShaderIDs._RayCountTexture, rrResources.rayCountTexture);
// LightLoop data
rrParams.lightCluster.BindLightClusterData(cmd);
// Note: Just in case, we rebind the directional light data (in case they were not)
cmd.SetGlobalBuffer(HDShaderIDs._DirectionalLightDatas, rrResources.directionalLightData);
// Set the data for the ray miss
cmd.SetRayTracingTextureParam(rrParams.recursiveRenderingRT, HDShaderIDs._SkyTexture, rrParams.skyTexture);
// If this is the right debug mode and we have at least one light, write the first shadow to the de-noised texture
cmd.SetRayTracingTextureParam(rrParams.recursiveRenderingRT, HDShaderIDs._RaytracingPrimaryDebug, rrResources.debugBuffer);
// Run the computation
cmd.DispatchRays(rrParams.recursiveRenderingRT, m_RayGenShaderName, (uint)rrParams.texWidth, (uint)rrParams.texHeight, (uint)rrParams.viewCount);
}
private void SetupGlobalParamsForCubemapInternal(CommandBuffer cmd, Matrix4x4 view, int cubemapSize, ref ShaderVariablesGlobal cb)
{
var gpuView = view;
if (ShaderConfig.s_CameraRelativeRendering != 0)
{
gpuView.SetColumn(3, new Vector4(0, 0, 0, 1));
}
var gpuProj = GL.GetGPUProjectionMatrix(CubeProj, false);
var vp = gpuProj * gpuView;
cb._ViewMatrix = gpuView;
cb._InvViewMatrix = gpuView.inverse;
cb._ProjMatrix = gpuProj;
cb._InvProjMatrix = gpuProj.inverse;
cb._ViewProjMatrix = vp;
cb._InvViewProjMatrix = vp.inverse;
cb._CameraViewProjMatrix = vp;
cb._ScreenSize = new Vector4(cubemapSize, cubemapSize, 1f / cubemapSize, 1f / cubemapSize);
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesGlobalCB, HDShaderIDs._ShaderVariablesGlobal);
}
void RenderIndirectDiffuseQuality(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, int frameCount)
{
// First thing to check is: Do we have a valid ray-tracing environment?
GlobalIllumination giSettings = hdCamera.volumeStack.GetComponent <GlobalIllumination>();
LightCluster lightClusterSettings = hdCamera.volumeStack.GetComponent <LightCluster>();
// Shaders that are used
RayTracingShader indirectDiffuseRT = m_Asset.renderPipelineRayTracingResources.indirectDiffuseRaytracingRT;
// Request the intermediate texture we will be using
RTHandle intermediateBuffer1 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA1);
// Bind all the parameters for ray tracing
BindRayTracedIndirectDiffuseData(cmd, hdCamera, indirectDiffuseRT, giSettings, lightClusterSettings, m_IndirectDiffuseBuffer0, intermediateBuffer1);
// Compute the actual resolution that is needed base on the quality
int widthResolution = hdCamera.actualWidth;
int heightResolution = hdCamera.actualHeight;
// Only use the shader variant that has multi bounce if the bounce count > 1
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", giSettings.bounceCount.value > 1);
// Run the computation
m_ShaderVariablesRayTracingCB._RayTracingDiffuseLightingOnly = 1;
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
cmd.DispatchRays(indirectDiffuseRT, m_RayGenIndirectDiffuseIntegrationName, (uint)widthResolution, (uint)heightResolution, (uint)hdCamera.viewCount);
// Disable the keywords we do not need anymore
CoreUtils.SetKeyword(cmd, "MULTI_BOUNCE_INDIRECT", false);
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingFilterIndirectDiffuse)))
{
if (giSettings.denoise.value)
{
DenoiseIndirectDiffuseBuffer(hdCamera, cmd, giSettings);
}
}
}
void RenderPathTracing(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture)
{
RayTracingShader pathTracingShader = m_Asset.renderPipelineRayTracingResources.pathTracing;
m_PathTracingSettings = hdCamera.volumeStack.GetComponent <PathTracing>();
// Check the validity of the state before moving on with the computation
if (!pathTracingShader || !m_PathTracingSettings.enable.value)
{
return;
}
if (hdCamera.viewCount > 1)
{
Debug.LogError("Path Tracing is not supported when using XR single-pass rendering.");
return;
}
CheckDirtiness(hdCamera);
// Inject the ray-tracing sampling data
BlueNoise blueNoiseManager = GetBlueNoiseManager();
blueNoiseManager.BindDitheredRNGData256SPP(cmd);
// Grab the acceleration structure and the list of HD lights for the target camera
RayTracingAccelerationStructure accelerationStructure = RequestAccelerationStructure();
HDRaytracingLightCluster lightCluster = RequestLightCluster();
LightCluster lightClusterSettings = hdCamera.volumeStack.GetComponent <LightCluster>();
if (!m_SubFrameManager.isRecording)
{
// If we are recording, the max iteration is set/overridden by the subframe manager, otherwise we read it from the path tracing volume
m_SubFrameManager.subFrameCount = (uint)m_PathTracingSettings.maximumSamples.value;
}
#if UNITY_HDRP_DXR_TESTS_DEFINE
if (Application.isPlaying)
{
m_SubFrameManager.subFrameCount = 1;
}
#endif
CameraData camData = m_SubFrameManager.GetCameraData(hdCamera.camera.GetInstanceID());
if (camData.currentIteration < m_SubFrameManager.subFrameCount)
{
// Define the shader pass to use for the path tracing pass
cmd.SetRayTracingShaderPass(pathTracingShader, "PathTracingDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(pathTracingShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure);
// Inject the ray-tracing sampling data
cmd.SetGlobalTexture(HDShaderIDs._OwenScrambledTexture, m_Asset.renderPipelineResources.textures.owenScrambled256Tex);
cmd.SetGlobalTexture(HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
// Update the global constant buffer
m_ShaderVariablesRayTracingCB._RaytracingNumSamples = (int)m_SubFrameManager.subFrameCount;
m_ShaderVariablesRayTracingCB._RaytracingMinRecursion = m_PathTracingSettings.minimumDepth.value;
m_ShaderVariablesRayTracingCB._RaytracingMaxRecursion = m_PathTracingSettings.maximumDepth.value;
m_ShaderVariablesRayTracingCB._RaytracingIntensityClamp = m_PathTracingSettings.maximumIntensity.value;
m_ShaderVariablesRayTracingCB._RaytracingSampleIndex = (int)camData.currentIteration;
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// LightLoop data
cmd.SetGlobalBuffer(HDShaderIDs._RaytracingLightCluster, lightCluster.GetCluster());
cmd.SetGlobalBuffer(HDShaderIDs._LightDatasRT, lightCluster.GetLightDatas());
// Set the data for the ray miss
cmd.SetRayTracingIntParam(pathTracingShader, HDShaderIDs._RaytracingCameraSkyEnabled, camData.skyEnabled ? 1 : 0);
cmd.SetRayTracingVectorParam(pathTracingShader, HDShaderIDs._RaytracingCameraClearColor, hdCamera.backgroundColorHDR);
cmd.SetRayTracingTextureParam(pathTracingShader, HDShaderIDs._SkyTexture, m_SkyManager.GetSkyReflection(hdCamera));
// Additional data for path tracing
cmd.SetRayTracingTextureParam(pathTracingShader, HDShaderIDs._RadianceTexture, m_RadianceTexture);
cmd.SetRayTracingMatrixParam(pathTracingShader, HDShaderIDs._PixelCoordToViewDirWS, hdCamera.mainViewConstants.pixelCoordToViewDirWS);
cmd.SetRayTracingVectorParam(pathTracingShader, HDShaderIDs._PathTracedDoFConstants, ComputeDoFConstants(hdCamera, m_PathTracingSettings));
// Run the computation
cmd.DispatchRays(pathTracingShader, "RayGen", (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, 1);
}
RenderAccumulation(hdCamera, cmd, m_RadianceTexture, outputTexture, true);
}
TextureHandle QualityRTGI(RenderGraph renderGraph, HDCamera hdCamera, TextureHandle depthPyramid, TextureHandle normalBuffer, TextureHandle rayCountTexture)
{
using (var builder = renderGraph.AddRenderPass <TraceQualityRTGIPassData>("Quality RT Indirect Diffuse", out var passData, ProfilingSampler.Get(HDProfileId.RaytracingIndirectDiffuseEvaluation)))
{
builder.EnableAsyncCompute(false);
var settings = hdCamera.volumeStack.GetComponent <GlobalIllumination>();
// Set the camera parameters
passData.texWidth = hdCamera.actualWidth;
passData.texHeight = hdCamera.actualHeight;
passData.viewCount = hdCamera.viewCount;
// Evaluation parameters
passData.rayLength = settings.rayLength;
passData.sampleCount = settings.sampleCount.value;
passData.clampValue = settings.clampValue;
passData.bounceCount = settings.bounceCount.value;
passData.lodBias = settings.textureLodBias.value;
// Grab the additional parameters
passData.indirectDiffuseRT = m_GlobalSettings.renderPipelineRayTracingResources.indirectDiffuseRaytracingRT;
passData.accelerationStructure = RequestAccelerationStructure();
passData.lightCluster = RequestLightCluster();
passData.skyTexture = m_SkyManager.GetSkyReflection(hdCamera);
passData.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
passData.ditheredTextureSet = GetBlueNoiseManager().DitheredTextureSet8SPP();
passData.depthBuffer = builder.ReadTexture(depthPyramid);
passData.normalBuffer = builder.ReadTexture(normalBuffer);
passData.rayCountTexture = builder.ReadWriteTexture(rayCountTexture);
passData.outputBuffer = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Ray Traced Indirect Diffuse"
}));
builder.SetRenderFunc(
(TraceQualityRTGIPassData data, RenderGraphContext ctx) =>
{
// Define the shader pass to use for the indirect diffuse pass
ctx.cmd.SetRayTracingShaderPass(data.indirectDiffuseRT, "IndirectDXR");
// Set the acceleration structure for the pass
ctx.cmd.SetRayTracingAccelerationStructure(data.indirectDiffuseRT, HDShaderIDs._RaytracingAccelerationStructureName, data.accelerationStructure);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(ctx.cmd, data.ditheredTextureSet);
// Set the data for the ray generation
ctx.cmd.SetRayTracingTextureParam(data.indirectDiffuseRT, HDShaderIDs._IndirectDiffuseTextureRW, data.outputBuffer);
ctx.cmd.SetRayTracingTextureParam(data.indirectDiffuseRT, HDShaderIDs._DepthTexture, data.depthBuffer);
ctx.cmd.SetRayTracingTextureParam(data.indirectDiffuseRT, HDShaderIDs._NormalBufferTexture, data.normalBuffer);
// Set ray count texture
ctx.cmd.SetRayTracingTextureParam(data.indirectDiffuseRT, HDShaderIDs._RayCountTexture, data.rayCountTexture);
// LightLoop data
data.lightCluster.BindLightClusterData(ctx.cmd);
// Set the data for the ray miss
ctx.cmd.SetRayTracingTextureParam(data.indirectDiffuseRT, HDShaderIDs._SkyTexture, data.skyTexture);
// Update global constant buffer
data.shaderVariablesRayTracingCB._RaytracingIntensityClamp = data.clampValue;
data.shaderVariablesRayTracingCB._RaytracingIncludeSky = 1;
data.shaderVariablesRayTracingCB._RaytracingRayMaxLength = data.rayLength;
data.shaderVariablesRayTracingCB._RaytracingNumSamples = data.sampleCount;
data.shaderVariablesRayTracingCB._RaytracingMaxRecursion = data.bounceCount;
data.shaderVariablesRayTracingCB._RayTracingDiffuseLightingOnly = 1;
data.shaderVariablesRayTracingCB._RayTracingLodBias = data.lodBias;
ConstantBuffer.PushGlobal(ctx.cmd, data.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Only use the shader variant that has multi bounce if the bounce count > 1
CoreUtils.SetKeyword(ctx.cmd, "MULTI_BOUNCE_INDIRECT", data.bounceCount > 1);
// Run the computation
ctx.cmd.DispatchRays(data.indirectDiffuseRT, m_RayGenIndirectDiffuseIntegrationName, (uint)data.texWidth, (uint)data.texHeight, (uint)data.viewCount);
// Disable the keywords we do not need anymore
CoreUtils.SetKeyword(ctx.cmd, "MULTI_BOUNCE_INDIRECT", false);
});
return(passData.outputBuffer);
}
}
TextureHandle TraceRTSSS(RenderGraph renderGraph, HDCamera hdCamera, TextureHandle depthStencilBuffer, TextureHandle normalBuffer, TextureHandle sssColor, TextureHandle ssgiBuffer, TextureHandle colorBuffer)
{
using (var builder = renderGraph.AddRenderPass <TraceRTSSSPassData>("Composing the result of RTSSS", out var passData, ProfilingSampler.Get(HDProfileId.RaytracingSSSTrace)))
{
builder.EnableAsyncCompute(false);
// Grab the SSS params
var settings = hdCamera.volumeStack.GetComponent <SubSurfaceScattering>();
// Camera parameters
passData.texWidth = hdCamera.actualWidth;
passData.texHeight = hdCamera.actualHeight;
passData.viewCount = hdCamera.viewCount;
// Evaluation parameters
passData.sampleCount = settings.sampleCount.value;
// Required kernels
passData.clearTextureKernel = m_SSSClearTextureKernel;
passData.rtDeferredLightingKernel = m_RaytracingDiffuseDeferredKernel;
// other required parameters
passData.rayTracingSubSurfaceRT = m_Asset.renderPipelineRayTracingResources.subSurfaceRayTracingRT;
passData.rayTracingSubSurfaceCS = m_Asset.renderPipelineRayTracingResources.subSurfaceRayTracingCS;
passData.deferredRayTracingCS = m_Asset.renderPipelineRayTracingResources.deferredRaytracingCS;
passData.accelerationStructure = RequestAccelerationStructure();
passData.lightCluster = RequestLightCluster();
passData.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
passData.ditheredTextureSet = GetBlueNoiseManager().DitheredTextureSet8SPP();
passData.depthStencilBuffer = builder.UseDepthBuffer(depthStencilBuffer, DepthAccess.Read);
passData.normalBuffer = builder.ReadTexture(normalBuffer);
passData.sssColor = builder.ReadTexture(sssColor);
passData.intermediateBuffer0 = builder.CreateTransientTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Intermediate Texture 0"
});
passData.intermediateBuffer1 = builder.CreateTransientTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Intermediate Texture 1"
});
passData.intermediateBuffer2 = builder.CreateTransientTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Intermediate Texture 2"
});
passData.intermediateBuffer3 = builder.CreateTransientTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Intermediate Texture 3"
});
passData.directionBuffer = builder.CreateTransientTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Distance buffer"
});
passData.outputBuffer = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Ray Traced SSS"
}));
builder.SetRenderFunc(
(TraceRTSSSPassData data, RenderGraphContext ctx) =>
{
// Evaluate the dispatch parameters
int numTilesXHR = (data.texWidth + (s_sssTileSize - 1)) / s_sssTileSize;
int numTilesYHR = (data.texHeight + (s_sssTileSize - 1)) / s_sssTileSize;
// Clear the integration texture first
ctx.cmd.SetComputeTextureParam(data.rayTracingSubSurfaceCS, data.clearTextureKernel, HDShaderIDs._DiffuseLightingTextureRW, data.outputBuffer);
ctx.cmd.DispatchCompute(data.rayTracingSubSurfaceCS, data.clearTextureKernel, numTilesXHR, numTilesYHR, data.viewCount);
// Define the shader pass to use for the reflection pass
ctx.cmd.SetRayTracingShaderPass(data.rayTracingSubSurfaceRT, "SubSurfaceDXR");
// Set the acceleration structure for the pass
ctx.cmd.SetRayTracingAccelerationStructure(data.rayTracingSubSurfaceRT, HDShaderIDs._RaytracingAccelerationStructureName, data.accelerationStructure);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(ctx.cmd, data.ditheredTextureSet);
// For every sample that we need to process
for (int sampleIndex = 0; sampleIndex < data.sampleCount; ++sampleIndex)
{
// Inject the ray generation data
data.shaderVariablesRayTracingCB._RaytracingNumSamples = data.sampleCount;
data.shaderVariablesRayTracingCB._RaytracingSampleIndex = sampleIndex;
ConstantBuffer.PushGlobal(ctx.cmd, data.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Bind the input textures for ray generation
ctx.cmd.SetRayTracingTextureParam(data.rayTracingSubSurfaceRT, HDShaderIDs._DepthTexture, data.depthStencilBuffer);
ctx.cmd.SetRayTracingTextureParam(data.rayTracingSubSurfaceRT, HDShaderIDs._NormalBufferTexture, data.normalBuffer);
ctx.cmd.SetRayTracingTextureParam(data.rayTracingSubSurfaceRT, HDShaderIDs._SSSBufferTexture, data.sssColor);
ctx.cmd.SetGlobalTexture(HDShaderIDs._StencilTexture, data.depthStencilBuffer, RenderTextureSubElement.Stencil);
// Set the output textures
ctx.cmd.SetRayTracingTextureParam(data.rayTracingSubSurfaceRT, HDShaderIDs._ThroughputTextureRW, data.intermediateBuffer0);
ctx.cmd.SetRayTracingTextureParam(data.rayTracingSubSurfaceRT, HDShaderIDs._NormalTextureRW, data.intermediateBuffer1);
ctx.cmd.SetRayTracingTextureParam(data.rayTracingSubSurfaceRT, HDShaderIDs._PositionTextureRW, data.intermediateBuffer2);
ctx.cmd.SetRayTracingTextureParam(data.rayTracingSubSurfaceRT, HDShaderIDs._DiffuseLightingTextureRW, data.intermediateBuffer3);
ctx.cmd.SetRayTracingTextureParam(data.rayTracingSubSurfaceRT, HDShaderIDs._DirectionTextureRW, data.directionBuffer);
// Run the computation
ctx.cmd.DispatchRays(data.rayTracingSubSurfaceRT, m_RayGenSubSurfaceShaderName, (uint)data.texWidth, (uint)data.texHeight, (uint)data.viewCount);
// Now let's do the deferred shading pass on the samples
// Bind the lightLoop data
data.lightCluster.BindLightClusterData(ctx.cmd);
// Bind the input textures
ctx.cmd.SetComputeTextureParam(data.deferredRayTracingCS, data.rtDeferredLightingKernel, HDShaderIDs._DepthTexture, data.depthStencilBuffer);
ctx.cmd.SetComputeTextureParam(data.deferredRayTracingCS, data.rtDeferredLightingKernel, HDShaderIDs._ThroughputTextureRW, data.intermediateBuffer0);
ctx.cmd.SetComputeTextureParam(data.deferredRayTracingCS, data.rtDeferredLightingKernel, HDShaderIDs._NormalTextureRW, data.intermediateBuffer1);
ctx.cmd.SetComputeTextureParam(data.deferredRayTracingCS, data.rtDeferredLightingKernel, HDShaderIDs._PositionTextureRW, data.intermediateBuffer2);
ctx.cmd.SetComputeTextureParam(data.deferredRayTracingCS, data.rtDeferredLightingKernel, HDShaderIDs._DirectionTextureRW, data.directionBuffer);
ctx.cmd.SetComputeTextureParam(data.deferredRayTracingCS, data.rtDeferredLightingKernel, HDShaderIDs._DiffuseLightingTextureRW, data.intermediateBuffer3);
// Bind the output texture (it is used for accumulation read and write)
ctx.cmd.SetComputeTextureParam(data.deferredRayTracingCS, data.rtDeferredLightingKernel, HDShaderIDs._RaytracingLitBufferRW, data.outputBuffer);
// Compute the Lighting
ctx.cmd.DispatchCompute(data.deferredRayTracingCS, data.rtDeferredLightingKernel, numTilesXHR, numTilesYHR, data.viewCount);
}
});
return(passData.outputBuffer);
}
}
static void ExecuteSSSAreaRayTrace(CommandBuffer cmd, RTSAreaRayTraceParameters parameters, RTSAreaRayTraceResources sssartResources)
{
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(cmd, parameters.ditheredTextureSet);
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesX = (parameters.texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesY = (parameters.texHeight + (areaTileSize - 1)) / areaTileSize;
// We have noticed from extensive profiling that ray-trace shaders are not as effective for running per-pixel computation. In order to reduce that,
// we do a first prepass that compute the analytic term and probability and generates the first integration sample
// Bind the light data
cmd.SetComputeMatrixParam(parameters.screenSpaceShadowsCS, HDShaderIDs._RaytracingAreaWorldToLocal, parameters.worldToLocalMatrix);
cmd.SetComputeIntParam(parameters.screenSpaceShadowsCS, HDShaderIDs._RaytracingTargetAreaLight, parameters.lightIndex);
parameters.shaderVariablesRayTracingCB._RaytracingNumSamples = parameters.numSamples;
ConstantBuffer.PushGlobal(cmd, parameters.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Bind the input buffers
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._DepthTexture, sssartResources.depthStencilBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._NormalBufferTexture, sssartResources.normalBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._GBufferTexture[0], sssartResources.gbuffer0);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._GBufferTexture[1], sssartResources.gbuffer1);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._GBufferTexture[2], sssartResources.gbuffer2);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._GBufferTexture[3], sssartResources.gbuffer3);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._StencilTexture, sssartResources.depthStencilBuffer, 0, RenderTextureSubElement.Stencil);
// Bind the output buffers
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._RaytracedAreaShadowIntegration, sssartResources.outputShadowTexture);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._RaytracedAreaShadowSample, sssartResources.intermediateBufferRGBA1);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._RaytracingDirectionBuffer, sssartResources.directionBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._RayTracingLengthBuffer, sssartResources.rayLengthBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, HDShaderIDs._AnalyticProbBuffer, sssartResources.intermediateBufferRG0);
cmd.DispatchCompute(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowPrepassKernel, numTilesX, numTilesY, parameters.viewCount);
// Set ray count texture
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RayCountTexture, sssartResources.rayCountTexture);
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(parameters.screenSpaceShadowsRT, HDShaderIDs._RaytracingAccelerationStructureName, parameters.accelerationStructure);
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(parameters.screenSpaceShadowsRT, "VisibilityDXR");
// Input data
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._DepthTexture, sssartResources.depthStencilBuffer);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._NormalBufferTexture, sssartResources.normalBuffer);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._AnalyticProbBuffer, sssartResources.intermediateBufferRG0);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RaytracedAreaShadowSample, sssartResources.intermediateBufferRGBA1);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RaytracingDirectionBuffer, sssartResources.directionBuffer);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RayTracingLengthBuffer, sssartResources.rayLengthBuffer);
cmd.SetRayTracingIntParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RaytracingTargetAreaLight, parameters.lightIndex);
// Output data
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RaytracedAreaShadowIntegration, sssartResources.outputShadowTexture);
// Evaluate the intersection
cmd.DispatchRays(parameters.screenSpaceShadowsRT, m_RayGenAreaShadowSingleName, (uint)parameters.texWidth, (uint)parameters.texHeight, (uint)parameters.viewCount);
// Let's do the following samples (if any)
for (int sampleIndex = 1; sampleIndex < parameters.numSamples; ++sampleIndex)
{
// Update global Constant Buffer
parameters.shaderVariablesRayTracingCB._RaytracingNumSamples = parameters.numSamples;
parameters.shaderVariablesRayTracingCB._RaytracingSampleIndex = sampleIndex;
ConstantBuffer.PushGlobal(cmd, parameters.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Bind the light data
cmd.SetComputeIntParam(parameters.screenSpaceShadowsCS, HDShaderIDs._RaytracingTargetAreaLight, parameters.lightIndex);
cmd.SetComputeMatrixParam(parameters.screenSpaceShadowsCS, HDShaderIDs._RaytracingAreaWorldToLocal, parameters.worldToLocalMatrix);
// Input Buffers
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._DepthTexture, sssartResources.depthStencilBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._NormalBufferTexture, sssartResources.normalBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._GBufferTexture[0], sssartResources.gbuffer0);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._GBufferTexture[1], sssartResources.gbuffer1);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._GBufferTexture[2], sssartResources.gbuffer2);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._GBufferTexture[3], sssartResources.gbuffer3);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._StencilTexture, sssartResources.depthStencilBuffer, 0, RenderTextureSubElement.Stencil);
// Output buffers
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._RaytracedAreaShadowSample, sssartResources.intermediateBufferRGBA1);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._RaytracingDirectionBuffer, sssartResources.directionBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._RayTracingLengthBuffer, sssartResources.rayLengthBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, HDShaderIDs._AnalyticProbBuffer, sssartResources.intermediateBufferRG0);
cmd.DispatchCompute(parameters.screenSpaceShadowsCS, parameters.areaRaytracingShadowNewSampleKernel, numTilesX, numTilesY, parameters.viewCount);
// Input buffers
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._DepthTexture, sssartResources.depthStencilBuffer);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._NormalBufferTexture, sssartResources.normalBuffer);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RaytracedAreaShadowSample, sssartResources.intermediateBufferRGBA1);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RaytracingDirectionBuffer, sssartResources.directionBuffer);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RayTracingLengthBuffer, sssartResources.rayLengthBuffer);
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._AnalyticProbBuffer, sssartResources.intermediateBufferRG0);
cmd.SetRayTracingIntParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RaytracingTargetAreaLight, parameters.lightIndex);
// Output buffers
cmd.SetRayTracingTextureParam(parameters.screenSpaceShadowsRT, HDShaderIDs._RaytracedAreaShadowIntegration, sssartResources.outputShadowTexture);
// Evaluate the intersection
cmd.DispatchRays(parameters.screenSpaceShadowsRT, m_RayGenAreaShadowSingleName, (uint)parameters.texWidth, (uint)parameters.texHeight, (uint)parameters.viewCount);
}
if (parameters.filterTracedShadow)
{
Vector4 shadowChannelMask0 = new Vector4();
Vector4 shadowChannelMask1 = new Vector4();
Vector4 shadowChannelMask2 = new Vector4();
GetShadowChannelMask(parameters.areaShadowSlot, ScreenSpaceShadowType.Area, ref shadowChannelMask0);
GetShadowChannelMask(parameters.areaShadowSlot, ScreenSpaceShadowType.GrayScale, ref shadowChannelMask1);
GetShadowChannelMask(parameters.areaShadowSlot + 1, ScreenSpaceShadowType.GrayScale, ref shadowChannelMask2);
// Global parameters
cmd.SetComputeIntParam(parameters.screenSpaceShadowsFilterCS, HDShaderIDs._RaytracingDenoiseRadius, parameters.filterSize);
cmd.SetComputeIntParam(parameters.screenSpaceShadowsFilterCS, HDShaderIDs._DenoisingHistorySlice, parameters.areaShadowSlot / 4);
cmd.SetComputeVectorParam(parameters.screenSpaceShadowsFilterCS, HDShaderIDs._DenoisingHistoryMask, shadowChannelMask0);
cmd.SetComputeVectorParam(parameters.screenSpaceShadowsFilterCS, HDShaderIDs._DenoisingHistoryMaskSn, shadowChannelMask1);
cmd.SetComputeVectorParam(parameters.screenSpaceShadowsFilterCS, HDShaderIDs._DenoisingHistoryMaskUn, shadowChannelMask2);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowApplyTAAKernel, HDShaderIDs._AnalyticProbBuffer, sssartResources.intermediateBufferRG0);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowApplyTAAKernel, HDShaderIDs._DepthTexture, sssartResources.depthStencilBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowApplyTAAKernel, HDShaderIDs._CameraMotionVectorsTexture, sssartResources.motionVectorsBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowApplyTAAKernel, HDShaderIDs._AreaShadowHistory, sssartResources.shadowHistoryArray);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowApplyTAAKernel, HDShaderIDs._AnalyticHistoryBuffer, sssartResources.analyticHistoryArray);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowApplyTAAKernel, HDShaderIDs._DenoiseInputTexture, sssartResources.outputShadowTexture);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowApplyTAAKernel, HDShaderIDs._DenoiseOutputTextureRW, sssartResources.intermediateBufferRGBA1);
cmd.SetComputeFloatParam(parameters.screenSpaceShadowsFilterCS, HDShaderIDs._HistoryValidity, parameters.historyValidity);
cmd.DispatchCompute(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowApplyTAAKernel, numTilesX, numTilesY, parameters.viewCount);
// Update the shadow history buffer
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaUpdateAnalyticHistoryKernel, HDShaderIDs._AnalyticProbBuffer, sssartResources.intermediateBufferRG0);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaUpdateAnalyticHistoryKernel, HDShaderIDs._AnalyticHistoryBuffer, sssartResources.analyticHistoryArray);
cmd.DispatchCompute(parameters.screenSpaceShadowsFilterCS, parameters.areaUpdateAnalyticHistoryKernel, numTilesX, numTilesY, parameters.viewCount);
// Update the analytic history buffer
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaUpdateShadowHistoryKernel, HDShaderIDs._DenoiseInputTexture, sssartResources.intermediateBufferRGBA1);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaUpdateShadowHistoryKernel, HDShaderIDs._AreaShadowHistoryRW, sssartResources.shadowHistoryArray);
cmd.DispatchCompute(parameters.screenSpaceShadowsFilterCS, parameters.areaUpdateShadowHistoryKernel, numTilesX, numTilesY, parameters.viewCount);
// Inject parameters for noise estimation
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaEstimateNoiseKernel, HDShaderIDs._DepthTexture, sssartResources.depthStencilBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaEstimateNoiseKernel, HDShaderIDs._NormalBufferTexture, sssartResources.normalBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaEstimateNoiseKernel, HDShaderIDs._ScramblingTexture, parameters.scramblingTex);
// Noise estimation pre-pass
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaEstimateNoiseKernel, HDShaderIDs._DenoiseInputTexture, sssartResources.intermediateBufferRGBA1);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaEstimateNoiseKernel, HDShaderIDs._DenoiseOutputTextureRW, sssartResources.outputShadowTexture);
cmd.DispatchCompute(parameters.screenSpaceShadowsFilterCS, parameters.areaEstimateNoiseKernel, numTilesX, numTilesY, parameters.viewCount);
// Reinject parameters for denoising
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaFirstDenoiseKernel, HDShaderIDs._DepthTexture, sssartResources.depthStencilBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaFirstDenoiseKernel, HDShaderIDs._NormalBufferTexture, sssartResources.normalBuffer);
// First denoising pass
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaFirstDenoiseKernel, HDShaderIDs._DenoiseInputTexture, sssartResources.outputShadowTexture);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaFirstDenoiseKernel, HDShaderIDs._DenoiseOutputTextureRW, sssartResources.intermediateBufferRGBA1);
cmd.DispatchCompute(parameters.screenSpaceShadowsFilterCS, parameters.areaFirstDenoiseKernel, numTilesX, numTilesY, parameters.viewCount);
// Re-inject parameters for denoising
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaSecondDenoiseKernel, HDShaderIDs._DepthTexture, sssartResources.depthStencilBuffer);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaSecondDenoiseKernel, HDShaderIDs._NormalBufferTexture, sssartResources.normalBuffer);
// Second (and final) denoising pass
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaSecondDenoiseKernel, HDShaderIDs._DenoiseInputTexture, sssartResources.intermediateBufferRGBA1);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaSecondDenoiseKernel, HDShaderIDs._DenoiseOutputTextureRW, sssartResources.outputShadowTexture);
cmd.DispatchCompute(parameters.screenSpaceShadowsFilterCS, parameters.areaSecondDenoiseKernel, numTilesX, numTilesY, parameters.viewCount);
}
else
{
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowNoDenoiseKernel, HDShaderIDs._AnalyticProbBuffer, sssartResources.intermediateBufferRG0);
cmd.SetComputeTextureParam(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowNoDenoiseKernel, HDShaderIDs._DenoiseOutputTextureRW, sssartResources.outputShadowTexture);
cmd.DispatchCompute(parameters.screenSpaceShadowsFilterCS, parameters.areaShadowNoDenoiseKernel, numTilesX, numTilesY, parameters.viewCount);
}
}
TextureHandle DirGenRTR(RenderGraph renderGraph, HDCamera hdCamera, ScreenSpaceReflection settings, TextureHandle depthPyramid, TextureHandle stencilBuffer, TextureHandle normalBuffer, TextureHandle clearCoatTexture, bool transparent)
{
using (var builder = renderGraph.AddRenderPass <DirGenRTRPassData>("Generating the rays for RTR", out var passData, ProfilingSampler.Get(HDProfileId.RaytracingIndirectDiffuseDirectionGeneration)))
{
builder.EnableAsyncCompute(false);
// Set the camera parameters
passData.texWidth = settings.fullResolution ? hdCamera.actualWidth : hdCamera.actualWidth / 2;
passData.texHeight = settings.fullResolution ? hdCamera.actualHeight : hdCamera.actualHeight / 2;
passData.viewCount = hdCamera.viewCount;
// Set the generation parameters
passData.minSmoothness = settings.minSmoothness;
// Grab the right kernel
passData.directionGenCS = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingCS;
if (settings.fullResolution)
{
passData.dirGenKernel = transparent ? m_RaytracingReflectionsTransparentFullResKernel : m_RaytracingReflectionsFullResKernel;
}
else
{
passData.dirGenKernel = transparent ? m_RaytracingReflectionsTransparentHalfResKernel : m_RaytracingReflectionsHalfResKernel;
}
// Grab the additional parameters
passData.ditheredTextureSet = GetBlueNoiseManager().DitheredTextureSet8SPP();
passData.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
passData.depthBuffer = builder.ReadTexture(depthPyramid);
passData.stencilBuffer = builder.ReadTexture(stencilBuffer);
passData.normalBuffer = builder.ReadTexture(normalBuffer);
passData.clearCoatMaskTexture = builder.ReadTexture(clearCoatTexture);
passData.outputBuffer = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Reflection Ray Directions"
}));
builder.SetRenderFunc(
(DirGenRTRPassData data, RenderGraphContext ctx) =>
{
// TODO: check if this is required, i do not think so
CoreUtils.SetRenderTarget(ctx.cmd, data.outputBuffer, ClearFlag.Color, clearColor: Color.black);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(ctx.cmd, data.ditheredTextureSet);
// Bind all the required scalars to the CB
data.shaderVariablesRayTracingCB._RaytracingReflectionMinSmoothness = data.minSmoothness;
ConstantBuffer.PushGlobal(ctx.cmd, data.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Bind all the required textures
ctx.cmd.SetComputeTextureParam(data.directionGenCS, data.dirGenKernel, HDShaderIDs._DepthTexture, data.depthBuffer);
ctx.cmd.SetComputeTextureParam(data.directionGenCS, data.dirGenKernel, HDShaderIDs._NormalBufferTexture, data.normalBuffer);
ctx.cmd.SetComputeTextureParam(data.directionGenCS, data.dirGenKernel, HDShaderIDs._SsrClearCoatMaskTexture, data.clearCoatMaskTexture);
ctx.cmd.SetComputeIntParam(data.directionGenCS, HDShaderIDs._SsrStencilBit, (int)StencilUsage.TraceReflectionRay);
ctx.cmd.SetComputeTextureParam(data.directionGenCS, data.dirGenKernel, HDShaderIDs._StencilTexture, data.stencilBuffer, 0, RenderTextureSubElement.Stencil);
// Bind the output buffers
ctx.cmd.SetComputeTextureParam(data.directionGenCS, data.dirGenKernel, HDShaderIDs._RaytracingDirectionBuffer, data.outputBuffer);
// Evaluate the dispatch parameters
int numTilesX = (data.texWidth + (rtReflectionsComputeTileSize - 1)) / rtReflectionsComputeTileSize;
int numTilesY = (data.texHeight + (rtReflectionsComputeTileSize - 1)) / rtReflectionsComputeTileSize;
// Compute the directions
ctx.cmd.DispatchCompute(data.directionGenCS, data.dirGenKernel, numTilesX, numTilesY, data.viewCount);
});
return(passData.outputBuffer);
}
}
static void ExecuteRTSubsurfaceScattering(CommandBuffer cmd, SSSRayTracingParameters sssrtParams, SSSRayTracingResources sssrtResources)
{
// Evaluate the dispatch parameters
int numTilesXHR = (sssrtParams.texWidth + (s_sssTileSize - 1)) / s_sssTileSize;
int numTilesYHR = (sssrtParams.texHeight + (s_sssTileSize - 1)) / s_sssTileSize;
// Clear the integration texture first
cmd.SetComputeTextureParam(sssrtParams.rayTracingSubSurfaceCS, sssrtParams.clearTextureKernel, HDShaderIDs._DiffuseLightingTextureRW, sssrtResources.outputBuffer);
cmd.DispatchCompute(sssrtParams.rayTracingSubSurfaceCS, sssrtParams.clearTextureKernel, numTilesXHR, numTilesYHR, sssrtParams.viewCount);
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(sssrtParams.rayTracingSubSurfaceRT, "SubSurfaceDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(sssrtParams.rayTracingSubSurfaceRT, HDShaderIDs._RaytracingAccelerationStructureName, sssrtParams.accelerationStructure);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(cmd, sssrtParams.ditheredTextureSet);
// For every sample that we need to process
for (int sampleIndex = 0; sampleIndex < sssrtParams.sampleCount; ++sampleIndex)
{
// Inject the ray generation data
sssrtParams.shaderVariablesRayTracingCB._RaytracingNumSamples = sssrtParams.sampleCount;
sssrtParams.shaderVariablesRayTracingCB._RaytracingSampleIndex = sampleIndex;
ConstantBuffer.PushGlobal(cmd, sssrtParams.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Bind the input textures for ray generation
cmd.SetRayTracingTextureParam(sssrtParams.rayTracingSubSurfaceRT, HDShaderIDs._DepthTexture, sssrtResources.depthStencilBuffer);
cmd.SetRayTracingTextureParam(sssrtParams.rayTracingSubSurfaceRT, HDShaderIDs._NormalBufferTexture, sssrtResources.normalBuffer);
cmd.SetRayTracingTextureParam(sssrtParams.rayTracingSubSurfaceRT, HDShaderIDs._SSSBufferTexture, sssrtResources.sssColor);
cmd.SetGlobalTexture(HDShaderIDs._StencilTexture, sssrtResources.depthStencilBuffer, RenderTextureSubElement.Stencil);
// Set the output textures
cmd.SetRayTracingTextureParam(sssrtParams.rayTracingSubSurfaceRT, HDShaderIDs._ThroughputTextureRW, sssrtResources.intermediateBuffer0);
cmd.SetRayTracingTextureParam(sssrtParams.rayTracingSubSurfaceRT, HDShaderIDs._NormalTextureRW, sssrtResources.intermediateBuffer1);
cmd.SetRayTracingTextureParam(sssrtParams.rayTracingSubSurfaceRT, HDShaderIDs._PositionTextureRW, sssrtResources.intermediateBuffer2);
cmd.SetRayTracingTextureParam(sssrtParams.rayTracingSubSurfaceRT, HDShaderIDs._DiffuseLightingTextureRW, sssrtResources.intermediateBuffer3);
cmd.SetRayTracingTextureParam(sssrtParams.rayTracingSubSurfaceRT, HDShaderIDs._DirectionTextureRW, sssrtResources.directionBuffer);
// Run the computation
cmd.DispatchRays(sssrtParams.rayTracingSubSurfaceRT, m_RayGenSubSurfaceShaderName, (uint)sssrtParams.texWidth, (uint)sssrtParams.texHeight, (uint)sssrtParams.viewCount);
// Now let's do the deferred shading pass on the samples
// Bind the lightLoop data
sssrtParams.lightCluster.BindLightClusterData(cmd);
// Bind the input textures
cmd.SetComputeTextureParam(sssrtParams.deferredRayTracingCS, sssrtParams.rtDeferredLightingKernel, HDShaderIDs._DepthTexture, sssrtResources.depthStencilBuffer);
cmd.SetComputeTextureParam(sssrtParams.deferredRayTracingCS, sssrtParams.rtDeferredLightingKernel, HDShaderIDs._ThroughputTextureRW, sssrtResources.intermediateBuffer0);
cmd.SetComputeTextureParam(sssrtParams.deferredRayTracingCS, sssrtParams.rtDeferredLightingKernel, HDShaderIDs._NormalTextureRW, sssrtResources.intermediateBuffer1);
cmd.SetComputeTextureParam(sssrtParams.deferredRayTracingCS, sssrtParams.rtDeferredLightingKernel, HDShaderIDs._PositionTextureRW, sssrtResources.intermediateBuffer2);
cmd.SetComputeTextureParam(sssrtParams.deferredRayTracingCS, sssrtParams.rtDeferredLightingKernel, HDShaderIDs._DirectionTextureRW, sssrtResources.directionBuffer);
cmd.SetComputeTextureParam(sssrtParams.deferredRayTracingCS, sssrtParams.rtDeferredLightingKernel, HDShaderIDs._DiffuseLightingTextureRW, sssrtResources.intermediateBuffer3);
// Bind the output texture (it is used for accumulation read and write)
cmd.SetComputeTextureParam(sssrtParams.deferredRayTracingCS, sssrtParams.rtDeferredLightingKernel, HDShaderIDs._RaytracingLitBufferRW, sssrtResources.outputBuffer);
// Compute the Lighting
cmd.DispatchCompute(sssrtParams.deferredRayTracingCS, sssrtParams.rtDeferredLightingKernel, numTilesXHR, numTilesYHR, sssrtParams.viewCount);
}
}
TextureHandle QualityRTR(RenderGraph renderGraph, HDCamera hdCamera, ScreenSpaceReflection settings,
TextureHandle depthPyramid, TextureHandle stencilBuffer, TextureHandle normalBuffer, TextureHandle clearCoatTexture, TextureHandle rayCountTexture, bool transparent)
{
using (var builder = renderGraph.AddRenderPass <TraceQualityRTRPassData>("Quality RT Reflections", out var passData, ProfilingSampler.Get(HDProfileId.RaytracingReflectionEvaluation)))
{
builder.EnableAsyncCompute(false);
// Camera parameters
passData.texWidth = hdCamera.actualWidth;
passData.texHeight = hdCamera.actualHeight;
passData.viewCount = hdCamera.viewCount;
// Reflection evaluation parameters
passData.clampValue = settings.clampValue;
passData.reflectSky = settings.reflectSky.value ? 1 : 0;
passData.rayLength = settings.rayLength;
passData.sampleCount = settings.sampleCount.value;
passData.bounceCount = settings.bounceCount.value;
passData.transparent = transparent;
passData.minSmoothness = settings.minSmoothness;
passData.smoothnessFadeStart = settings.smoothnessFadeStart;
// Other parameters
passData.accelerationStructure = RequestAccelerationStructure();
passData.lightCluster = RequestLightCluster();
passData.ditheredTextureSet = GetBlueNoiseManager().DitheredTextureSet8SPP();
passData.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
passData.skyTexture = m_SkyManager.GetSkyReflection(hdCamera);
passData.reflectionShader = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
passData.depthBuffer = builder.ReadTexture(depthPyramid);
passData.stencilBuffer = builder.ReadTexture(stencilBuffer);
passData.normalBuffer = builder.ReadTexture(normalBuffer);
passData.clearCoatMaskTexture = builder.ReadTexture(clearCoatTexture);
passData.rayCountTexture = builder.ReadWriteTexture(rayCountTexture);
passData.outputTexture = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
{
colorFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, name = "Ray Traced Reflections"
}));
builder.SetRenderFunc(
(TraceQualityRTRPassData data, RenderGraphContext ctx) =>
{
// Define the shader pass to use for the reflection pass
ctx.cmd.SetRayTracingShaderPass(data.reflectionShader, "IndirectDXR");
// Set the acceleration structure for the pass
ctx.cmd.SetRayTracingAccelerationStructure(data.reflectionShader, HDShaderIDs._RaytracingAccelerationStructureName, data.accelerationStructure);
// Global reflection parameters
data.shaderVariablesRayTracingCB._RaytracingIntensityClamp = data.clampValue;
data.shaderVariablesRayTracingCB._RaytracingIncludeSky = data.reflectSky;
// Inject the ray generation data
data.shaderVariablesRayTracingCB._RaytracingRayMaxLength = data.rayLength;
data.shaderVariablesRayTracingCB._RaytracingNumSamples = data.sampleCount;
// Set the number of bounces for reflections
data.shaderVariablesRayTracingCB._RaytracingMaxRecursion = data.bounceCount;
data.shaderVariablesRayTracingCB._RayTracingDiffuseLightingOnly = 0;
// Bind all the required scalars to the CB
data.shaderVariablesRayTracingCB._RaytracingReflectionMinSmoothness = data.minSmoothness;
data.shaderVariablesRayTracingCB._RaytracingReflectionSmoothnessFadeStart = data.smoothnessFadeStart;
ConstantBuffer.PushGlobal(ctx.cmd, data.shaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Inject the ray-tracing sampling data
BlueNoise.BindDitheredTextureSet(ctx.cmd, data.ditheredTextureSet);
// Set the data for the ray generation
ctx.cmd.SetRayTracingTextureParam(data.reflectionShader, HDShaderIDs._SsrLightingTextureRW, data.outputTexture);
ctx.cmd.SetRayTracingTextureParam(data.reflectionShader, HDShaderIDs._DepthTexture, data.depthBuffer);
ctx.cmd.SetRayTracingTextureParam(data.reflectionShader, HDShaderIDs._NormalBufferTexture, data.normalBuffer);
ctx.cmd.SetGlobalTexture(HDShaderIDs._StencilTexture, data.stencilBuffer, RenderTextureSubElement.Stencil);
ctx.cmd.SetRayTracingIntParams(data.reflectionShader, HDShaderIDs._SsrStencilBit, (int)StencilUsage.TraceReflectionRay);
// Set ray count texture
ctx.cmd.SetRayTracingTextureParam(data.reflectionShader, HDShaderIDs._RayCountTexture, data.rayCountTexture);
// Bind the lightLoop data
data.lightCluster.BindLightClusterData(ctx.cmd);
// Evaluate the clear coat mask texture based on the lit shader mode
ctx.cmd.SetRayTracingTextureParam(data.reflectionShader, HDShaderIDs._SsrClearCoatMaskTexture, data.clearCoatMaskTexture);
// Set the data for the ray miss
ctx.cmd.SetRayTracingTextureParam(data.reflectionShader, HDShaderIDs._SkyTexture, data.skyTexture);
// Only use the shader variant that has multi bounce if the bounce count > 1
CoreUtils.SetKeyword(ctx.cmd, "MULTI_BOUNCE_INDIRECT", data.bounceCount > 1);
// Run the computation
ctx.cmd.DispatchRays(data.reflectionShader, data.transparent ? m_RayGenIntegrationTransparentName : m_RayGenIntegrationName, (uint)data.texWidth, (uint)data.texHeight, (uint)data.viewCount);
// Disable multi-bounce
CoreUtils.SetKeyword(ctx.cmd, "MULTI_BOUNCE_INDIRECT", false);
});
return(passData.outputTexture);
}
}
public void RenderAO(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ShaderVariablesRaytracing globalCB, ScriptableRenderContext renderContext, int frameCount)
{
// If any of the previous requirements is missing, the effect is not requested or no acceleration structure, set the default one and leave right away
if (!m_RenderPipeline.GetRayTracingState())
{
SetDefaultAmbientOcclusionTexture(cmd);
return;
}
RayTracingShader aoShader = m_PipelineRayTracingResources.aoRaytracing;
var aoSettings = hdCamera.volumeStack.GetComponent <AmbientOcclusion>();
RayCountManager rayCountManager = m_RenderPipeline.GetRayCountManager();
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingAmbientOcclusion)))
{
// Grab the acceleration structure for the target camera
RayTracingAccelerationStructure accelerationStructure = m_RenderPipeline.RequestAccelerationStructure();
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(aoShader, "VisibilityDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(aoShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure);
// Inject the ray generation data (be careful of the global constant buffer limitation)
globalCB._RaytracingRayMaxLength = aoSettings.rayLength;
globalCB._RaytracingNumSamples = aoSettings.sampleCount;
ConstantBuffer.PushGlobal(cmd, globalCB, HDShaderIDs._ShaderVariablesRaytracing);
// Set the data for the ray generation
cmd.SetRayTracingTextureParam(aoShader, HDShaderIDs._DepthTexture, m_RenderPipeline.sharedRTManager.GetDepthStencilBuffer());
cmd.SetRayTracingTextureParam(aoShader, HDShaderIDs._NormalBufferTexture, m_RenderPipeline.sharedRTManager.GetNormalBuffer());
// Inject the ray-tracing sampling data
BlueNoise blueNoise = m_RenderPipeline.GetBlueNoiseManager();
blueNoise.BindDitheredRNGData8SPP(cmd);
// Value used to scale the ao intensity
cmd.SetRayTracingFloatParam(aoShader, HDShaderIDs._RaytracingAOIntensity, aoSettings.intensity.value);
// Set the output textures
cmd.SetRayTracingTextureParam(aoShader, HDShaderIDs._RayCountTexture, rayCountManager.GetRayCountTexture());
cmd.SetRayTracingTextureParam(aoShader, HDShaderIDs._AmbientOcclusionTextureRW, m_AOIntermediateBuffer0);
// Run the computation
cmd.DispatchRays(aoShader, m_RayGenShaderName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, (uint)hdCamera.viewCount);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingFilterAmbientOcclusion)))
{
if (aoSettings.denoise)
{
// Grab the history buffer
RTHandle ambientOcclusionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedAmbientOcclusion)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedAmbientOcclusion, AmbientOcclusionHistoryBufferAllocatorFunction, 1);
float historyValidity = 1.0f;
#if UNITY_HDRP_DXR_TESTS_DEFINE
if (Application.isPlaying)
{
historyValidity = 0.0f;
}
else
#endif
// We need to check if something invalidated the history buffers
historyValidity = m_RenderPipeline.ValidRayTracingHistory(hdCamera) ? 1.0f : 0.0f;
// Apply the temporal denoiser
HDTemporalFilter temporalFilter = m_RenderPipeline.GetTemporalFilter();
temporalFilter.DenoiseBuffer(cmd, hdCamera, m_AOIntermediateBuffer0, ambientOcclusionHistory, m_AOIntermediateBuffer1, historyValidity: historyValidity);
// Apply the diffuse denoiser
HDDiffuseDenoiser diffuseDenoiser = m_RenderPipeline.GetDiffuseDenoiser();
diffuseDenoiser.DenoiseBuffer(cmd, hdCamera, m_AOIntermediateBuffer1, outputTexture, aoSettings.denoiserRadius);
}
else
{
HDUtils.BlitCameraTexture(cmd, m_AOIntermediateBuffer0, outputTexture);
}
}
// Bind the textures and the params
cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, outputTexture);
// TODO: All the push-debug stuff should be centralized somewhere
(RenderPipelineManager.currentPipeline as HDRenderPipeline).PushFullScreenDebugTexture(hdCamera, cmd, outputTexture, FullScreenDebugMode.SSAO);
}
/// <summary>
/// Updates shader variables in ShaderVariablesGlobal CBuffer with given camera properties.
/// </summary>
/// <param name="cmd">CommandBuffer used for queueing commands.</param>
/// <param name="camera">Camera from which values will be taken.</param>
public void UpdateShaderVariablesForCamera(CommandBuffer cmd, HDCamera camera)
{
camera.UpdateShaderVariablesGlobalCB(ref m_ShaderVariablesGlobalCB);
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesGlobalCB, HDShaderIDs._ShaderVariablesGlobal);
}
void RenderSubsurfaceScattering(HDCamera hdCamera, CommandBuffer cmd, RTHandle colorBufferRT,
RTHandle diffuseBufferRT, RTHandle depthStencilBufferRT, RTHandle depthTextureRT)
{
if (!hdCamera.frameSettings.IsEnabled(FrameSettingsField.SubsurfaceScattering))
{
return;
}
BuildCoarseStencilAndResolveIfNeeded(hdCamera, cmd);
var settings = hdCamera.volumeStack.GetComponent <SubSurfaceScattering>();
// If ray tracing is enabled for the camera, if the volume override is active and if the RAS is built, we want to do ray traced SSS
if (hdCamera.frameSettings.IsEnabled(FrameSettingsField.RayTracing) && settings.rayTracing.value && GetRayTracingState())
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.SubsurfaceScattering)))
{
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = (hdCamera.actualWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (hdCamera.actualHeight + (areaTileSize - 1)) / areaTileSize;
// Fetch the volume overrides that we shall be using
RayTracingShader subSurfaceShader = m_Asset.renderPipelineRayTracingResources.subSurfaceRayTracing;
ComputeShader deferredRayTracing = m_Asset.renderPipelineRayTracingResources.deferredRaytracingCS;
// Fetch all the intermediate buffers that we need
RTHandle intermediateBuffer0 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA0);
RTHandle intermediateBuffer1 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA1);
RTHandle intermediateBuffer2 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA2);
RTHandle intermediateBuffer3 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA3);
RTHandle intermediateBuffer4 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA4);
RTHandle directionBuffer = GetRayTracingBuffer(InternalRayTracingBuffers.Direction);
// Clear the integration texture first
cmd.SetComputeTextureParam(m_ScreenSpaceShadowsCS, m_ClearShadowTexture, HDShaderIDs._RaytracedShadowIntegration, intermediateBuffer4);
cmd.DispatchCompute(m_ScreenSpaceShadowsCS, m_ClearShadowTexture, numTilesXHR, numTilesYHR, hdCamera.viewCount);
// Grab the acceleration structure for the target camera
RayTracingAccelerationStructure accelerationStructure = RequestAccelerationStructure();
// Define the shader pass to use for the reflection pass
cmd.SetRayTracingShaderPass(subSurfaceShader, "SubSurfaceDXR");
// Set the acceleration structure for the pass
cmd.SetRayTracingAccelerationStructure(subSurfaceShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure);
// Inject the ray-tracing sampling data
BlueNoise blueNoise = GetBlueNoiseManager();
blueNoise.BindDitheredRNGData8SPP(cmd);
// For every sample that we need to process
for (int sampleIndex = 0; sampleIndex < settings.sampleCount.value; ++sampleIndex)
{
// Inject the ray generation data
m_ShaderVariablesRayTracingCB._RaytracingNumSamples = settings.sampleCount.value;
m_ShaderVariablesRayTracingCB._RaytracingSampleIndex = sampleIndex;
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Bind the textures for ray generation
cmd.SetRayTracingTextureParam(subSurfaceShader, HDShaderIDs._DepthTexture, sharedRTManager.GetDepthStencilBuffer());
cmd.SetRayTracingTextureParam(subSurfaceShader, HDShaderIDs._NormalBufferTexture, sharedRTManager.GetNormalBuffer());
cmd.SetRayTracingTextureParam(subSurfaceShader, HDShaderIDs._SSSBufferTexture, m_SSSColor);
cmd.SetGlobalTexture(HDShaderIDs._StencilTexture, sharedRTManager.GetDepthStencilBuffer(), RenderTextureSubElement.Stencil);
// Set the output textures
cmd.SetRayTracingTextureParam(subSurfaceShader, HDShaderIDs._ThroughputTextureRW, intermediateBuffer0);
cmd.SetRayTracingTextureParam(subSurfaceShader, HDShaderIDs._NormalTextureRW, intermediateBuffer1);
cmd.SetRayTracingTextureParam(subSurfaceShader, HDShaderIDs._PositionTextureRW, intermediateBuffer2);
cmd.SetRayTracingTextureParam(subSurfaceShader, HDShaderIDs._DiffuseLightingTextureRW, intermediateBuffer3);
cmd.SetRayTracingTextureParam(subSurfaceShader, HDShaderIDs._DirectionTextureRW, directionBuffer);
// Run the computation
cmd.DispatchRays(subSurfaceShader, m_RayGenSubSurfaceShaderName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, (uint)hdCamera.viewCount);
// Now let's do the deferred shading pass on the samples
// TODO: Do this only once in the init pass
int currentKernel = deferredRayTracing.FindKernel("RaytracingDiffuseDeferred");
// Bind the lightLoop data
HDRaytracingLightCluster lightCluster = RequestLightCluster();
lightCluster.BindLightClusterData(cmd);
// Bind the input textures
cmd.SetComputeTextureParam(deferredRayTracing, currentKernel, HDShaderIDs._DepthTexture, sharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(deferredRayTracing, currentKernel, HDShaderIDs._ThroughputTextureRW, intermediateBuffer0);
cmd.SetComputeTextureParam(deferredRayTracing, currentKernel, HDShaderIDs._NormalTextureRW, intermediateBuffer1);
cmd.SetComputeTextureParam(deferredRayTracing, currentKernel, HDShaderIDs._PositionTextureRW, intermediateBuffer2);
cmd.SetComputeTextureParam(deferredRayTracing, currentKernel, HDShaderIDs._DirectionTextureRW, directionBuffer);
cmd.SetComputeTextureParam(deferredRayTracing, currentKernel, HDShaderIDs._DiffuseLightingTextureRW, intermediateBuffer3);
// Bind the output texture (it is used for accumulation read and write)
cmd.SetComputeTextureParam(deferredRayTracing, currentKernel, HDShaderIDs._RaytracingLitBufferRW, intermediateBuffer4);
// Compute the Lighting
cmd.DispatchCompute(deferredRayTracing, currentKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
}
// Grab the history buffer
RTHandle subsurfaceHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RayTracedSubSurface)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RayTracedSubSurface, SubSurfaceHistoryBufferAllocatorFunction, 1);
// Check if we need to invalidate the history
float historyValidity = 1.0f;
#if UNITY_HDRP_DXR_TESTS_DEFINE
if (Application.isPlaying)
{
historyValidity = 0.0f;
}
else
#endif
// We need to check if something invalidated the history buffers
historyValidity *= ValidRayTracingHistory(hdCamera) ? 1.0f : 0.0f;
// Apply temporal filtering to the buffer
HDTemporalFilter temporalFilter = GetTemporalFilter();
temporalFilter.DenoiseBuffer(cmd, hdCamera, intermediateBuffer4, subsurfaceHistory, intermediateBuffer0, singleChannel: false, historyValidity: historyValidity);
// Now based on the mask, we need to blend the subsurface and the diffuse lighting
ComputeShader rayTracingSubSurfaceCS = m_Asset.renderPipelineRayTracingResources.subSurfaceRayTracingCS;
int m_CombineSubSurfaceKernel = rayTracingSubSurfaceCS.FindKernel("BlendSubSurfaceData");
cmd.SetComputeTextureParam(rayTracingSubSurfaceCS, m_CombineSubSurfaceKernel, HDShaderIDs._SubSurfaceLightingBuffer, intermediateBuffer0);
cmd.SetComputeTextureParam(rayTracingSubSurfaceCS, m_CombineSubSurfaceKernel, HDShaderIDs._DiffuseLightingTextureRW, diffuseBufferRT);
cmd.SetComputeTextureParam(rayTracingSubSurfaceCS, m_CombineSubSurfaceKernel, HDShaderIDs._SSSBufferTexture, m_SSSColor);
cmd.DispatchCompute(rayTracingSubSurfaceCS, m_CombineSubSurfaceKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
// Push this version of the texture for debug
PushFullScreenDebugTexture(hdCamera, cmd, diffuseBufferRT, FullScreenDebugMode.RayTracedSubSurface);
// Combine it with the rest of the lighting
m_CombineLightingPass.SetTexture(HDShaderIDs._IrradianceSource, diffuseBufferRT);
HDUtils.DrawFullScreen(cmd, m_CombineLightingPass, colorBufferRT, depthStencilBufferRT, shaderPassId: 1);
}
}
else
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.SubsurfaceScattering)))
{
var parameters = PrepareSubsurfaceScatteringParameters(hdCamera);
var resources = new SubsurfaceScatteringResources();
resources.colorBuffer = colorBufferRT;
resources.diffuseBuffer = diffuseBufferRT;
resources.depthStencilBuffer = depthStencilBufferRT;
resources.depthTexture = depthTextureRT;
resources.cameraFilteringBuffer = m_SSSCameraFilteringBuffer;
resources.coarseStencilBuffer = parameters.coarseStencilBuffer;
resources.sssBuffer = m_SSSColor;
// For Jimenez we always need an extra buffer, for Disney it depends on platform
if (parameters.needTemporaryBuffer)
{
// Clear the SSS filtering target
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.ClearSSSFilteringTarget)))
{
CoreUtils.SetRenderTarget(cmd, m_SSSCameraFilteringBuffer, ClearFlag.Color, Color.clear);
}
}
RenderSubsurfaceScattering(parameters, resources, cmd);
}
}
}
static void TraceVolumetricClouds_Accumulation(CommandBuffer cmd, VolumetricCloudsParameters_Accumulation parameters, ComputeBuffer ambientProbe,
RTHandle colorBuffer, RTHandle depthPyramid, RTHandle motionVectors, RTHandle volumetricLightingTexture, RTHandle scatteringFallbackTexture, RTHandle maxZMask,
RTHandle currentHistory0Buffer, RTHandle previousHistory0Buffer,
RTHandle currentHistory1Buffer, RTHandle previousHistory1Buffer,
RTHandle intermediateLightingBuffer0, RTHandle intermediateLightingBuffer1, RTHandle intermediateDepthBuffer0, RTHandle intermediateDepthBuffer1, RTHandle intermediateDepthBuffer2,
RTHandle intermediateColorBuffer, RTHandle intermediateUpscaleBuffer)
{
// Compute the number of tiles to evaluate
int traceTX = (parameters.traceWidth + (8 - 1)) / 8;
int traceTY = (parameters.traceHeight + (8 - 1)) / 8;
// Compute the number of tiles to evaluate
int intermediateTX = (parameters.intermediateWidth + (8 - 1)) / 8;
int intermediateTY = (parameters.intermediateHeight + (8 - 1)) / 8;
// Compute the number of tiles to evaluate
int finalTX = (parameters.finalWidth + (8 - 1)) / 8;
int finalTY = (parameters.finalHeight + (8 - 1)) / 8;
// Bind the sampling textures
BlueNoise.BindDitheredTextureSet(cmd, parameters.commonData.ditheredTextureSet);
// Set the multi compiles
CoreUtils.SetKeyword(cmd, "LOCAL_VOLUMETRIC_CLOUDS", parameters.commonData.localClouds);
// We only need to handle history buffers if this is not a reflection probe
// We need to make sure that the allocated size of the history buffers and the dispatch size are perfectly equal.
// The ideal approach would be to have a function for that returns the converted size from a viewport and texture size.
// but for now we do it like this.
Vector2Int previousViewportSize = previousHistory0Buffer.GetScaledSize(parameters.previousViewportSize);
parameters.commonData.cloudsCB._HistoryViewportSize = new Vector2(previousViewportSize.x, previousViewportSize.y);
parameters.commonData.cloudsCB._HistoryBufferSize = new Vector2(previousHistory0Buffer.rt.width, previousHistory0Buffer.rt.height);
// Bind the constant buffer (global as we need it for the .shader as well)
ConstantBuffer.PushGlobal(cmd, parameters.commonData.cloudsCB, HDShaderIDs._ShaderVariablesClouds);
RTHandle currentDepthBuffer = depthPyramid;
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.VolumetricCloudsPrepare)))
{
if (parameters.commonData.cameraType == TVolumetricCloudsCameraType.PlanarReflection)
{
// In order to be able to work with planar
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.convertObliqueDepthKernel, HDShaderIDs._DepthTexture, depthPyramid);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.convertObliqueDepthKernel, HDShaderIDs._DepthBufferRW, intermediateDepthBuffer2);
cmd.DispatchCompute(parameters.commonData.volumetricCloudsCS, parameters.convertObliqueDepthKernel, finalTX, finalTY, parameters.viewCount);
currentDepthBuffer = intermediateDepthBuffer2;
}
// Compute the alternative version of the mip 1 of the depth (min instead of max that is required to handle high frequency meshes (vegetation, hair)
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.depthDownscaleKernel, HDShaderIDs._DepthTexture, currentDepthBuffer);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.depthDownscaleKernel, HDShaderIDs._HalfResDepthBufferRW, intermediateDepthBuffer0);
cmd.DispatchCompute(parameters.commonData.volumetricCloudsCS, parameters.depthDownscaleKernel, intermediateTX, intermediateTY, parameters.viewCount);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.VolumetricCloudsTrace)))
{
// Ray-march the clouds for this frame
CoreUtils.SetKeyword(cmd, "PHYSICALLY_BASED_SUN", parameters.commonData.cloudsCB._PhysicallyBasedSun == 1);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, HDShaderIDs._MaxZMaskTexture, maxZMask);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, HDShaderIDs._VolumetricCloudsSourceDepth, intermediateDepthBuffer0);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, HDShaderIDs._Worley128RGBA, parameters.commonData.worley128RGBA);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, HDShaderIDs._ErosionNoise, parameters.commonData.erosionNoise);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, HDShaderIDs._CloudMapTexture, parameters.commonData.cloudMapTexture);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, HDShaderIDs._CloudLutTexture, parameters.commonData.cloudLutTexture);
cmd.SetComputeBufferParam(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, HDShaderIDs._VolumetricCloudsAmbientProbeBuffer, ambientProbe);
// Output buffers
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, HDShaderIDs._CloudsLightingTextureRW, intermediateLightingBuffer0);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, HDShaderIDs._CloudsDepthTextureRW, intermediateDepthBuffer1);
cmd.DispatchCompute(parameters.commonData.volumetricCloudsCS, parameters.renderKernel, traceTX, traceTY, parameters.viewCount);
CoreUtils.SetKeyword(cmd, "PHYSICALLY_BASED_SUN", false);
}
// We only reproject for realtime clouds
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.VolumetricCloudsReproject)))
{
if (!parameters.historyValidity)
{
CoreUtils.SetRenderTarget(cmd, previousHistory1Buffer, clearFlag: ClearFlag.Color, clearColor: Color.black);
}
// Re-project the result from the previous frame
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.reprojectKernel, HDShaderIDs._CloudsLightingTexture, intermediateLightingBuffer0);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.reprojectKernel, HDShaderIDs._CloudsDepthTexture, intermediateDepthBuffer1);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.reprojectKernel, HDShaderIDs._HalfResDepthBuffer, intermediateDepthBuffer0);
// History buffers
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.reprojectKernel, HDShaderIDs._HistoryVolumetricClouds0Texture, previousHistory0Buffer);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.reprojectKernel, HDShaderIDs._HistoryVolumetricClouds1Texture, previousHistory1Buffer);
// Output textures
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.reprojectKernel, HDShaderIDs._CloudsLightingTextureRW, currentHistory0Buffer);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.reprojectKernel, HDShaderIDs._CloudsAdditionalTextureRW, currentHistory1Buffer);
// Re-project from the previous frame
cmd.DispatchCompute(parameters.commonData.volumetricCloudsCS, parameters.reprojectKernel, intermediateTX, intermediateTY, parameters.viewCount);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.VolumetricCloudsUpscaleAndCombine)))
{
if (parameters.needExtraColorBufferCopy)
{
HDUtils.BlitCameraTexture(cmd, colorBuffer, intermediateColorBuffer);
}
// Compute the final resolution parameters
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.upscaleAndCombineKernel, HDShaderIDs._DepthStatusTexture, currentHistory1Buffer);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.upscaleAndCombineKernel, HDShaderIDs._VolumetricCloudsTexture, currentHistory0Buffer);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.upscaleAndCombineKernel, HDShaderIDs._DepthTexture, currentDepthBuffer);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.upscaleAndCombineKernel, HDShaderIDs._CameraColorTexture, intermediateColorBuffer);
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.upscaleAndCombineKernel, HDShaderIDs._VBufferLighting, volumetricLightingTexture);
if (parameters.commonData.cloudsCB._PhysicallyBasedSun == 0)
{
// This has to be done in the global space given that the "correct" one happens in the global space.
// If we do it in the local space, there are some cases when the previous frames local take precedence over the current frame global one.
cmd.SetGlobalTexture(HDShaderIDs._AirSingleScatteringTexture, scatteringFallbackTexture);
cmd.SetGlobalTexture(HDShaderIDs._AerosolSingleScatteringTexture, scatteringFallbackTexture);
cmd.SetGlobalTexture(HDShaderIDs._MultipleScatteringTexture, scatteringFallbackTexture);
}
if (parameters.needsTemporaryBuffer)
{
CoreUtils.SetKeyword(cmd, "USE_INTERMEDIATE_BUFFER", true);
// Provide this second upscaling + combine strategy in case a temporary buffer is requested (ie MSAA).
// In the case of an MSAA color target, we cannot use the in-place blending of the clouds with the color target.
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.upscaleAndCombineKernel, HDShaderIDs._VolumetricCloudsUpscaleTextureRW, intermediateUpscaleBuffer);
// Perform the upscale into an intermediate buffer.
cmd.DispatchCompute(parameters.commonData.volumetricCloudsCS, parameters.upscaleAndCombineKernel, finalTX, finalTY, parameters.viewCount);
parameters.cloudCombinePass.SetTexture(HDShaderIDs._VolumetricCloudsUpscaleTextureRW, intermediateUpscaleBuffer);
// Composite the clouds into the MSAA target via hardware blending.
HDUtils.DrawFullScreen(cmd, parameters.cloudCombinePass, colorBuffer, null, 0);
CoreUtils.SetKeyword(cmd, "USE_INTERMEDIATE_BUFFER", false);
}
else
{
cmd.SetComputeTextureParam(parameters.commonData.volumetricCloudsCS, parameters.upscaleAndCombineKernel, HDShaderIDs._VolumetricCloudsUpscaleTextureRW, colorBuffer);
// Perform the upscale and combine with the color buffer in place.
cmd.DispatchCompute(parameters.commonData.volumetricCloudsCS, parameters.upscaleAndCombineKernel, finalTX, finalTY, parameters.viewCount);
}
}
// Reset all the multi-compiles
CoreUtils.SetKeyword(cmd, "LOCAL_VOLUMETRIC_CLOUDS", false);
}