Internal/6000.2/staging

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeGIBaking.Placement.cs

@@ -164,7 +164,7 @@ static ProbeSubdivisionResult GetWorldSubdivision(ref bool canceledByUser)
                 return GetBricksFromLoaded();
 
             var ctx = PrepareProbeSubdivisionContext();
-            return BakeBricks(ctx, m_BakingBatch.contributors, ref canceledByUser);
+            return BakeBricks(ctx, m_BakingBatch.contributors, showProgress: true, ref canceledByUser);
         }
 
         static NativeList<Vector3> ApplySubdivisionResults(ProbeSubdivisionResult results, ref bool canceledByUser)
@@ -319,7 +319,7 @@ static internal ProbeSubdivisionContext PrepareProbeSubdivisionContext(bool live
             return ctx;
         }
 
-        static internal ProbeSubdivisionResult BakeBricks(ProbeSubdivisionContext ctx, in GIContributors contributors, ref bool canceledByUser)
+        static internal ProbeSubdivisionResult BakeBricks(ProbeSubdivisionContext ctx, in GIContributors contributors, bool showProgress, ref bool canceledByUser)
         {
             var result = new ProbeSubdivisionResult();
 
@@ -334,7 +334,7 @@ static internal ProbeSubdivisionResult BakeBricks(ProbeSubdivisionContext ctx, i
                 // subdivide all the cells and generate brick positions
                 foreach (var cell in ctx.cells)
                 {
-                    if (cellIdx++ % freq == 0)  // Don't refresh progress bar at every iteration because it's slow
+                    if (showProgress && cellIdx++ % freq == 0)  // Don't refresh progress bar at every iteration because it's slow
                     {
                         if (EditorUtility.DisplayCancelableProgressBar("Generating Probe Volume Bricks", $"Processing cell {cellIdx} out of {ctx.cells.Count}", Mathf.Lerp(progress0, progress1, cellIdx / (float)ctx.cells.Count)))
                         {

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeSubdivisionContext.cs

@@ -53,7 +53,7 @@ static void UpdateRealtimeSubdivisionDebug()
                     if (s_CurrentSubdivision == null)
                     {
                         // Start a new Subdivision
-                        s_CurrentSubdivision = Subdivide();
+                        s_CurrentSubdivision = Subdivide(showProgress: false);
                     }
 
                     // Step the subdivision with the amount of cell per frame in debug menu
@@ -71,7 +71,7 @@ static void UpdateRealtimeSubdivisionDebug()
                         }
                     }
 
-                    IEnumerator Subdivide()
+                    IEnumerator Subdivide(bool showProgress)
                     {
                         var ctx = AdaptiveProbeVolumes.PrepareProbeSubdivisionContext(true);
                         var contributors = GIContributors.Find(GIContributors.ContributorFilter.All);
@@ -115,7 +115,7 @@ IEnumerator Subdivide()
                             ctx.cells.Add(cell);
 
                             bool canceledByUser = false;
-                            var result = AdaptiveProbeVolumes.BakeBricks(ctx, contributors, ref canceledByUser);
+                            var result = AdaptiveProbeVolumes.BakeBricks(ctx, contributors, showProgress, ref canceledByUser);
 
                             if (result.cells.Count != 0)
                                 ProbeReferenceVolume.instance.realtimeSubdivisionInfo[cell.bounds] = result.cells[0].bricks;

Packages/com.unity.render-pipelines.core/Editor/PostProcessing/LensFlareDataSRPEditor.cs

@@ -760,7 +760,7 @@ void DrawSummary(Rect summaryRect, SerializedProperty element, int index)
             {
                 SerializedProperty lensFlareDataSRP = element.FindPropertyRelative("lensFlareDataSRP");
                 fieldRect.MoveNext();
-                EditorGUI.PropertyField(fieldRect.Current, lensFlareDataSRP, Styles.lensFlareDataSRP);
+                DrawLensFlareDataSRPFieldWithCycleDetection(fieldRect.Current, lensFlareDataSRP, Styles.lensFlareDataSRP);
                 EditorGUIUtility.labelWidth = oldLabelWidth;
                 return;
             }
@@ -918,7 +918,7 @@ void DrawTypeCathegory(ref Rect remainingRect, SerializedProperty element)
                     {
                         SerializedProperty lensFlareDataSRP = element.FindPropertyRelative("lensFlareDataSRP");
                         fieldRect.MoveNext();
-                        EditorGUI.PropertyField(fieldRect.Current, lensFlareDataSRP, Styles.lensFlareDataSRP);
+                        DrawLensFlareDataSRPFieldWithCycleDetection(fieldRect.Current, lensFlareDataSRP, Styles.lensFlareDataSRP);
                     }
                 break;
             }
@@ -1247,6 +1247,67 @@ T GetEnum<T>(SerializedProperty property)
 
         void SetEnum<T>(SerializedProperty property, T value)
             => property.intValue = (int)(object)value;
+
+        void DrawLensFlareDataSRPFieldWithCycleDetection(Rect rect, SerializedProperty lensFlareDataSRPProperty, GUIContent label)
+        {
+            LensFlareDataSRP currentAsset = target as LensFlareDataSRP;
+
+            EditorGUI.BeginChangeCheck();
+            LensFlareDataSRP newValue = EditorGUI.ObjectField(rect, label, lensFlareDataSRPProperty.objectReferenceValue, typeof(LensFlareDataSRP), false) as LensFlareDataSRP;
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                // Check for cycles before setting the value
+                bool wouldCreateCycle = false;
+
+                if (newValue != null && currentAsset != null)
+                {
+                    // Direct self-reference check
+                    if (currentAsset == newValue)
+                    {
+                        wouldCreateCycle = true;
+                    }
+                    else
+                    {
+                        // Multi-level cycle check - see if newValue already references currentAsset
+                        HashSet<LensFlareDataSRP> visited = new HashSet<LensFlareDataSRP>();
+
+                        // Recursive function to check if targetAsset is found in asset's dependency chain
+                        bool CheckCycle(LensFlareDataSRP asset, LensFlareDataSRP targetAsset)
+                        {
+                            if (asset == null || visited.Contains(asset))
+                                return false;
+
+                            visited.Add(asset);
+
+                            foreach (var element in asset.elements)
+                            {
+                                if (element.flareType == SRPLensFlareType.LensFlareDataSRP && element.lensFlareDataSRP != null)
+                                {
+                                    if (element.lensFlareDataSRP == targetAsset || CheckCycle(element.lensFlareDataSRP, targetAsset))
+                                        return true;
+                                }
+                            }
+                            return false;
+                        }
+
+                        wouldCreateCycle = CheckCycle(newValue, currentAsset);
+                    }
+                }
+
+                if (wouldCreateCycle)
+                {
+                    // Cycle detected - set to null and show a warning
+                    lensFlareDataSRPProperty.objectReferenceValue = null;
+                    Debug.LogWarning($"Cannot assign lens flare asset '{newValue.name}' because it would create a cyclic dependency. Setting to null to prevent infinite loop.");
+                }
+                else
+                {
+                    lensFlareDataSRPProperty.objectReferenceValue = newValue;
+                }
+            }
+        }
+
         #endregion
     }
 }

Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/InstanceCuller.cs

