RenderGraph - Fix "Cannot return local 'actualPasses'" error

Author: YohannVaastUnity

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/CompilerContextData.cs

@@ -58,6 +58,7 @@ void AllocateNativeDataStructuresIfNeeded(int estimatedNumPasses)
                 // These are risky heuristics that only work because we purposely estimate a very high number of passes
                 // We need to fix this with a proper size computation
                 passData = new NativeList<PassData>(estimatedNumPasses, AllocatorManager.Persistent);
+                compactedNonCulledRasterPasses = new NativeList<PassData>(0, AllocatorManager.Persistent); // Will be resized during the compilation
                 inputData = new NativeList<PassInputData>(estimatedNumPasses * 2, AllocatorManager.Persistent);
                 outputData = new NativeList<PassOutputData>(estimatedNumPasses * 2, AllocatorManager.Persistent);
                 fragmentData = new NativeList<PassFragmentData>(estimatedNumPasses * 4, AllocatorManager.Persistent);
@@ -87,6 +88,7 @@ public void Clear()
             if (m_AreNativeListsAllocated)
             {
                 passData.Clear();
+                compactedNonCulledRasterPasses.Clear();
                 fences.Clear();
                 inputData.Clear();
                 outputData.Clear();
@@ -139,6 +141,7 @@ public ref ResourceReaderData ResourceReader(in ResourceHandle h, int i)
 
         // Data per graph level renderpass
         public NativeList<PassData> passData;
+        public NativeList<PassData> compactedNonCulledRasterPasses;
         public Dictionary<int, GraphicsFence> fences;
         public DynamicArray<Name> passNames;
 
@@ -369,6 +372,7 @@ void Cleanup()
             if (m_AreNativeListsAllocated)
             {
                 passData.Dispose();
+                compactedNonCulledRasterPasses.Dispose();
                 inputData.Dispose();
                 outputData.Dispose();
                 fragmentData.Dispose();

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/NativePassCompiler.cs

@@ -35,6 +35,9 @@ internal struct RenderGraphInputInfo
 
         NativeList<AttachmentDescriptor> m_BeginRenderPassAttachments;
 
+        // Contains the index of the non culled passes for native render passes that has at least one pass culled.
+        NativeList<int> m_NonCulledPassIndicesForRasterPasses;
+
         internal static bool s_ForceGenerateAuditsForTests = false;
 
         public NativePassCompiler(RenderGraphCompilationCache cache)
@@ -76,6 +79,11 @@ public void Cleanup()
             {
                 m_BeginRenderPassAttachments.Dispose();
             }
+
+            if (m_NonCulledPassIndicesForRasterPasses.IsCreated)
+            {
+                m_NonCulledPassIndicesForRasterPasses.Dispose();
+            }
         }
 
         public bool Initialize(RenderGraphResourceRegistry resources, List<RenderGraphPass> renderPasses, RenderGraphDebugParams debugParams, string debugName, bool useCompilationCaching,
@@ -155,6 +163,8 @@ public void Compile(RenderGraphResourceRegistry resources)
 
             if (graph.renderTextureUVOriginStrategy == RenderTextureUVOriginStrategy.PropagateAttachmentOrientation)
                 PropagateTextureUVOrigin();
+
+            CompactNonCulledPassesForRasterPasses();
         }
 
         public void Clear(bool clearContextData)
@@ -632,6 +642,9 @@ void TryMergeNativePasses()
 #if UNITY_EDITOR || DEVELOPMENT_BUILD
                 bool generatePassBreakAudits = RenderGraphDebugSession.hasActiveDebugSession || s_ForceGenerateAuditsForTests;
 #endif
+                int indexSinceLastCulledPass = 0;
+                bool passWasCulled = false;
+                bool nonCulledPassIndicesListWasCleared = false;
 
                 for (var passIdx = 0; passIdx < ctx.passData.Length; ++passIdx)
                 {
@@ -640,6 +653,7 @@ void TryMergeNativePasses()
                     // If the pass has been culled, just ignore it
                     if (passToAdd.culled)
                     {
+                        passWasCulled = true;
                         continue;
                     }
 
@@ -653,6 +667,9 @@ void TryMergeNativePasses()
                             ctx.nativePassData.Add(new NativePassData(ref passToAdd, ctx));
                             passToAdd.nativePassIndex = ctx.nativePassData.LastIndex();
                             activeNativePassId = passToAdd.nativePassIndex;
+
+                            indexSinceLastCulledPass = passIdx;
+                            passWasCulled = false;
                         }
                     }
                     // There is an native pass currently open, try to add the current graph pass to it
