[HDRP][PathTracing] High resolution sky on camera ray misses

com.unity.render-pipelines.high-definition/CHANGELOG.md

@@ -69,6 +69,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Change labels about scroll direction and cloud type.
 - Improved shadow cascade GUI drawing with pixel perfect, hover and focus functionalities.
 - Improving the screen space global illumination.
+- Changed resolution (to match the render buffer) of the sky used for camera misses in Path Tracing. (case 1304114).
 
 ## [11.0.0] - 2020-10-21
 

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Accumulation/Shaders/Accumulation.compute

@@ -4,11 +4,11 @@
 
 #pragma kernel KMain
 
-#pragma multi_compile _ INPUT_FROM_RADIANCE_TEXTURE
+#pragma multi_compile _ INPUT_FROM_FRAME_TEXTURE
 
 // Inputs
-#ifdef INPUT_FROM_RADIANCE_TEXTURE
-TEXTURE2D_X(_RadianceTexture);
+#ifdef INPUT_FROM_FRAME_TEXTURE
+TEXTURE2D_X(_FrameTexture);
 #endif
 
 float4      _AccumulationWeights;
@@ -63,8 +63,8 @@ void KMain(uint3 dispatchThreadId : SV_DispatchThreadID)
     }
     else
     {
-#ifdef INPUT_FROM_RADIANCE_TEXTURE
-        float4 color = _RadianceTexture[COORD_TEXTURE2D_X(dispatchThreadId.xy)];
+#ifdef INPUT_FROM_FRAME_TEXTURE
+        float4 color = _FrameTexture[COORD_TEXTURE2D_X(dispatchThreadId.xy)];
 #else
         float4 color = _CameraColorTextureRW[COORD_TEXTURE2D_X(dispatchThreadId.xy)];
 #endif

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Accumulation/SubFrameManager.cs

@@ -286,7 +286,7 @@ RenderAccumulationParameters PrepareRenderAccumulationParameters(HDCamera hdCame
             parameters.accumulationCS.shaderKeywords = null;
             if (inputFromRadianceTexture)
             {
-                parameters.accumulationCS.EnableKeyword("INPUT_FROM_RADIANCE_TEXTURE");
+                parameters.accumulationCS.EnableKeyword("INPUT_FROM_FRAME_TEXTURE");
             }
             return parameters;
         }
@@ -311,7 +311,7 @@ static void RenderAccumulation(in RenderAccumulationParameters parameters, RTHan
             cmd.SetComputeTextureParam(accumulationShader, parameters.accumulationKernel, HDShaderIDs._CameraColorTextureRW, outputTexture);
             if (!inputTexture.Equals(outputTexture))
             {
-                cmd.SetComputeTextureParam(accumulationShader, parameters.accumulationKernel, HDShaderIDs._RadianceTexture, inputTexture);
+                cmd.SetComputeTextureParam(accumulationShader, parameters.accumulationKernel, HDShaderIDs._FrameTexture, inputTexture);
             }
             cmd.SetComputeVectorParam(accumulationShader, HDShaderIDs._AccumulationWeights, frameWeights);
             cmd.SetComputeIntParam(accumulationShader, HDShaderIDs._AccumulationNeedsExposure, parameters.needExposure ? 1 : 0);

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.RenderGraph.cs

@@ -116,7 +116,7 @@ class TempPassData {};
 
                 if (hdCamera.viewCount == 1)
                 {
-                    colorBuffer = RenderPathTracing(m_RenderGraph, hdCamera);
+                    colorBuffer = RenderPathTracing(m_RenderGraph, hdCamera, colorBuffer);
                 }
                 else
                 {

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.cs

@@ -473,7 +473,7 @@ public HDRenderPipeline(HDRenderPipelineAsset asset, HDRenderPipelineAsset defau
                 InitRayTracedIndirectDiffuse();
                 InitRaytracingDeferred();
                 InitRecursiveRenderer();
-                InitPathTracing();
+                InitPathTracing(m_RenderGraph);
                 InitRayTracingAmbientOcclusion();
             }
 

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDStringConstants.cs

@@ -717,12 +717,13 @@ static class HDShaderIDs
         public static readonly int _SubSurfaceLightingBuffer        = Shader.PropertyToID("_SubSurfaceLightingBuffer");
         public static readonly int _IndirectDiffuseLightingBuffer   = Shader.PropertyToID("_IndirectDiffuseLightingBuffer");
 
-        // Accumulation
+        // Accumulation and path tracing
         public static readonly int _AccumulationFrameIndex          = Shader.PropertyToID("_AccumulationFrameIndex");
         public static readonly int _AccumulationNumSamples          = Shader.PropertyToID("_AccumulationNumSamples");
         public static readonly int _AccumulationWeights             = Shader.PropertyToID("_AccumulationWeights");
         public static readonly int _AccumulationNeedsExposure       = Shader.PropertyToID("_AccumulationNeedsExposure");
-        public static readonly int _RadianceTexture                 = Shader.PropertyToID("_RadianceTexture");
+        public static readonly int _FrameTexture                    = Shader.PropertyToID("_FrameTexture");
+        public static readonly int _SkyCameraTexture                = Shader.PropertyToID("_SkyCameraTexture");
 
         // Preintegrated texture name
         public static readonly int _PreIntegratedFGD_GGXDisneyDiffuse = Shader.PropertyToID("_PreIntegratedFGD_GGXDisneyDiffuse");

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/PathTracing.cs

@@ -69,20 +69,31 @@ public partial class HDRenderPipeline
 #endif // UNITY_EDITOR
         ulong m_CacheAccelSize = 0;
         uint  m_CacheLightCount = 0;
+        bool  m_RenderSky = true;
 
-        RTHandle m_RadianceTexture; // stores the per-pixel results of path tracing for this frame
+        TextureHandle m_FrameTexture; // stores the per-pixel results of path tracing for one frame
+        TextureHandle m_SkyTexture; // stores the sky background
 
-        void InitPathTracing()
+        void InitPathTracing(RenderGraph renderGraph)
         {
 #if UNITY_EDITOR
             Undo.postprocessModifications += OnUndoRecorded;
             Undo.undoRedoPerformed += OnSceneEdit;
             SceneView.duringSceneGui += OnSceneGui;
 #endif // UNITY_EDITOR
 
-            m_RadianceTexture = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R32G32B32A32_SFloat, dimension: TextureXR.dimension,
-                enableRandomWrite: true, useMipMap: false, autoGenerateMips: false,
-                name: "PathTracingFrameBuffer");
+            TextureDesc td = new TextureDesc(Vector2.one, true, true);
+            td.colorFormat = GraphicsFormat.R32G32B32A32_SFloat;
+            td.useMipMap = false;
+            td.autoGenerateMips = false;
+
+            td.name = "PathTracingFrameBuffer";
+            td.enableRandomWrite = true;
+            m_FrameTexture = renderGraph.CreateSharedTexture(td);
+
+            td.name = "PathTracingSkyBuffer";
+            td.enableRandomWrite = false;
+            m_SkyTexture = renderGraph.CreateSharedTexture(td);
         }
 
         void ReleasePathTracing()
@@ -92,15 +103,21 @@ void ReleasePathTracing()
             Undo.undoRedoPerformed -= OnSceneEdit;
             SceneView.duringSceneGui -= OnSceneGui;
 #endif // UNITY_EDITOR
-
-            RTHandles.Release(m_RadianceTexture);
         }
 
         internal void ResetPathTracing()
         {
+            m_RenderSky = true;
             m_SubFrameManager.Reset();
         }
 
+        internal void ResetPathTracing(int camID, CameraData camData)
+        {
+            m_RenderSky = true;
+            camData.ResetIteration();
+            m_SubFrameManager.SetCameraData(camID, camData);
+        }
+
         private Vector4 ComputeDoFConstants(HDCamera hdCamera, PathTracing settings)
         {
             var dofSettings = hdCamera.volumeStack.GetComponent<DepthOfField>();
@@ -119,6 +136,7 @@ private void OnSceneEdit()
             // If we just change the sample count, we don't necessarily want to reset iteration
             if (m_PathTracingSettings && m_CacheMaxIteration != m_PathTracingSettings.maximumSamples.value)
             {
+                m_RenderSky = true;
                 m_CacheMaxIteration = (uint)m_PathTracingSettings.maximumSamples.value;
                 m_SubFrameManager.SelectiveReset(m_CacheMaxIteration);
             }
@@ -157,8 +175,7 @@ private void CheckDirtiness(HDCamera hdCamera)
             {
                 camData.width = (uint)hdCamera.actualWidth;
                 camData.height = (uint)hdCamera.actualHeight;
-                camData.ResetIteration();
-                m_SubFrameManager.SetCameraData(camID, camData);
+                ResetPathTracing(camID, camData);
                 return;
             }
 
@@ -167,8 +184,7 @@ private void CheckDirtiness(HDCamera hdCamera)
             if (enabled != camData.skyEnabled)
             {
                 camData.skyEnabled = enabled;
-                camData.ResetIteration();
-                m_SubFrameManager.SetCameraData(camID, camData);
+                ResetPathTracing(camID, camData);
                 return;
             }
 
@@ -177,16 +193,14 @@ private void CheckDirtiness(HDCamera hdCamera)
             if (enabled != camData.fogEnabled)
             {
                 camData.fogEnabled = enabled;
-                camData.ResetIteration();
-                m_SubFrameManager.SetCameraData(camID, camData);
+                ResetPathTracing(camID, camData);
                 return;
             }
 
             // Check camera matrix dirtiness
             if (hdCamera.mainViewConstants.nonJitteredViewProjMatrix != (hdCamera.mainViewConstants.prevViewProjMatrix))
             {
-                camData.ResetIteration();
-                m_SubFrameManager.SetCameraData(camID, camData);
+                ResetPathTracing(camID, camData);
                 return;
             }
 
@@ -203,6 +217,7 @@ private void CheckDirtiness(HDCamera hdCamera)
             {
                 m_TransformDirty = false;
                 ResetPathTracing();
+                return;
             }
 
             // Check lights dirtiness
@@ -270,7 +285,7 @@ PathTracingParameters PreparePathTracingParameters(HDCamera hdCamera)
             return parameters;
         }
 
-        static void RenderPathTracing(in PathTracingParameters parameters, RTHandle radianceTexture, CommandBuffer cmd)
+        static void RenderPathTracing(in PathTracingParameters parameters, RTHandle frameTexture, RTHandle skyTexture, CommandBuffer cmd)
         {
             // Define the shader pass to use for the path tracing pass
             cmd.SetRayTracingShaderPass(parameters.pathTracingShader, "PathTracingDXR");
@@ -291,10 +306,11 @@ static void RenderPathTracing(in PathTracingParameters parameters, RTHandle radi
             // Set the data for the ray miss
             cmd.SetRayTracingIntParam(parameters.pathTracingShader, HDShaderIDs._RaytracingCameraSkyEnabled, parameters.cameraData.skyEnabled ? 1 : 0);
             cmd.SetRayTracingVectorParam(parameters.pathTracingShader, HDShaderIDs._RaytracingCameraClearColor, parameters.backgroundColor);
+            cmd.SetRayTracingTextureParam(parameters.pathTracingShader, HDShaderIDs._SkyCameraTexture, skyTexture);
             cmd.SetRayTracingTextureParam(parameters.pathTracingShader, HDShaderIDs._SkyTexture, parameters.skyReflection);
 
             // Additional data for path tracing
-            cmd.SetRayTracingTextureParam(parameters.pathTracingShader, HDShaderIDs._RadianceTexture, radianceTexture);
+            cmd.SetRayTracingTextureParam(parameters.pathTracingShader, HDShaderIDs._FrameTexture, frameTexture);
             cmd.SetRayTracingMatrixParam(parameters.pathTracingShader, HDShaderIDs._PixelCoordToViewDirWS, parameters.pixelCoordToViewDirWS);
             cmd.SetRayTracingVectorParam(parameters.pathTracingShader, HDShaderIDs._PathTracedDoFConstants, parameters.dofParameters);
 
@@ -306,26 +322,52 @@ class RenderPathTracingData
         {
             public PathTracingParameters parameters;
             public TextureHandle output;
+            public TextureHandle sky;
         }
 
-        TextureHandle RenderPathTracing(RenderGraph renderGraph, in PathTracingParameters parameters, TextureHandle pathTracingBuffer)
+        TextureHandle RenderPathTracing(RenderGraph renderGraph, in PathTracingParameters parameters, TextureHandle pathTracingBuffer, TextureHandle skyBuffer)
         {
             using (var builder = renderGraph.AddRenderPass<RenderPathTracingData>("Render PathTracing", out var passData))
             {
                 passData.parameters = parameters;
                 passData.output = builder.WriteTexture(pathTracingBuffer);
+                passData.sky = builder.ReadTexture(skyBuffer);
 
                 builder.SetRenderFunc(
                     (RenderPathTracingData data, RenderGraphContext ctx) =>
                     {
-                        RenderPathTracing(data.parameters, data.output, ctx.cmd);
+                        RenderPathTracing(data.parameters, data.output, data.sky, ctx.cmd);
                     });
 
                 return passData.output;
             }
         }
 
-        TextureHandle RenderPathTracing(RenderGraph renderGraph, HDCamera hdCamera)
+        // Simpler variant used by path tracing, without depth buffer or volumetric computations
+        void RenderSky(RenderGraph renderGraph, HDCamera hdCamera, TextureHandle skyBuffer)
+        {
+            if (m_CurrentDebugDisplaySettings.DebugHideSky(hdCamera))
+                return;
+
+            using (var builder = renderGraph.AddRenderPass<RenderSkyPassData>("Render Sky for Path Tracing", out var passData))
+            {
+                passData.visualEnvironment = hdCamera.volumeStack.GetComponent<VisualEnvironment>();
+                passData.sunLight = GetCurrentSunLight();
+                passData.hdCamera = hdCamera;
+                passData.colorBuffer = builder.WriteTexture(skyBuffer);
+                passData.depthTexture = builder.WriteTexture(CreateDepthBuffer(renderGraph, true, false));
+                passData.debugDisplaySettings = m_CurrentDebugDisplaySettings;
+                passData.skyManager = m_SkyManager;
+
+                builder.SetRenderFunc(
+                    (RenderSkyPassData data, RenderGraphContext context) =>
+                    {
+                        data.skyManager.RenderSky(data.hdCamera, data.sunLight, data.colorBuffer, data.depthTexture, data.debugDisplaySettings, context.cmd);
+                    });
+            }
+        }
+
+        TextureHandle RenderPathTracing(RenderGraph renderGraph, HDCamera hdCamera, TextureHandle colorBuffer)
         {
             RayTracingShader pathTracingShader = m_Asset.renderPipelineRayTracingResources.pathTracing;
             m_PathTracingSettings = hdCamera.volumeStack.GetComponent<PathTracing>();
@@ -336,34 +378,33 @@ TextureHandle RenderPathTracing(RenderGraph renderGraph, HDCamera hdCamera)
 
             CheckDirtiness(hdCamera);
 
-            var parameters = PreparePathTracingParameters(hdCamera);
-            TextureHandle outputTexture = CreateColorBuffer(renderGraph, hdCamera, false);
-            // TODO RENDERGRAPH: This texture needs to be persistent
-            // (apparently it only matters for some tests, loading a regular scene with pathtracing works even if this one is not persistent)
-            // So we need to import a regular RTHandle. This is not good because it means the texture will always be allocate even if not used...
-            // Refactor that when we formalize how to handle persistent textures better (with automatic lifetime and such).
-            var radianceTexture = renderGraph.ImportTexture(m_RadianceTexture);
-
             if (!m_SubFrameManager.isRecording)
             {
                 // If we are recording, the max iteration is set/overridden by the subframe manager, otherwise we read it from the path tracing volume
                 m_SubFrameManager.subFrameCount = (uint)m_PathTracingSettings.maximumSamples.value;
             }
 
-
 #if UNITY_HDRP_DXR_TESTS_DEFINE
             if (Application.isPlaying)
                 m_SubFrameManager.subFrameCount = 1;
 #endif
 
+            var parameters = PreparePathTracingParameters(hdCamera);
             if (parameters.cameraData.currentIteration < m_SubFrameManager.subFrameCount)
             {
-                RenderPathTracing(m_RenderGraph, parameters, radianceTexture);
+                // Keep a sky texture around, that we compute only once per accumulation (except when recording, with potential camera motion blur)
+                if (m_RenderSky || m_SubFrameManager.isRecording)
+                {
+                    RenderSky(m_RenderGraph, hdCamera, m_SkyTexture);
+                    m_RenderSky = false;   
+                }
+
+                RenderPathTracing(m_RenderGraph, parameters, m_FrameTexture, m_SkyTexture);
             }
 
-            RenderAccumulation(m_RenderGraph, hdCamera, radianceTexture, outputTexture, true);
+            RenderAccumulation(m_RenderGraph, hdCamera, m_FrameTexture, colorBuffer, true);
 
-            return outputTexture;
+            return colorBuffer;
         }
     }
 }

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingMain.raytrace

@@ -26,21 +26,23 @@
 float4x4 _PixelCoordToViewDirWS;
 int      _RaytracingCameraSkyEnabled;
 float4   _RaytracingCameraClearColor;
-
-// DoF related parameters
-float4   _PathTracedDoFConstants; // x: aperture radius, y: focus distance, zw: unused
+TEXTURE2D_X(_SkyCameraTexture);
 
 // Output(s)
-RWTexture2D<float4> _RadianceTexture;
+RW_TEXTURE2D_X(float4, _FrameTexture);
+
+// DoF related parameters
+float4 _PathTracedDoFConstants; // x: aperture radius, y: focus distance, zw: unused
 
 [shader("miss")]
 void MissCamera(inout PathIntersection pathIntersection : SV_RayPayload)
 {
     bool skyEnabled = _EnvLightSkyEnabled && _RaytracingCameraSkyEnabled;
-    pathIntersection.value = skyEnabled ? SampleSkyTexture(WorldRayDirection(), 0.0, 0).xyz : _RaytracingCameraClearColor.xyz * GetInverseCurrentExposureMultiplier();
-    pathIntersection.alpha = skyEnabled ? 1.0 : _RaytracingCameraClearColor.w;
+    float4 missColor = skyEnabled ? _SkyCameraTexture[COORD_TEXTURE2D_X(pathIntersection.pixelCoord)] : _RaytracingCameraClearColor;
+    pathIntersection.value = missColor.xyz * GetInverseCurrentExposureMultiplier();
+    pathIntersection.alpha = missColor.w;
 
-    ApplyFogAttenuation(WorldRayOrigin(), WorldRayDirection(), pathIntersection.value);
+    ApplyFogAttenuation(WorldRayOrigin(), WorldRayDirection(), pathIntersection.value, pathIntersection.alpha);
 
     if (_EnableVolumetricFog && _RaytracingMinRecursion <= 1)
     {
@@ -149,7 +151,7 @@ void RayGen()
     // Evaluate the ray intersection
     TraceRay(_RaytracingAccelerationStructure, RAY_FLAG_CULL_BACK_FACING_TRIANGLES, RAYTRACINGRENDERERFLAG_PATH_TRACING, 0, 1, 0, rayDescriptor, pathIntersection);
 
-    _RadianceTexture[currentPixelCoord] = float4(pathIntersection.value, pathIntersection.alpha);
+    _FrameTexture[COORD_TEXTURE2D_X(currentPixelCoord)] = float4(pathIntersection.value, pathIntersection.alpha);
 }
 
 // This should never be called, return magenta just in case

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/Shaders/Common/AtmosphericScatteringRayTracing.hlsl

@@ -35,4 +35,21 @@ void ApplyFogAttenuation(float3 origin, float3 direction, inout float3 value)
     }
 }
 
+void ApplyFogAttenuation(float3 origin, float3 direction, inout float3 value, inout float alpha)
+{
+    if (_FogEnabled)
+    {
+        float dist = min(_MipFogFar, _MaxFogDistance);
+        float absFogBaseHeight = _HeightFogBaseHeight;
+        float fogTransmittance = TransmittanceHeightFog(_HeightFogBaseExtinction, absFogBaseHeight, _HeightFogExponents, direction.y, origin.y, dist);
+
+        // This is designed to match the raster volumes... even though I'm not sure why it's working that way
+        float3 fogColor = !_EnableVolumetricFog ?
+            GetFogColor(-direction, dist) * _HeightFogBaseScattering.xyz / _HeightFogBaseExtinction :
+            0.0;
+        value = lerp(fogColor, value, fogTransmittance);
+        alpha = saturate(1.0 - fogTransmittance);
+    }
+}
+
 #endif // UNITY_ATMOSPHERIC_SCATTERING_RAY_TRACING_INCLUDED