Render Graph - Fix support of Transient Textures & Buffers.

Transient resources support is broken in NRP RG.
Reported initially here: https://forum.unity.com/threads/introduction-of-render-graph-in-the-universal-render-pipeline-urp.1500833/page-7#post-9768534

This PR fixes this behavior by removing the error in the console and adding the support of transient resources through the `transientResourceList`. 
Added some unit tests to verify transient resources works well / well created and are can't be shared between passes.

Author: YohannVaastUnity

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/NativePassCompiler.cs

@@ -284,6 +284,34 @@ void BuildGraph()
 
                             ctxPass.numInputs++;
                         }
+
+                        var resourceTrans = inputPass.transientResourceList[type];
+                        var resourceTransCount = resourceTrans.Count;
+
+                        for (var i = 0; i < resourceTransCount; ++i)
+                        {
+                            var resource = resourceTrans[i]; 
+
+                            // Mark this pass as reading from this version of the resource
+                            ctx.resources[resource].RegisterReadingPass(ctx, resource, passId, ctxPass.numInputs);
+
+                            ctx.inputData.Add(new PassInputData
+                            {
+                                resource = resource,
+                            });
+
+                            ctxPass.numInputs++;
+
+                            // Mark this pass as writing to this version of the resource
+                            ctx.resources[resource].SetWritingPass(ctx, resource, passId);
+
+                            ctx.outputData.Add(new PassOutputData
+                            {
+                                resource = resource,
+                            });
+
+                            ctxPass.numOutputs++;
+                        }
                     }
                 }
             }

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

@@ -371,7 +371,7 @@ public bool nativeRenderPassesEnabled
         internal/*for tests*/ RenderGraphResourceRegistry m_Resources;
         RenderGraphObjectPool m_RenderGraphPool = new RenderGraphObjectPool();
         RenderGraphBuilders m_builderInstance = new RenderGraphBuilders();
-        List<RenderGraphPass> m_RenderPasses = new List<RenderGraphPass>(64);
+        internal/*for tests*/ List<RenderGraphPass> m_RenderPasses = new List<RenderGraphPass>(64);
         List<RendererListHandle> m_RendererLists = new List<RendererListHandle>(32);
         RenderGraphDebugParams m_DebugParameters = new RenderGraphDebugParams();
         RenderGraphLogger m_FrameInformationLogger = new RenderGraphLogger();

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

