public void PostDispatchWork(CommandBuffer cmd, HDCamera camera, SharedRTManager sharedRTManager)
{
// Grab current settings
var settings = VolumeManager.instance.stack.GetComponent <AmbientOcclusion>();
if (!IsActive(camera, settings))
{
// No AO applied - neutral is black, see the comment in the shaders
cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, TextureXR.GetBlackTexture());
cmd.SetGlobalVector(HDShaderIDs._AmbientOcclusionParam, Vector4.zero);
return;
}
// MSAA Resolve
if (camera.frameSettings.IsEnabled(FrameSettingsField.MSAA))
{
using (new ProfilingSample(cmd, "Resolve AO Buffer", CustomSamplerId.ResolveSSAO.GetSampler()))
{
HDUtils.SetRenderTarget(cmd, camera, m_AmbientOcclusionTex);
m_ResolvePropertyBlock.SetTexture(HDShaderIDs._DepthValuesTexture, sharedRTManager.GetDepthValuesTexture());
m_ResolvePropertyBlock.SetTexture(HDShaderIDs._MultiAmbientOcclusionTexture, m_MultiAmbientOcclusionTex);
cmd.DrawProcedural(Matrix4x4.identity, m_ResolveMaterial, 0, MeshTopology.Triangles, 3, 1, m_ResolvePropertyBlock);
}
}
cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, m_AmbientOcclusionTex);
cmd.SetGlobalVector(HDShaderIDs._AmbientOcclusionParam, new Vector4(0f, 0f, 0f, settings.directLightingStrength.value));
// TODO: All the pushdebug stuff should be centralized somewhere
(RenderPipelineManager.currentPipeline as HDRenderPipeline).PushFullScreenDebugTexture(camera, cmd, m_AmbientOcclusionTex, FullScreenDebugMode.SSAO);
}
public void Render(CommandBuffer cmd, HDCamera camera, SharedRTManager sharedRTManager, ScriptableRenderContext renderContext, int frameCount)
{
var settings = VolumeManager.instance.stack.GetComponent <AmbientOcclusion>();
if (!IsActive(camera, settings))
{
// No AO applied - neutral is black, see the comment in the shaders
cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, TextureXR.GetBlackTexture());
cmd.SetGlobalVector(HDShaderIDs._AmbientOcclusionParam, Vector4.zero);
return;
}
else
{
#if ENABLE_RAYTRACING
HDRaytracingEnvironment rtEnvironement = m_RayTracingManager.CurrentEnvironment();
if (rtEnvironement != null && settings.enableRaytracing.value)
{
m_RaytracingAmbientOcclusion.RenderAO(camera, cmd, m_AmbientOcclusionTex, renderContext, frameCount);
}
else
#endif
{
Dispatch(cmd, camera, sharedRTManager, frameCount);
PostDispatchWork(cmd, camera, sharedRTManager);
}
}
}
public RenderGraphResource Render(RenderGraph renderGraph, HDCamera hdCamera, RenderGraphResource depthPyramid, RenderGraphResource motionVectors, int frameCount)
{
var settings = hdCamera.volumeStack.GetComponent <AmbientOcclusion>();
RenderGraphResource result;
// AO has side effects (as it uses an imported history buffer)
// So we can't rely on automatic pass stripping. This is why we have to be explicit here.
if (IsActive(hdCamera, settings))
{
{
EnsureRTSize(settings, hdCamera);
var historyRT = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.AmbientOcclusion);
var currentHistory = renderGraph.ImportTexture(historyRT);
var outputHistory = renderGraph.ImportTexture(hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.AmbientOcclusion));
Vector2 historySize = new Vector2(historyRT.referenceSize.x * historyRT.scaleFactor.x,
historyRT.referenceSize.y * historyRT.scaleFactor.y);
var rtScaleForHistory = hdCamera.historyRTHandleProperties.rtHandleScale;
var aoParameters = PrepareRenderAOParameters(hdCamera, renderGraph.rtHandleProperties, historySize * rtScaleForHistory, frameCount);
var packedData = RenderAO(renderGraph, aoParameters, depthPyramid);
result = DenoiseAO(renderGraph, aoParameters, motionVectors, packedData, currentHistory, outputHistory);
}
}
else
{
result = renderGraph.ImportTexture(TextureXR.GetBlackTexture(), HDShaderIDs._AmbientOcclusionTexture);
}
return(result);
}
public void Render(CommandBuffer cmd, HDCamera camera, ScriptableRenderContext renderContext, int frameCount)
{
var settings = VolumeManager.instance.stack.GetComponent <AmbientOcclusion>();
if (!IsActive(camera, settings))
{
// No AO applied - neutral is black, see the comment in the shaders
cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, TextureXR.GetBlackTexture());
return;
}
else
{
#if ENABLE_RAYTRACING
if (camera.frameSettings.IsEnabled(FrameSettingsField.RayTracing) && settings.rayTracing.value)
{
m_RaytracingAmbientOcclusion.RenderAO(camera, cmd, m_AmbientOcclusionTex, renderContext, frameCount);
}
else
#endif
{
Dispatch(cmd, camera, frameCount);
PostDispatchWork(cmd, camera);
}
}
}
TemporalFilterArrayResources PrepareTemporalFilterArrayResources(HDCamera hdCamera, RTHandle noisyBuffer, RTHandle distanceBuffer, RTHandle validationBuffer,
RTHandle historyBuffer, RTHandle validationHistoryBuffer, RTHandle distanceHistorySignal,
RTHandle outputBuffer, RTHandle outputDistanceSignal)
{
TemporalFilterArrayResources tfaResources = new TemporalFilterArrayResources();
// Input buffers
tfaResources.depthStencilBuffer = m_SharedRTManager.GetDepthStencilBuffer();
tfaResources.normalBuffer = m_SharedRTManager.GetNormalBuffer();
tfaResources.velocityBuffer = TextureXR.GetBlackTexture();
tfaResources.historyDepthTexture = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Depth);
tfaResources.historyNormalTexture = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Normal);
tfaResources.noisyBuffer = noisyBuffer;
tfaResources.distanceBuffer = distanceBuffer;
// Temporary buffers
tfaResources.validationBuffer = validationBuffer;
// InOut buffers
tfaResources.historyBuffer = historyBuffer;
tfaResources.validationHistoryBuffer = validationHistoryBuffer;
tfaResources.distanceHistorySignal = distanceHistorySignal;
// Output buffers
tfaResources.outputBuffer = outputBuffer;
tfaResources.outputDistanceSignal = outputDistanceSignal;
return(tfaResources);
}
public void BindBlackTextures(CommandBuffer cmd)
{
for (int i = 0; i < m_BufferCount; ++i)
{
cmd.SetGlobalTexture(m_TextureShaderIDs[i], TextureXR.GetBlackTexture());
}
}
public TemporalFilterResources PrepareTemporalFilterResources(HDCamera hdCamera, RTHandle validationBuffer, RTHandle noisyBuffer, RTHandle historyBuffer, RTHandle outputBuffer)
{
TemporalFilterResources tfResources = new TemporalFilterResources();
tfResources.depthStencilBuffer = m_SharedRTManager.GetDepthStencilBuffer();
tfResources.normalBuffer = m_SharedRTManager.GetNormalBuffer();
tfResources.velocityBuffer = TextureXR.GetBlackTexture();
tfResources.historyDepthTexture = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Depth);
tfResources.historyNormalTexture = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Normal);
tfResources.noisyBuffer = noisyBuffer;
if (hdCamera.frameSettings.IsEnabled(FrameSettingsField.MotionVectors))
{
tfResources.motionVectorBuffer = m_SharedRTManager.GetMotionVectorsBuffer();
}
else
{
tfResources.motionVectorBuffer = TextureXR.GetBlackTexture();
}
// Temporary buffers
tfResources.validationBuffer = validationBuffer;
// Output buffers
tfResources.historyBuffer = historyBuffer;
tfResources.outputBuffer = outputBuffer;
return(tfResources);
}
internal void InitializeForRendering(RenderGraph renderGraph)
{
blackTexture = renderGraph.ImportTexture(m_BlackTexture2D);
whiteTexture = renderGraph.ImportTexture(m_WhiteTexture2D);
clearTextureXR = renderGraph.ImportTexture(TextureXR.GetClearTexture());
magentaTextureXR = renderGraph.ImportTexture(TextureXR.GetMagentaTexture());
blackTextureXR = renderGraph.ImportTexture(TextureXR.GetBlackTexture());
blackTextureArrayXR = renderGraph.ImportTexture(TextureXR.GetBlackTextureArray());
blackUIntTextureXR = renderGraph.ImportTexture(TextureXR.GetBlackUIntTexture());
blackTexture3DXR = renderGraph.ImportTexture(TextureXR.GetBlackTexture3D());
whiteTextureXR = renderGraph.ImportTexture(TextureXR.GetWhiteTexture());
}
SSSAreaRayTraceResources PrepareSSSAreaRayTraceResources(HDCamera hdCamera, RTHandle directionBuffer, RTHandle rayLengthBuffer,
RTHandle intermediateBufferRGBA0, RTHandle intermediateBufferRGBA1, RTHandle intermediateBufferRG0,
RTHandle shadowHistoryArray, RTHandle analyticHistoryArray)
{
SSSAreaRayTraceResources sssartResources = new SSSAreaRayTraceResources();
// Input Buffers
sssartResources.depthStencilBuffer = m_SharedRTManager.GetDepthStencilBuffer();
sssartResources.normalBuffer = m_SharedRTManager.GetNormalBuffer();
sssartResources.lightData = m_LightLoopLightData.lightData;
if (hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred)
{
sssartResources.gbuffer0 = m_GbufferManager.GetBuffer(0);
sssartResources.gbuffer1 = m_GbufferManager.GetBuffer(1);
sssartResources.gbuffer2 = m_GbufferManager.GetBuffer(2);
sssartResources.gbuffer3 = m_GbufferManager.GetBuffer(3);
}
else
{
sssartResources.gbuffer0 = TextureXR.GetBlackTexture();
sssartResources.gbuffer1 = TextureXR.GetBlackTexture();
sssartResources.gbuffer2 = TextureXR.GetBlackTexture();
sssartResources.gbuffer3 = TextureXR.GetBlackTexture();
}
sssartResources.cookieAtlasTexture = m_TextureCaches.lightCookieManager.atlasTexture;
sssartResources.shadowHistoryArray = shadowHistoryArray;
sssartResources.analyticHistoryArray = analyticHistoryArray;
// Intermediate buffers
sssartResources.directionBuffer = directionBuffer;
sssartResources.rayLengthBuffer = rayLengthBuffer;
sssartResources.intermediateBufferRGBA0 = intermediateBufferRGBA0;
sssartResources.intermediateBufferRGBA1 = intermediateBufferRGBA1;
sssartResources.intermediateBufferRG0 = intermediateBufferRG0;
// Debug textures
RayCountManager rayCountManager = GetRayCountManager();
sssartResources.rayCountTexture = rayCountManager.GetRayCountTexture();
// Output buffers
sssartResources.screenSpaceShadowTextureArray = m_ScreenSpaceShadowTextureArray;
return(sssartResources);
}
public void PushGlobalParams(HDCamera hdCamera, CommandBuffer cmd)
{
if (hdCamera.frameSettings.IsEnabled(FrameSettingsField.Decals))
{
cmd.SetGlobalInt(HDShaderIDs._EnableDecals, enableDecals ? 1 : 0);
cmd.SetGlobalVector(HDShaderIDs._DecalAtlasResolution, new Vector2(HDUtils.hdrpSettings.decalSettings.atlasWidth, HDUtils.hdrpSettings.decalSettings.atlasHeight));
BindBufferAsTextures(cmd);
}
else
{
cmd.SetGlobalInt(HDShaderIDs._EnableDecals, 0);
// We still bind black textures to make sure that something is bound (can be a problem on some platforms)
for (int i = 0; i < m_BufferCount; ++i)
{
cmd.SetGlobalTexture(m_TextureShaderIDs[i], TextureXR.GetBlackTexture());
}
}
}
RTSAreaRayTraceResources PrepareRTSAreaRayTraceResources(HDCamera hdCamera, RTHandle directionBuffer, RTHandle rayLengthBuffer,
RTHandle intermediateBufferRGBA0, RTHandle intermediateBufferRGBA1, RTHandle intermediateBufferRG0,
RTHandle shadowHistoryArray, RTHandle analyticHistoryArray)
{
RTSAreaRayTraceResources rtsartResources = new RTSAreaRayTraceResources();
// Input Buffers
rtsartResources.depthStencilBuffer = m_SharedRTManager.GetDepthStencilBuffer();
rtsartResources.normalBuffer = m_SharedRTManager.GetNormalBuffer();
rtsartResources.motionVectorsBuffer = m_SharedRTManager.GetMotionVectorsBuffer();
if (hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred)
{
rtsartResources.gbuffer0 = m_GbufferManager.GetBuffer(0);
rtsartResources.gbuffer1 = m_GbufferManager.GetBuffer(1);
rtsartResources.gbuffer2 = m_GbufferManager.GetBuffer(2);
rtsartResources.gbuffer3 = m_GbufferManager.GetBuffer(3);
}
else
{
rtsartResources.gbuffer0 = TextureXR.GetBlackTexture();
rtsartResources.gbuffer1 = TextureXR.GetBlackTexture();
rtsartResources.gbuffer2 = TextureXR.GetBlackTexture();
rtsartResources.gbuffer3 = TextureXR.GetBlackTexture();
}
rtsartResources.shadowHistoryArray = shadowHistoryArray;
rtsartResources.analyticHistoryArray = analyticHistoryArray;
// Intermediate buffers
rtsartResources.directionBuffer = directionBuffer;
rtsartResources.rayLengthBuffer = rayLengthBuffer;
rtsartResources.intermediateBufferRGBA1 = intermediateBufferRGBA1;
rtsartResources.intermediateBufferRG0 = intermediateBufferRG0;
// Debug textures
RayCountManager rayCountManager = GetRayCountManager();
rtsartResources.rayCountTexture = rayCountManager.GetRayCountTexture();
// Output texture
rtsartResources.outputShadowTexture = intermediateBufferRGBA0;
return(rtsartResources);
}
public void Render(RenderGraph renderGraph,
HDCamera hdCamera,
BlueNoise blueNoise,
TextureHandle colorBuffer,
TextureHandle afterPostProcessTexture,
TextureHandle depthBuffer,
TextureHandle finalRT,
bool flipY)
{
var dynResHandler = DynamicResolutionHandler.instance;
bool isSceneView = hdCamera.camera.cameraType == CameraType.SceneView;
var source = colorBuffer;
TextureHandle alphaTexture = renderGraph.defaultResources.whiteTextureXR;
// Save the alpha and apply it back into the final pass if rendering in fp16 and post-processing in r11g11b10
if (m_KeepAlpha)
{
using (var builder = renderGraph.AddRenderPass <AlphaCopyPassData>("Alpha Copy", out var passData, ProfilingSampler.Get(HDProfileId.AlphaCopy)))
{
passData.parameters = PrepareCopyAlphaParameters(hdCamera);
passData.source = builder.ReadTexture(source);
passData.outputAlpha = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
{
name = "Alpha Channel Copy", colorFormat = GraphicsFormat.R16_SFloat, enableRandomWrite = true
}));
builder.SetRenderFunc(
(AlphaCopyPassData data, RenderGraphContext ctx) =>
{
DoCopyAlpha(data.parameters,
ctx.resources.GetTexture(data.source),
ctx.resources.GetTexture(data.outputAlpha),
ctx.cmd);
});
alphaTexture = passData.outputAlpha;
}
}
// TODO RENDERGRAPH: Implement
// if (m_PostProcessEnabled)
// {
// // Guard bands (also known as "horrible hack") to avoid bleeding previous RTHandle
// // content into smaller viewports with some effects like Bloom that rely on bilinear
// // filtering and can't use clamp sampler and the likes
// // Note: some platforms can't clear a partial render target so we directly draw black triangles
// {
// int w = camera.actualWidth;
// int h = camera.actualHeight;
// cmd.SetRenderTarget(source, 0, CubemapFace.Unknown, -1);
// if (w < source.rt.width || h < source.rt.height)
// {
// cmd.SetViewport(new Rect(w, 0, k_RTGuardBandSize, h));
// cmd.DrawProcedural(Matrix4x4.identity, m_ClearBlackMaterial, 0, MeshTopology.Triangles, 3, 1);
// cmd.SetViewport(new Rect(0, h, w + k_RTGuardBandSize, k_RTGuardBandSize));
// cmd.DrawProcedural(Matrix4x4.identity, m_ClearBlackMaterial, 0, MeshTopology.Triangles, 3, 1);
// }
// }
// // Optional NaN killer before post-processing kicks in
// bool stopNaNs = camera.stopNaNs && m_StopNaNFS;
//#if UNITY_EDITOR
// if (isSceneView)
// stopNaNs = HDAdditionalSceneViewSettings.sceneViewStopNaNs;
//#endif
// if (stopNaNs)
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.StopNaNs)))
// {
// var destination = m_Pool.Get(Vector2.one, m_ColorFormat);
// DoStopNaNs(cmd, camera, source, destination);
// PoolSource(ref source, destination);
// }
// }
// }
// // Dynamic exposure - will be applied in the next frame
// // Not considered as a post-process so it's not affected by its enabled state
// if (!IsExposureFixed() && m_ExposureControlFS)
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.DynamicExposure)))
// {
// if (m_Exposure.mode.value == ExposureMode.AutomaticHistogram)
// {
// DoHistogramBasedExposure(cmd, camera, source);
// }
// else
// {
// DoDynamicExposure(cmd, camera, source);
// }
// // On reset history we need to apply dynamic exposure immediately to avoid
// // white or black screen flashes when the current exposure isn't anywhere
// // near 0
// if (camera.resetPostProcessingHistory)
// {
// var destination = m_Pool.Get(Vector2.one, m_ColorFormat);
// var cs = m_Resources.shaders.applyExposureCS;
// int kernel = cs.FindKernel("KMain");
// // Note: we call GetPrevious instead of GetCurrent because the textures
// // are swapped internally as the system expects the texture will be used
// // on the next frame. So the actual "current" for this frame is in
// // "previous".
// cmd.SetComputeTextureParam(cs, kernel, HDShaderIDs._ExposureTexture, GetPreviousExposureTexture(camera));
// cmd.SetComputeTextureParam(cs, kernel, HDShaderIDs._InputTexture, source);
// cmd.SetComputeTextureParam(cs, kernel, HDShaderIDs._OutputTexture, destination);
// cmd.DispatchCompute(cs, kernel, (camera.actualWidth + 7) / 8, (camera.actualHeight + 7) / 8, camera.viewCount);
// PoolSource(ref source, destination);
// }
// }
// }
if (m_PostProcessEnabled)
{
// // Temporal anti-aliasing goes first
// bool taaEnabled = false;
// if (m_AntialiasingFS)
// {
// taaEnabled = camera.antialiasing == AntialiasingMode.TemporalAntialiasing;
// if (taaEnabled)
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.TemporalAntialiasing)))
// {
// var destination = m_Pool.Get(Vector2.one, m_ColorFormat);
// DoTemporalAntialiasing(cmd, camera, source, destination, depthBuffer, depthMipChain);
// PoolSource(ref source, destination);
// }
// }
// else if (camera.antialiasing == AntialiasingMode.SubpixelMorphologicalAntiAliasing)
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.SMAA)))
// {
// var destination = m_Pool.Get(Vector2.one, m_ColorFormat);
// DoSMAA(cmd, camera, source, destination, depthBuffer);
// PoolSource(ref source, destination);
// }
// }
// }
// if (camera.frameSettings.IsEnabled(FrameSettingsField.CustomPostProcess))
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.CustomPostProcessBeforePP)))
// {
// foreach (var typeString in HDRenderPipeline.defaultAsset.beforePostProcessCustomPostProcesses)
// RenderCustomPostProcess(cmd, camera, ref source, colorBuffer, Type.GetType(typeString));
// }
// }
// // If Path tracing is enabled, then DoF is computed in the path tracer by sampling the lens aperure (when using the physical camera mode)
// bool isDoFPathTraced = (camera.frameSettings.IsEnabled(FrameSettingsField.RayTracing) &&
// camera.volumeStack.GetComponent<PathTracing>().enable.value &&
// camera.camera.cameraType != CameraType.Preview &&
// m_DepthOfField.focusMode == DepthOfFieldMode.UsePhysicalCamera);
// // Depth of Field is done right after TAA as it's easier to just re-project the CoC
// // map rather than having to deal with all the implications of doing it before TAA
// if (m_DepthOfField.IsActive() && !isSceneView && m_DepthOfFieldFS && !isDoFPathTraced)
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.DepthOfField)))
// {
// var destination = m_Pool.Get(Vector2.one, m_ColorFormat);
// DoDepthOfField(cmd, camera, source, destination, taaEnabled);
// PoolSource(ref source, destination);
// }
// }
// // Motion blur after depth of field for aesthetic reasons (better to see motion
// // blurred bokeh rather than out of focus motion blur)
// if (m_MotionBlur.IsActive() && m_AnimatedMaterialsEnabled && !camera.resetPostProcessingHistory && m_MotionBlurFS)
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.MotionBlur)))
// {
// var destination = m_Pool.Get(Vector2.one, m_ColorFormat);
// DoMotionBlur(cmd, camera, source, destination);
// PoolSource(ref source, destination);
// }
// }
// // Panini projection is done as a fullscreen pass after all depth-based effects are
// // done and before bloom kicks in
// // This is one effect that would benefit from an overscan mode or supersampling in
// // HDRP to reduce the amount of resolution lost at the center of the screen
// if (m_PaniniProjection.IsActive() && !isSceneView && m_PaniniProjectionFS)
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.PaniniProjection)))
// {
// var destination = m_Pool.Get(Vector2.one, m_ColorFormat);
// DoPaniniProjection(cmd, camera, source, destination);
// PoolSource(ref source, destination);
// }
// }
// Uber post-process
//// Generate the bloom texture
//bool bloomActive = m_Bloom.IsActive() && m_BloomFS;
//if (bloomActive)
//{
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.Bloom)))
// {
// DoBloom(cmd, camera, source, uberPostParams.uberPostCS, uberPostParams.uberPostKernel);
// }
//}
//else
//{
// cmd.SetComputeTextureParam(uberPostParams.uberPostCS, uberPostParams.uberPostKernel, HDShaderIDs._BloomTexture, TextureXR.GetBlackTexture());
// cmd.SetComputeTextureParam(uberPostParams.uberPostCS, uberPostParams.uberPostKernel, HDShaderIDs._BloomDirtTexture, Texture2D.blackTexture);
// cmd.SetComputeVectorParam(uberPostParams.uberPostCS, HDShaderIDs._BloomParams, Vector4.zero);
//}
TextureHandle logLutOutput;
using (var builder = renderGraph.AddRenderPass <ColorGradingPassData>("Color Grading", out var passData, ProfilingSampler.Get(HDProfileId.ColorGradingLUTBuilder)))
{
TextureHandle logLut = renderGraph.CreateTexture(new TextureDesc(m_LutSize, m_LutSize)
{
name = "Color Grading Log Lut",
dimension = TextureDimension.Tex3D,
slices = m_LutSize,
depthBufferBits = DepthBits.None,
colorFormat = m_LutFormat,
filterMode = FilterMode.Bilinear,
wrapMode = TextureWrapMode.Clamp,
anisoLevel = 0,
useMipMap = false,
enableRandomWrite = true
});
passData.parameters = PrepareColorGradingParameters();
passData.logLut = builder.WriteTexture(logLut);
logLutOutput = passData.logLut;
builder.SetRenderFunc(
(ColorGradingPassData data, RenderGraphContext ctx) =>
{
DoColorGrading(data.parameters, ctx.resources.GetTexture(data.logLut), ctx.cmd);
});
}
using (var builder = renderGraph.AddRenderPass <UberPostPassData>("Uber Post", out var passData, ProfilingSampler.Get(HDProfileId.UberPost)))
{
TextureHandle dest = renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
{
name = "Uber Post Destination",
colorFormat = m_ColorFormat,
useMipMap = false,
enableRandomWrite = true
});
passData.parameters = PrepareUberPostParameters(hdCamera, isSceneView);
passData.source = builder.ReadTexture(source);
passData.logLut = builder.ReadTexture(logLutOutput);
passData.destination = builder.WriteTexture(dest);
builder.SetRenderFunc(
(UberPostPassData data, RenderGraphContext ctx) =>
{
// Temp until bloom is implemented.
ctx.cmd.SetComputeTextureParam(data.parameters.uberPostCS, data.parameters.uberPostKernel, HDShaderIDs._BloomTexture, TextureXR.GetBlackTexture());
ctx.cmd.SetComputeTextureParam(data.parameters.uberPostCS, data.parameters.uberPostKernel, HDShaderIDs._BloomDirtTexture, Texture2D.blackTexture);
ctx.cmd.SetComputeVectorParam(data.parameters.uberPostCS, HDShaderIDs._BloomParams, Vector4.zero);
DoUberPostProcess(data.parameters,
ctx.resources.GetTexture(data.source),
ctx.resources.GetTexture(data.destination),
ctx.resources.GetTexture(data.logLut),
ctx.resources.GetTexture(data.source), // TODO: TMP VALUE, should be bloom texture and will be as soon as PP is ported to rendergraph.
ctx.cmd);
});
source = passData.destination;
}
m_HDInstance.PushFullScreenDebugTexture(renderGraph, source, FullScreenDebugMode.ColorLog);
// if (camera.frameSettings.IsEnabled(FrameSettingsField.CustomPostProcess))
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.CustomPostProcessAfterPP)))
// {
// foreach (var typeString in HDRenderPipeline.defaultAsset.afterPostProcessCustomPostProcesses)
// RenderCustomPostProcess(cmd, camera, ref source, colorBuffer, Type.GetType(typeString));
// }
// }
}
// if (dynResHandler.DynamicResolutionEnabled() && // Dynamic resolution is on.
// camera.antialiasing == AntialiasingMode.FastApproximateAntialiasing &&
// m_AntialiasingFS)
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.FXAA)))
// {
// var destination = m_Pool.Get(Vector2.one, m_ColorFormat);
// DoFXAA(cmd, camera, source, destination);
// PoolSource(ref source, destination);
// }
// }
// // Contrast Adaptive Sharpen Upscaling
// if (dynResHandler.DynamicResolutionEnabled() &&
// dynResHandler.filter == DynamicResUpscaleFilter.ContrastAdaptiveSharpen)
// {
// using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.ContrastAdaptiveSharpen)))
// {
// var destination = m_Pool.Get(Vector2.one, m_ColorFormat);
// var cs = m_Resources.shaders.contrastAdaptiveSharpenCS;
// int kInit = cs.FindKernel("KInitialize");
// int kMain = cs.FindKernel("KMain");
// if (kInit >= 0 && kMain >= 0)
// {
// cmd.SetComputeFloatParam(cs, HDShaderIDs._Sharpness, 1);
// cmd.SetComputeTextureParam(cs, kMain, HDShaderIDs._InputTexture, source);
// cmd.SetComputeVectorParam(cs, HDShaderIDs._InputTextureDimensions, new Vector4(source.rt.width, source.rt.height));
// cmd.SetComputeTextureParam(cs, kMain, HDShaderIDs._OutputTexture, destination);
// cmd.SetComputeVectorParam(cs, HDShaderIDs._OutputTextureDimensions, new Vector4(destination.rt.width, destination.rt.height));
// ValidateComputeBuffer(ref m_ContrastAdaptiveSharpen, 2, sizeof(uint) * 4);
// cmd.SetComputeBufferParam(cs, kInit, "CasParameters", m_ContrastAdaptiveSharpen);
// cmd.SetComputeBufferParam(cs, kMain, "CasParameters", m_ContrastAdaptiveSharpen);
// cmd.DispatchCompute(cs, kInit, 1, 1, 1);
// int dispatchX = (int)System.Math.Ceiling(destination.rt.width / 16.0f);
// int dispatchY = (int)System.Math.Ceiling(destination.rt.height / 16.0f);
// cmd.DispatchCompute(cs, kMain, dispatchX, dispatchY, camera.viewCount);
// }
// PoolSource(ref source, destination);
// }
// }
using (var builder = renderGraph.AddRenderPass <FinalPassData>("Final Pass", out var passData, ProfilingSampler.Get(HDProfileId.FinalPost)))
{
passData.parameters = PrepareFinalPass(hdCamera, blueNoise, flipY);
passData.source = builder.ReadTexture(source);
passData.afterPostProcessTexture = builder.ReadTexture(afterPostProcessTexture);
passData.alphaTexture = builder.ReadTexture(alphaTexture);
passData.destination = builder.WriteTexture(finalRT);
builder.SetRenderFunc(
(FinalPassData data, RenderGraphContext ctx) =>
{
DoFinalPass(data.parameters,
ctx.resources.GetTexture(data.source),
ctx.resources.GetTexture(data.afterPostProcessTexture),
ctx.resources.GetTexture(data.destination),
ctx.resources.GetTexture(data.alphaTexture),
ctx.cmd);
});
}
}
RTRQualityRenderingResources PrepareRTRQualityRenderingResources(HDCamera hdCamera, RTHandle outputTexture)
{
RTRQualityRenderingResources rtrQualityRenderingResources = new RTRQualityRenderingResources();
// Input texture
rtrQualityRenderingResources.depthBuffer = m_SharedRTManager.GetDepthStencilBuffer();
rtrQualityRenderingResources.normalBuffer = m_SharedRTManager.GetNormalBuffer();
rtrQualityRenderingResources.clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
rtrQualityRenderingResources.stencilBuffer = m_SharedRTManager.GetStencilBuffer();
// Debug texture
RayCountManager rayCountManager = GetRayCountManager();
rtrQualityRenderingResources.rayCountTexture = rayCountManager.GetRayCountTexture();
// Output texture
rtrQualityRenderingResources.outputTexture = outputTexture;
return(rtrQualityRenderingResources);
}
RTReflectionUpscaleResources PrepareRTReflectionUpscaleResources(HDCamera hdCamera, RTHandle lightingTexture, RTHandle hitPointTexture, RTHandle outputTexture)
{
RTReflectionUpscaleResources rtrUpscaleResources = new RTReflectionUpscaleResources();
rtrUpscaleResources.depthStencilBuffer = m_SharedRTManager.GetDepthStencilBuffer();
rtrUpscaleResources.normalBuffer = m_SharedRTManager.GetNormalBuffer();
rtrUpscaleResources.lightingTexture = lightingTexture;
rtrUpscaleResources.hitPointTexture = hitPointTexture;
rtrUpscaleResources.outputTexture = outputTexture;
rtrUpscaleResources.clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
return(rtrUpscaleResources);
}
RTReflectionDirGenResources PrepareRTReflectionDirGenResources(HDCamera hdCamera, RTHandle outputBuffer)
{
RTReflectionDirGenResources rtrDirGenResources = new RTReflectionDirGenResources();
// Input buffers
rtrDirGenResources.depthBuffer = m_SharedRTManager.GetDepthStencilBuffer();
rtrDirGenResources.stencilBuffer = m_SharedRTManager.GetStencilBuffer();
rtrDirGenResources.normalBuffer = m_SharedRTManager.GetNormalBuffer();
rtrDirGenResources.clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
// Output buffers
rtrDirGenResources.outputBuffer = outputBuffer;
return(rtrDirGenResources);
}
public void RenderReflectionsT1(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount)
{
// First thing to check is: Do we have a valid ray-tracing environment?
HDRaytracingEnvironment rtEnvironment = m_RayTracingManager.CurrentEnvironment();
// If no ray tracing environment, then we do not want to evaluate this effect
if (rtEnvironment == null)
{
return;
}
// Fetch the required resources
BlueNoise blueNoise = m_RayTracingManager.GetBlueNoiseManager();
RayTracingShader reflectionShaderRT = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
ComputeShader reflectionShaderCS = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingCS;
ComputeShader reflectionFilter = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
// Fetch all the settings
var settings = VolumeManager.instance.stack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = VolumeManager.instance.stack.GetComponent <LightCluster>();
if (settings.deferredMode.value)
{
// Fetch the new sample kernel
int currentKernel = reflectionShaderCS.FindKernel(settings.fullResolution.value ? "RaytracingReflectionsFullRes" : "RaytracingReflectionsHalfRes");
// Bind all the required textures
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._OwenScrambledTexture, m_Asset.renderPipelineResources.textures.owenScrambledTex);
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
RenderTargetIdentifier clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Bind all the required scalars
cmd.SetComputeFloatParam(reflectionShaderCS, HDShaderIDs._RaytracingIntensityClamp, settings.clampValue.value);
cmd.SetComputeFloatParam(reflectionShaderCS, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._RaytracingReflectSky, settings.reflectSky.value ? 1 : 0);
// Bind the sampling data
int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)m_FrameCount % 8;
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._RaytracingFrameIndex, frameIndex);
// Bind the output buffers
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._RaytracingDirectionBuffer, m_ReflIntermediateTexture1);
// Texture dimensions
int texWidth = hdCamera.actualWidth;
int texHeight = hdCamera.actualHeight;
if (settings.fullResolution.value)
{
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Compute the directions
cmd.DispatchCompute(reflectionShaderCS, currentKernel, numTilesXHR, numTilesYHR, 1);
}
else
{
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = (texWidth / 2 + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (texHeight / 2 + (areaTileSize - 1)) / areaTileSize;
// Compute the directions
cmd.DispatchCompute(reflectionShaderCS, currentKernel, numTilesXHR, numTilesYHR, 1);
}
// Evaluate the deferred lighting
cmd.SetGlobalInt(HDShaderIDs._RaytracingReflectSky, settings.reflectSky.value ? 1 : 0);
RenderRaytracingDeferredLighting(cmd, hdCamera, rtEnvironment, m_ReflIntermediateTexture1, settings.rayBinning.value, rtEnvironment.reflLayerMask, settings.rayLength.value, m_ReflIntermediateTexture0, disableSpecularLighting: true, halfResolution: !settings.fullResolution.value);
}
else
{
// Bind all the required data for ray tracing
BindRayTracedReflectionData(cmd, hdCamera, rtEnvironment, reflectionShaderRT, settings, lightClusterSettings);
// Set the data for the ray miss
cmd.SetRayTracingTextureParam(reflectionShaderRT, HDShaderIDs._SkyTexture, m_SkyManager.skyReflection);
// Force to disable specular lighting
cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, 0);
// Run the computation
if (settings.fullResolution.value)
{
cmd.DispatchRays(reflectionShaderRT, m_RayGenReflectionFullResName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, 1);
}
else
{
// Run the computation
cmd.DispatchRays(reflectionShaderRT, m_RayGenReflectionHalfResName, (uint)(hdCamera.actualWidth / 2), (uint)(hdCamera.actualHeight / 2), 1);
}
// Restore the previous state of specular lighting
cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, hdCamera.frameSettings.IsEnabled(FrameSettingsField.SpecularLighting) ? 1 : 0);
}
using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler()))
{
// Fetch the right filter to use
int currentKernel = 0;
if (settings.fullResolution.value)
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleFullRes");
}
else
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleHalfRes");
}
// Inject all the parameters for the compute
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrLightingTextureRW, m_ReflIntermediateTexture0);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrHitPointTexture, m_ReflIntermediateTexture1);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_NoiseTexture", blueNoise.textureArray16RGB);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_RaytracingReflectionTexture", outputTexture);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._SpatialFilterRadius, settings.spatialFilterRadius.value);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._RaytracingDenoiseRadius, settings.enableFilter.value ? settings.filterRadius.value : 0);
cmd.SetComputeFloatParam(reflectionFilter, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
// Texture dimensions
int texWidth = hdCamera.actualWidth;
int texHeight = hdCamera.actualHeight;
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Bind the right texture for clear coat support
RenderTargetIdentifier clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Compute the texture
cmd.DispatchCompute(reflectionFilter, currentKernel, numTilesXHR, numTilesYHR, 1);
using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler()))
{
if (settings.enableFilter.value)
{
// Grab the history buffer
RTHandleSystem.RTHandle reflectionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
HDSimpleDenoiser simpleDenoiser = m_RayTracingManager.GetSimpleDenoiser();
simpleDenoiser.DenoiseBuffer(cmd, hdCamera, outputTexture, reflectionHistory, m_ReflIntermediateTexture0, settings.filterRadius.value, singleChannel: false);
HDUtils.BlitCameraTexture(cmd, m_ReflIntermediateTexture0, outputTexture);
}
}
}
}
SSGITraceResources PrepareSSGITraceResources(HDCamera hdCamera, RTHandle outputBuffer0, RTHandle outputBuffer1, RTHandle hitPointBuffer)
{
SSGITraceResources ssgiTraceResources = new SSGITraceResources();
// Input buffers
ssgiTraceResources.depthTexture = m_SharedRTManager.GetDepthTexture();
ssgiTraceResources.normalBuffer = m_SharedRTManager.GetNormalBuffer();
ssgiTraceResources.motionVectorsBuffer = m_SharedRTManager.GetMotionVectorsBuffer();
var previousColorPyramid = hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.ColorBufferMipChain);
ssgiTraceResources.colorPyramid = previousColorPyramid != null ? previousColorPyramid : TextureXR.GetBlackTexture();
var historyDepthBuffer = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Depth);
ssgiTraceResources.historyDepth = historyDepthBuffer != null ? historyDepthBuffer : TextureXR.GetBlackTexture();
// Output buffers
ssgiTraceResources.hitPointBuffer = hitPointBuffer;
// Output buffers
ssgiTraceResources.outputBuffer0 = outputBuffer0;
ssgiTraceResources.outputBuffer1 = outputBuffer1;
return(ssgiTraceResources);
}
static public void SetDefaultAmbientOcclusionTexture(CommandBuffer cmd)
{
cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, TextureXR.GetBlackTexture());
}
void RenderSSGI(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, int frameCount)
{
// Grab the global illumination volume component
GlobalIllumination giSettings = hdCamera.volumeStack.GetComponent <GlobalIllumination>();
// Grab the noise texture manager
BlueNoise blueNoise = GetBlueNoiseManager();
// Grab the shaders we shall be using
ComputeShader ssGICS = m_Asset.renderPipelineResources.shaders.screenSpaceGlobalIlluminationCS;
// Evaluate the dispatch parameters
int texWidth, texHeight;
if (giSettings.fullResolutionSS)
{
texWidth = hdCamera.actualWidth;
texHeight = hdCamera.actualHeight;
halfScreenSize.Set(texWidth * 0.5f, texHeight * 0.5f, 2.0f / texWidth, 2.0f / texHeight);
}
else
{
texWidth = hdCamera.actualWidth / 2;
texHeight = hdCamera.actualHeight / 2;
halfScreenSize.Set(texWidth, texHeight, 1.0f / texWidth, 1.0f / texHeight);
}
int areaTileSize = 8;
int numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Based on if we are doing it in half resolution or full, we need to define initial and final buffer to avoid a useless blit
RTHandle buffer0, buffer1;
if (!giSettings.fullResolutionSS)
{
buffer0 = m_IndirectDiffuseBuffer0;
buffer1 = m_IndirectDiffuseBuffer1;
}
else
{
buffer0 = m_IndirectDiffuseBuffer1;
buffer1 = m_IndirectDiffuseBuffer0;
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.SsgiPass)))
{
// Fetch the right tracing kernel
int currentKernel = giSettings.fullResolutionSS ? m_TraceGlobalIlluminationKernel : m_TraceGlobalIlluminationHalfKernel;
// Inject all the input scalars
float n = hdCamera.camera.nearClipPlane;
float f = hdCamera.camera.farClipPlane;
float thickness = giSettings.depthBufferThickness.value;
float thicknessScale = 1.0f / (1.0f + thickness);
float thicknessBias = -n / (f - n) * (thickness * thicknessScale);
cmd.SetComputeFloatParam(ssGICS, HDShaderIDs._IndirectDiffuseThicknessScale, thicknessScale);
cmd.SetComputeFloatParam(ssGICS, HDShaderIDs._IndirectDiffuseThicknessBias, thicknessBias);
cmd.SetComputeIntParam(ssGICS, HDShaderIDs._IndirectDiffuseSteps, giSettings.raySteps);
cmd.SetComputeFloatParam(ssGICS, HDShaderIDs._IndirectDiffuseMaximalRadius, giSettings.maximalRadius);
// Inject half screen size if required
if (!giSettings.fullResolutionSS)
{
cmd.SetComputeVectorParam(ssGICS, HDShaderIDs._HalfScreenSize, halfScreenSize);
}
// Inject the ray-tracing sampling data
blueNoise.BindDitheredRNGData1SPP(cmd);
// Inject all the input textures/buffers
cmd.SetComputeTextureParam(ssGICS, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthTexture());
cmd.SetComputeTextureParam(ssGICS, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(ssGICS, currentKernel, HDShaderIDs._IndirectDiffuseHitPointTextureRW, m_IndirectDiffuseHitPointBuffer);
var info = m_SharedRTManager.GetDepthBufferMipChainInfo();
cmd.SetComputeBufferParam(ssGICS, currentKernel, HDShaderIDs._DepthPyramidMipLevelOffsets, info.GetOffsetBufferData(m_DepthPyramidMipLevelOffsetsBuffer));
cmd.SetGlobalBuffer(HDShaderIDs.g_vLightListGlobal, m_TileAndClusterData.lightList);
// Do the ray marching
cmd.DispatchCompute(ssGICS, currentKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
// Fetch the right kernel to use
currentKernel = giSettings.fullResolutionSS ? m_ReprojectGlobalIlluminationKernel : m_ReprojectGlobalIlluminationHalfKernel;
// 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 udpated here.
m_ShaderVariablesRayTracingCB._RaytracingIntensityClamp = giSettings.clampValueSS;
ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesRayTracingCB, HDShaderIDs._ShaderVariablesRaytracing);
// Inject all the input scalars
cmd.SetComputeVectorParam(ssGICS, HDShaderIDs._ColorPyramidUvScaleAndLimitPrevFrame, HDUtils.ComputeViewportScaleAndLimit(hdCamera.historyRTHandleProperties.previousViewportSize, hdCamera.historyRTHandleProperties.previousRenderTargetSize));
// Bind all the input buffers
cmd.SetComputeTextureParam(ssGICS, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(ssGICS, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(ssGICS, currentKernel, HDShaderIDs._IndirectDiffuseHitPointTexture, m_IndirectDiffuseHitPointBuffer);
var previousColorPyramid = hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.ColorBufferMipChain);
cmd.SetComputeTextureParam(ssGICS, currentKernel, HDShaderIDs._ColorPyramidTexture, previousColorPyramid != null ? previousColorPyramid : TextureXR.GetBlackTexture());
var historyDepthBuffer = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Depth);
cmd.SetComputeTextureParam(ssGICS, currentKernel, HDShaderIDs._HistoryDepthTexture, historyDepthBuffer != null ? historyDepthBuffer : TextureXR.GetBlackTexture());
cmd.SetComputeBufferParam(ssGICS, currentKernel, HDShaderIDs._DepthPyramidMipLevelOffsets, info.GetOffsetBufferData(m_DepthPyramidMipLevelOffsetsBuffer));
// Bind the output texture
cmd.SetComputeTextureParam(ssGICS, currentKernel, HDShaderIDs._IndirectDiffuseTextureRW, buffer1);
// Do the reprojection
cmd.DispatchCompute(ssGICS, currentKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
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;
// Do the denoising part
SSGIDenoiser ssgiDenoiser = GetSSGIDenoiser();
ssgiDenoiser.Denoise(cmd, hdCamera, buffer1, buffer0, halfResolution: !giSettings.fullResolutionSS, historyValidity: historyValidity);
// If this was a half resolution effect, we still have to upscale it
if (!giSettings.fullResolutionSS)
{
ComputeShader bilateralUpsampleCS = m_Asset.renderPipelineResources.shaders.bilateralUpsampleCS;
// Re-evaluate the dispatch parameters (we are evaluating the upsample in full resolution)
numTilesXHR = (hdCamera.actualWidth + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (hdCamera.actualHeight + (areaTileSize - 1)) / areaTileSize;
// Inject the input scalars
cmd.SetComputeVectorParam(bilateralUpsampleCS, HDShaderIDs._HalfScreenSize, halfScreenSize);
firstMipOffset.Set(HDShadowUtils.Asfloat((uint)info.mipLevelOffsets[1].x), HDShadowUtils.Asfloat((uint)info.mipLevelOffsets[1].y));
cmd.SetComputeVectorParam(bilateralUpsampleCS, HDShaderIDs._DepthPyramidFirstMipLevelOffset, firstMipOffset);
// Inject all the input buffers
cmd.SetComputeTextureParam(bilateralUpsampleCS, m_BilateralUpSampleColorTMKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthTexture());
cmd.SetComputeTextureParam(bilateralUpsampleCS, m_BilateralUpSampleColorTMKernel, HDShaderIDs._LowResolutionTexture, buffer1);
cmd.SetComputeBufferParam(bilateralUpsampleCS, m_BilateralUpSampleColorTMKernel, HDShaderIDs._DepthPyramidMipLevelOffsets, info.GetOffsetBufferData(m_DepthPyramidMipLevelOffsetsBuffer));
// Inject the output textures
cmd.SetComputeTextureParam(bilateralUpsampleCS, m_BilateralUpSampleColorTMKernel, HDShaderIDs._OutputUpscaledTexture, buffer0);
// Upscale the buffer to full resolution
cmd.DispatchCompute(bilateralUpsampleCS, m_BilateralUpSampleColorTMKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
}
(RenderPipelineManager.currentPipeline as HDRenderPipeline).PushFullScreenDebugTexture(hdCamera, cmd, m_IndirectDiffuseBuffer0, FullScreenDebugMode.ScreenSpaceGlobalIllumination);
}
}
void RenderReflectionsPerformance(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount)
{
// Fetch the required resources
BlueNoise blueNoise = GetBlueNoiseManager();
RayTracingShader reflectionShaderRT = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
ComputeShader reflectionShaderCS = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingCS;
ComputeShader reflectionFilter = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
RTHandle intermediateBuffer0 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA0);
RTHandle intermediateBuffer1 = GetRayTracingBuffer(InternalRayTracingBuffers.RGBA1);
// Fetch all the settings
var settings = hdCamera.volumeStack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = hdCamera.volumeStack.GetComponent <LightCluster>();
RayTracingSettings rtSettings = hdCamera.volumeStack.GetComponent <RayTracingSettings>();
// Texture dimensions
int texWidth = hdCamera.actualWidth;
int texHeight = hdCamera.actualHeight;
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = 0, numTilesYHR = 0;
int currentKernel = 0;
RenderTargetIdentifier clearCoatMaskTexture;
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingIntegrateReflection)))
{
// Fetch the new sample kernel
currentKernel = reflectionShaderCS.FindKernel(settings.fullResolution.value ? "RaytracingReflectionsFullRes" : "RaytracingReflectionsHalfRes");
// Inject the ray-tracing sampling data
blueNoise.BindDitheredRNGData8SPP(cmd);
// Bind all the required textures
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._SsrStencilBit, (int)StencilUsage.TraceReflectionRay);
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._StencilTexture, m_SharedRTManager.GetDepthStencilBuffer(), 0, RenderTextureSubElement.Stencil);
// Bind all the required scalars
cmd.SetComputeFloatParam(reflectionShaderCS, HDShaderIDs._RaytracingIntensityClamp, settings.clampValue.value);
cmd.SetComputeFloatParam(reflectionShaderCS, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._RaytracingIncludeSky, settings.reflectSky.value ? 1 : 0);
// Bind the sampling data
int frameIndex = RayTracingFrameIndex(hdCamera);
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._RaytracingFrameIndex, frameIndex);
// Bind the output buffers
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._RaytracingDirectionBuffer, intermediateBuffer1);
if (settings.fullResolution.value)
{
// Evaluate the dispatch parameters
numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
}
else
{
// Evaluate the dispatch parameters
numTilesXHR = (texWidth / 2 + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (texHeight / 2 + (areaTileSize - 1)) / areaTileSize;
}
// Compute the directions
cmd.DispatchCompute(reflectionShaderCS, currentKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
// Prepare the components for the deferred lighting
DeferredLightingRTParameters deferredParamters = PrepareReflectionDeferredLightingRTParameters(hdCamera);
DeferredLightingRTResources deferredResources = PrepareDeferredLightingRTResources(hdCamera, intermediateBuffer1, intermediateBuffer0);
// Evaluate the deferred lighting
RenderRaytracingDeferredLighting(cmd, deferredParamters, deferredResources);
// Fetch the right filter to use
if (settings.fullResolution.value)
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleFullRes");
}
else
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleHalfRes");
}
// Inject all the parameters for the compute
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrLightingTextureRW, intermediateBuffer0);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrHitPointTexture, intermediateBuffer1);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._BlueNoiseTexture, blueNoise.textureArray16RGB);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_RaytracingReflectionTexture", outputTexture);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._SpatialFilterRadius, settings.upscaleRadius.value);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._RaytracingDenoiseRadius, settings.denoise.value ? settings.denoiserRadius.value : 0);
cmd.SetComputeFloatParam(reflectionFilter, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
cmd.SetComputeFloatParam(reflectionFilter, HDShaderIDs._RaytracingReflectionSmoothnessFadeStart, settings.smoothnessFadeStart.value);
numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Bind the right texture for clear coat support
clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Compute the texture
cmd.DispatchCompute(reflectionFilter, currentKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(HDProfileId.RaytracingFilterReflection)))
{
if (settings.denoise.value)
{
// 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, outputTexture, reflectionHistory, intermediateBuffer0, historyValidity: historyValidity);
HDUtils.BlitCameraTexture(cmd, intermediateBuffer0, outputTexture);
}
}
}
void BindBlackShadowTexture(CommandBuffer cmd)
{
cmd.SetGlobalTexture(HDShaderIDs._ScreenSpaceShadowsTexture, TextureXR.GetBlackTexture());
}
public void BindRayTracedReflectionData(CommandBuffer cmd, HDCamera hdCamera, HDRaytracingEnvironment rtEnvironment, RayTracingShader reflectionShader, ScreenSpaceReflection settings, LightCluster lightClusterSettings)
{
// Grab the acceleration structures and the light cluster to use
RayTracingAccelerationStructure accelerationStructure = m_RayTracingManager.RequestAccelerationStructure(rtEnvironment.reflLayerMask);
HDRaytracingLightCluster lightCluster = m_RayTracingManager.RequestLightCluster(rtEnvironment.reflLayerMask);
// 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);
// Inject the ray-tracing sampling data
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._OwenScrambledTexture, m_Asset.renderPipelineResources.textures.owenScrambledTex);
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
// Global reflection parameters
cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingIntensityClamp, settings.clampValue.value);
cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingReflectSky, settings.reflectSky.value ? 1 : 0);
// Inject the ray generation data
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtEnvironment.rayBias);
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayMaxLength, settings.rayLength.value);
cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingNumSamples, settings.numSamples.value);
int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)m_FrameCount % 8;
cmd.SetRayTracingIntParam(reflectionShader, HDShaderIDs._RaytracingFrameIndex, frameIndex);
// 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
cmd.SetRayTracingIntParam(reflectionShader, HDShaderIDs._RayCountEnabled, m_RayTracingManager.rayCountManager.RayCountIsEnabled());
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._RayCountTexture, m_RayTracingManager.rayCountManager.rayCountTexture);
// Compute the pixel spread value
float pixelSpreadAngle = Mathf.Atan(2.0f * Mathf.Tan(hdCamera.camera.fieldOfView * Mathf.PI / 360.0f) / Mathf.Min(hdCamera.actualWidth, hdCamera.actualHeight));
cmd.SetRayTracingFloatParam(reflectionShader, HDShaderIDs._RaytracingPixelSpreadAngle, pixelSpreadAngle);
// LightLoop data
cmd.SetGlobalBuffer(HDShaderIDs._RaytracingLightCluster, lightCluster.GetCluster());
cmd.SetGlobalBuffer(HDShaderIDs._LightDatasRT, lightCluster.GetLightDatas());
cmd.SetGlobalVector(HDShaderIDs._MinClusterPos, lightCluster.GetMinClusterPos());
cmd.SetGlobalVector(HDShaderIDs._MaxClusterPos, lightCluster.GetMaxClusterPos());
cmd.SetGlobalInt(HDShaderIDs._LightPerCellCount, lightClusterSettings.maxNumLightsPercell.value);
cmd.SetGlobalInt(HDShaderIDs._PunctualLightCountRT, lightCluster.GetPunctualLightCount());
cmd.SetGlobalInt(HDShaderIDs._AreaLightCountRT, lightCluster.GetAreaLightCount());
// 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);
}
public void RenderReflectionsT1(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount)
{
// First thing to check is: Do we have a valid ray-tracing environment?
HDRaytracingEnvironment rtEnvironment = m_RaytracingManager.CurrentEnvironment();
HDRenderPipeline renderPipeline = m_RaytracingManager.GetRenderPipeline();
BlueNoise blueNoise = m_RaytracingManager.GetBlueNoiseManager();
ComputeShader reflectionFilter = m_PipelineAsset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
RayTracingShader reflectionShader = m_PipelineAsset.renderPipelineRayTracingResources.reflectionRaytracing;
bool invalidState = rtEnvironment == null || blueNoise == null ||
reflectionFilter == null || reflectionShader == null ||
m_PipelineResources.textures.owenScrambledTex == null || m_PipelineResources.textures.scramblingTex == null;
// If no acceleration structure available, end it now
if (invalidState)
{
return;
}
var settings = VolumeManager.instance.stack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = VolumeManager.instance.stack.GetComponent <LightCluster>();
// Grab the acceleration structures and the light cluster to use
RayTracingAccelerationStructure accelerationStructure = m_RaytracingManager.RequestAccelerationStructure(rtEnvironment.reflLayerMask);
HDRaytracingLightCluster lightCluster = m_RaytracingManager.RequestLightCluster(rtEnvironment.reflLayerMask);
// Compute the actual resolution that is needed base on the quality
string targetRayGen = m_RayGenHalfResName;
// 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);
// Inject the ray-tracing sampling data
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._OwenScrambledTexture, m_PipelineResources.textures.owenScrambledTex);
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._ScramblingTexture, m_PipelineResources.textures.scramblingTex);
// Global reflection parameters
cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingIntensityClamp, settings.clampValue.value);
cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingReflectSky, settings.reflectSky.value ? 1 : 0);
// Inject the ray generation data
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtEnvironment.rayBias);
cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayMaxLength, settings.rayLength.value);
cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingNumSamples, settings.numSamples.value);
int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)frameCount % 8;
cmd.SetGlobalInt(HDShaderIDs._RaytracingFrameIndex, frameIndex);
// Set the data for the ray generation
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrLightingTextureRW, m_LightingTexture);
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrHitPointTexture, m_HitPdfTexture);
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
// Set ray count tex
cmd.SetRayTracingIntParam(reflectionShader, HDShaderIDs._RayCountEnabled, m_RaytracingManager.rayCountManager.RayCountIsEnabled());
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._RayCountTexture, m_RaytracingManager.rayCountManager.rayCountTexture);
// Compute the pixel spread value
float pixelSpreadAngle = Mathf.Atan(2.0f * Mathf.Tan(hdCamera.camera.fieldOfView * Mathf.PI / 360.0f) / Mathf.Min(hdCamera.actualWidth, hdCamera.actualHeight));
cmd.SetRayTracingFloatParam(reflectionShader, HDShaderIDs._RaytracingPixelSpreadAngle, pixelSpreadAngle);
// LightLoop data
cmd.SetGlobalBuffer(HDShaderIDs._RaytracingLightCluster, lightCluster.GetCluster());
cmd.SetGlobalBuffer(HDShaderIDs._LightDatasRT, lightCluster.GetLightDatas());
cmd.SetGlobalVector(HDShaderIDs._MinClusterPos, lightCluster.GetMinClusterPos());
cmd.SetGlobalVector(HDShaderIDs._MaxClusterPos, lightCluster.GetMaxClusterPos());
cmd.SetGlobalInt(HDShaderIDs._LightPerCellCount, lightClusterSettings.maxNumLightsPercell.value);
cmd.SetGlobalInt(HDShaderIDs._PunctualLightCountRT, lightCluster.GetPunctualLightCount());
cmd.SetGlobalInt(HDShaderIDs._AreaLightCountRT, lightCluster.GetAreaLightCount());
// Note: Just in case, we rebind the directional light data (in case they were not)
cmd.SetGlobalBuffer(HDShaderIDs._DirectionalLightDatas, renderPipeline.m_LightLoopLightData.directionalLightData);
cmd.SetGlobalInt(HDShaderIDs._DirectionalLightCount, renderPipeline.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 data for the ray miss
cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SkyTexture, m_SkyManager.skyReflection);
// Compute the actual resolution that is needed base on the quality
uint widthResolution = (uint)hdCamera.actualWidth / 2;
uint heightResolution = (uint)hdCamera.actualHeight / 2;
// Force to disable specular lighting
cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, 0);
// Run the computation
cmd.DispatchRays(reflectionShader, targetRayGen, widthResolution, heightResolution, 1);
// Restore the previous state of specular lighting
cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, hdCamera.frameSettings.IsEnabled(FrameSettingsField.SpecularLighting) ? 1 : 0);
using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler()))
{
// Fetch the right filter to use
int currentKernel = reflectionFilter.FindKernel("RaytracingReflectionFilter");
// Inject all the parameters for the compute
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrLightingTextureRW, m_LightingTexture);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrHitPointTexture, m_HitPdfTexture);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_NoiseTexture", blueNoise.textureArray16RGB);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_VarianceTexture", m_VarianceBuffer);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_MinColorRangeTexture", m_MinBoundBuffer);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_MaxColorRangeTexture", m_MaxBoundBuffer);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_RaytracingReflectionTexture", outputTexture);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._ScramblingTexture, m_PipelineResources.textures.scramblingTex);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._SpatialFilterRadius, settings.spatialFilterRadius.value);
cmd.SetComputeFloatParam(reflectionFilter, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
// Texture dimensions
int texWidth = outputTexture.rt.width;
int texHeight = outputTexture.rt.height;
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Bind the right texture for clear coat support
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Compute the texture
cmd.DispatchCompute(reflectionFilter, currentKernel, numTilesXHR, numTilesYHR, 1);
int numTilesXFR = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesYFR = (texHeight + (areaTileSize - 1)) / areaTileSize;
RTHandleSystem.RTHandle history = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
// Fetch the right filter to use
currentKernel = reflectionFilter.FindKernel("TemporalAccumulationFilter");
cmd.SetComputeFloatParam(reflectionFilter, HDShaderIDs._TemporalAccumuationWeight, settings.temporalAccumulationWeight.value);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._AccumulatedFrameTexture, history);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._CurrentFrameTexture, outputTexture);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_MinColorRangeTexture", m_MinBoundBuffer);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_MaxColorRangeTexture", m_MaxBoundBuffer);
cmd.DispatchCompute(reflectionFilter, currentKernel, numTilesXFR, numTilesYFR, 1);
}
}
SSSCombineResources PrepareSSSCombineResources(RTHandle sssColor, RTHandle colorBufferRT, RTHandle diffuseLightingBuffer, RTHandle sssBuffer, bool validSSGI)
{
SSSCombineResources ssscResources = new SSSCombineResources();
// Input buffers
ssscResources.depthStencilBuffer = sharedRTManager.GetDepthStencilBuffer();
ssscResources.sssColor = sssColor;
ssscResources.ssgiBuffer = validSSGI ? m_IndirectDiffuseBuffer0 : TextureXR.GetBlackTexture();
ssscResources.diffuseLightingBuffer = diffuseLightingBuffer;
ssscResources.subsurfaceBuffer = sssBuffer;
// Output Buffers
ssscResources.outputColorBuffer = colorBufferRT;
return(ssscResources);
}
// Denoiser variant for non history array
public void DenoiseBuffer(CommandBuffer cmd, HDCamera hdCamera,
RTHandle noisySignal, RTHandle historySignal,
RTHandle outputSignal,
bool singleChannel = true, float historyValidity = 1.0f)
{
// If we do not have a depth and normal history buffers, we can skip right away
var historyDepthBuffer = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Depth);
var historyNormalBuffer = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Normal);
if (historyDepthBuffer == null || historyNormalBuffer == null)
{
HDUtils.BlitCameraTexture(cmd, noisySignal, historySignal);
HDUtils.BlitCameraTexture(cmd, noisySignal, outputSignal);
return;
}
// Fetch texture dimensions
int texWidth = hdCamera.actualWidth;
int texHeight = hdCamera.actualHeight;
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesX = (texWidth + (areaTileSize - 1)) / areaTileSize;
int numTilesY = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Request the intermediate buffer we need
RTHandle validationBuffer = m_RenderPipeline.GetRayTracingBuffer(InternalRayTracingBuffers.R0);
// First of all we need to validate the history to know where we can or cannot use the history signal
int m_KernelFilter = m_TemporalFilterCS.FindKernel("ValidateHistory");
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryDepthTexture, historyDepthBuffer);
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryNormalBufferTexture, historyNormalBuffer);
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._ValidationBufferRW, validationBuffer);
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._VelocityBuffer, TextureXR.GetBlackTexture());
cmd.SetComputeFloatParam(m_TemporalFilterCS, HDShaderIDs._HistoryValidity, historyValidity);
cmd.SetComputeFloatParam(m_TemporalFilterCS, HDShaderIDs._PixelSpreadAngleTangent, HDRenderPipeline.GetPixelSpreadTangent(hdCamera.camera.fieldOfView, hdCamera.actualWidth, hdCamera.actualHeight));
cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount);
// Now that we have validated our history, let's accumulate
m_KernelFilter = m_TemporalFilterCS.FindKernel(singleChannel ? "TemporalAccumulationSingle" : "TemporalAccumulationColor");
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, noisySignal);
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryBuffer, historySignal);
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, outputSignal);
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._ValidationBuffer, validationBuffer);
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._VelocityBuffer, TextureXR.GetBlackTexture());
cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount);
// Make sure to copy the new-accumulated signal in our history buffer
m_KernelFilter = m_TemporalFilterCS.FindKernel(singleChannel ? "CopyHistorySingle" : "CopyHistoryColor");
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, outputSignal);
cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, historySignal);
cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount);
}
public void RenderReflectionsT1(HDCamera hdCamera, CommandBuffer cmd, RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount)
{
// Fetch the required resources
BlueNoise blueNoise = GetBlueNoiseManager();
RayTracingShader reflectionShaderRT = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingRT;
ComputeShader reflectionShaderCS = m_Asset.renderPipelineRayTracingResources.reflectionRaytracingCS;
ComputeShader reflectionFilter = m_Asset.renderPipelineRayTracingResources.reflectionBilateralFilterCS;
// Fetch all the settings
var settings = VolumeManager.instance.stack.GetComponent <ScreenSpaceReflection>();
LightCluster lightClusterSettings = VolumeManager.instance.stack.GetComponent <LightCluster>();
RayTracingSettings rtSettings = VolumeManager.instance.stack.GetComponent <RayTracingSettings>();
// Texture dimensions
int texWidth = hdCamera.actualWidth;
int texHeight = hdCamera.actualHeight;
// Evaluate the dispatch parameters
int areaTileSize = 8;
int numTilesXHR = 0, numTilesYHR = 0;
int currentKernel = 0;
RenderTargetIdentifier clearCoatMaskTexture;
using (new ProfilingSample(cmd, "Ray Traced Reflection", CustomSamplerId.RaytracingIntegrateReflection.GetSampler()))
{
if (settings.deferredMode.value)
{
// Fetch the new sample kernel
currentKernel = reflectionShaderCS.FindKernel(settings.fullResolution.value ? "RaytracingReflectionsFullRes" : "RaytracingReflectionsHalfRes");
// Inject the ray-tracing sampling data
blueNoise.BindDitheredRNGData8SPP(cmd);
// Bind all the required textures
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Bind all the required scalars
cmd.SetComputeFloatParam(reflectionShaderCS, HDShaderIDs._RaytracingIntensityClamp, settings.clampValue.value);
cmd.SetComputeFloatParam(reflectionShaderCS, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._RaytracingIncludeSky, settings.reflectSky.value ? 1 : 0);
// Bind the sampling data
int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)m_FrameCount % 8;
cmd.SetComputeIntParam(reflectionShaderCS, HDShaderIDs._RaytracingFrameIndex, frameIndex);
// Bind the output buffers
cmd.SetComputeTextureParam(reflectionShaderCS, currentKernel, HDShaderIDs._RaytracingDirectionBuffer, m_ReflIntermediateTexture1);
if (settings.fullResolution.value)
{
// Evaluate the dispatch parameters
numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
}
else
{
// Evaluate the dispatch parameters
numTilesXHR = (texWidth / 2 + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (texHeight / 2 + (areaTileSize - 1)) / areaTileSize;
}
// Compute the directions
cmd.DispatchCompute(reflectionShaderCS, currentKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
// Prepare the components for the deferred lighting
DeferredLightingRTParameters deferredParamters = PrepareReflectionDeferredLightingRTParameters(hdCamera);
DeferredLightingRTResources deferredResources = PrepareDeferredLightingRTResources(hdCamera, m_ReflIntermediateTexture1, m_ReflIntermediateTexture0);
// Evaluate the deferred lighting
RenderRaytracingDeferredLighting(cmd, deferredParamters, deferredResources);
}
else
{
// Bind all the required data for ray tracing
BindRayTracedReflectionData(cmd, hdCamera, reflectionShaderRT, settings, lightClusterSettings, rtSettings);
// Run the computation
if (settings.fullResolution.value)
{
cmd.DispatchRays(reflectionShaderRT, m_RayGenReflectionFullResName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, (uint)hdCamera.viewCount);
}
else
{
// Run the computation
cmd.DispatchRays(reflectionShaderRT, m_RayGenReflectionHalfResName, (uint)(hdCamera.actualWidth / 2), (uint)(hdCamera.actualHeight / 2), (uint)hdCamera.viewCount);
}
}
// Fetch the right filter to use
if (settings.fullResolution.value)
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleFullRes");
}
else
{
currentKernel = reflectionFilter.FindKernel("ReflectionIntegrationUpscaleHalfRes");
}
// Inject all the parameters for the compute
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrLightingTextureRW, m_ReflIntermediateTexture0);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrHitPointTexture, m_ReflIntermediateTexture1);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer());
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._BlueNoiseTexture, blueNoise.textureArray16RGB);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_RaytracingReflectionTexture", outputTexture);
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._SpatialFilterRadius, settings.upscaleRadius.value);
cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._RaytracingDenoiseRadius, settings.denoise.value ? settings.denoiserRadius.value : 0);
cmd.SetComputeFloatParam(reflectionFilter, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value);
numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize;
numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize;
// Bind the right texture for clear coat support
clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture();
cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture);
// Compute the texture
cmd.DispatchCompute(reflectionFilter, currentKernel, numTilesXHR, numTilesYHR, hdCamera.viewCount);
}
using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler()))
{
if (settings.denoise.value)
{
// Grab the history buffer
RTHandle reflectionHistory = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection)
?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1);
HDSimpleDenoiser simpleDenoiser = GetSimpleDenoiser();
simpleDenoiser.DenoiseBuffer(cmd, hdCamera, outputTexture, reflectionHistory, m_ReflIntermediateTexture0, settings.denoiserRadius.value, singleChannel: false);
HDUtils.BlitCameraTexture(cmd, m_ReflIntermediateTexture0, outputTexture);
}
}
}
// If there is no SSGI, bind a black 1x1 texture
static void BindBlackIndirectDiffuseTexture(CommandBuffer cmd)
{
cmd.SetGlobalTexture(HDShaderIDs._IndirectDiffuseTexture, TextureXR.GetBlackTexture());
}
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));
}
public void SetDefaultAmbientOcclusionTexture(CommandBuffer cmd)
{
cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, TextureXR.GetBlackTexture());
cmd.SetGlobalVector(HDShaderIDs._AmbientOcclusionParam, Vector4.zero);
}
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));
}