@@ -848,7 +848,7 @@ unsafe public void Execute()
                     allocInfo.drawCount = outIndirectCommandIndex;
                     allocInfo.instanceCount = outIndirectVisibleInstanceIndex;
 
-                    int drawAllocCount = allocInfo.drawCount + IndirectBufferContextStorage.kExtraDrawAllocationCount;
+                    int drawAllocCount = allocInfo.drawCount;
                     int drawAllocEnd = Interlocked.Add(ref UnsafeUtility.AsRef<int>(allocCounters + (int)IndirectAllocator.NextDrawIndex), drawAllocCount);
                     allocInfo.drawAllocIndex = drawAllocEnd - drawAllocCount;
 
@@ -1758,6 +1758,7 @@ private static class ShaderIDs
             public static readonly int InstanceOcclusionCullerShaderVariables = Shader.PropertyToID("InstanceOcclusionCullerShaderVariables");
             public static readonly int _DrawInfo = Shader.PropertyToID("_DrawInfo");
             public static readonly int _InstanceInfo = Shader.PropertyToID("_InstanceInfo");
+            public static readonly int _DispatchArgs = Shader.PropertyToID("_DispatchArgs");
             public static readonly int _DrawArgs = Shader.PropertyToID("_DrawArgs");
             public static readonly int _InstanceIndices = Shader.PropertyToID("_InstanceIndices");
             public static readonly int _InstanceDataBuffer = Shader.PropertyToID("_InstanceDataBuffer");
@@ -2091,7 +2092,7 @@ public unsafe JobHandle CreateCullJobTree(
                     cullingOutput = cullingOutput.drawCommands,
                     indirectBufferLimits = indirectBufferLimits,
                     visibleInstancesBufferHandle = m_IndirectStorage.visibleInstanceBufferHandle,
-                    indirectArgsBufferHandle = m_IndirectStorage.indirectArgsBufferHandle,
+                    indirectArgsBufferHandle = m_IndirectStorage.indirectDrawArgsBufferHandle,
                     indirectBufferAllocInfo = indirectBufferAllocInfo,
                     indirectInstanceInfoGlobalArray = m_IndirectStorage.instanceInfoGlobalArray,
                     indirectDrawInfoGlobalArray = m_IndirectStorage.drawInfoGlobalArray,
@@ -2386,7 +2387,7 @@ internal void EnsureValidOcclusionTestResults(int viewInstanceID)
                     int kernel = m_CopyInstancesKernel;
                     cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawInfo, m_IndirectStorage.drawInfoBuffer);
                     cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._InstanceInfo, m_IndirectStorage.instanceInfoBuffer);