@@ -25,7 +25,7 @@ public struct RenderGraphBuilder : IDisposable
         /// <returns>An updated resource handle to the input resource.</returns>
         public TextureHandle UseColorBuffer(in TextureHandle input, int index)
         {
-            CheckResource(input.handle, true);
+            CheckResource(input.handle, false);
             m_Resources.IncrementWriteCount(input.handle);
             m_RenderPass.SetColorBuffer(input, index);
             return input;
@@ -39,7 +39,7 @@ public TextureHandle UseColorBuffer(in TextureHandle input, int index)
         /// <returns>An updated resource handle to the input resource.</returns>
         public TextureHandle UseDepthBuffer(in TextureHandle input, DepthAccess flags)
         {
-            CheckResource(input.handle, true);
+            CheckResource(input.handle, false);
 
             if ((flags & DepthAccess.Write) != 0)
                 m_Resources.IncrementWriteCount(input.handle);
@@ -320,15 +320,15 @@ void Dispose(bool disposing)
         }
 
         [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR")]
-        void CheckResource(in ResourceHandle res, bool dontCheckTransientReadWrite = false)
+        void CheckResource(in ResourceHandle res, bool checkTransientReadWrite = true)
         {
             if(RenderGraph.enableValidityChecks)
             {
                 if (res.IsValid())
                 {
                     int transientIndex = m_Resources.GetRenderGraphResourceTransientIndex(res);
                     // We have dontCheckTransientReadWrite here because users may want to use UseColorBuffer/UseDepthBuffer API to benefit from render target auto binding. In this case we don't want to raise the error.
-                    if (transientIndex == m_RenderPass.index && !dontCheckTransientReadWrite)
+                    if (transientIndex == m_RenderPass.index && checkTransientReadWrite)
                     {
                         Debug.LogError($"Trying to read or write a transient resource at pass {m_RenderPass.name}.Transient resource are always assumed to be both read and written.");
                     }

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphBuilders.cs

@@ -74,31 +74,27 @@ public void EnableFoveatedRasterization(bool value)
         public BufferHandle CreateTransientBuffer(in BufferDesc desc)
         {
             var result = m_Resources.CreateBuffer(desc, m_RenderPass.index);
-            m_RenderPass.AddTransientResource(result.handle);
+            UseResource(result.handle, AccessFlags.Write | AccessFlags.Read, isTransient: true);
             return result;
         }
 
         public BufferHandle CreateTransientBuffer(in BufferHandle computebuffer)
         {
             var desc = m_Resources.GetBufferResourceDesc(computebuffer.handle);
-            var result = m_Resources.CreateBuffer(desc, m_RenderPass.index);
-            m_RenderPass.AddTransientResource(result.handle);
-            return result;
+            return CreateTransientBuffer(desc);
         }
 
         public TextureHandle CreateTransientTexture(in TextureDesc desc)
         {
             var result = m_Resources.CreateTexture(desc, m_RenderPass.index);
-            m_RenderPass.AddTransientResource(result.handle);
+            UseResource(result.handle, AccessFlags.Write | AccessFlags.Read, isTransient: true);
             return result;
         }
 
         public TextureHandle CreateTransientTexture(in TextureHandle texture)
         {
             var desc = m_Resources.GetTextureResourceDesc(texture.handle);
-            var result = m_Resources.CreateTexture(desc, m_RenderPass.index);
-            m_RenderPass.AddTransientResource(result.handle);
-            return result;
+            return CreateTransientTexture(desc);
         }
 
         public void Dispose()
@@ -188,7 +184,7 @@ private void ValidateWriteTo(in ResourceHandle handle)
             }
         }
 
-        private ResourceHandle UseResource(in ResourceHandle handle, AccessFlags flags)
+        private ResourceHandle UseResource(in ResourceHandle handle, AccessFlags flags, bool isTransient = false)
         {
             CheckResource(handle);
 
@@ -206,6 +202,12 @@ private ResourceHandle UseResource(in ResourceHandle handle, AccessFlags flags)
                     versioned = handle;
                 }
 
+                if (isTransient)
+                {
+                    m_RenderPass.AddTransientResource(versioned);
+                    return GetLatestVersionHandle(handle);
+                }
+
                 m_RenderPass.AddResourceRead(versioned);
 
                 if ((flags & AccessFlags.Read) == 0)
@@ -475,22 +477,22 @@ private ResourceHandle GetLatestVersionHandle(in ResourceHandle handle)
         }
 
         [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR")]
-        void CheckResource(in ResourceHandle res, bool dontCheckTransientReadWrite = false)
+        void CheckResource(in ResourceHandle res, bool checkTransientReadWrite = false)
         {
             if(RenderGraph.enableValidityChecks)
             {
                 if (res.IsValid())
                 {
                     int transientIndex = m_Resources.GetRenderGraphResourceTransientIndex(res);
                     // We have dontCheckTransientReadWrite here because users may want to use UseColorBuffer/UseDepthBuffer API to benefit from render target auto binding. In this case we don't want to raise the error.
-                    if (transientIndex == m_RenderPass.index && !dontCheckTransientReadWrite)
+                    if (transientIndex == m_RenderPass.index && checkTransientReadWrite)
                     {
                         Debug.LogError($"Trying to read or write a transient resource at pass {m_RenderPass.name}.Transient resource are always assumed to be both read and written.");
                     }
 
                     if (transientIndex != -1 && transientIndex != m_RenderPass.index)
                     {
-                        throw new ArgumentException($"Trying to use a transient texture (pass index {transientIndex}) in a different pass (pass index {m_RenderPass.index}).");
+                        throw new ArgumentException($"Trying to use a transient {res.type} (pass index {transientIndex}) in a different pass (pass index {m_RenderPass.index}).");
                     }
                 }
                 else

Packages/com.unity.render-pipelines.core/Tests/Editor/NativePassCompilerRenderGraphTests.cs

@@ -1,4 +1,5 @@
 using NUnit.Framework;
+using System;
 using System.Collections.Generic;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering.RenderGraphModule;
@@ -820,7 +821,6 @@ public void BuffersWork()
             Assert.AreEqual(1, lastUsedList.Length);
             Assert.AreEqual(buffer.handle.index, lastUsedList[0].index);
             Assert.AreEqual(RenderGraphResourceType.Buffer, lastUsedList[0].type);
-
         }
 
         [Test]
@@ -888,5 +888,79 @@ public void ResolveMSAAImportColor()
             // When discarding MSAA color, we only discard the MSAA buffers but keep the resolved texture
             Assert.AreEqual(RenderBufferStoreAction.Resolve, passes[0].attachments[1].storeAction);
         }
+
+        [Test]
+        public void TransientTexturesCantBeReused()
+        {
+            var g = AllocateRenderGraph();
+            var buffers = ImportAndCreateBuffers(g);
+            var textureTransientHandle = TextureHandle.nullHandle;
+
+            // Render something to textureTransientHandle, created locally in the pass.
+            // No exception and no error(s) should be thrown in the Console.
+            {
+                var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("TestPass0", out var passData);
+
+                var textDesc = new TextureDesc(Vector2.one, false, false)
+                {
+                    width = 1920,
+                    height = 1080,
+                    colorFormat = GraphicsFormat.B10G11R11_UFloatPack32,
+                    clearBuffer = true,
+                    clearColor = Color.red,
+                    name = "Transient Texture"
+                };
+                textureTransientHandle = builder.CreateTransientTexture(textDesc);
+
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                builder.Dispose();
+
+                Assert.IsTrue(g.m_RenderPasses.Count != 0);
+                Assert.IsTrue(g.m_RenderPasses[^1].transientResourceList[(int)textureTransientHandle.handle.type].Count != 0);
+            }
+
+            // Try to render something to textureTransientHandle, reusing the previous TextureHandle.
+            // UseTexture should throw an exception.
+            Assert.Throws<ArgumentException>(() =>
+            {
+                var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("TestPass1", out var passData);
+                builder.UseTexture(textureTransientHandle, AccessFlags.Read | AccessFlags.Write);
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                builder.Dispose();
+            });
+        }
+
+        [Test]
+        public void TransientBuffersCantBeReused()
+        {
+            var g = AllocateRenderGraph();
+            var buffers = ImportAndCreateBuffers(g);
+            var bufferTransientHandle = BufferHandle.nullHandle;
+
+            // Render something to textureTransientHandle, created locally in the pass.
+            // No error(s) should be thrown in the Console.
+            {
+                var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("TestPass0", out var passData);
+
+                var prefixBuffer0Desc = new BufferDesc(1920 * 1080, 4, GraphicsBuffer.Target.Raw) { name = "prefixBuffer0" };
+                bufferTransientHandle = builder.CreateTransientBuffer(prefixBuffer0Desc);
+
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                builder.Dispose();
+
+                Assert.IsTrue(g.m_RenderPasses.Count != 0);
+                Assert.IsTrue(g.m_RenderPasses[^1].transientResourceList[(int)bufferTransientHandle.handle.type].Count != 0);
+            }
+
+            // Try to render something to textureTransientHandle, reusing the previous TextureHandle.
+            // UseTexture should throw an exception.
+            Assert.Throws<ArgumentException>(() =>
+            {
+                var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("TestPass1", out var passData);
+                builder.UseBuffer(bufferTransientHandle, AccessFlags.Read | AccessFlags.Write);
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                builder.Dispose();
+            });
+        }
     }
 }

Packages/com.unity.render-pipelines.core/Tests/Editor/RenderGraphTests.cs

@@ -481,7 +481,7 @@ public void TransientResourceNotCulled()
         }
 
         [Test]
-        public void AsyncPassWriteWaitOnGraphcisPipe()
+        public void AsyncPassWriteWaitOnGraphicsPipe()
         {
             TextureHandle texture0;
             using (var builder = m_RenderGraph.AddRenderPass<RenderGraphTestPassData>("TestPass0", out var passData))
@@ -513,7 +513,7 @@ public void AsyncPassWriteWaitOnGraphcisPipe()
         }
 
         [Test]
-        public void AsyncPassReadWaitOnGraphcisPipe()
+        public void AsyncPassReadWaitOnGraphicsPipe()
         {
             TextureHandle texture0;
             TextureHandle texture1;