[HDRP] Simplifying Screen Space Reflection and adding missing fence when async

jmekh · Evergreen · commit 02100d2833ba · 2024-06-06T15:32:14.000Z
This PR applies multiple fixes to HDRP Screen Space Reflection:
- It removes the SSR lighting texture by reusing the SSR accumulation texture
- It adds a fence before async work, so they wait for resources to be cleared when it reuses pooled resources. This fixes flickering on some platform where graphics and async command buffer are more sensitive to missing fences.
- It changes the hit point texture and lighting texture clears to be async if the pass is async. Due to the new fence, it couldn't overlap with shadow rendering, but moving the clear to the same queue as the rest of the work, is more optimized and has no fence.
diff --git a/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraph.cs b/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraph.cs
@@ -2205,12 +2205,13 @@ void PreRenderPassExecute(in CompiledPassInfo passInfo, RenderGraphPass pass, In
         {
             // Need to save the command buffer to restore it later as the one in the context can changed if running a pass async.
             m_PreviousCommandBuffer = rgContext.cmd;
-
+            
+            bool executedWorkDuringResourceCreation = false;
             for (int type = 0; type < (int)RenderGraphResourceType.Count; ++type)
             {
                 foreach (int resource in passInfo.resourceCreateList[type])
                 {
-                    m_Resources.CreatePooledResource(rgContext, type, resource);
+                    executedWorkDuringResourceCreation |= m_Resources.CreatePooledResource(rgContext, type, resource);
                 }
             }
 
@@ -2221,6 +2222,12 @@ void PreRenderPassExecute(in CompiledPassInfo passInfo, RenderGraphPass pass, In
 
             if (passInfo.enableAsyncCompute)
             {
+                GraphicsFence previousFence = new GraphicsFence();
+                if (executedWorkDuringResourceCreation)
+                {
+                    previousFence = rgContext.cmd.CreateGraphicsFence(GraphicsFenceType.AsyncQueueSynchronisation, SynchronisationStageFlags.AllGPUOperations);
+                }
+
                 // Flush current command buffer on the render context before enqueuing async commands.
                 if (rgContext.contextlessTesting == false)
                     rgContext.renderContext.ExecuteCommandBuffer(rgContext.cmd);
@@ -2229,6 +2236,11 @@ void PreRenderPassExecute(in CompiledPassInfo passInfo, RenderGraphPass pass, In
                 CommandBuffer asyncCmd = CommandBufferPool.Get(pass.name);
                 asyncCmd.SetExecutionFlags(CommandBufferExecutionFlags.AsyncCompute);
                 rgContext.cmd = asyncCmd;
+
+                if (executedWorkDuringResourceCreation)
+                {
+                    rgContext.cmd.WaitOnAsyncGraphicsFence(previousFence);
+                }
             }
 
             // Synchronize with graphics or compute pipe if needed.
diff --git a/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphResourceRegistry.cs b/Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphResourceRegistry.cs
@@ -91,15 +91,16 @@ internal static RenderGraphResourceRegistry current
                 m_CurrentRegistry = value;
             }
         }
-
+        
+        delegate bool ResourceCreateCallback(InternalRenderGraphContext rgContext, IRenderGraphResource res);
         delegate void ResourceCallback(InternalRenderGraphContext rgContext, IRenderGraphResource res);
 
         class RenderGraphResourcesData
         {
             public DynamicArray<IRenderGraphResource> resourceArray = new DynamicArray<IRenderGraphResource>();
             public int sharedResourcesCount;
             public IRenderGraphResourcePool pool;
-            public ResourceCallback createResourceCallback;
+            public ResourceCreateCallback createResourceCallback;
             public ResourceCallback releaseResourceCallback;
 
             public RenderGraphResourcesData()
@@ -1012,10 +1013,11 @@ void ManageSharedRenderGraphResources()
             }
         }
 
-        internal void CreatePooledResource(InternalRenderGraphContext rgContext, int type, int index)
+        internal bool CreatePooledResource(InternalRenderGraphContext rgContext, int type, int index)
         {
             Debug.Assert(index != 0, "Index 0 indicates the null object it can't be used here");
 
+            bool? executedWork = false;
             var resource = m_RenderGraphResources[type].resourceArray[index];
             if (!resource.imported)
             {
@@ -1024,20 +1026,22 @@ internal void CreatePooledResource(InternalRenderGraphContext rgContext, int typ
                 if (m_RenderGraphDebug.enableLogging)
                     resource.LogCreation(m_FrameInformationLogger);
 
-                m_RenderGraphResources[type].createResourceCallback?.Invoke(rgContext, resource);
+                executedWork = m_RenderGraphResources[type].createResourceCallback?.Invoke(rgContext, resource);
             }
+
+            return executedWork ?? false;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void CreatePooledResource(InternalRenderGraphContext rgContext, in ResourceHandle handle)
+        internal bool CreatePooledResource(InternalRenderGraphContext rgContext, in ResourceHandle handle)
         {
-            CreatePooledResource(rgContext, handle.iType, handle.index);
+            return CreatePooledResource(rgContext, handle.iType, handle.index);
         }
 
         // Only modified by native compiler when using native render pass
         internal bool forceManualClearOfResource = true;
 
-        void CreateTextureCallback(InternalRenderGraphContext rgContext, IRenderGraphResource res)
+        bool CreateTextureCallback(InternalRenderGraphContext rgContext, IRenderGraphResource res)
         {
             var resource = res as TextureResource;
 
@@ -1049,13 +1053,16 @@ void CreateTextureCallback(InternalRenderGraphContext rgContext, IRenderGraphRes
             }
 #endif
 
+            bool executedWork = false;
             if ((forceManualClearOfResource && resource.desc.clearBuffer) || m_RenderGraphDebug.clearRenderTargetsAtCreation)
             {
                 bool debugClear = m_RenderGraphDebug.clearRenderTargetsAtCreation && !resource.desc.clearBuffer;
                 var clearFlag = resource.desc.depthBufferBits != DepthBits.None ? ClearFlag.DepthStencil : ClearFlag.Color;
                 var clearColor = debugClear ? Color.magenta : resource.desc.clearColor;
                 CoreUtils.SetRenderTarget(rgContext.cmd, resource.graphicsResource, clearFlag, clearColor);
+                executedWork = true;
             }
+            return executedWork;
         }
 
         internal void ReleasePooledResource(InternalRenderGraphContext rgContext, int type, int index)
diff --git a/Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceReflections.compute b/Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceReflections.compute
@@ -101,7 +101,6 @@ TEXTURE2D_X(_DepthTexture);
 #else //if defined(SSR_ACCUMULATE)
        TEXTURE2D_X(        _SsrHitPointTexture);
     RW_TEXTURE2D_X(float4, _SsrAccumPrev);
-    RW_TEXTURE2D_X(float4, _SsrLightingTextureRW);
     RW_TEXTURE2D_X(float4, _SSRAccumTexture);
 #endif
 
@@ -835,7 +834,6 @@ void MAIN_ACC(uint3 dispatchThreadId : SV_DispatchThreadID)
     result.rgb = isPosFin ? result.rgb : 0;
     result.w = isPosFin ? result.w : 0;
 
-    _SsrLightingTextureRW[COORD_TEXTURE2D_X(positionSS)] = result;
     _SSRAccumTexture[COORD_TEXTURE2D_X(positionSS)] = result;
 }
 
diff --git a/Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.LightLoop.cs b/Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.LightLoop.cs
@@ -975,7 +975,6 @@ class RenderSSRPassData
 
             public bool transparentSSR;
             public bool usePBRAlgo;
-            public bool accumNeedClear;
             public bool previousAccumNeedClear;
             public bool validColorPyramid;
 
@@ -993,7 +992,6 @@ class RenderSSRPassData
             public TextureHandle stencilBuffer;
             public TextureHandle hitPointsTexture;
             public TextureHandle ssrAccum;
-            public TextureHandle lightingTexture;
             public TextureHandle ssrAccumPrev;
             public TextureHandle clearCoatMask;
 
@@ -1027,7 +1025,7 @@ static void ClearColorBuffer2D(RenderSSRPassData data, CommandBuffer cmd, Textur
             }
             else
             {
-                cmd.SetComputeTextureParam(data.clearBuffer2DCS, data.clearBuffer2DKernel, HDShaderIDs._Buffer2D, data.ssrAccum);
+                cmd.SetComputeTextureParam(data.clearBuffer2DCS, data.clearBuffer2DKernel, HDShaderIDs._Buffer2D, rt);
                 cmd.SetComputeVectorParam(data.clearBuffer2DCS, HDShaderIDs._ClearValue, clearColor);
                 cmd.SetComputeVectorParam(data.clearBuffer2DCS, HDShaderIDs._BufferSize, new Vector4((float)data.width, (float)data.height, 0.0f, 0.0f));
                 cmd.DispatchCompute(data.clearBuffer2DCS, data.clearBuffer2DKernel, HDUtils.DivRoundUp(data.width, 8), HDUtils.DivRoundUp(data.height, 8), data.viewCount);
@@ -1128,12 +1126,12 @@ TextureHandle RenderSSR(RenderGraph renderGraph,
                     bool useAsync = hdCamera.frameSettings.SSRRunsAsync() && !transparent;
                     builder.EnableAsyncCompute(useAsync);
 
-                    hdCamera.AllocateScreenSpaceAccumulationHistoryBuffer(1.0f);
-
                     bool usePBRAlgo = !transparent && settings.usedAlgorithm.value == ScreenSpaceReflectionAlgorithm.PBRAccumulation;
                     var colorPyramid = renderGraph.ImportTexture(colorPyramidRT);
                     var volumeSettings = hdCamera.volumeStack.GetComponent<ScreenSpaceReflection>();
 
+                    hdCamera.AllocateScreenSpaceAccumulationHistoryBuffer(1.0f);
+
                     UpdateSSRConstantBuffer(hdCamera, volumeSettings, transparent, ref passData.cb);
 
                     passData.hdCamera = hdCamera;
@@ -1167,8 +1165,7 @@ TextureHandle RenderSSR(RenderGraph renderGraph,
                     passData.height = hdCamera.actualHeight;
                     passData.viewCount = hdCamera.viewCount;
                     passData.offsetBufferData = hdCamera.depthBufferMipChainInfo.GetOffsetBufferData(m_DepthPyramidMipLevelOffsetsBuffer);
-                    passData.accumNeedClear = usePBRAlgo;
-                    passData.previousAccumNeedClear = usePBRAlgo && (hdCamera.currentSSRAlgorithm == ScreenSpaceReflectionAlgorithm.Approximation || hdCamera.isFirstFrame || hdCamera.resetPostProcessingHistory);
+                    passData.previousAccumNeedClear = usePBRAlgo && (hdCamera.isFirstFrame || hdCamera.resetPostProcessingHistory);
                     hdCamera.currentSSRAlgorithm = volumeSettings.usedAlgorithm.value; // Store for next frame comparison
                     passData.validColorPyramid = hdCamera.colorPyramidHistoryValidFrames > 1;
 
@@ -1204,42 +1201,45 @@ TextureHandle RenderSSR(RenderGraph renderGraph,
                     // In practice, these textures are sparse (mostly black). Therefore, clearing them is fast (due to CMASK),
                     // and much faster than fully overwriting them from within SSR shaders.
                     passData.hitPointsTexture = builder.CreateTransientTexture(new TextureDesc(Vector2.one, true, true)
-                    { colorFormat = GraphicsFormat.R16G16_UNorm, clearBuffer = true, clearColor = Color.clear, enableRandomWrite = true, name = transparent ? "SSR_Hit_Point_Texture_Trans" : "SSR_Hit_Point_Texture" });
+                    { colorFormat = GraphicsFormat.R16G16_UNorm, clearBuffer = !useAsync, clearColor = Color.clear, enableRandomWrite = true, name = transparent ? "SSR_Hit_Point_Texture_Trans" : "SSR_Hit_Point_Texture" });
 
                     if (usePBRAlgo)
                     {
                         passData.ssrAccum = builder.WriteTexture(renderGraph.ImportTexture(hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.ScreenSpaceReflectionAccumulation)));
                         passData.ssrAccumPrev = builder.WriteTexture(renderGraph.ImportTexture(hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.ScreenSpaceReflectionAccumulation)));
-                        passData.lightingTexture = builder.CreateTransientTexture(new TextureDesc(Vector2.one, true, true)
-                        { colorFormat = GraphicsFormat.R16G16B16A16_SFloat, clearBuffer = true, clearColor = Color.clear, enableRandomWrite = true, name = "SSR_Lighting_Texture" });
                     }
                     else
                     {
-                        passData.lightingTexture = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
-                        { colorFormat = GraphicsFormat.R16G16B16A16_SFloat, clearBuffer = true, clearColor = Color.clear, enableRandomWrite = true, name = "SSR_Lighting_Texture" }));
+                        passData.ssrAccum = builder.WriteTexture(renderGraph.CreateTexture(new TextureDesc(Vector2.one, true, true)
+                        { colorFormat = GraphicsFormat.R16G16B16A16_SFloat, clearBuffer = !useAsync, clearColor = Color.clear, enableRandomWrite = true, name = "SSR_Lighting_Texture" }));
                     }
 
                     builder.SetRenderFunc(
                         (RenderSSRPassData data, RenderGraphContext ctx) =>
                         {
                             var cs = data.ssrCS;
 
-                            if (!data.usePBRAlgo)
-                                ctx.cmd.EnableShaderKeyword("SSR_APPROX");
-                            else
+                            CoreUtils.SetKeyword(ctx.cmd, "SSR_APPROX", !data.usePBRAlgo);
+                            CoreUtils.SetKeyword(ctx.cmd, "DEPTH_SOURCE_NOT_FROM_MIP_CHAIN", data.transparentSSR);
+
+                            if (data.usePBRAlgo)
                             {
-                                if (data.accumNeedClear || data.debugDisplaySpeed)
-                                    ClearColorBuffer2D(data, ctx.cmd, data.ssrAccum, Color.clear, data.useAsync);
+                                ClearColorBuffer2D(data, ctx.cmd, data.ssrAccum, Color.clear, data.useAsync);
+
                                 if (data.previousAccumNeedClear || data.debugDisplaySpeed)
                                     ClearColorBuffer2D(data, ctx.cmd, data.ssrAccumPrev, Color.clear, data.useAsync);
-
-                                ctx.cmd.DisableShaderKeyword("SSR_APPROX");
+                            }
+                            else if (data.useAsync)
+                            {
+                                // If the pass is synchronous, clear is done when the accumulation texture is created
+                                ClearColorBuffer2D(data, ctx.cmd, data.ssrAccum, Color.clear, data.useAsync);
                             }
 
-                            if (data.transparentSSR)
-                                ctx.cmd.EnableShaderKeyword("DEPTH_SOURCE_NOT_FROM_MIP_CHAIN");
-                            else
-                                ctx.cmd.DisableShaderKeyword("DEPTH_SOURCE_NOT_FROM_MIP_CHAIN");
+                            if (data.useAsync)
+                            {
+                                // If the pass is synchronous, clear is done when the hit point texture is created
+                                ClearColorBuffer2D(data, ctx.cmd, data.hitPointsTexture, Color.clear, data.useAsync);
+                            }
 
                             using (new ProfilingScope(ctx.cmd, ProfilingSampler.Get(HDProfileId.SsrTracing)))
                             {
@@ -1276,7 +1276,7 @@ TextureHandle RenderSSR(RenderGraph renderGraph,
                                 ctx.cmd.SetComputeTextureParam(cs, data.reprojectionKernel, HDShaderIDs._ColorPyramidTexture, data.colorPyramid);
                                 ctx.cmd.SetComputeTextureParam(cs, data.reprojectionKernel, HDShaderIDs._NormalBufferTexture, data.normalBuffer);
                                 ctx.cmd.SetComputeTextureParam(cs, data.reprojectionKernel, HDShaderIDs._SsrHitPointTexture, data.hitPointsTexture);
-                                ctx.cmd.SetComputeTextureParam(cs, data.reprojectionKernel, HDShaderIDs._SSRAccumTexture, data.usePBRAlgo ? data.ssrAccum : data.lightingTexture);
+                                ctx.cmd.SetComputeTextureParam(cs, data.reprojectionKernel, HDShaderIDs._SSRAccumTexture, data.ssrAccum);
                                 ctx.cmd.SetComputeTextureParam(cs, data.reprojectionKernel, HDShaderIDs._SsrClearCoatMaskTexture, data.clearCoatMask);
                                 ctx.cmd.SetComputeTextureParam(cs, data.reprojectionKernel, HDShaderIDs._CameraMotionVectorsTexture, data.motionVectorsBuffer);
 
@@ -1370,7 +1370,6 @@ TextureHandle RenderSSR(RenderGraph renderGraph,
                                         ctx.cmd.SetComputeTextureParam(cs, pass, HDShaderIDs._ColorPyramidTexture, data.colorPyramid);
                                         ctx.cmd.SetComputeTextureParam(cs, pass, HDShaderIDs._SsrHitPointTexture, data.hitPointsTexture);
                                         ctx.cmd.SetComputeTextureParam(cs, pass, HDShaderIDs._SSRAccumTexture, data.ssrAccum);
-                                        ctx.cmd.SetComputeTextureParam(cs, pass, HDShaderIDs._SsrLightingTextureRW, data.lightingTexture);
                                         ctx.cmd.SetComputeTextureParam(cs, pass, HDShaderIDs._SsrAccumPrev, data.ssrAccumPrev);
                                         ctx.cmd.SetComputeTextureParam(cs, pass, HDShaderIDs._SsrClearCoatMaskTexture, data.clearCoatMask);
                                         ctx.cmd.SetComputeTextureParam(cs, pass, HDShaderIDs._CameraMotionVectorsTexture, data.motionVectorsBuffer);
@@ -1388,17 +1387,13 @@ TextureHandle RenderSSR(RenderGraph renderGraph,
 
                     if (usePBRAlgo)
                     {
-                        result = passData.ssrAccum;
-
                         PushFullScreenDebugTexture(renderGraph, passData.ssrAccum, FullScreenDebugMode.ScreenSpaceReflectionsAccum);
                         PushFullScreenDebugTexture(renderGraph, passData.ssrAccumPrev, FullScreenDebugMode.ScreenSpaceReflectionsPrev);
-                        PushFullScreenDebugTexture(renderGraph, passData.ssrAccum, FullScreenDebugMode.ScreenSpaceReflectionSpeedRejection);
-                    }
-                    else
-                    {
-                        result = passData.lightingTexture;
-                        PushFullScreenDebugTexture(renderGraph, result, FullScreenDebugMode.ScreenSpaceReflectionSpeedRejection);
                     }
+
+                    PushFullScreenDebugTexture(renderGraph, passData.ssrAccum, FullScreenDebugMode.ScreenSpaceReflectionSpeedRejection);
+                    
+                    result = passData.ssrAccum;
                 }
 
                 if (!hdCamera.colorPyramidHistoryIsValid)
diff --git a/Tests/SRPTests/Projects/HDRP_RuntimeTests/Assets/ShaderVariantLists/Default.shadervariantlist b/Tests/SRPTests/Projects/HDRP_RuntimeTests/Assets/ShaderVariantLists/Default.shadervariantlist
@@ -8,6 +8,7 @@ Compiled compute shader: BloomPrefilter, kernel: KMain, keywords ENABLE_ALPHA LO
 Compiled compute shader: BloomPrefilter, kernel: KMain, keywords LOW_QUALITY
 Compiled compute shader: BloomUpsample, kernel: KMain, keywords HIGH_QUALITY
 Compiled compute shader: BloomUpsample, kernel: KMain, keywords LOW_QUALITY
+Compiled compute shader: ClearBuffer2D, kernel: ClearBuffer2DMain, keywords <no keywords>
 Compiled compute shader: ClearLightLists, kernel: ClearList, keywords <no keywords>
 Compiled compute shader: ClearUIntTextureArray, kernel: ClearUIntTexture, keywords <no keywords>
 Compiled compute shader: ClearUIntTextureArray, kernel: ClearUIntTextureArray, keywords <no keywords>

Original file line number	Diff line number	Diff line change
`@@ -2205,12 +2205,13 @@ void PreRenderPassExecute(in CompiledPassInfo passInfo, RenderGraphPass pass, In`
`2205`	`2205`	`{`
`2206`	`2206`	`// Need to save the command buffer to restore it later as the one in the context can changed if running a pass async.`
`2207`	`2207`	`m_PreviousCommandBuffer = rgContext.cmd;`
`2208`		`-`
	`2208`	`+`
	`2209`	`+ bool executedWorkDuringResourceCreation = false;`
`2209`	`2210`	`for (int type = 0; type < (int)RenderGraphResourceType.Count; ++type)`
`2210`	`2211`	`{`
`2211`	`2212`	`foreach (int resource in passInfo.resourceCreateList[type])`
`2212`	`2213`	`{`
`2213`		`- m_Resources.CreatePooledResource(rgContext, type, resource);`
	`2214`	`+ executedWorkDuringResourceCreation \|= m_Resources.CreatePooledResource(rgContext, type, resource);`
`2214`	`2215`	`}`
`2215`	`2216`	`}`
`2216`	`2217`
`@@ -2221,6 +2222,12 @@ void PreRenderPassExecute(in CompiledPassInfo passInfo, RenderGraphPass pass, In`
`2221`	`2222`
`2222`	`2223`	`if (passInfo.enableAsyncCompute)`
`2223`	`2224`	`{`
	`2225`	`+ GraphicsFence previousFence = new GraphicsFence();`
	`2226`	`+ if (executedWorkDuringResourceCreation)`
	`2227`	`+ {`
	`2228`	`+ previousFence = rgContext.cmd.CreateGraphicsFence(GraphicsFenceType.AsyncQueueSynchronisation, SynchronisationStageFlags.AllGPUOperations);`
	`2229`	`+ }`
	`2230`	`+`
`2224`	`2231`	`// Flush current command buffer on the render context before enqueuing async commands.`
`2225`	`2232`	`if (rgContext.contextlessTesting == false)`
`2226`	`2233`	`rgContext.renderContext.ExecuteCommandBuffer(rgContext.cmd);`
`@@ -2229,6 +2236,11 @@ void PreRenderPassExecute(in CompiledPassInfo passInfo, RenderGraphPass pass, In`
`2229`	`2236`	`CommandBuffer asyncCmd = CommandBufferPool.Get(pass.name);`
`2230`	`2237`	`asyncCmd.SetExecutionFlags(CommandBufferExecutionFlags.AsyncCompute);`
`2231`	`2238`	`rgContext.cmd = asyncCmd;`
	`2239`	`+`
	`2240`	`+ if (executedWorkDuringResourceCreation)`
	`2241`	`+ {`
	`2242`	`+ rgContext.cmd.WaitOnAsyncGraphicsFence(previousFence);`
	`2243`	`+ }`
`2232`	`2244`	`}`
`2233`	`2245`
`2234`	`2246`	`// Synchronize with graphics or compute pipe if needed.`
Original file line number	Diff line number	Diff line change
`@@ -91,15 +91,16 @@ internal static RenderGraphResourceRegistry current`
`91`	`91`	`m_CurrentRegistry = value;`
`92`	`92`	`}`
`93`	`93`	`}`
`94`		`-`
	`94`	`+`
	`95`	`+ delegate bool ResourceCreateCallback(InternalRenderGraphContext rgContext, IRenderGraphResource res);`
`95`	`96`	`delegate void ResourceCallback(InternalRenderGraphContext rgContext, IRenderGraphResource res);`
`96`	`97`
`97`	`98`	`class RenderGraphResourcesData`
`98`	`99`	`{`
`99`	`100`	`public DynamicArray<IRenderGraphResource> resourceArray = new DynamicArray<IRenderGraphResource>();`
`100`	`101`	`public int sharedResourcesCount;`
`101`	`102`	`public IRenderGraphResourcePool pool;`
`102`		`- public ResourceCallback createResourceCallback;`
	`103`	`+ public ResourceCreateCallback createResourceCallback;`
`103`	`104`	`public ResourceCallback releaseResourceCallback;`
`104`	`105`
`105`	`106`	`public RenderGraphResourcesData()`
`@@ -1012,10 +1013,11 @@ void ManageSharedRenderGraphResources()`
`1012`	`1013`	`}`
`1013`	`1014`	`}`
`1014`	`1015`
`1015`		`- internal void CreatePooledResource(InternalRenderGraphContext rgContext, int type, int index)`
	`1016`	`+ internal bool CreatePooledResource(InternalRenderGraphContext rgContext, int type, int index)`
`1016`	`1017`	`{`
`1017`	`1018`	`Debug.Assert(index != 0, "Index 0 indicates the null object it can't be used here");`
`1018`	`1019`
	`1020`	`+ bool? executedWork = false;`
`1019`	`1021`	`var resource = m_RenderGraphResources[type].resourceArray[index];`
`1020`	`1022`	`if (!resource.imported)`
`1021`	`1023`	`{`
`@@ -1024,20 +1026,22 @@ internal void CreatePooledResource(InternalRenderGraphContext rgContext, int typ`
`1024`	`1026`	`if (m_RenderGraphDebug.enableLogging)`
`1025`	`1027`	`resource.LogCreation(m_FrameInformationLogger);`
`1026`	`1028`
`1027`		`- m_RenderGraphResources[type].createResourceCallback?.Invoke(rgContext, resource);`
	`1029`	`+ executedWork = m_RenderGraphResources[type].createResourceCallback?.Invoke(rgContext, resource);`
`1028`	`1030`	`}`
	`1031`	`+`
	`1032`	`+ return executedWork ?? false;`
`1029`	`1033`	`}`
`1030`	`1034`
`1031`	`1035`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`1032`		`- internal void CreatePooledResource(InternalRenderGraphContext rgContext, in ResourceHandle handle)`
	`1036`	`+ internal bool CreatePooledResource(InternalRenderGraphContext rgContext, in ResourceHandle handle)`
`1033`	`1037`	`{`
`1034`		`- CreatePooledResource(rgContext, handle.iType, handle.index);`
	`1038`	`+ return CreatePooledResource(rgContext, handle.iType, handle.index);`
`1035`	`1039`	`}`
`1036`	`1040`
`1037`	`1041`	`// Only modified by native compiler when using native render pass`
`1038`	`1042`	`internal bool forceManualClearOfResource = true;`
`1039`	`1043`
`1040`		`- void CreateTextureCallback(InternalRenderGraphContext rgContext, IRenderGraphResource res)`
	`1044`	`+ bool CreateTextureCallback(InternalRenderGraphContext rgContext, IRenderGraphResource res)`
`1041`	`1045`	`{`
`1042`	`1046`	`var resource = res as TextureResource;`
`1043`	`1047`
`@@ -1049,13 +1053,16 @@ void CreateTextureCallback(InternalRenderGraphContext rgContext, IRenderGraphRes`
`1049`	`1053`	`}`
`1050`	`1054`	`#endif`
`1051`	`1055`
	`1056`	`+ bool executedWork = false;`
`1052`	`1057`	`if ((forceManualClearOfResource && resource.desc.clearBuffer) \|\| m_RenderGraphDebug.clearRenderTargetsAtCreation)`
`1053`	`1058`	`{`
`1054`	`1059`	`bool debugClear = m_RenderGraphDebug.clearRenderTargetsAtCreation && !resource.desc.clearBuffer;`
`1055`	`1060`	`var clearFlag = resource.desc.depthBufferBits != DepthBits.None ? ClearFlag.DepthStencil : ClearFlag.Color;`
`1056`	`1061`	`var clearColor = debugClear ? Color.magenta : resource.desc.clearColor;`
`1057`	`1062`	`CoreUtils.SetRenderTarget(rgContext.cmd, resource.graphicsResource, clearFlag, clearColor);`
	`1063`	`+ executedWork = true;`
`1058`	`1064`	`}`
	`1065`	`+ return executedWork;`
`1059`	`1066`	`}`
`1060`	`1067`
`1061`	`1068`	`internal void ReleasePooledResource(InternalRenderGraphContext rgContext, int type, int index)`