Graphics/SRP/RPF - [UUM-102113] Fixed Render Graph pass merging with VRS

axoloto · Evergreen · commit 9e9c9bfd20d1 · 2025-09-30T02:54:52.000Z
diff --git a/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/CompilerContextData.cs b/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/CompilerContextData.cs
@@ -180,8 +180,8 @@ public bool TryAddToFragmentList(TextureAccess access, int listFirstIndex, int n
                 }
             }
 
-            // Validate that we're correctly building up the fragment lists we can only append to the last list
-            // not int the middle of lists
+            // Validate that we're correctly building up the fragment lists, we can only append to the last list
+            // not in the middle of the other lists
             Debug.Assert(listFirstIndex + numItems == fragmentData.Length);
 
             fragmentData.Add(new PassFragmentData(
diff --git a/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/NativePassCompiler.cs b/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/NativePassCompiler.cs
@@ -265,16 +265,18 @@ bool TrySetupRasterFragmentList(ref PassData ctxPass, ref RenderGraphPass inputP
                 }
             }
 
-            // shading rate
-            if (inputPass.hasShadingRateImage &&
-                inputPass.shadingRateAccess.textureHandle.handle.IsValid())
+            // shading rate image - this is a specific type of attachment (more of an image resource that can't be sampled, only used by the rasterizer)
+            if (inputPass.hasShadingRateImage && inputPass.shadingRateAccess.textureHandle.handle.IsValid())
             {
-                ctxPass.shadingRateImageIndex = ctx.fragmentData.Length;
-                ctx.TryAddToFragmentList(inputPass.shadingRateAccess, ctxPass.shadingRateImageIndex, 0, out errorMessage);
+                if (ctx.TryAddToFragmentList(inputPass.shadingRateAccess, ctxPass.firstFragment, ctxPass.numFragments, out errorMessage))
+                {
+                    ctxPass.shadingRateImageIndex = ctx.fragmentData.Length - 1;
+                }
 
                 if (errorMessage != null)
                 {
-                    errorMessage = $"when trying to add VRS attachment of type {inputPass.shadingRateAccess.textureHandle.handle.type} at index {inputPass.shadingRateAccess.textureHandle.handle.index} - {errorMessage}";
+                    errorMessage =
+                        $"when trying to add VRS attachment of type {inputPass.shadingRateAccess.textureHandle.handle.type} at index {inputPass.shadingRateAccess.textureHandle.handle.index} - {errorMessage}";
                     return false;
                 }
             }
@@ -287,9 +289,7 @@ bool TrySetupRasterFragmentList(ref PassData ctxPass, ref RenderGraphPass inputP
                 // Skip unused fragment input slots
                 if (!inputPass.fragmentInputAccess[ci].textureHandle.IsValid()) continue;
 
-                var resource = inputPass.fragmentInputAccess[ci].textureHandle;
-                if (ctx.TryAddToFragmentList(inputPass.fragmentInputAccess[ci], ctxPass.firstFragmentInput,
-                        ctxPass.numFragmentInputs, out errorMessage))
+                if (ctx.TryAddToFragmentList(inputPass.fragmentInputAccess[ci], ctxPass.firstFragmentInput, ctxPass.numFragmentInputs, out errorMessage))
                 {
                     ctxPass.TryAddFragmentInput(inputPass.fragmentInputAccess[ci].textureHandle.handle, ctx, out errorMessage);
                 }
@@ -312,8 +312,7 @@ bool TrySetupRasterFragmentList(ref PassData ctxPass, ref RenderGraphPass inputP
                 // Skip unused random write slots
                 if (!uav.h.IsValid()) continue;
 
-                if (ctx.TryAddToRandomAccessResourceList(uav.h, ci, uav.preserveCounterValue,
-                        ctxPass.firstRandomAccessResource, ctxPass.numRandomAccessResources, out errorMessage))
+                if (ctx.TryAddToRandomAccessResourceList(uav.h, ci, uav.preserveCounterValue, ctxPass.firstRandomAccessResource, ctxPass.numRandomAccessResources, out errorMessage))
                 {
                     ctxPass.AddRandomAccessResource();
                 }
@@ -481,8 +480,12 @@ void CullUnusedRenderGraphPasses()
                     // Flow upstream from this node
                     foreach (ref readonly var input in passData.Inputs(ctx))
                     {
-                        int inputPassIndex = ctx.resources[input.resource].writePassId;
-                        m_HasSideEffectPassIdCullingStack.Push(inputPassIndex);
+                        ref var inputVersionedDataRes = ref ctx.resources[input.resource];
+
+                        if (inputVersionedDataRes.written)
+                        {
+                            m_HasSideEffectPassIdCullingStack.Push(inputVersionedDataRes.writePassId);
+                        }
                     }
 
                     // We need this node, don't cull it
diff --git a/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/PassesData.cs b/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/PassesData.cs
@@ -265,14 +265,17 @@ public readonly ReadOnlySpan<PassOutputData> Outputs(CompilerContextData ctx)
         public readonly ReadOnlySpan<PassInputData> Inputs(CompilerContextData ctx)
             => ctx.inputData.MakeReadOnlySpan(firstInput, numInputs);
 
+        // RenderAttachments - MRT colors and depth
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public readonly ReadOnlySpan<PassFragmentData> Fragments(CompilerContextData ctx)
             => ctx.fragmentData.MakeReadOnlySpan(firstFragment, numFragments);
 
+        // ShadingRateImageAttachment
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public readonly PassFragmentData ShadingRateImage(CompilerContextData ctx)
             => ctx.fragmentData[shadingRateImageIndex];
 
+        // RenderInputAttachments
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public readonly ReadOnlySpan<PassFragmentData> FragmentInputs(CompilerContextData ctx)
             => ctx.fragmentData.MakeReadOnlySpan(firstFragmentInput, numFragmentInputs);
@@ -913,19 +916,22 @@ public static PassBreakAudit CanMerge(CompilerContextData contextData, int activ
             foreach (ref readonly var input in passToMerge.Inputs(contextData))
             {
                 var inputResource = input.resource;
-                var writingPassId = contextData.resources[inputResource].writePassId;
-                // Is the writing pass enclosed in the current native renderpass
-                if (writingPassId >= nativePass.firstGraphPass && writingPassId < nativePass.lastGraphPass + 1)
+
+                ref readonly var inputDataVersioned = ref contextData.VersionedResourceData(inputResource);
+
+                bool isWrittenInCurrNativePass = inputDataVersioned.written && (inputDataVersioned.writePassId >= nativePass.firstGraphPass && inputDataVersioned.writePassId < nativePass.lastGraphPass + 1);
+
+                if (isWrittenInCurrNativePass)
                 {
-                    // If it's not used as a fragment, it's used as some sort of texture read of load so we need so sync it out
+                    // If it's not used as a fragment, it's used as some sort of texture read or load so we need to break the current native render pass
+                    // as we can't sample and write to it in the same native render pass
                     if (!passToMerge.IsUsedAsFragment(inputResource, contextData))
                     {
                         return new PassBreakAudit(PassBreakReason.NextPassReadsTexture, passIdToMerge);
                     }
                 }
             }
 
-
             // Gather which attachments to add to the current renderpass
             var attachmentsToTryAdding = new FixedAttachmentArray<PassFragmentData>();
 
@@ -961,7 +967,7 @@ public static PassBreakAudit CanMerge(CompilerContextData contextData, int activ
                     }
                 }
 
-                // Check if this fragment is already sampled in the native renderpass not as a fragment but as an input
+                // Check if this fragment is already sampled in the native renderpass as a standard texture
                 for (int i = nativePass.firstGraphPass; i <= nativePass.lastGraphPass; ++i)
                 {
                     ref var earlierPassData = ref contextData.passData.ElementAt(i);
@@ -980,7 +986,6 @@ public static PassBreakAudit CanMerge(CompilerContextData contextData, int activ
                 }
             }
 
-
             foreach (ref readonly var fragmentInput in passToMerge.FragmentInputs(contextData))
             {
                 bool alreadyAttached = false;
@@ -1315,7 +1320,8 @@ void AddDepthAttachmentFirstDuringMerge(CompilerContextData contextData, in Pass
                 }
             }
 
-            // We also need to update the shading rate image index (VRS)
+            // We also need to update the shading rate image SRI index (used for VRS)
+            // This is unlikely to happen because the SRI is always added last, after color and input attachments
             if (hasShadingRateImage && shadingRateImageIndex == 0)
             {
                 shadingRateImageIndex = prevDepthIdx;
diff --git a/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphBuilders.cs b/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphBuilders.cs
@@ -493,6 +493,13 @@ public TextureHandle SetRandomAccessAttachment(TextureHandle input, int index, A
             return input;
         }
 
+        public void SetShadingRateImageAttachment(in TextureHandle tex)
+        {
+            CheckNotUseFragment(tex);
+            var versionedTextureHandle = new TextureHandle(UseResource(tex.handle, AccessFlags.Read));
+            m_RenderPass.SetShadingRateImageRaw(versionedTextureHandle);
+        }
+
         public BufferHandle UseBufferRandomAccess(BufferHandle input, int index, AccessFlags flags = AccessFlags.Read)
         {
             var h = UseBuffer(input, flags);
@@ -588,17 +595,6 @@ void CheckFrameBufferFetchEmulationIsSupported(in TextureHandle tex)
             }
         }
 
-        public void SetShadingRateImageAttachment(in TextureHandle sriTextureHandle)
-        {
-            CheckNotUseFragment(sriTextureHandle);
-
-            // shading rate image access flag is always read, only 1 mip and 1 slice
-            var newSriTextureHandle = new TextureHandle();
-            newSriTextureHandle.handle = UseResource(sriTextureHandle.handle, AccessFlags.Read);
-
-            m_RenderPass.SetShadingRateImage(newSriTextureHandle, AccessFlags.Read, 0, 0);
-        }
-
         public void SetShadingRateFragmentSize(ShadingRateFragmentSize shadingRateFragmentSize)
         {
             m_RenderPass.SetShadingRateFragmentSize(shadingRateFragmentSize);
diff --git a/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphPass.cs b/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphPass.cs
@@ -553,6 +553,16 @@ public void ComputeHash(ref HashFNV1A32 generator, RenderGraphResourceRegistry r
             generator.Append(GetRenderFuncHash());
         }
 
+        public void SetShadingRateImageRaw(in TextureHandle shadingRateImage)
+        {
+            if (ShadingRateInfo.supportsPerImageTile)
+            {
+                hasShadingRateImage = true;
+                // shading rate image access flag is always read, only 1 mip and 1 slice
+                shadingRateAccess = new TextureAccess(shadingRateImage, AccessFlags.Read, 0, 0);
+            }
+        }
+
         public void SetShadingRateImage(in TextureHandle shadingRateImage, AccessFlags accessFlags, int mipLevel, int depthSlice)
         {
             if (ShadingRateInfo.supportsPerImageTile)
diff --git a/Packages/com.unity.render-pipelines.core/Tests/Editor/NativePassCompilerRenderGraphTests.cs b/Packages/com.unity.render-pipelines.core/Tests/Editor/NativePassCompilerRenderGraphTests.cs
@@ -48,7 +48,7 @@ TestRenderTargets ImportAndCreateRenderTargets(RenderGraph g)
             var extraDepthBufferHandle = RTHandles.Alloc(depthBuffer, "Extra Depth Buffer");
             var extraDepthBufferBottomLeftHandle = RTHandles.Alloc(depthBuffer, "Extra Depth Buffer Bottom Left");
             var extraTextureTopLeftHandle = RTHandles.Alloc(backBuffer, "ExtraTextureTopLeft");
-            var extraTextureBottomLeftHandle = RTHandles.Alloc(backBuffer,"ExtraTextureBottomLeft");
+            var extraTextureBottomLeftHandle = RTHandles.Alloc(backBuffer, "ExtraTextureBottomLeft");
 
             ImportResourceParams importParams = new ImportResourceParams();
             importParams.textureUVOrigin = TextureUVOrigin.TopLeft;
@@ -1629,57 +1629,98 @@ public void UpdateSubpassAttachmentIndices_WhenDepthAttachmentIsAdded()
             Assert.IsTrue(subPassDesc3.inputs[0] == 3);
         }
 
-/* //VRS bug. It seems that there is a bug with VRS forcing pass breaking between passes using the same shading rate image where it shouldn't: UUM-102113.
         [Test]
-        public void UpdateShadingRateImageIndex_WhenDepthAttachmentIsAdded()
+        public void MergePasses_WhenSameShadingRateImage()
         {
             var g = AllocateRenderGraph();
             var renderTargets = ImportAndCreateRenderTargets(g);
 
-            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("NoDepth_Subpass0", out var passData))
+            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("Pass0", out var passData))
             {
-                builder.SetShadingRateImageAttachment(renderTargets.extraTextures[0]);
                 builder.SetRenderAttachment(renderTargets.extraTextures[1], 0);
+                builder.SetShadingRateImageAttachment(renderTargets.extraTextures[0]);
                 builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
                 builder.AllowPassCulling(false);
             }
 
-            // Render Pass
-            //   attachments: [extraTextures[0], extraTextures[1]]
-            //   shading rate image : [0]
-            //   subpass 0: color outputs : [1]
-
-            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("Depth_Subpass1", out var passData))
+            // Same attachments, we should merge in the same subpass as Pass0's one
+            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("Pass1", out var passData))
             {
+                builder.SetRenderAttachment(renderTargets.extraTextures[1], 0);
                 builder.SetShadingRateImageAttachment(renderTargets.extraTextures[0]);
-                builder.SetRenderAttachmentDepth(renderTargets.depthBuffer, AccessFlags.Write);
-                builder.SetRenderAttachment(renderTargets.extraTextures[2], 0);
                 builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
                 builder.AllowPassCulling(false);
             }
 
-            // Render Pass
-            //   attachments: [depthBuffer, extraTextures[1], extraTextures[0], extraTextures[2]]
-            //   shading rate image : [0 -> 2]
-            //   subpass 0: color outputs : [1]
-            //   subpass 1: color outputs : [3]
+            // Same shading rate image but different render attachments, we should stay in the same native render pass but in a different subpass
+            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("Pass2", out var passData))
+            {
+                builder.SetRenderAttachment(renderTargets.extraTextures[2], 0);
+                builder.SetShadingRateImageAttachment(renderTargets.extraTextures[0]);
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                builder.AllowPassCulling(false);
+            }
 
             var result = g.CompileNativeRenderGraph(g.ComputeGraphHash());
             var passes = result.contextData.GetNativePasses();
 
             // All graph passes are merged in the same render pass
-            Assert.IsTrue(passes != null && passes.Count == 1 && passes[0].numGraphPasses == 2 && passes[0].numNativeSubPasses == 2);
+            Assert.IsTrue(passes != null && passes.Count == 1 && passes[0].numGraphPasses == 3 && passes[0].numNativeSubPasses == 2);
 
-            // Depth is the first attachment
-            Assert.IsTrue(passes[0].attachments[0].handle.index == renderTargets.depthBuffer.handle.index);
-            Assert.IsTrue(passes[0].attachments[1].handle.index == renderTargets.extraTextures[1].handle.index);
-            Assert.IsTrue(passes[0].attachments[2].handle.index == renderTargets.extraTextures[0].handle.index);
-            Assert.IsTrue(passes[0].attachments[3].handle.index == renderTargets.extraTextures[2].handle.index);
+            // If no SRI support, we just discard the API call
+            if (ShadingRateInfo.supportsPerImageTile)
+            {
+                var shadingRateImageAttachmentIndex = passes[0].shadingRateImageIndex;
+                Assert.IsTrue(shadingRateImageAttachmentIndex == 1); // always after color and depth attachments
+                Assert.IsTrue(passes[0].attachments[shadingRateImageAttachmentIndex].handle.index == renderTargets.extraTextures[0].handle.index);
+            }
+        }
 
-            // Check Shading Rate Image index is correctly updated
-            Assert.IsTrue(passes[0].shadingRateImageIndex == renderTargets.extraTextures[0].handle.index);
+        [Test]
+        public void BreakPasses_WhenNoOrDifferentShadingRateImage()
+        {
+            var g = AllocateRenderGraph();
+            var renderTargets = ImportAndCreateRenderTargets(g);
+
+            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("Pass0", out var passData))
+            {
+                builder.SetRenderAttachment(renderTargets.extraTextures[1], 0);
+                builder.SetShadingRateImageAttachment(renderTargets.extraTextures[0]);
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                builder.AllowPassCulling(false);
+            }
+
+            // Different SRI, we should break into a new native render pass
+            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("Pass1", out var passData))
+            {
+                builder.SetRenderAttachment(renderTargets.extraTextures[1], 0);
+                builder.SetShadingRateImageAttachment(renderTargets.extraTextures[2]);
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                builder.AllowPassCulling(false);
+            }
+
+            // No SRI, we should break into a new native render pass
+            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("Pass2", out var passData))
+            {
+                builder.SetRenderAttachment(renderTargets.extraTextures[1], 0);
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                builder.AllowPassCulling(false);
+            }
+
+            var result = g.CompileNativeRenderGraph(g.ComputeGraphHash());
+            var passes = result.contextData.GetNativePasses();
+
+            if (ShadingRateInfo.supportsPerImageTile)
+            {
+                // All graph passes are in different native render passes
+                Assert.IsTrue(passes != null && passes.Count == 3);
+            }
+            else
+            {
+                // If no SRI support, we just discard the API call, all graph passes are merged together
+                Assert.IsTrue(passes != null && passes.Count == 1);
+            }
         }
-*/
 
 /* // DepthAttachment bug: https://jira.unity3d.com/projects/SRP/issues/SRP-897
         [Test]

Original file line number	Diff line number	Diff line change
`@@ -180,8 +180,8 @@ public bool TryAddToFragmentList(TextureAccess access, int listFirstIndex, int n`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`183`		`- // Validate that we're correctly building up the fragment lists we can only append to the last list`
`184`		`- // not int the middle of lists`
	`183`	`+ // Validate that we're correctly building up the fragment lists, we can only append to the last list`
	`184`	`+ // not in the middle of the other lists`
`185`	`185`	`Debug.Assert(listFirstIndex + numItems == fragmentData.Length);`
`186`	`186`
`187`	`187`	`fragmentData.Add(new PassFragmentData(`
Original file line number	Diff line number	Diff line change
`@@ -265,16 +265,18 @@ bool TrySetupRasterFragmentList(ref PassData ctxPass, ref RenderGraphPass inputP`
`265`	`265`	`}`
`266`	`266`	`}`
`267`	`267`
`268`		`- // shading rate`
`269`		`- if (inputPass.hasShadingRateImage &&`
`270`		`- inputPass.shadingRateAccess.textureHandle.handle.IsValid())`
	`268`	`+ // shading rate image - this is a specific type of attachment (more of an image resource that can't be sampled, only used by the rasterizer)`
	`269`	`+ if (inputPass.hasShadingRateImage && inputPass.shadingRateAccess.textureHandle.handle.IsValid())`
`271`	`270`	`{`
`272`		`- ctxPass.shadingRateImageIndex = ctx.fragmentData.Length;`
`273`		`- ctx.TryAddToFragmentList(inputPass.shadingRateAccess, ctxPass.shadingRateImageIndex, 0, out errorMessage);`
	`271`	`+ if (ctx.TryAddToFragmentList(inputPass.shadingRateAccess, ctxPass.firstFragment, ctxPass.numFragments, out errorMessage))`
	`272`	`+ {`
	`273`	`+ ctxPass.shadingRateImageIndex = ctx.fragmentData.Length - 1;`
	`274`	`+ }`
`274`	`275`
`275`	`276`	`if (errorMessage != null)`
`276`	`277`	`{`
`277`		`- errorMessage = $"when trying to add VRS attachment of type {inputPass.shadingRateAccess.textureHandle.handle.type} at index {inputPass.shadingRateAccess.textureHandle.handle.index} - {errorMessage}";`
	`278`	`+ errorMessage =`
	`279`	`+ $"when trying to add VRS attachment of type {inputPass.shadingRateAccess.textureHandle.handle.type} at index {inputPass.shadingRateAccess.textureHandle.handle.index} - {errorMessage}";`
`278`	`280`	`return false;`
`279`	`281`	`}`
`280`	`282`	`}`
`@@ -287,9 +289,7 @@ bool TrySetupRasterFragmentList(ref PassData ctxPass, ref RenderGraphPass inputP`
`287`	`289`	`// Skip unused fragment input slots`
`288`	`290`	`if (!inputPass.fragmentInputAccess[ci].textureHandle.IsValid()) continue;`
`289`	`291`
`290`		`- var resource = inputPass.fragmentInputAccess[ci].textureHandle;`
`291`		`- if (ctx.TryAddToFragmentList(inputPass.fragmentInputAccess[ci], ctxPass.firstFragmentInput,`
`292`		`- ctxPass.numFragmentInputs, out errorMessage))`
	`292`	`+ if (ctx.TryAddToFragmentList(inputPass.fragmentInputAccess[ci], ctxPass.firstFragmentInput, ctxPass.numFragmentInputs, out errorMessage))`
`293`	`293`	`{`
`294`	`294`	`ctxPass.TryAddFragmentInput(inputPass.fragmentInputAccess[ci].textureHandle.handle, ctx, out errorMessage);`
`295`	`295`	`}`
`@@ -312,8 +312,7 @@ bool TrySetupRasterFragmentList(ref PassData ctxPass, ref RenderGraphPass inputP`
`312`	`312`	`// Skip unused random write slots`
`313`	`313`	`if (!uav.h.IsValid()) continue;`
`314`	`314`
`315`		`- if (ctx.TryAddToRandomAccessResourceList(uav.h, ci, uav.preserveCounterValue,`
`316`		`- ctxPass.firstRandomAccessResource, ctxPass.numRandomAccessResources, out errorMessage))`
	`315`	`+ if (ctx.TryAddToRandomAccessResourceList(uav.h, ci, uav.preserveCounterValue, ctxPass.firstRandomAccessResource, ctxPass.numRandomAccessResources, out errorMessage))`
`317`	`316`	`{`
`318`	`317`	`ctxPass.AddRandomAccessResource();`
`319`	`318`	`}`
`@@ -481,8 +480,12 @@ void CullUnusedRenderGraphPasses()`
`481`	`480`	`// Flow upstream from this node`
`482`	`481`	`foreach (ref readonly var input in passData.Inputs(ctx))`
`483`	`482`	`{`
`484`		`- int inputPassIndex = ctx.resources[input.resource].writePassId;`
`485`		`- m_HasSideEffectPassIdCullingStack.Push(inputPassIndex);`
	`483`	`+ ref var inputVersionedDataRes = ref ctx.resources[input.resource];`
	`484`	`+`
	`485`	`+ if (inputVersionedDataRes.written)`
	`486`	`+ {`
	`487`	`+ m_HasSideEffectPassIdCullingStack.Push(inputVersionedDataRes.writePassId);`
	`488`	`+ }`
`486`	`489`	`}`
`487`	`490`
`488`	`491`	`// We need this node, don't cull it`
Original file line number	Diff line number	Diff line change
`@@ -265,14 +265,17 @@ public readonly ReadOnlySpan<PassOutputData> Outputs(CompilerContextData ctx)`
`265`	`265`	`public readonly ReadOnlySpan<PassInputData> Inputs(CompilerContextData ctx)`
`266`	`266`	`=> ctx.inputData.MakeReadOnlySpan(firstInput, numInputs);`
`267`	`267`
	`268`	`+ // RenderAttachments - MRT colors and depth`
`268`	`269`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`269`	`270`	`public readonly ReadOnlySpan<PassFragmentData> Fragments(CompilerContextData ctx)`
`270`	`271`	`=> ctx.fragmentData.MakeReadOnlySpan(firstFragment, numFragments);`
`271`	`272`
	`273`	`+ // ShadingRateImageAttachment`
`272`	`274`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`273`	`275`	`public readonly PassFragmentData ShadingRateImage(CompilerContextData ctx)`
`274`	`276`	`=> ctx.fragmentData[shadingRateImageIndex];`
`275`	`277`
	`278`	`+ // RenderInputAttachments`
`276`	`279`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`277`	`280`	`public readonly ReadOnlySpan<PassFragmentData> FragmentInputs(CompilerContextData ctx)`
`278`	`281`	`=> ctx.fragmentData.MakeReadOnlySpan(firstFragmentInput, numFragmentInputs);`
`@@ -913,19 +916,22 @@ public static PassBreakAudit CanMerge(CompilerContextData contextData, int activ`
`913`	`916`	`foreach (ref readonly var input in passToMerge.Inputs(contextData))`
`914`	`917`	`{`
`915`	`918`	`var inputResource = input.resource;`
`916`		`- var writingPassId = contextData.resources[inputResource].writePassId;`
`917`		`- // Is the writing pass enclosed in the current native renderpass`
`918`		`- if (writingPassId >= nativePass.firstGraphPass && writingPassId < nativePass.lastGraphPass + 1)`
	`919`	`+`
	`920`	`+ ref readonly var inputDataVersioned = ref contextData.VersionedResourceData(inputResource);`
	`921`	`+`
	`922`	`+ bool isWrittenInCurrNativePass = inputDataVersioned.written && (inputDataVersioned.writePassId >= nativePass.firstGraphPass && inputDataVersioned.writePassId < nativePass.lastGraphPass + 1);`
	`923`	`+`
	`924`	`+ if (isWrittenInCurrNativePass)`
`919`	`925`	`{`
`920`		`- // If it's not used as a fragment, it's used as some sort of texture read of load so we need so sync it out`
	`926`	`+ // If it's not used as a fragment, it's used as some sort of texture read or load so we need to break the current native render pass`
	`927`	`+ // as we can't sample and write to it in the same native render pass`
`921`	`928`	`if (!passToMerge.IsUsedAsFragment(inputResource, contextData))`
`922`	`929`	`{`
`923`	`930`	`return new PassBreakAudit(PassBreakReason.NextPassReadsTexture, passIdToMerge);`
`924`	`931`	`}`
`925`	`932`	`}`
`926`	`933`	`}`
`927`	`934`
`928`		`-`
`929`	`935`	`// Gather which attachments to add to the current renderpass`
`930`	`936`	`var attachmentsToTryAdding = new FixedAttachmentArray<PassFragmentData>();`
`931`	`937`
`@@ -961,7 +967,7 @@ public static PassBreakAudit CanMerge(CompilerContextData contextData, int activ`
`961`	`967`	`}`
`962`	`968`	`}`
`963`	`969`
`964`		`- // Check if this fragment is already sampled in the native renderpass not as a fragment but as an input`
	`970`	`+ // Check if this fragment is already sampled in the native renderpass as a standard texture`
`965`	`971`	`for (int i = nativePass.firstGraphPass; i <= nativePass.lastGraphPass; ++i)`
`966`	`972`	`{`
`967`	`973`	`ref var earlierPassData = ref contextData.passData.ElementAt(i);`
`@@ -980,7 +986,6 @@ public static PassBreakAudit CanMerge(CompilerContextData contextData, int activ`
`980`	`986`	`}`
`981`	`987`	`}`
`982`	`988`
`983`		`-`
`984`	`989`	`foreach (ref readonly var fragmentInput in passToMerge.FragmentInputs(contextData))`
`985`	`990`	`{`
`986`	`991`	`bool alreadyAttached = false;`
`@@ -1315,7 +1320,8 @@ void AddDepthAttachmentFirstDuringMerge(CompilerContextData contextData, in Pass`
`1315`	`1320`	`}`
`1316`	`1321`	`}`
`1317`	`1322`
`1318`		`- // We also need to update the shading rate image index (VRS)`
	`1323`	`+ // We also need to update the shading rate image SRI index (used for VRS)`
	`1324`	`+ // This is unlikely to happen because the SRI is always added last, after color and input attachments`
`1319`	`1325`	`if (hasShadingRateImage && shadingRateImageIndex == 0)`
`1320`	`1326`	`{`
`1321`	`1327`	`shadingRateImageIndex = prevDepthIdx;`
Original file line number	Diff line number	Diff line change
`@@ -493,6 +493,13 @@ public TextureHandle SetRandomAccessAttachment(TextureHandle input, int index, A`
`493`	`493`	`return input;`
`494`	`494`	`}`
`495`	`495`
	`496`	`+ public void SetShadingRateImageAttachment(in TextureHandle tex)`
	`497`	`+ {`
	`498`	`+ CheckNotUseFragment(tex);`
	`499`	`+ var versionedTextureHandle = new TextureHandle(UseResource(tex.handle, AccessFlags.Read));`
	`500`	`+ m_RenderPass.SetShadingRateImageRaw(versionedTextureHandle);`
	`501`	`+ }`
	`502`	`+`
`496`	`503`	`public BufferHandle UseBufferRandomAccess(BufferHandle input, int index, AccessFlags flags = AccessFlags.Read)`
`497`	`504`	`{`
`498`	`505`	`var h = UseBuffer(input, flags);`
`@@ -588,17 +595,6 @@ void CheckFrameBufferFetchEmulationIsSupported(in TextureHandle tex)`
`588`	`595`	`}`
`589`	`596`	`}`
`590`	`597`
`591`		`- public void SetShadingRateImageAttachment(in TextureHandle sriTextureHandle)`
`592`		`- {`
`593`		`- CheckNotUseFragment(sriTextureHandle);`
`594`		`-`
`595`		`- // shading rate image access flag is always read, only 1 mip and 1 slice`
`596`		`- var newSriTextureHandle = new TextureHandle();`
`597`		`- newSriTextureHandle.handle = UseResource(sriTextureHandle.handle, AccessFlags.Read);`
`598`		`-`
`599`		`- m_RenderPass.SetShadingRateImage(newSriTextureHandle, AccessFlags.Read, 0, 0);`
`600`		`- }`
`601`		`-`
`602`	`598`	`public void SetShadingRateFragmentSize(ShadingRateFragmentSize shadingRateFragmentSize)`
`603`	`599`	`{`
`604`	`600`	`m_RenderPass.SetShadingRateFragmentSize(shadingRateFragmentSize);`