Fix graphics corruption when enabling live subdivision

Fix this:
![image](https://media.github.cds.internal.unity3d.com/user/745/files/17568716-a6be-4a3a-8263-3f36e084ec42)

Author: Antoine Lelièvre

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

@@ -44,8 +44,8 @@ public class GPUSubdivisionContext : IDisposable
             public RenderTexture dummyRenderTarget;
 
             public ComputeBuffer probeVolumesBuffer;
+            public ComputeBuffer brickCountBuffer;
             public ComputeBuffer[] bricksBuffers;
-            public ComputeBuffer[] readbackCountBuffers;
 
             public Vector4[] brickPositions;
 
@@ -91,14 +91,14 @@ public GPUSubdivisionContext(int probeVolumeCount, ProbeVolumeProfileInfo profil
                 maxSubdivisionLevelInSubCell = Mathf.Min(maxSubdivisionLevel, k_MaxSubdivisionInSubCell);
                 maxBrickCountPerAxisInSubCell = (int)Mathf.Pow(3, maxSubdivisionLevelInSubCell);
                 bricksBuffers = new ComputeBuffer[maxSubdivisionLevelInSubCell + 1];
-                readbackCountBuffers = new ComputeBuffer[maxSubdivisionLevelInSubCell + 1];
                 for (int i = 0; i <= maxSubdivisionLevelInSubCell; i++)
                 {
                     int brickCountPerAxis = (int)Mathf.Pow(3, maxSubdivisionLevelInSubCell - i);
-                    bricksBuffers[i] = new ComputeBuffer(brickCountPerAxis * brickCountPerAxis * brickCountPerAxis, sizeof(float) * 4, ComputeBufferType.Append);
-                    readbackCountBuffers[i] = new ComputeBuffer(1, sizeof(int), ComputeBufferType.Raw);
+                    bricksBuffers[i] = new ComputeBuffer(brickCountPerAxis * brickCountPerAxis * brickCountPerAxis, sizeof(float) * 4, ComputeBufferType.Structured);
                 }
 
+                brickCountBuffer = new ComputeBuffer(maxSubdivisionLevelInSubCell + 1, sizeof(uint), ComputeBufferType.Structured);
+
                 brickPositions = new Vector4[maxBrickCountPerAxisInSubCell * maxBrickCountPerAxisInSubCell * maxBrickCountPerAxisInSubCell];
             }
 
@@ -108,16 +108,16 @@ public void Dispose()
                 RenderTexture.ReleaseTemporary(sceneSDF2);
                 RenderTexture.ReleaseTemporary(dummyRenderTarget);
                 probeVolumesBuffer.Release();
+                brickCountBuffer.Release();
 
                 for (int i = 0; i <= maxSubdivisionLevelInSubCell; i++)
-                {
                     bricksBuffers[i].Release();
-                    readbackCountBuffers[i].Release();
-                }
             }
         }
 
         static readonly int _BricksToClear = Shader.PropertyToID("_BricksToClear");
+        static readonly int _BricksToClearCount = Shader.PropertyToID("_BricksToClearCount");
+        static readonly int _BrickCountBuffer = Shader.PropertyToID("_BrickCountBuffer");
         static readonly int _Output = Shader.PropertyToID("_Output");
         static readonly int _OutputSize = Shader.PropertyToID("_OutputSize");
         static readonly int _VolumeWorldOffset = Shader.PropertyToID("_VolumeWorldOffset");
