Add Depth Dependency Logic into RG CopyDepth Path

In the non-RG path, there's specialized logic that ensures the copy depth operation runs before any custom passes that require depth as input. Prior to this change, we didn't have similar logic in the RG path, so we were incorrectly executing some custom passes before the copy depth operation which can produce incorrect results.

This change introduces similar scheduling logic to the RG path to ensure it behaves consistently with the non-RG path in the context of custom pass execution.

Author: gmitrano-unity

Packages/com.unity.render-pipelines.universal/Runtime/ScriptableRenderer.cs

@@ -1202,34 +1202,39 @@ internal virtual void OnFinishRenderGraphRendering(CommandBuffer cmd)
         {
         }
 
-        /// <summary>
-        /// TODO RENDERGRAPH
-        /// </summary>
-        /// <param name="context"></param>
-        /// <param name="renderingData"></param>
-        /// <param name="injectionPoint"></param>
-        internal void RecordCustomRenderGraphPasses(RenderGraph renderGraph, RenderPassEvent injectionPoint)
+        internal void RecordCustomRenderGraphPassesInEventRange(RenderGraph renderGraph, RenderPassEvent eventStart, RenderPassEvent eventEnd)
         {
-            int range = ScriptableRenderPass.GetRenderPassEventRange(injectionPoint);
-            int nextValue = (int) injectionPoint + range;
-
-            foreach (ScriptableRenderPass pass in m_ActiveRenderPassQueue)
+            // Only iterate over the active pass queue if we have a non-empty range
+            if (eventStart != eventEnd)
             {
-                if (pass.renderPassEvent >= injectionPoint && (int) pass.renderPassEvent < nextValue)
-                    pass.RecordRenderGraph(renderGraph, m_frameData);
+                foreach (ScriptableRenderPass pass in m_ActiveRenderPassQueue)
+                {
+                    if (pass.renderPassEvent >= eventStart && pass.renderPassEvent < eventEnd)
+                        pass.RecordRenderGraph(renderGraph, m_frameData);
+                }
             }
         }
 
+        internal void CalculateSplitEventRange(RenderPassEvent startInjectionPoint, RenderPassEvent targetEvent, out RenderPassEvent startEvent, out RenderPassEvent splitEvent, out RenderPassEvent endEvent)
+        {
+            int range = ScriptableRenderPass.GetRenderPassEventRange(startInjectionPoint);
+
+            startEvent = startInjectionPoint;
+            endEvent = startEvent + range;
+
+            splitEvent = (RenderPassEvent)Math.Clamp((int)targetEvent, (int)startEvent, (int)endEvent);
+        }
+
         internal void RecordCustomRenderGraphPasses(RenderGraph renderGraph, RenderPassEvent startInjectionPoint, RenderPassEvent endInjectionPoint)
         {
             int range = ScriptableRenderPass.GetRenderPassEventRange(endInjectionPoint);
-            int nextValue = (int) endInjectionPoint + range;
 
-            foreach (ScriptableRenderPass pass in m_ActiveRenderPassQueue)
-            {
-                if (pass.renderPassEvent >= startInjectionPoint && (int) pass.renderPassEvent < nextValue)
-                    pass.RecordRenderGraph(renderGraph, m_frameData);
-            }
+            RecordCustomRenderGraphPassesInEventRange(renderGraph, startInjectionPoint, endInjectionPoint + range);
+        }
+
+        internal void RecordCustomRenderGraphPasses(RenderGraph renderGraph, RenderPassEvent injectionPoint)
+        {
+            RecordCustomRenderGraphPasses(renderGraph, injectionPoint, injectionPoint);
         }
 
         // ScriptableRenderPass if executed in a critical point (such as in between Deferred and GBuffer) has to have

Packages/com.unity.render-pipelines.universal/Runtime/UniversalRendererRenderGraph.cs

