Various fixes for Graphics tests with Render Graph

com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphBuilder.cs

@@ -148,6 +148,18 @@ public void EnableAsyncCompute(bool value)
             m_RenderPass.EnableAsyncCompute(value);
         }
 
+        /// <summary>
+        /// Allow or not pass pruning
+        /// By default all passes can be pruned out if the render graph detects it's not actually used.
+        /// In some cases, a pass may not write or read any texture but rather do something with side effects (like setting a global texture parameter for example).
+        /// This function can be used to tell the system that it should not prune this pass.
+        /// </summary>
+        /// <param name="value"></param>
+        public void AllowPassPruning(bool value)
+        {
+            m_RenderPass.AllowPassPruning(value);
+        }
+
         /// <summary>
         /// Dispose the RenderGraphBuilder instance.
         /// </summary>
@@ -175,7 +187,7 @@ void Dispose(bool disposing)
 
         void CheckTransientTexture(TextureHandle input)
         {
-            if (input.transientPassIndex != -1 && input.transientPassIndex != m_RenderPass.index)
+            if (input.IsValid() && input.transientPassIndex != -1 && input.transientPassIndex != m_RenderPass.index)
             {
                 throw new ArgumentException($"Trying to use a transient texture (pass index {input.transientPassIndex}) in a different pass (pass index {m_RenderPass.index}.");
             }

com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphPass.cs

@@ -12,45 +12,40 @@ public RenderFunc<PassData> GetExecuteDelegate<PassData>()
             where PassData : class, new() => ((RenderGraphPass<PassData>)this).renderFunc;
 
         public abstract void Execute(RenderGraphContext renderGraphContext);
-        public abstract void Release(RenderGraphContext renderGraphContext);
+        public abstract void Release(RenderGraphObjectPool pool);
         public abstract bool HasRenderFunc();
 
         public string           name { get; protected set; }
         public int              index { get; protected set; }
         public ProfilingSampler customSampler { get; protected set; }
         public bool             enableAsyncCompute { get; protected set; }
+        public bool             allowPassPruning { get; protected set; }
 
         public TextureHandle    depthBuffer { get; protected set; }
         public TextureHandle[]  colorBuffers { get; protected set; } = new TextureHandle[RenderGraph.kMaxMRTCount];
         public int              colorBufferMaxIndex { get; protected set; } = -1;
         public int              refCount { get; protected set; }
 
-        List<TextureHandle>         m_TextureReadList = new List<TextureHandle>();
-        List<TextureHandle>         m_TextureWriteList = new List<TextureHandle>();
-        List<TextureHandle>         m_TransientTextureList = new List<TextureHandle>();
-        List<ComputeBufferHandle>   m_BufferReadList = new List<ComputeBufferHandle>();
-        List<ComputeBufferHandle>   m_BufferWriteList = new List<ComputeBufferHandle>();
-        List<RendererListHandle>    m_UsedRendererListList = new List<RendererListHandle>();
-
-        public IReadOnlyCollection<TextureHandle>       textureReadList { get { return m_TextureReadList; } }
-        public IReadOnlyCollection<TextureHandle>       textureWriteList { get { return m_TextureWriteList; } }
-        public IReadOnlyCollection<TextureHandle>       transientTextureList { get { return m_TransientTextureList; } }
-        public IReadOnlyCollection<ComputeBufferHandle> bufferReadList { get { return m_BufferReadList; } }
-        public IReadOnlyCollection<ComputeBufferHandle> bufferWriteList { get { return m_BufferWriteList; } }
-        public IReadOnlyCollection<RendererListHandle> usedRendererListList { get { return m_UsedRendererListList; } }
+        public List<TextureHandle>          textureReadList = new List<TextureHandle>();
+        public List<TextureHandle>          textureWriteList = new List<TextureHandle>();
+        public List<TextureHandle>          transientTextureList = new List<TextureHandle>();
+        public List<ComputeBufferHandle>    bufferReadList = new List<ComputeBufferHandle>();
+        public List<ComputeBufferHandle>    bufferWriteList = new List<ComputeBufferHandle>();
+        public List<RendererListHandle>     usedRendererListList = new List<RendererListHandle>();
 
         public void Clear()
         {
             name = "";
             index = -1;
             customSampler = null;
-            m_TextureReadList.Clear();
-            m_TextureWriteList.Clear();
-            m_BufferReadList.Clear();
-            m_BufferWriteList.Clear();
-            m_TransientTextureList.Clear();
-            m_UsedRendererListList.Clear();
+            textureReadList.Clear();
+            textureWriteList.Clear();
+            bufferReadList.Clear();
+            bufferWriteList.Clear();
+            transientTextureList.Clear();
+            usedRendererListList.Clear();
             enableAsyncCompute = false;
+            allowPassPruning = true;
             refCount = 0;
 
             // Invalidate everything
@@ -64,41 +59,46 @@ public void Clear()
 
         public void AddTextureWrite(TextureHandle texture)
         {
-            m_TextureWriteList.Add(texture);
+            textureWriteList.Add(texture);
             refCount++;
         }
 
         public void AddTextureRead(TextureHandle texture)
         {
-            m_TextureReadList.Add(texture);
+            textureReadList.Add(texture);
         }
 
         public void AddBufferWrite(ComputeBufferHandle buffer)
         {
-            m_BufferWriteList.Add(buffer);
+            bufferWriteList.Add(buffer);
             refCount++;
         }
 
         public void AddTransientTexture(TextureHandle texture)
         {
-            m_TransientTextureList.Add(texture);
+            transientTextureList.Add(texture);
         }
 
         public void AddBufferRead(ComputeBufferHandle buffer)
         {
-            m_BufferReadList.Add(buffer);
+            bufferReadList.Add(buffer);
         }
 
         public void UseRendererList(RendererListHandle rendererList)
         {
-            m_UsedRendererListList.Add(rendererList);
+            usedRendererListList.Add(rendererList);
         }
 
         public void EnableAsyncCompute(bool value)
         {
             enableAsyncCompute = value;
         }
 
+        public void AllowPassPruning(bool value)
+        {
+            allowPassPruning = value;
+        }
+
         public void SetColorBuffer(TextureHandle resource, int index)
         {
             Debug.Assert(index < RenderGraph.kMaxMRTCount && index >= 0);
@@ -110,9 +110,9 @@ public void SetColorBuffer(TextureHandle resource, int index)
         public void SetDepthBuffer(TextureHandle resource, DepthAccess flags)
         {
             depthBuffer = resource;
-            if ((flags | DepthAccess.Read) != 0)
+            if ((flags & DepthAccess.Read) != 0)
                 AddTextureRead(resource);
-            if ((flags | DepthAccess.Write) != 0)
+            if ((flags & DepthAccess.Write) != 0)
                 AddTextureWrite(resource);
         }
     }
@@ -138,13 +138,15 @@ public void Initialize(int passIndex, PassData passData, string passName, Profil
             customSampler = sampler;
         }
 
-        public override void Release(RenderGraphContext renderGraphContext)
+        public override void Release(RenderGraphObjectPool pool)
         {
             Clear();
-            renderGraphContext.renderGraphPool.Release(data);
+            pool.Release(data);
             data = null;
             renderFunc = null;
-            renderGraphContext.renderGraphPool.Release(this);
+
+            // We need to do the release from here because we need the final type.
+            pool.Release(this);
         }
 
         public override bool HasRenderFunc()

com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphResourceRegistry.cs

@@ -421,7 +421,7 @@ public RTHandle GetTexture(in TextureHandle handle)
         /// <returns>The Renderer List associated with the provided resource handle or an invalid renderer list if the handle is invalid.</returns>
         public RendererList GetRendererList(in RendererListHandle handle)
         {
-            if (!handle.IsValid())
+            if (!handle.IsValid() || handle >= m_RendererListResources.size)
                 return RendererList.nullRendererList;
 
             return m_RendererListResources[handle].rendererList;
@@ -476,9 +476,9 @@ internal bool IsTextureImported(TextureHandle handle)
         internal TextureHandle ImportBackbuffer(RenderTargetIdentifier rt)
         {
             if (m_CurrentBackbuffer != null)
-                m_RTHandleSystem.Release(m_CurrentBackbuffer);
-
-            m_CurrentBackbuffer = m_RTHandleSystem.Alloc(rt);
+                m_CurrentBackbuffer.SetTexture(rt);
+            else
+                m_CurrentBackbuffer = m_RTHandleSystem.Alloc(rt);
 
             int newHandle = m_TextureResources.Add(new TextureResource(m_CurrentBackbuffer, 0));
             return new TextureHandle(newHandle);
@@ -603,7 +603,7 @@ void CreateTextureForPass(ref TextureResource resource)
             resource.cachedHash = hashCode;
         }
 
-        void SetGlobalTextures(RenderGraphContext rgContext, IReadOnlyCollection<TextureHandle> textures, bool bindDummyTexture)
+        void SetGlobalTextures(RenderGraphContext rgContext, List<TextureHandle> textures, bool bindDummyTexture)
         {
             foreach (var resource in textures)
             {
@@ -620,12 +620,12 @@ void SetGlobalTextures(RenderGraphContext rgContext, IReadOnlyCollection<Texture
         }
 
 
-        internal void PreRenderPassSetGlobalTextures(RenderGraphContext rgContext, IReadOnlyCollection<TextureHandle> textures)
+        internal void PreRenderPassSetGlobalTextures(RenderGraphContext rgContext, List<TextureHandle> textures)
         {
             SetGlobalTextures(rgContext, textures, false);
         }
 
-        internal void PostRenderPassUnbindGlobalTextures(RenderGraphContext rgContext, IReadOnlyCollection<TextureHandle> textures)
+        internal void PostRenderPassUnbindGlobalTextures(RenderGraphContext rgContext, List<TextureHandle> textures)
         {
             SetGlobalTextures(rgContext, textures, true);
         }
@@ -748,7 +748,7 @@ internal void CreateRendererLists(List<RendererListHandle> rendererLists)
             }
         }
 
-        internal void Clear()
+        internal void Clear(bool onException)
         {
             LogResources();
 
@@ -757,7 +757,7 @@ internal void Clear()
             m_ComputeBufferResources.Clear();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (m_AllocatedTextures.Count != 0)
+            if (m_AllocatedTextures.Count != 0 && !onException)
             {
                 string logMessage = "RenderGraph: Not all textures were released.";
 
@@ -770,6 +770,10 @@ internal void Clear()
 
                 Debug.LogWarning(logMessage);
             }
+
+            // If an error occurred during execution, it's expected that textures are not all release so we clear the trakcing list.
+            if (onException)
+                m_AllocatedTextures.Clear();
 #endif
         }