-                    cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawArgs, m_IndirectStorage.argsBuffer);
+                    cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawArgs, m_IndirectStorage.drawArgsBuffer);
                     cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._InstanceIndices, m_IndirectStorage.instanceBuffer);
 
                     cmd.DispatchCompute(cs, kernel, (allocInfo.instanceCount + 63) / 64, 1, 1);
@@ -2539,10 +2540,10 @@ private void AddOcclusionCullingDispatch(
                         if (doCopyInstances)
                         {
                             int kernel = m_CopyInstancesKernel;
-                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawInfo, m_IndirectStorage.drawInfoBuffer);
-                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._InstanceInfo, m_IndirectStorage.instanceInfoBuffer);
-                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawArgs, m_IndirectStorage.argsBuffer);
-                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._InstanceIndices, m_IndirectStorage.instanceBuffer);
+                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawInfo, bufferHandles.drawInfoBuffer);
+                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._InstanceInfo, bufferHandles.instanceInfoBuffer);
+                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawArgs, bufferHandles.drawArgsBuffer);
+                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._InstanceIndices, bufferHandles.instanceBuffer);
 
                             cmd.DispatchCompute(cs, kernel, (allocInfo.instanceCount + 63) / 64, 1, 1);
                         }
@@ -2551,7 +2552,10 @@ private void AddOcclusionCullingDispatch(
                         {
                             int kernel = m_ResetDrawArgsKernel;
                             cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawInfo, bufferHandles.drawInfoBuffer);
-                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawArgs, bufferHandles.argsBuffer);
+                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawArgs, bufferHandles.drawArgsBuffer);
+                            if (isSecondPass)
+                                cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DispatchArgs, bufferHandles.dispatchArgsBuffer);
+
                             cmd.DispatchCompute(cs, kernel, (allocInfo.drawCount + 63) / 64, 1, 1);
                         }
 
@@ -2560,7 +2564,7 @@ private void AddOcclusionCullingDispatch(
                             int kernel = m_CullInstancesKernel;
                             cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawInfo, bufferHandles.drawInfoBuffer);
                             cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._InstanceInfo, bufferHandles.instanceInfoBuffer);
-                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawArgs, bufferHandles.argsBuffer);
+                            cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._DrawArgs, bufferHandles.drawArgsBuffer);
                             cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._InstanceIndices, bufferHandles.instanceBuffer);
                             cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._InstanceDataBuffer, batchersContext.gpuInstanceDataBuffer);
                             cmd.SetComputeBufferParam(cs, kernel, ShaderIDs._OcclusionDebugCounters, m_OcclusionEventDebugArray.CounterBuffer);
@@ -2572,7 +2576,7 @@ private void AddOcclusionCullingDispatch(
                                 OcclusionCullingCommon.SetDebugPyramid(cmd, m_OcclusionTestShader, kernel, occluderHandles);
 
                             if (isSecondPass)
-                                cmd.DispatchCompute(cs, kernel, bufferHandles.argsBuffer, (uint)(GraphicsBuffer.IndirectDrawIndexedArgs.size * allocInfo.GetExtraDrawInfoSlotIndex()));
+                                cmd.DispatchCompute(cs, kernel, bufferHandles.dispatchArgsBuffer, 0);
                             else
                                 cmd.DispatchCompute(cs, kernel, (allocInfo.instanceCount + 63) / 64, 1, 1);
                         }
