TextureHandle RenderReflectionsPerformance(RenderGraph renderGraph, HDCamera hdCamera,
TextureHandle depthPyramid, TextureHandle stencilBuffer, TextureHandle normalBuffer, TextureHandle motionVectors, TextureHandle rayCountTexture, TextureHandle clearCoatTexture, Texture skyTexture,
ShaderVariablesRaytracing shaderVariablesRaytracing, bool transparent)
{
// Pointer to the final result
TextureHandle rtrResult;
// Fetch all the settings
ScreenSpaceReflection settings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
TextureHandle directionBuffer = DirGenRTR(renderGraph, hdCamera, settings, depthPyramid, stencilBuffer, normalBuffer, clearCoatTexture, transparent);
DeferredLightingRTParameters deferredParamters = PrepareReflectionDeferredLightingRTParameters(hdCamera);
TextureHandle lightingBuffer = DeferredLightingRT(renderGraph, in deferredParamters, directionBuffer, depthPyramid, normalBuffer, skyTexture, rayCountTexture);
rtrResult = AdjustWeightRTR(renderGraph, hdCamera, settings, depthPyramid, normalBuffer, clearCoatTexture, lightingBuffer, directionBuffer);
// Denoise if required
if (settings.denoise && !transparent)
{
rtrResult = DenoiseReflection(renderGraph, hdCamera, settings.fullResolution, settings.denoiserRadius, singleReflectionBounce: true, settings.affectSmoothSurfaces,
rtrResult, depthPyramid, normalBuffer, motionVectors, clearCoatTexture);
}
// We only need to upscale if the effect was not rendered in full res
if (!settings.fullResolution)
{
rtrResult = UpscaleRTR(renderGraph, hdCamera, depthPyramid, rtrResult);
}
return(rtrResult);
}
TextureHandle RenderRayTracedReflections(RenderGraph renderGraph, HDCamera hdCamera,
TextureHandle depthPyramid, TextureHandle stencilBuffer, TextureHandle normalBuffer, TextureHandle motionVectors, TextureHandle clearCoatTexture, Texture skyTexture, TextureHandle rayCountTexture,
ShaderVariablesRaytracing shaderVariablesRaytracing, bool transparent)
{
ScreenSpaceReflection reflectionSettings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
bool qualityMode = false;
// Based on what the asset supports, follow the volume or force the right mode.
if (m_Asset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Both)
{
qualityMode = reflectionSettings.mode.value == RayTracingMode.Quality;
}
else
{
qualityMode = m_Asset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Quality;
}
if (qualityMode)
{
return(RenderReflectionsQuality(renderGraph, hdCamera,
depthPyramid, stencilBuffer, normalBuffer, motionVectors, rayCountTexture, clearCoatTexture, skyTexture,
shaderVariablesRaytracing, transparent));
}
else
{
return(RenderReflectionsPerformance(renderGraph, hdCamera,
depthPyramid, stencilBuffer, normalBuffer, motionVectors, rayCountTexture, clearCoatTexture, skyTexture,
shaderVariablesRaytracing, transparent));
}
}
void RenderRayTracedReflections(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount, bool transparent = false)
{
ScreenSpaceReflection reflectionSettings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
// Based on what the asset supports, follow the volume or force the right mode.
if (m_Asset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Both)
{
switch (reflectionSettings.mode.value)
{
case RayTracingMode.Performance:
{
RenderReflectionsPerformance(hdCamera, cmd, outputTexture, renderContext, frameCount, transparent);
}
break;
case RayTracingMode.Quality:
{
RenderReflectionsQuality(hdCamera, cmd, outputTexture, renderContext, frameCount, transparent);
}
break;
}
}
else if (m_Asset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Quality)
{
RenderReflectionsQuality(hdCamera, cmd, outputTexture, renderContext, frameCount, transparent);
}
else
{
RenderReflectionsPerformance(hdCamera, cmd, outputTexture, renderContext, frameCount, transparent);
}
}
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);
}
}
void RenderReflectionsPerformance(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount, bool transparent)
{
// Fetch the required resources
RTHandle intermediateBuffer0 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA0);
RTHandle intermediateBuffer1 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA1);
// Fetch all the settings
ScreenSpaceReflection settings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
// Generate the signal
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingReflectionDirectionGeneration)))
{
// Prepare the components for the direction generation
RTReflectionDirGenParameters rtrDirGenParameters = PrepareRTReflectionDirGenParameters(hdCamera, transparent, settings);
RTReflectionDirGenResources rtrDirGenResousources = PrepareRTReflectionDirGenResources(hdCamera, intermediateBuffer1);
RTReflectionDirectionGeneration(cmd, rtrDirGenParameters, rtrDirGenResousources);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingReflectionEvaluation)))
{
// Prepare the components for the deferred lighting
DeferredLightingRTParameters deferredParamters = PrepareReflectionDeferredLightingRTParameters(hdCamera);
DeferredLightingRTResources deferredResources = PrepareDeferredLightingRTResources(hdCamera, intermediateBuffer1, intermediateBuffer0);
RenderRaytracingDeferredLighting(cmd, deferredParamters, deferredResources);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingReflectionUpscaleGeneration)))
{
// Prepare the parameters for the upscale pass
RTReflectionUpscaleParameters rtrUpscaleParameters = PrepareRTReflectionUpscaleParameters(hdCamera, settings);
RTReflectionUpscaleResources rtrUpscaleResources = PrepareRTReflectionUpscaleResources(hdCamera, intermediateBuffer0, intermediateBuffer1, outputTexture);
UpscaleRTReflections(cmd, rtrUpscaleParameters, rtrUpscaleResources);
}
// Denoise if required
if (settings.denoise && !transparent)
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingFilterReflection)))
{
// Grab the history buffer
RTHandle reflectionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
// Prepare the parameters and the resources
HDReflectionDenoiser reflectionDenoiser = GetReflectionDenoiser();
ReflectionDenoiserParameters reflDenoiserParameters = reflectionDenoiser.PrepareReflectionDenoiserParameters(hdCamera, EvaluateHistoryValidity(hdCamera), settings.denoiserRadius);
ReflectionDenoiserResources reflectionDenoiserResources = reflectionDenoiser.PrepareReflectionDenoiserResources(hdCamera, outputTexture, reflectionHistory,
intermediateBuffer0, intermediateBuffer1);
// Denoise
HDReflectionDenoiser.DenoiseBuffer(cmd, reflDenoiserParameters, reflectionDenoiserResources);
}
}
}
internal void BuildRayTracingLightCluster(CommandBuffer cmd, HDCamera hdCamera)
{
ScreenSpaceReflection reflSettings = VolumeManager.instance.stack.GetComponent <ScreenSpaceReflection>();
GlobalIllumination giSettings = VolumeManager.instance.stack.GetComponent <GlobalIllumination>();
RecursiveRendering recursiveSettings = VolumeManager.instance.stack.GetComponent <RecursiveRendering>();
PathTracing pathTracingSettings = VolumeManager.instance.stack.GetComponent <PathTracing>();
if (m_ValidRayTracingState && (reflSettings.rayTracing.value || giSettings.rayTracing.value || recursiveSettings.enable.value || pathTracingSettings.enable.value))
{
m_RayTracingLightCluster.EvaluateLightClusters(cmd, hdCamera, m_RayTracingLights);
m_ValidRayTracingCluster = true;
}
}
RTRUpscaleParameters PrepareRTRUpscaleParameters(HDCamera hdCamera, ScreenSpaceReflection settings)
{
RTRUpscaleParameters parameters = new RTRUpscaleParameters();
// Camera parameters
parameters.texWidth = hdCamera.actualWidth;
parameters.texHeight = hdCamera.actualHeight;
parameters.viewCount = hdCamera.viewCount;
// Other parameters
parameters.reflectionFilterCS = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
parameters.upscaleKernel = m_ReflectionUpscaleKernel;
return(parameters);
}
/// <summary>
/// Function that returns the ray tracing and path tracing effects that are enabled for a given camera.
/// </summary>
/// <param name="hdCamera">The input camera</param>
/// <param name="rayTracedShadows">Flag that defines if at least one light has ray traced shadows.</param>
/// <param name="rayTracedContactShadows">Flag that defines if at least one light has ray traced contact shadows</param>
/// <returns>HDEffectsParameters type.</returns>
public static HDEffectsParameters EvaluateEffectsParameters(HDCamera hdCamera, bool rayTracedShadows, bool rayTracedContactShadows)
{
HDEffectsParameters parameters = new HDEffectsParameters();
// Aggregate the shadow requirements
parameters.shadows = hdCamera.frameSettings.IsEnabled(FrameSettingsField.ScreenSpaceShadows) && (rayTracedShadows || rayTracedContactShadows);
// Aggregate the ambient occlusion parameters
AmbientOcclusion aoSettings = hdCamera.volumeStack.GetComponent <AmbientOcclusion>();
parameters.ambientOcclusion = aoSettings.rayTracing.value && hdCamera.frameSettings.IsEnabled(FrameSettingsField.SSAO);
parameters.aoLayerMask = aoSettings.layerMask.value;
// Aggregate the reflections parameters
ScreenSpaceReflection reflSettings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
parameters.reflections = reflSettings.enabled.value && ScreenSpaceReflection.RayTracingActive(reflSettings) && hdCamera.frameSettings.IsEnabled(FrameSettingsField.SSR);
parameters.reflLayerMask = reflSettings.layerMask.value;
// Aggregate the global illumination parameters
GlobalIllumination giSettings = hdCamera.volumeStack.GetComponent <GlobalIllumination>();
parameters.globalIllumination = giSettings.enable.value && GlobalIllumination.RayTracingActive(giSettings) && hdCamera.frameSettings.IsEnabled(FrameSettingsField.SSGI);
parameters.giLayerMask = giSettings.layerMask.value;
// Aggregate the global illumination parameters
RecursiveRendering recursiveSettings = hdCamera.volumeStack.GetComponent <RecursiveRendering>();
parameters.recursiveRendering = recursiveSettings.enable.value;
parameters.recursiveLayerMask = recursiveSettings.layerMask.value;
// Aggregate the sub surface parameters
SubSurfaceScattering sssSettings = hdCamera.volumeStack.GetComponent <SubSurfaceScattering>();
parameters.subSurface = sssSettings.rayTracing.value && hdCamera.frameSettings.IsEnabled(FrameSettingsField.SubsurfaceScattering);
// Aggregate the path parameters
PathTracing pathTracingSettings = hdCamera.volumeStack.GetComponent <PathTracing>();
parameters.pathTracing = pathTracingSettings.enable.value;
parameters.ptLayerMask = pathTracingSettings.layerMask.value;
// We need to check if at least one effect will require the acceleration structure
parameters.rayTracingRequired = parameters.ambientOcclusion || parameters.reflections ||
parameters.globalIllumination || parameters.recursiveRendering || parameters.subSurface ||
parameters.pathTracing || parameters.shadows;
// Return the result
return(parameters);
}
internal bool RayTracingLightClusterRequired(HDCamera hdCamera)
{
ScreenSpaceReflection reflSettings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
GlobalIllumination giSettings = hdCamera.volumeStack.GetComponent <GlobalIllumination>();
RecursiveRendering recursiveSettings = hdCamera.volumeStack.GetComponent <RecursiveRendering>();
PathTracing pathTracingSettings = hdCamera.volumeStack.GetComponent <PathTracing>();
SubSurfaceScattering subSurface = hdCamera.volumeStack.GetComponent <SubSurfaceScattering>();
return(m_ValidRayTracingState && (reflSettings.rayTracing.value ||
giSettings.rayTracing.value ||
recursiveSettings.enable.value ||
pathTracingSettings.enable.value ||
subSurface.rayTracing.value));
}
void RenderRayTracedReflections(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount)
{
ScreenSpaceReflection reflectionSettings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
switch (reflectionSettings.mode.value)
{
case RayTracingMode.Performance:
{
RenderReflectionsPerformance(hdCamera, cmd, outputTexture, renderContext, frameCount);
}
break;
case RayTracingMode.Quality:
{
RenderReflectionsQuality(hdCamera, cmd, outputTexture, renderContext, frameCount);
}
break;
}
}
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);
}
}
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));
}
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);
}
}
internal void BuildRayTracingAccelerationStructure(HDCamera hdCamera)
{
// Clear all the per frame-data
m_RayTracingRendererReference.Clear();
m_RayTracingLights.hdDirectionalLightArray.Clear();
m_RayTracingLights.hdPointLightArray.Clear();
m_RayTracingLights.hdLineLightArray.Clear();
m_RayTracingLights.hdRectLightArray.Clear();
m_RayTracingLights.hdLightArray.Clear();
m_RayTracingLights.reflectionProbeArray.Clear();
m_RayTracingLights.lightCount = 0;
m_CurrentRAS.Dispose();
m_CurrentRAS = new RayTracingAccelerationStructure();
m_ValidRayTracingState = false;
m_ValidRayTracingCluster = false;
bool rayTracedShadow = false;
// fetch all the lights in the scene
HDAdditionalLightData[] hdLightArray = UnityEngine.GameObject.FindObjectsOfType <HDAdditionalLightData>();
for (int lightIdx = 0; lightIdx < hdLightArray.Length; ++lightIdx)
{
HDAdditionalLightData hdLight = hdLightArray[lightIdx];
if (hdLight.enabled)
{
// Check if there is a ray traced shadow in the scene
rayTracedShadow |= (hdLight.useRayTracedShadows || (hdLight.useContactShadow.@override && hdLight.rayTraceContactShadow));
switch (hdLight.type)
{
case HDLightType.Directional:
m_RayTracingLights.hdDirectionalLightArray.Add(hdLight);
break;
case HDLightType.Point:
case HDLightType.Spot:
m_RayTracingLights.hdPointLightArray.Add(hdLight);
break;
case HDLightType.Area:
switch (hdLight.areaLightShape)
{
case AreaLightShape.Rectangle:
m_RayTracingLights.hdRectLightArray.Add(hdLight);
break;
case AreaLightShape.Tube:
m_RayTracingLights.hdLineLightArray.Add(hdLight);
break;
//TODO: case AreaLightShape.Disc:
}
break;
}
}
}
m_RayTracingLights.hdLightArray.AddRange(m_RayTracingLights.hdPointLightArray);
m_RayTracingLights.hdLightArray.AddRange(m_RayTracingLights.hdLineLightArray);
m_RayTracingLights.hdLightArray.AddRange(m_RayTracingLights.hdRectLightArray);
HDAdditionalReflectionData[] reflectionProbeArray = UnityEngine.GameObject.FindObjectsOfType <HDAdditionalReflectionData>();
for (int reflIdx = 0; reflIdx < reflectionProbeArray.Length; ++reflIdx)
{
HDAdditionalReflectionData reflectionProbe = reflectionProbeArray[reflIdx];
// Add it to the list if enabled
if (reflectionProbe.enabled)
{
m_RayTracingLights.reflectionProbeArray.Add(reflectionProbe);
}
}
m_RayTracingLights.lightCount = m_RayTracingLights.hdPointLightArray.Count
+ m_RayTracingLights.hdLineLightArray.Count
+ m_RayTracingLights.hdRectLightArray.Count
+ m_RayTracingLights.reflectionProbeArray.Count;
AmbientOcclusion aoSettings = hdCamera.volumeStack.GetComponent <AmbientOcclusion>();
ScreenSpaceReflection reflSettings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
GlobalIllumination giSettings = hdCamera.volumeStack.GetComponent <GlobalIllumination>();
RecursiveRendering recursiveSettings = hdCamera.volumeStack.GetComponent <RecursiveRendering>();
PathTracing pathTracingSettings = hdCamera.volumeStack.GetComponent <PathTracing>();
LODGroup[] lodGroupArray = UnityEngine.GameObject.FindObjectsOfType <LODGroup>();
for (var i = 0; i < lodGroupArray.Length; i++)
{
// Grab the current LOD group
LODGroup lodGroup = lodGroupArray[i];
// Get the set of LODs
LOD[] lodArray = lodGroup.GetLODs();
for (int lodIdx = 0; lodIdx < lodArray.Length; ++lodIdx)
{
LOD currentLOD = lodArray[lodIdx];
// We only want to push to the acceleration structure the lod0, we do not have defined way to select the right LOD at the moment
if (lodIdx == 0)
{
for (int rendererIdx = 0; rendererIdx < currentLOD.renderers.Length; ++rendererIdx)
{
// Fetch the renderer that we are interested in
Renderer currentRenderer = currentLOD.renderers[rendererIdx];
// This objects should but included into the RAS
AddInstanceToRAS(currentRenderer,
rayTracedShadow,
aoSettings.rayTracing.value, aoSettings.layerMask.value,
reflSettings.rayTracing.value, reflSettings.layerMask.value,
giSettings.rayTracing.value, giSettings.layerMask.value,
recursiveSettings.enable.value, recursiveSettings.layerMask.value,
pathTracingSettings.enable.value, pathTracingSettings.layerMask.value);
}
}
// Add them to the processed set so that they are not taken into account when processing all the renderers
for (int rendererIdx = 0; rendererIdx < currentLOD.renderers.Length; ++rendererIdx)
{
Renderer currentRenderer = currentLOD.renderers[rendererIdx];
// Add this fella to the renderer list
m_RayTracingRendererReference.Add(currentRenderer.GetInstanceID(), 1);
}
}
}
// Grab all the renderers from the scene
var rendererArray = UnityEngine.GameObject.FindObjectsOfType <Renderer>();
for (var i = 0; i < rendererArray.Length; i++)
{
// Fetch the current renderer
Renderer currentRenderer = rendererArray[i];
// If it is not active skip it
if (currentRenderer.enabled == false)
{
continue;
}
// Grab the current game object
GameObject gameObject = currentRenderer.gameObject;
// Has this object already been processed, just skip it
if (m_RayTracingRendererReference.ContainsKey(currentRenderer.GetInstanceID()))
{
continue;
}
// Does this object have a reflection probe component? if yes we do not want to have it in the acceleration structure
if (gameObject.TryGetComponent <ReflectionProbe>(out reflectionProbe))
{
continue;
}
// This objects should but included into the RAS
AddInstanceToRAS(currentRenderer,
rayTracedShadow,
aoSettings.rayTracing.value, aoSettings.layerMask.value,
reflSettings.rayTracing.value, reflSettings.layerMask.value,
giSettings.rayTracing.value, giSettings.layerMask.value,
recursiveSettings.enable.value, recursiveSettings.layerMask.value,
pathTracingSettings.enable.value, pathTracingSettings.layerMask.value);
}
// build the acceleration structure
m_CurrentRAS.Build();
// tag the structures as valid
m_ValidRayTracingState = true;
}
RTReflectionDirGenParameters PrepareRTReflectionDirGenParameters(HDCamera hdCamera, bool transparent, ScreenSpaceReflection settings)
{
RTReflectionDirGenParameters rtrDirGenParams = new RTReflectionDirGenParameters();
// Set the camera parameters
rtrDirGenParams.texWidth = hdCamera.actualWidth;
rtrDirGenParams.texHeight = hdCamera.actualHeight;
rtrDirGenParams.viewCount = hdCamera.viewCount;
// Set the generation parameters
rtrDirGenParams.fullResolution = settings.fullResolution;
rtrDirGenParams.minSmoothness = settings.minSmoothness;
// Grab the right kernel
rtrDirGenParams.directionGenCS = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingCS;
if (settings.fullResolution)
{
rtrDirGenParams.dirGenKernel = transparent ? m_RaytracingReflectionsTransparentFullResKernel : m_RaytracingReflectionsFullResKernel;
}
else
{
rtrDirGenParams.dirGenKernel = transparent ? m_RaytracingReflectionsTransparentHalfResKernel : m_RaytracingReflectionsHalfResKernel;
}
// Grab the additional parameters
BlueNoise blueNoise = GetBlueNoiseManager();
rtrDirGenParams.ditheredTextureSet = blueNoise.DitheredTextureSet8SPP();
rtrDirGenParams.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
return(rtrDirGenParams);
}
internal void BuildRayTracingAccelerationStructure(HDCamera hdCamera)
{
// Clear all the per frame-data
m_RayTracingRendererReference.Clear();
m_RayTracingLights.hdDirectionalLightArray.Clear();
m_RayTracingLights.hdPointLightArray.Clear();
m_RayTracingLights.hdLineLightArray.Clear();
m_RayTracingLights.hdRectLightArray.Clear();
m_RayTracingLights.hdLightArray.Clear();
m_RayTracingLights.reflectionProbeArray.Clear();
m_RayTracingLights.lightCount = 0;
m_CurrentRAS.Dispose();
m_CurrentRAS = new RayTracingAccelerationStructure();
m_ValidRayTracingState = false;
m_ValidRayTracingCluster = false;
m_ValidRayTracingClusterCulling = false;
m_RayTracedShadowsRequired = false;
m_RayTracedContactShadowsRequired = false;
// If the camera does not have a ray tracing frame setting
// or it is a preview camera (due to the fact that the sphere does not exist as a game object we can't create the RTAS)
// we do not want to build a RTAS
if (!hdCamera.frameSettings.IsEnabled(FrameSettingsField.RayTracing) || hdCamera.camera.cameraType == CameraType.Preview)
{
return;
}
// We only support ray traced shadows if the camera supports ray traced shadows
bool screenSpaceShadowsSupported = hdCamera.frameSettings.IsEnabled(FrameSettingsField.ScreenSpaceShadows);
// fetch all the lights in the scene
HDAdditionalLightData[] hdLightArray = UnityEngine.GameObject.FindObjectsOfType <HDAdditionalLightData>();
for (int lightIdx = 0; lightIdx < hdLightArray.Length; ++lightIdx)
{
HDAdditionalLightData hdLight = hdLightArray[lightIdx];
if (hdLight.enabled)
{
// Check if there is a ray traced shadow in the scene
m_RayTracedShadowsRequired |= (hdLight.useRayTracedShadows && screenSpaceShadowsSupported);
m_RayTracedContactShadowsRequired |= (hdLight.useContactShadow.@override && hdLight.rayTraceContactShadow);
switch (hdLight.type)
{
case HDLightType.Directional:
m_RayTracingLights.hdDirectionalLightArray.Add(hdLight);
break;
case HDLightType.Point:
case HDLightType.Spot:
m_RayTracingLights.hdPointLightArray.Add(hdLight);
break;
case HDLightType.Area:
switch (hdLight.areaLightShape)
{
case AreaLightShape.Rectangle:
m_RayTracingLights.hdRectLightArray.Add(hdLight);
break;
case AreaLightShape.Tube:
m_RayTracingLights.hdLineLightArray.Add(hdLight);
break;
//TODO: case AreaLightShape.Disc:
}
break;
}
}
}
// Aggregate the shadow requirement
bool rayTracedShadows = m_RayTracedShadowsRequired || m_RayTracedContactShadowsRequired;
m_RayTracingLights.hdLightArray.AddRange(m_RayTracingLights.hdPointLightArray);
m_RayTracingLights.hdLightArray.AddRange(m_RayTracingLights.hdLineLightArray);
m_RayTracingLights.hdLightArray.AddRange(m_RayTracingLights.hdRectLightArray);
HDAdditionalReflectionData[] reflectionProbeArray = UnityEngine.GameObject.FindObjectsOfType <HDAdditionalReflectionData>();
for (int reflIdx = 0; reflIdx < reflectionProbeArray.Length; ++reflIdx)
{
HDAdditionalReflectionData reflectionProbe = reflectionProbeArray[reflIdx];
// Add it to the list if enabled
if (reflectionProbe.enabled)
{
m_RayTracingLights.reflectionProbeArray.Add(reflectionProbe);
}
}
m_RayTracingLights.lightCount = m_RayTracingLights.hdPointLightArray.Count
+ m_RayTracingLights.hdLineLightArray.Count
+ m_RayTracingLights.hdRectLightArray.Count
+ m_RayTracingLights.reflectionProbeArray.Count;
AmbientOcclusion aoSettings = hdCamera.volumeStack.GetComponent <AmbientOcclusion>();
bool rtAOEnabled = aoSettings.rayTracing.value && hdCamera.frameSettings.IsEnabled(FrameSettingsField.SSAO);
ScreenSpaceReflection reflSettings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
bool rtREnabled = reflSettings.enabled.value && reflSettings.rayTracing.value && hdCamera.frameSettings.IsEnabled(FrameSettingsField.SSR);
GlobalIllumination giSettings = hdCamera.volumeStack.GetComponent <GlobalIllumination>();
bool rtGIEnabled = giSettings.enable.value && giSettings.rayTracing.value && hdCamera.frameSettings.IsEnabled(FrameSettingsField.SSGI);
RecursiveRendering recursiveSettings = hdCamera.volumeStack.GetComponent <RecursiveRendering>();
bool rrEnabled = recursiveSettings.enable.value;
SubSurfaceScattering sssSettings = hdCamera.volumeStack.GetComponent <SubSurfaceScattering>();
bool rtSSSEnabled = sssSettings.rayTracing.value && hdCamera.frameSettings.IsEnabled(FrameSettingsField.SubsurfaceScattering);
PathTracing pathTracingSettings = hdCamera.volumeStack.GetComponent <PathTracing>();
bool ptEnabled = pathTracingSettings.enable.value;
// We need to check if we should be building the ray tracing acceleration structure (if required by any effect)
bool rayTracingRequired = rtAOEnabled || rtREnabled || rtGIEnabled || rrEnabled || rtSSSEnabled || ptEnabled || rayTracedShadows;
if (!rayTracingRequired)
{
return;
}
// We need to process the emissive meshes of the rectangular area lights
for (var i = 0; i < m_RayTracingLights.hdRectLightArray.Count; i++)
{
// Fetch the current renderer of the rectangular area light (if any)
MeshRenderer currentRenderer = m_RayTracingLights.hdRectLightArray[i].emissiveMeshRenderer;
// If there is none it means that there is no emissive mesh for this light
if (currentRenderer == null)
{
continue;
}
// This objects should be included into the RAS
AddInstanceToRAS(currentRenderer,
rayTracedShadows,
rtAOEnabled, aoSettings.layerMask.value,
rtREnabled, reflSettings.layerMask.value,
rtGIEnabled, giSettings.layerMask.value,
rrEnabled, recursiveSettings.layerMask.value,
ptEnabled, pathTracingSettings.layerMask.value);
}
int matCount = m_MaterialCRCs.Count;
LODGroup[] lodGroupArray = UnityEngine.GameObject.FindObjectsOfType <LODGroup>();
for (var i = 0; i < lodGroupArray.Length; i++)
{
// Grab the current LOD group
LODGroup lodGroup = lodGroupArray[i];
// Get the set of LODs
LOD[] lodArray = lodGroup.GetLODs();
for (int lodIdx = 0; lodIdx < lodArray.Length; ++lodIdx)
{
LOD currentLOD = lodArray[lodIdx];
// We only want to push to the acceleration structure the lod0, we do not have defined way to select the right LOD at the moment
if (lodIdx == 0)
{
for (int rendererIdx = 0; rendererIdx < currentLOD.renderers.Length; ++rendererIdx)
{
// Fetch the renderer that we are interested in
Renderer currentRenderer = currentLOD.renderers[rendererIdx];
// This objects should but included into the RAS
AddInstanceToRAS(currentRenderer,
rayTracedShadows,
aoSettings.rayTracing.value, aoSettings.layerMask.value,
reflSettings.rayTracing.value, reflSettings.layerMask.value,
giSettings.rayTracing.value, giSettings.layerMask.value,
recursiveSettings.enable.value, recursiveSettings.layerMask.value,
pathTracingSettings.enable.value, pathTracingSettings.layerMask.value);
}
}
// Add them to the processed set so that they are not taken into account when processing all the renderers
for (int rendererIdx = 0; rendererIdx < currentLOD.renderers.Length; ++rendererIdx)
{
Renderer currentRenderer = currentLOD.renderers[rendererIdx];
// Add this fella to the renderer list
// Unfortunately, we need to check that this renderer was not already pushed into the list (happens if the user uses the same mesh renderer
// for two LODs)
if (!m_RayTracingRendererReference.ContainsKey(currentRenderer.GetInstanceID()))
{
m_RayTracingRendererReference.Add(currentRenderer.GetInstanceID(), 1);
}
}
}
}
// Grab all the renderers from the scene
var rendererArray = UnityEngine.GameObject.FindObjectsOfType <Renderer>();
for (var i = 0; i < rendererArray.Length; i++)
{
// Fetch the current renderer
Renderer currentRenderer = rendererArray[i];
// If it is not active skip it
if (currentRenderer.enabled == false)
{
continue;
}
// Grab the current game object
GameObject gameObject = currentRenderer.gameObject;
// Has this object already been processed, just skip it
if (m_RayTracingRendererReference.ContainsKey(currentRenderer.GetInstanceID()))
{
continue;
}
// Does this object have a reflection probe component? if yes we do not want to have it in the acceleration structure
if (gameObject.TryGetComponent <ReflectionProbe>(out reflectionProbe))
{
continue;
}
// This objects should be included into the RAS
AddInstanceToRAS(currentRenderer,
rayTracedShadows,
aoSettings.rayTracing.value, aoSettings.layerMask.value,
reflSettings.rayTracing.value, reflSettings.layerMask.value,
giSettings.rayTracing.value, giSettings.layerMask.value,
recursiveSettings.enable.value, recursiveSettings.layerMask.value,
pathTracingSettings.enable.value, pathTracingSettings.layerMask.value);
}
// Check if the amount of materials being tracked has changed
m_MaterialsDirty |= (matCount != m_MaterialCRCs.Count);
// build the acceleration structure
m_CurrentRAS.Build();
// tag the structures as valid
m_ValidRayTracingState = true;
}
internal static bool RayTracingActive(ScreenSpaceReflection volume)
{
return(volume.tracing.value != RayCastingMode.RayMarching);
}
RTRQualityRenderingParameters PrepareRTRQualityRenderingParameters(HDCamera hdCamera, ScreenSpaceReflection settings, bool transparent)
{
RTRQualityRenderingParameters rtrQualityRenderingParameters = new RTRQualityRenderingParameters();
// Camera parameters
rtrQualityRenderingParameters.texWidth = hdCamera.actualWidth;
rtrQualityRenderingParameters.texHeight = hdCamera.actualHeight;
rtrQualityRenderingParameters.viewCount = hdCamera.viewCount;
// Reflection evaluation parameters
rtrQualityRenderingParameters.clampValue = settings.clampValue;
rtrQualityRenderingParameters.reflectSky = settings.reflectSky.value ? 1 : 0;
rtrQualityRenderingParameters.rayLength = settings.rayLength;
rtrQualityRenderingParameters.sampleCount = settings.sampleCount.value;
rtrQualityRenderingParameters.bounceCount = settings.bounceCount.value;
rtrQualityRenderingParameters.transparent = transparent;
// Other parameters
rtrQualityRenderingParameters.accelerationStructure = RequestAccelerationStructure();
rtrQualityRenderingParameters.lightCluster = RequestLightCluster();
BlueNoise blueNoise = GetBlueNoiseManager();
rtrQualityRenderingParameters.ditheredTextureSet = blueNoise.DitheredTextureSet8SPP();
rtrQualityRenderingParameters.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
rtrQualityRenderingParameters.skyTexture = m_SkyManager.GetSkyReflection(hdCamera);
rtrQualityRenderingParameters.reflectionShader = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
return(rtrQualityRenderingParameters);
}
RTRAdjustWeightParameters PrepareRTRAdjustWeightParameters(HDCamera hdCamera, ScreenSpaceReflection settings)
{
RTRAdjustWeightParameters parameters = new RTRAdjustWeightParameters();
// Camera parameters
parameters.texWidth = settings.fullResolution ? hdCamera.actualWidth : hdCamera.actualWidth / 2;
parameters.texHeight = settings.fullResolution ? hdCamera.actualHeight : hdCamera.actualHeight / 2;
parameters.viewCount = hdCamera.viewCount;
// Requires parameters
parameters.minSmoothness = settings.minSmoothness;
parameters.smoothnessFadeStart = settings.smoothnessFadeStart;
// Other parameters
parameters.reflectionFilterCS = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
parameters.adjustWeightKernel = settings.fullResolution ? m_ReflectionAdjustWeightKernel : m_ReflectionRescaleAndAdjustWeightKernel;
parameters.shaderVariablesRayTracingCB = m_ShaderVariablesRayTracingCB;
return(parameters);
}
RTReflectionUpscaleParameters PrepareRTReflectionUpscaleParameters(HDCamera hdCamera, ScreenSpaceReflection settings)
{
RTReflectionUpscaleParameters rtrUpscaleParams = new RTReflectionUpscaleParameters();
// Camera parameters
rtrUpscaleParams.texWidth = hdCamera.actualWidth;
rtrUpscaleParams.texHeight = hdCamera.actualHeight;
rtrUpscaleParams.viewCount = hdCamera.viewCount;
// De-noising parameters
rtrUpscaleParams.upscaleRadius = settings.upscaleRadius;
rtrUpscaleParams.denoise = settings.denoise;
rtrUpscaleParams.denoiserRadius = settings.denoiserRadius;
// Kernels
rtrUpscaleParams.upscaleKernel = settings.fullResolution ? m_ReflectionIntegrationUpscaleFullResKernel : m_ReflectionIntegrationUpscaleHalfResKernel;
// Other parameters
rtrUpscaleParams.blueNoiseTexture = GetBlueNoiseManager().textureArray16RGB;
rtrUpscaleParams.reflectionFilterCS = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
return(rtrUpscaleParams);
}
void BindRayTracedReflectionData(CommandBuffer cmd, HDCamera hdCamera, RayTracingShader reflectionShader, ScreenSpaceReflection settings, LightCluster lightClusterSettings, RayTracingSettings rtSettings)
{
// 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
cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingIntensityClamp, settings.clampValue.value);
cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingIncludeSky, settings.reflectSky.value ? 1 : 0);
// Inject the ray generation data
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtSettings.rayBias.value);
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayMaxLength, settings.rayLength.value);
cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingNumSamples, settings.sampleCount.value);
int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)m_FrameCount % 8;
cmd.SetRayTracingIntParam(reflectionShader, HDShaderIDs._RaytracingFrameIndex, frameIndex);
// Inject the ray-tracing sampling data
blueNoise.BindDitheredRNGData8SPP(cmd);
// Set the data for the ray generation
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrLightingTextureRW, m_ReflIntermediateTexture0);
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrHitPointTexture, m_ReflIntermediateTexture1);
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
// Set ray count tex
RayCountManager rayCountManager = GetRayCountManager();
cmd.SetRayTracingIntParam(reflectionShader, HDShaderIDs._RayCountEnabled, rayCountManager.RayCountIsEnabled());
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._RayCountTexture, rayCountManager.GetRayCountTexture());
// Compute the pixel spread value
cmd.SetGlobalFloat(HDShaderIDs._RaytracingPixelSpreadAngle, GetPixelSpreadAngle(hdCamera.camera.fieldOfView, hdCamera.actualWidth, hdCamera.actualHeight));
// 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);
cmd.SetGlobalInt(HDShaderIDs._DirectionalLightCount, m_lightList.directionalLights.Count);
// 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 number of bounces for reflections
cmd.SetGlobalInt(HDShaderIDs._RaytracingMaxRecursion, settings.bounceCount.value);
// Set the data for the ray miss
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SkyTexture, m_SkyManager.GetSkyReflection(hdCamera));
}