@@ -684,10 +701,25 @@ void TryMergeNativePasses()
                                 passToAdd.nativePassIndex = ctx.nativePassData.LastIndex();
                                 activeNativePassId = passToAdd.nativePassIndex;
                             }
+
+                            if (passWasCulled)
+                            {
+                                CollectNonCulledPassIndicesForRasterPasses(passIdx, indexSinceLastCulledPass, mergeTestResult.reason != PassBreakReason.NonRasterPass, !nonCulledPassIndicesListWasCleared);
+                                passWasCulled = false;
+                                nonCulledPassIndicesListWasCleared = true;
+                            }
+
+                            indexSinceLastCulledPass = passIdx;
                         }
                     }
                 }
 
+                // Handle the last native pass
+                if (passWasCulled)
+                {
+                    CollectNonCulledPassIndicesForRasterPasses(ctx.passData.Length, indexSinceLastCulledPass, clearList: !nonCulledPassIndicesListWasCleared);
+                }
+
                 if (activeNativePassId >= 0)
                 {
                     // "Close" the last native pass by marking the last graph pass as end
@@ -703,6 +735,66 @@ void TryMergeNativePasses()
             }
         }
 
+        void CollectNonCulledPassIndicesForRasterPasses(int currentPassIdx, int indexSinceLastCulledPass, bool usePreviousNativePass = false, bool clearList = false)
+        {
+            var ctx = contextData;
+
+            // In some cases, we create a new native render pass (we allocate a new stand-alone native renderpass based on the current pass)
+            // but we need to update the data of the previous native pass and not the newly one created.
+            var indexLastNativePassData = (usePreviousNativePass) ? ctx.nativePassData.LastIndex() - 1 : ctx.nativePassData.LastIndex();
+
+            // In case we have a graph without any render pass.
+            if (indexLastNativePassData == -1)
+                return;
+
+            // Filling the attachments array to be sent to the rendering command buffer
+            if (!m_NonCulledPassIndicesForRasterPasses.IsCreated)
+            {
+                m_NonCulledPassIndicesForRasterPasses = new NativeList<int>(ctx.passData.Length, Allocator.Persistent);
+            }
+            else if (clearList)
+            {
+                m_NonCulledPassIndicesForRasterPasses.Clear();
+                m_NonCulledPassIndicesForRasterPasses.SetCapacity(ctx.passData.Length);
+            }
+
+            ref var lastNativePassData = ref ctx.nativePassData.ElementAt(indexLastNativePassData);
+            lastNativePassData.firstCompactedNonCulledRasterPass = m_NonCulledPassIndicesForRasterPasses.Length;
+
+            // The native pass has at least one pass culled, so we iterate over each pass to retrieve
+            // the index of the non culled pass, so they can be copied later on in a new NativeList that
+            // will be contiguous in memory.
+            for (var nonCulledPassIdx = 0; nonCulledPassIdx < currentPassIdx - indexSinceLastCulledPass; ++nonCulledPassIdx)
+            {
+                ref var passToCopy = ref ctx.passData.ElementAt(indexSinceLastCulledPass + nonCulledPassIdx);
+
+                if (!passToCopy.culled)
+                {
+                    m_NonCulledPassIndicesForRasterPasses.Add(indexSinceLastCulledPass + nonCulledPassIdx);
+                }
+            }
+
+            lastNativePassData.lastCompactedNonCulledRasterPass = m_NonCulledPassIndicesForRasterPasses.Length - 1;
+        }
+
+        // Must be called at the end of the compilation, when PassData is not modified anymore.
+        void CompactNonCulledPassesForRasterPasses()
+        {
+            if (!m_NonCulledPassIndicesForRasterPasses.IsCreated || m_NonCulledPassIndicesForRasterPasses.Length == 0)
+                return;
+
+            var ctx = contextData;
+            ctx.compactedNonCulledRasterPasses.ResizeUninitialized(m_NonCulledPassIndicesForRasterPasses.Length);
+
+            // Copy and cache only the PassData that were not contiguous in memory because of culling.
+            // They are copied in a new NativeArray that is contiguous in memory so we avoid further copies
+            // later at many places (Initialize, Destroy, etc.) by using directly a ReadOnlySpan of this array.
+            for (int i = 0; i < m_NonCulledPassIndicesForRasterPasses.Length; ++i)
+            {
+                ctx.compactedNonCulledRasterPasses[i] = ctx.passData.ElementAt(m_NonCulledPassIndicesForRasterPasses[i]);
+            }
+        }
+
         bool FindFirstPassIdOnGraphicsQueueAwaitingFenceGoingForward(ref PassData startAsyncPass, out int firstPassIdAwaiting)
         {
             var ctx = contextData;

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/PassesData.cs

@@ -668,6 +668,9 @@ internal struct NativePassData
         public int lastGraphPass;
         public int numGraphPasses;
 
+        public int firstCompactedNonCulledRasterPass;
+        public int lastCompactedNonCulledRasterPass;
+
         public int firstNativeSubPass; // Offset+count in context subpass array
         public int numNativeSubPasses;
         public int width;
@@ -693,6 +696,8 @@ public NativePassData(ref PassData pass, CompilerContextData ctx)
             numGraphPasses = 1;
             firstNativeSubPass = -1; // Set up during compile
             numNativeSubPasses = 0;
+            firstCompactedNonCulledRasterPass = -1;
+            lastCompactedNonCulledRasterPass = -1;
 
             fragments = new FixedAttachmentArray<PassFragmentData>();
             attachments = new FixedAttachmentArray<NativePassAttachment>();
@@ -768,6 +773,8 @@ public void Clear()
         {
             firstGraphPass = 0;
             numGraphPasses = 0;
+            firstCompactedNonCulledRasterPass = -1;
+            lastCompactedNonCulledRasterPass = -1;
             attachments.Clear();
             fragments.Clear();
             loadAudit.Clear();
@@ -780,6 +787,7 @@ public readonly bool IsValid()
             return numGraphPasses > 0;
         }
 
+        // This method cannot be called during the Compile step.
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public readonly ReadOnlySpan<PassData> GraphPasses(CompilerContextData ctx)
         {
@@ -789,20 +797,9 @@ public readonly ReadOnlySpan<PassData> GraphPasses(CompilerContextData ctx)
                 return ctx.passData.MakeReadOnlySpan(firstGraphPass, numGraphPasses);
             }
 
-            var actualPasses =
-                new NativeArray<PassData>(numGraphPasses, Allocator.Temp,
-                    NativeArrayOptions.UninitializedMemory);
+            Debug.Assert(!ctx.compactedNonCulledRasterPasses.IsEmpty);
 
-            for (int i = firstGraphPass, index = 0; i < lastGraphPass + 1; ++i)
-            {
-                var pass = ctx.passData[i];
-                if (!pass.culled)
-                {
-                    actualPasses[index++] = pass;
-                }
-            }
-
-            return actualPasses;
+            return ctx.compactedNonCulledRasterPasses.MakeReadOnlySpan(firstCompactedNonCulledRasterPass, lastCompactedNonCulledRasterPass - firstCompactedNonCulledRasterPass + 1);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -953,9 +950,12 @@ public static PassBreakAudit CanMerge(CompilerContextData contextData, int activ
                 // Temporary cache of sampled textures in current Native Render Pass for conflict detection against fragments
                 using (HashSetPool<int>.Get(out var tempSampledTextures))
                 {
-                    var graphPasses = nativePass.GraphPasses(contextData);
-                    foreach (ref readonly var graphPass in graphPasses)
+                    for (int i = nativePass.firstGraphPass; i < nativePass.lastGraphPass + 1; ++i)
                     {
+                        ref var graphPass = ref contextData.passData.ElementAt(i);
+                        if (graphPass.culled)
+                            continue;
+
                         if (graphPass.numSampledOnlyRaster > 0) // Skip passes with no sampled textures
                         {
                             foreach (ref readonly var earlierInput in graphPass.SampledTexturesIfRaster(contextData))