@@ -934,6 +934,21 @@ private void InstanceOcclusionTest(RenderGraph renderGraph, UniversalCameraData
             GPUResidentDrawer.InstanceOcclusionTest(renderGraph, settings, subviewOcclusionTests);
         }
 
+        // Records the depth copy pass along with the specified custom passes in a way that properly handles depth read dependencies
+        private void RecordCustomPassesWithDepthCopy(RenderGraph renderGraph, UniversalResourceData resourceData, RenderPassEvent earliestDepthReadEvent, RenderPassEvent currentEvent)
+        {
+            // Custom passes typically come before built-in passes but there's an exception for passes that require depth.
+            // In cases where custom passes passes may depend on depth, we split the event range and execute the depth copy as late as possible while still ensuring valid depth reads.
+
+            CalculateSplitEventRange(currentEvent, earliestDepthReadEvent, out var startEvent, out var splitEvent, out var endEvent);
+
+            RecordCustomRenderGraphPassesInEventRange(renderGraph, startEvent, splitEvent);
+
+            m_CopyDepthPass.Render(renderGraph, frameData, resourceData.cameraDepthTexture, resourceData.activeDepthTexture, true);
+
+            RecordCustomRenderGraphPassesInEventRange(renderGraph, splitEvent, endEvent);
+        }
+
         private void OnMainRendering(RenderGraph renderGraph, ScriptableRenderContext context)
         {
             UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();
@@ -1134,14 +1149,10 @@ private void OnMainRendering(RenderGraph renderGraph, ScriptableRenderContext co
                 needsOccluderUpdate = false;
             }
 
-            // Custom passes come before built-in passes to keep parity with non-RG code path where custom passes are added before renderer Setup.
-            RecordCustomRenderGraphPasses(renderGraph, RenderPassEvent.AfterRenderingOpaques);
-
             if (requiresDepthCopyPass && m_CopyDepthMode != CopyDepthMode.AfterTransparents)
-            {
-                TextureHandle cameraDepthTexture = resourceData.cameraDepthTexture;
-                m_CopyDepthPass.Render(renderGraph, frameData, cameraDepthTexture, resourceData.activeDepthTexture, true);
-            }
+                RecordCustomPassesWithDepthCopy(renderGraph, resourceData, renderPassInputs.requiresDepthTextureEarliestEvent, RenderPassEvent.AfterRenderingOpaques);
+            else
+                RecordCustomRenderGraphPasses(renderGraph, RenderPassEvent.AfterRenderingOpaques);
 
             // Depends on the camera (copy) depth texture. Depth is reprojected to calculate motion vectors.
             if (renderPassInputs.requiresMotionVectors && m_CopyDepthMode != CopyDepthMode.AfterTransparents)
@@ -1191,12 +1202,10 @@ private void OnMainRendering(RenderGraph renderGraph, ScriptableRenderContext co
                     resourceData.additionalShadowsTexture);
             }
 
-            // Custom passes come before built-in passes to keep parity with non-RG code path where custom passes are added before renderer Setup.
-
-            RecordCustomRenderGraphPasses(renderGraph, RenderPassEvent.AfterRenderingTransparents);
-
             if (requiresDepthCopyPass && m_CopyDepthMode == CopyDepthMode.AfterTransparents)
-                m_CopyDepthPass.Render(renderGraph, frameData, resourceData.cameraDepthTexture, resourceData.activeDepthTexture, true);
+                RecordCustomPassesWithDepthCopy(renderGraph, resourceData, renderPassInputs.requiresDepthTextureEarliestEvent, RenderPassEvent.AfterRenderingTransparents);
+            else
+                RecordCustomRenderGraphPasses(renderGraph, RenderPassEvent.AfterRenderingTransparents);
 
             // TODO: Postprocess pass should be able configure its render pass inputs per camera per frame (settings) BEFORE building any of the graph
             // TODO: Alternatively we could always build the graph (a potential graph) and cull away unused passes if "record + cull" is fast enough.