@@ -356,6 +356,9 @@ static void SubdivideSubCell(Bounds cellAABB, ProbeSubdivisionContext subdivisio
             var probeSubdivisionData = ctx.sceneSDF2;
             VoxelizeProbeVolumeData(cmd, cellAABB, probeVolumes, ctx);
 
+            // Clear the brick counter, equivalent to SetBufferCounterValue(0) but we can't use append buffers
+            cmd.SetBufferData(ctx.brickCountBuffer, new int[ctx.maxSubdivisionLevelInSubCell + 1]);
+
             // Find the maximum subdivision level we can have in this cell (avoid extra work if not needed)
             int globalMaxSubdiv = ProbeVolumeBakingSet.GetMaxSubdivision(ctx.maxSubdivisionLevel);
             int startSubdivisionLevel = Mathf.Max(0, ctx.maxSubdivisionLevelInSubCell - GetMaxSubdivision(ctx, probeVolumes.Max(p => p.component.GetMaxSubdivMultiplier(globalMaxSubdiv))));
@@ -364,22 +367,21 @@ static void SubdivideSubCell(Bounds cellAABB, ProbeSubdivisionContext subdivisio
                 // Add the bricks from the probe volume min subdivision level:
                 int brickCountPerAxis = (int)Mathf.Pow(3, ctx.maxSubdivisionLevelInSubCell - subdivisionLevel);
                 var bricksBuffer = ctx.bricksBuffers[subdivisionLevel];
-                var brickCountReadbackBuffer = ctx.readbackCountBuffers[subdivisionLevel];
 
                 using (new ProfilingScope(cmd, new ProfilingSampler("Clear Bricks Buffer")))
                 {
                     cmd.SetComputeBufferParam(subdivideSceneCS, s_ClearBufferKernel, _BricksToClear, bricksBuffer);
-                    DispatchCompute(cmd, s_ClearBufferKernel, brickCountPerAxis * brickCountPerAxis * brickCountPerAxis, 1);
-                    cmd.SetBufferCounterValue(bricksBuffer, 0);
+                    int count = brickCountPerAxis * brickCountPerAxis * brickCountPerAxis;
+                    cmd.SetComputeIntParam(subdivideSceneCS, _BricksToClearCount, count);
+                    DispatchCompute(cmd, s_ClearBufferKernel, count, 1);
                 }
 
                 // Generate the list of bricks on the GPU
-                SubdivideFromDistanceField(cmd, cellAABB, ctx, probeSubdivisionData, bricksBuffer, brickCountPerAxis, subdivisionLevel, minBrickSize, cellOffset);
+                SubdivideFromDistanceField(cmd, cellAABB, ctx, probeSubdivisionData, bricksBuffer, ctx.brickCountBuffer, brickCountPerAxis, subdivisionLevel, minBrickSize, cellOffset);
 
-                cmd.CopyCounterValue(bricksBuffer, brickCountReadbackBuffer, 0);
                 // Capture locally the subdivision level to use it inside the lambda
                 int localSubdivLevel = subdivisionLevel;
-                cmd.RequestAsyncReadback(brickCountReadbackBuffer, sizeof(int), 0, (data) => {
+                cmd.RequestAsyncReadback(ctx.brickCountBuffer, sizeof(int), subdivisionLevel * sizeof(int), (data) => {
                     int readbackBrickCount = data.GetData<int>()[0];
 
                     if (readbackBrickCount > 0)
@@ -394,11 +396,13 @@ static void SubdivideSubCell(Bounds cellAABB, ProbeSubdivisionContext subdivisio
                     }
                 });
             }
+            // ExternalGPUProfiler.BeginGPUCapture();
 
             cmd.WaitAllAsyncReadbackRequests();
             Graphics.ExecuteCommandBuffer(cmd);
             cmd.Clear();
             CommandBufferPool.Release(cmd);
+            // ExternalGPUProfiler.EndGPUCapture();
         }
 
         static bool RasterizeGeometry(CommandBuffer cmd, Bounds cellAABB, GPUSubdivisionContext ctx, GIContributors contributors)
@@ -633,7 +637,7 @@ static void VoxelizeProbeVolumeData(CommandBuffer cmd, Bounds cellAABB,
 
         static void SubdivideFromDistanceField(
             CommandBuffer cmd, Bounds volume, GPUSubdivisionContext ctx, RenderTexture probeVolumeData,
-            ComputeBuffer buffer, int brickCount, int subdivisionLevel, float minBrickSize, Vector3 cellOffset)
+            ComputeBuffer buffer, ComputeBuffer brickCountBuffer, int brickCount, int subdivisionLevel, float minBrickSize, Vector3 cellOffset)
         {
             using (new ProfilingScope(cmd, new ProfilingSampler($"Subdivide Bricks at level {Mathf.Log(brickCount, 3)}")))
             {
@@ -642,6 +646,7 @@ static void SubdivideFromDistanceField(
                 Vector3 volumeBrickPosition = (volume.center - volume.extents - cellOffset) / minBrickSize;
                 cmd.SetComputeVectorParam(subdivideSceneCS, _VolumeOffsetInBricks, volumeBrickPosition);
                 cmd.SetComputeBufferParam(subdivideSceneCS, s_SubdivideKernel, _Bricks, buffer);
+                cmd.SetComputeBufferParam(subdivideSceneCS, s_SubdivideKernel, _BrickCountBuffer, brickCountBuffer);
                 cmd.SetComputeVectorParam(subdivideSceneCS, _MaxBrickSize, Vector3.one * brickCount);
                 cmd.SetComputeFloatParam(subdivideSceneCS, _SubdivisionLevel, subdivisionLevel);
                 cmd.SetComputeFloatParam(subdivideSceneCS, _MaxSubdivisionLevel, ctx.maxSubdivisionLevelInSubCell);

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeVolumeSubdivide.compute

@@ -19,7 +19,8 @@ RWTexture3D<float4> _Output;
 RWTexture3D<float4> _FinalOutput;
 
 // Technically float3, but AppendBuffers stride must be a multiple of 4
-AppendStructuredBuffer<float4> _Bricks;
+RWStructuredBuffer<float4> _Bricks;
+RWStructuredBuffer<uint> _BrickCountBuffer;
 RWStructuredBuffer<float3> _BricksToClear;
 
 StructuredBuffer<GPUProbeVolumeOBB> _ProbeVolumes;
@@ -37,6 +38,7 @@ float _SubdivisionLevel;
 float _MaxSubdivisionLevel;
 float _ProbeVolumeCount;
 float _ClearValue;
+uint _BricksToClearCount;
 CBUFFER_END
 
 [numthreads(8,8,1)]
@@ -51,6 +53,9 @@ void Clear(uint3 id : SV_DispatchThreadID)
 [numthreads(64,1,1)]
 void ClearBuffer(uint3 id : SV_DispatchThreadID)
 {
+    if (id.x >=_BricksToClearCount)
+        return;
+
     _BricksToClear[id.x] = 0;
 }
 
@@ -264,6 +269,8 @@ void Subdivide(uint3 id : SV_DispatchThreadID)
     {
         // transform id to world position
         float3 positionInCell = _VolumeOffsetInBricks.xyz + (id / _MaxBrickSize.xyz) * _VolumeSizeInBricks.xyz;
-        _Bricks.Append(float4(positionInCell, 0.0f));
+        uint brickIndex;
+        InterlockedAdd(_BrickCountBuffer[_SubdivisionLevel], 1, brickIndex);
+        _Bricks[brickIndex] = float4(positionInCell, 0.0f);
     }
 }