@@ -2610,6 +2614,7 @@ private void OnEndSceneViewCameraRendering()
 
         public void UpdateFrame(int cameraCount)
         {
+            DisposeSceneViewHiddenBits();
             DisposeCompactVisibilityMasks();
             if (cameraCount > m_LODParamsToCameraID.Capacity)
                 m_LODParamsToCameraID.Capacity = cameraCount;

Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/InstanceOcclusionCuller.cs

@@ -560,22 +560,23 @@ internal struct IndirectBufferContextHandles
     {
         public BufferHandle instanceBuffer;
         public BufferHandle instanceInfoBuffer;
-        public BufferHandle argsBuffer;
+        public BufferHandle dispatchArgsBuffer;
+        public BufferHandle drawArgsBuffer;
         public BufferHandle drawInfoBuffer;
 
         public void UseForOcclusionTest(IBaseRenderGraphBuilder builder)
         {
             instanceBuffer = builder.UseBuffer(instanceBuffer, AccessFlags.ReadWrite);
             instanceInfoBuffer = builder.UseBuffer(instanceInfoBuffer, AccessFlags.Read);
-            argsBuffer = builder.UseBuffer(argsBuffer, AccessFlags.ReadWrite);
+            dispatchArgsBuffer = builder.UseBuffer(dispatchArgsBuffer, AccessFlags.ReadWrite);
+            drawArgsBuffer = builder.UseBuffer(drawArgsBuffer, AccessFlags.ReadWrite);
             drawInfoBuffer = builder.UseBuffer(drawInfoBuffer, AccessFlags.Read);
         }
     }
 
     internal struct IndirectBufferContextStorage : IDisposable
     {
         private const int kAllocatorCount = (int)IndirectAllocator.Count;
-        internal const int kExtraDrawAllocationCount = 1;           // over-allocate by one for indirect args scratch space GPU-side
         internal const int kInstanceInfoGpuOffsetMultiplier = 2;    // GPU side allocates storage for extra copy of instance list
 
         private IndirectBufferLimits m_BufferLimits;
@@ -584,7 +585,8 @@ internal struct IndirectBufferContextStorage : IDisposable
         private GraphicsBuffer m_InstanceInfoBuffer;
         private NativeArray<IndirectInstanceInfo> m_InstanceInfoStaging;
 
-        private GraphicsBuffer m_ArgsBuffer;
+        private GraphicsBuffer m_DispatchArgsBuffer;
+        private GraphicsBuffer m_DrawArgsBuffer;
         private GraphicsBuffer m_DrawInfoBuffer;
         private NativeArray<IndirectDrawInfo> m_DrawInfoStaging;
 
@@ -596,19 +598,21 @@ internal struct IndirectBufferContextStorage : IDisposable
 
         public GraphicsBuffer instanceBuffer { get { return m_InstanceBuffer; } }
         public GraphicsBuffer instanceInfoBuffer { get { return m_InstanceInfoBuffer; } }
-        public GraphicsBuffer argsBuffer { get { return m_ArgsBuffer; } }
+        public GraphicsBuffer dispatchArgsBuffer { get { return m_DispatchArgsBuffer; } }
+        public GraphicsBuffer drawArgsBuffer { get { return m_DrawArgsBuffer; } }
         public GraphicsBuffer drawInfoBuffer { get { return m_DrawInfoBuffer; } }
 
         public GraphicsBufferHandle visibleInstanceBufferHandle { get { return m_InstanceBuffer.bufferHandle; } }
-        public GraphicsBufferHandle indirectArgsBufferHandle { get { return m_ArgsBuffer.bufferHandle; } }
+        public GraphicsBufferHandle indirectDrawArgsBufferHandle { get { return m_DrawArgsBuffer.bufferHandle; } }
 
         public IndirectBufferContextHandles ImportBuffers(RenderGraph renderGraph)
         {
             return new IndirectBufferContextHandles()
             {
                 instanceBuffer = renderGraph.ImportBuffer(m_InstanceBuffer),
                 instanceInfoBuffer = renderGraph.ImportBuffer(m_InstanceInfoBuffer),
-                argsBuffer = renderGraph.ImportBuffer(m_ArgsBuffer),
+                dispatchArgsBuffer = renderGraph.ImportBuffer(m_DispatchArgsBuffer),
+                drawArgsBuffer = renderGraph.ImportBuffer(m_DrawArgsBuffer),
                 drawInfoBuffer = renderGraph.ImportBuffer(m_DrawInfoBuffer),
             };
         }
@@ -653,15 +657,18 @@ void FreeInstanceBuffers()
 
         void AllocateDrawBuffers(int maxDrawCount)
         {
-            m_ArgsBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured | GraphicsBuffer.Target.IndirectArguments, (maxDrawCount + kExtraDrawAllocationCount) * (GraphicsBuffer.IndirectDrawIndexedArgs.size / sizeof(int)), sizeof(int));
+            // Compute dispatch arguments are number of thread groups in X,Y and Z dimensions, hence 3 integers for the size.
+            m_DispatchArgsBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured | GraphicsBuffer.Target.IndirectArguments, 3, sizeof(int));
+            m_DrawArgsBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured | GraphicsBuffer.Target.IndirectArguments, maxDrawCount * (GraphicsBuffer.IndirectDrawIndexedArgs.size / sizeof(int)), sizeof(int));
             m_DrawInfoBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured, maxDrawCount, System.Runtime.InteropServices.Marshal.SizeOf<IndirectDrawInfo>());
             m_DrawInfoStaging = new NativeArray<IndirectDrawInfo>(maxDrawCount, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
             m_BufferLimits.maxDrawCount = maxDrawCount;
         }
 
         void FreeDrawBuffers()
         {
-            m_ArgsBuffer.Release();
+            m_DispatchArgsBuffer.Release();
+            m_DrawArgsBuffer.Release();
             m_DrawInfoBuffer.Release();
             m_DrawInfoStaging.Dispose();
             m_BufferLimits.maxDrawCount = 0;