Internal/6000.0/staging

Internal/6000.0/staging

Author: claire-nicholson

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

@@ -1420,7 +1420,7 @@ public void ExecuteGraph(InternalRenderGraphContext rgContext, RenderGraphResour
                 if (pass.waitOnGraphicsFencePassId != -1)
                 {
                     var fence = contextData.fences[pass.waitOnGraphicsFencePassId];
-                    rgContext.cmd.WaitOnAsyncGraphicsFence(fence);
+                    rgContext.cmd.WaitOnAsyncGraphicsFence(fence, SynchronisationStageFlags.PixelProcessing);
                 }
 
                 var nrpBegan = false;

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

@@ -146,7 +146,7 @@ public void SetWritingPass(CompilerContextData ctx, ResourceHandle h, int passId
         public void RegisterReadingPass(CompilerContextData ctx, ResourceHandle h, int passId, int index)
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (numReaders >= ctx.resources.MaxReaders)
+            if (numReaders >= ctx.resources.MaxReaders[h.iType])
             {
                 string passName = ctx.GetPassName(passId);
                 string resourceName = ctx.GetResourceName(h);
@@ -194,8 +194,8 @@ internal class ResourcesData
         public NativeList<ResourceVersionedData>[] versionedData; // Flattened fixed size array storing up to MaxVersions versions per resource id.
         public NativeList<ResourceReaderData>[] readerData; // Flattened fixed size array storing up to MaxReaders per resource id per version.
 
-        public int MaxVersions;
-        public int MaxReaders;
+        public int[] MaxVersions;
+        public int[] MaxReaders;
 
         public DynamicArray<Name>[] resourceNames;
 
@@ -205,6 +205,8 @@ public ResourcesData()
             versionedData = new NativeList<ResourceVersionedData>[(int)RenderGraphResourceType.Count];
             readerData = new NativeList<ResourceReaderData>[(int)RenderGraphResourceType.Count];
             resourceNames = new DynamicArray<Name>[(int)RenderGraphResourceType.Count];
+            MaxVersions = new int[(int)RenderGraphResourceType.Count];
+            MaxReaders = new int[(int)RenderGraphResourceType.Count];
 
             for (int t = 0; t < (int)RenderGraphResourceType.Count; t++)
                 resourceNames[t] = new DynamicArray<Name>(0); // T in NativeList<T> cannot contain managed types, so the names are stored separately
@@ -241,14 +243,14 @@ void AllocateAndResizeNativeListIfNeeded<T>(ref NativeList<T> nativeList, int si
 
         public void Initialize(RenderGraphResourceRegistry resources)
         {
-            uint maxReaders = 0;
-            uint maxWriters = 0;
-
             for (int t = 0; t < (int)RenderGraphResourceType.Count; t++)
             {
                 RenderGraphResourceType resourceType = (RenderGraphResourceType) t;
                 var numResources = resources.GetResourceCount(resourceType);
 
+                uint maxReaders = 0;
+                uint maxWriters = 0;
+
                 // We don't clear the list as we reinitialize it right after
                 AllocateAndResizeNativeListIfNeeded(ref unversionedData[t], numResources, NativeArrayOptions.UninitializedMemory);
 
@@ -308,12 +310,12 @@ public void Initialize(RenderGraphResourceRegistry resources)
                 }
 
                 // The first resource is a null resource, so we need to add 1 to the count.
-                MaxReaders = (int)maxReaders + 1;
-                MaxVersions = (int)maxWriters + 1;
+                MaxReaders[t] = (int)maxReaders + 1;
+                MaxVersions[t]  = (int)maxWriters + 1;
 
                 // Clear the other caching structures, they will be filled later
-                AllocateAndResizeNativeListIfNeeded(ref versionedData[t], MaxVersions * numResources, NativeArrayOptions.ClearMemory);
-                AllocateAndResizeNativeListIfNeeded(ref readerData[t], MaxVersions * MaxReaders * numResources, NativeArrayOptions.ClearMemory);
+                AllocateAndResizeNativeListIfNeeded(ref versionedData[t], MaxVersions[t] * numResources, NativeArrayOptions.ClearMemory);
+                AllocateAndResizeNativeListIfNeeded(ref readerData[t], MaxVersions[t] * MaxReaders[t] * numResources, NativeArrayOptions.ClearMemory);
             }
         }
 
@@ -322,23 +324,23 @@ public void Initialize(RenderGraphResourceRegistry resources)
         public int Index(ResourceHandle h)
         {
 #if UNITY_EDITOR // Hot path
-            if (h.version < 0 || h.version >= MaxVersions)
+            if (h.version < 0 || h.version >= MaxVersions[h.iType])
                 throw new Exception("Invalid version: " + h.version);
 #endif
-            return h.index * MaxVersions + h.version;
+            return h.index * MaxVersions[h.iType] + h.version;
         }
 
         // Flatten array index
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public int IndexReader(ResourceHandle h, int readerID)
         {
 #if UNITY_EDITOR // Hot path
-            if (h.version < 0 || h.version >= MaxVersions)
+            if (h.version < 0 || h.version >= MaxVersions[h.iType])
                 throw new Exception("Invalid version");
-            if (readerID < 0 || readerID >= MaxReaders)
+            if (readerID < 0 || readerID >= MaxReaders[h.iType])
                 throw new Exception("Invalid reader");
 #endif
-            return (h.index * MaxVersions + h.version) * MaxReaders + readerID;
+            return (h.index * MaxVersions[h.iType] + h.version) * MaxReaders[h.iType] + readerID;
         }
 
         // Lookup data for a given handle

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

@@ -524,7 +524,7 @@ public void Cleanup()
 
             nativeCompiler?.Cleanup();
 
-            m_CompilationCache?.Clear();
+            m_CompilationCache?.Cleanup();
         }
 
         internal RenderGraphDebugParams debugParams => m_DebugParameters;
@@ -1119,7 +1119,7 @@ public RenderGraphBuilder AddRenderPass<PassData>(string passName, out PassData
             [CallerLineNumber] int line = 0) where PassData : class, new()
 #endif
         {
-            var renderPass = m_RenderGraphPool.Get<RenderGraphPass<PassData>>();          
+            var renderPass = m_RenderGraphPool.Get<RenderGraphPass<PassData>>();
             renderPass.Initialize(m_RenderPasses.Count, m_RenderGraphPool.Get<PassData>(), passName, RenderGraphPassType.Legacy, sampler);
             renderPass.AllowGlobalState(true);// Old pass types allow global state by default as HDRP relies on it
 
@@ -2263,14 +2263,14 @@ void PreRenderPassExecute(in CompiledPassInfo passInfo, RenderGraphPass pass, In
 
                 if (executedWorkDuringResourceCreation)
                 {
-                    rgContext.cmd.WaitOnAsyncGraphicsFence(previousFence);
+                    rgContext.cmd.WaitOnAsyncGraphicsFence(previousFence, SynchronisationStageFlags.PixelProcessing);
                 }
             }
 
             // Synchronize with graphics or compute pipe if needed.
             if (passInfo.syncToPassIndex != -1)
             {
-                rgContext.cmd.WaitOnAsyncGraphicsFence(m_CurrentCompiledGraph.compiledPassInfos[passInfo.syncToPassIndex].fence);
+                rgContext.cmd.WaitOnAsyncGraphicsFence(m_CurrentCompiledGraph.compiledPassInfos[passInfo.syncToPassIndex].fence, SynchronisationStageFlags.PixelProcessing);
             }
         }
 

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

@@ -96,14 +96,41 @@ public bool GetCompilationCache(int hash, int frameIndex, out CompilerContextDat
         return GetCompilationCache(hash, frameIndex, out outGraph, m_NativeHashEntries, m_NativeCompiledGraphPool, s_NativeEntryComparer);
     }
 
-    public void Clear()
+    public void Cleanup()
     {
+        // We clear the contents of the pools but not the pool themselves, because they are only
+        // filled at the beginning of the renderer pipeline and never after. This means when we call
+        // Cleanup() after an error, if we were clearing the pools, the render graph could not gracefully start
+        // back up because the cache would have a size of 0 (so no room to cache anything).
+
+        // Cleanup compiled graphs currently in the cache
         for (int i = 0; i < m_HashEntries.size; ++i)
-            m_CompiledGraphPool.Push(m_HashEntries[i].compiledGraph);
+        {
+            var compiledGraph = m_HashEntries[i].compiledGraph;
+            compiledGraph.Clear();
+        }
         m_HashEntries.Clear();
 
+        // Cleanup compiled graphs that might be left in the pool
+        var compiledGraphs = m_CompiledGraphPool.ToArray();
+        for (int i = 0; i < compiledGraphs.Length; ++i)
+        {
+            compiledGraphs[i].Clear();
+        }
+
+        // Dispose of CompilerContextData currently in the cache
         for (int i = 0; i < m_NativeHashEntries.size; ++i)
-            m_NativeCompiledGraphPool.Push(m_NativeHashEntries[i].compiledGraph);
+        {
+            var compiledGraph = m_NativeHashEntries[i].compiledGraph;
+            compiledGraph.Dispose();
+        }
         m_NativeHashEntries.Clear();
+
+        // Dispose of CompilerContextData that might be left in the pool
+        var nativeCompiledGraphs = m_NativeCompiledGraphPool.ToArray();
+        for (int i = 0; i < nativeCompiledGraphs.Length; ++i)
+        {
+            nativeCompiledGraphs[i].Dispose();
+        }
     }
 }

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

@@ -48,7 +48,7 @@ private void InitDefaultResourcesIfNeeded()
                 m_WhiteTexture2D = RTHandles.Alloc(Texture2D.whiteTexture);
 
             if (m_ShadowTexture2D == null)
-                m_ShadowTexture2D = RTHandles.Alloc(1, 1, Experimental.Rendering.GraphicsFormat.D32_SFloat, isShadowMap: true, name: "DefaultShadowTexture");
+                m_ShadowTexture2D = RTHandles.Alloc(1, 1, CoreUtils.GetDefaultDepthOnlyFormat(), isShadowMap: true, name: "DefaultShadowTexture");
         }
 
         internal void Cleanup()

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

@@ -876,11 +876,11 @@ public void MaxReadersAndMaxVersionsAreCorrectForBuffers()
 
             // The resource with the biggest MaxReaders is buffer2:
             // 1 implicit read (TestPass0) + 1 explicit read (TestPass1) + 1 for the offset.
-            Assert.AreEqual(result.contextData.resources.MaxReaders, 3);
+            Assert.AreEqual(result.contextData.resources.MaxReaders[(int)RenderGraphResourceType.Buffer], 3);
 
             // The resource with the biggest MaxVersion is buffer2:
             // 1 explicit write (TestPass0) + 1 explicit readwrite (TestPass1) + 1 for the offset
-            Assert.AreEqual(result.contextData.resources.MaxVersions, 3);
+            Assert.AreEqual(result.contextData.resources.MaxVersions[(int)RenderGraphResourceType.Buffer], 3);
         }
 
         [Test]
@@ -917,11 +917,11 @@ public void MaxReadersAndMaxVersionsAreCorrectForTextures()
 
             // Resources with the biggest MaxReaders are extraBuffers[0] and depthBuffer (both being equal):
             // 1 implicit read (TestPass0) + 2 explicit read (TestPass1 & TestPass2) + 1 for the offset
-            Assert.AreEqual(result.contextData.resources.MaxReaders, 4);
+            Assert.AreEqual(result.contextData.resources.MaxReaders[(int)RenderGraphResourceType.Texture], 4);
 
             // The resource with the biggest MaxVersion is extraBuffers[0]:
             // 1 explicit write (TestPass0) + 1 explicit read-write (TestPass1) + 1 for the offset
-            Assert.AreEqual(result.contextData.resources.MaxVersions, 3);
+            Assert.AreEqual(result.contextData.resources.MaxVersions[(int)RenderGraphResourceType.Texture], 3);
         }
 
         [Test]
@@ -959,11 +959,88 @@ public void MaxReadersAndMaxVersionsAreCorrectForBuffersMultiplePasses()
 
             // The resource with the biggest MaxReaders is buffer2:
             // 5 implicit read (TestPass0-2-4-6-8) + 5 explicit read (TestPass1-3-5-7-9) + 1 for the offset.
-            Assert.AreEqual(result.contextData.resources.MaxReaders, 11);
+            Assert.AreEqual(result.contextData.resources.MaxReaders[(int)RenderGraphResourceType.Buffer], 11);
 
             // The resource with the biggest MaxVersion is buffer2:
             // 5 explicit write (TestPass0-2-4-6-8) + 5 explicit readwrite (TestPass1-3-5-7-9) + 1 for the offset
-            Assert.AreEqual(result.contextData.resources.MaxVersions, 11);
+            Assert.AreEqual(result.contextData.resources.MaxVersions[(int)RenderGraphResourceType.Buffer], 11);
+        }
+
+        [Test]
+        public void ResourcesData_MaxReadersAndVersionsPerResourceType()
+        {
+            var g = AllocateRenderGraph();
+            var renderTargets = ImportAndCreateBuffers(g);
+
+            var desc = new BufferDesc(1024, 16);
+            var buffer = g.CreateBuffer(desc);
+
+            int indexName = 0;
+
+            // TEXTURE PASSES: Create 2 versions with different reader counts
+            // Texture Pass 0: Create version 1 of extraBuffers[0] (ReadWrite = 1 write + 1 implicit read)
+            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("TestPassTexture" + indexName++, out var passData))
+            {
+                builder.AllowPassCulling(false);
+                builder.SetRenderAttachment(renderTargets.extraBuffers[0], 0, AccessFlags.ReadWrite);
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+            }
+            // Texture Pass 1: Create version 2 of extraBuffers[0] (ReadWrite = 1 write + 1 explicit read of version 1)
+            using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("TestPassTexture" + indexName++, out var passData))
+            {
+                builder.AllowPassCulling(false);
+                builder.SetRenderAttachment(renderTargets.extraBuffers[0], 0, AccessFlags.ReadWrite);
+                builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+            }
+
+            // BUFFER PASSES: Create many versions to test higher reader/version counts
+            indexName = 0;
+            for (int i = 0; i < 5; ++i)
+            {
+                // Buffer Pass (Write): Creates version N (1 write + 1 implicit read from previous version)
+                using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("TestPassBuffer" + indexName++, out var passData))
+                {
+                    builder.AllowPassCulling(false);
+                    builder.UseBufferRandomAccess(buffer, 0, AccessFlags.Write);
+                    builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                }
+                // Buffer Pass (ReadWrite): Creates version N+1 (1 write + 1 explicit read from version N)
+                using (var builder = g.AddRasterRenderPass<RenderGraphTestPassData>("TestPassBuffer" + indexName++, out var passData))
+                {
+                    builder.AllowPassCulling(false);
+                    builder.UseBufferRandomAccess(buffer, 0, AccessFlags.ReadWrite);
+                    builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
+                }
+            }
+
+            var result = g.CompileNativeRenderGraph(g.ComputeGraphHash());
+            var passes = result.contextData.GetNativePasses();
+
+            // VERIFY: MaxReaders and MaxVersions are calculated PER RESOURCE TYPE
+            // TEXTURE TYPE:
+            // 2 readwrite operations = 2 versions + 1 offset = 3 versions/readers.
+            Assert.AreEqual(result.contextData.resources.MaxReaders[(int)RenderGraphResourceType.Texture], 3);
+            Assert.AreEqual(result.contextData.resources.MaxVersions[(int)RenderGraphResourceType.Texture], 3);
+
+            // BUFFER TYPE:
+            // 5 write operations + 5 readwrite operations = 10 versions + 1 offset = 11 versions/readers.
+            Assert.AreEqual(result.contextData.resources.MaxReaders[(int)RenderGraphResourceType.Buffer], 11);
+            Assert.AreEqual(result.contextData.resources.MaxVersions[(int)RenderGraphResourceType.Buffer], 11);
+
+            // VERIFY: Index calculations work correctly with per-type maximums
+            // Get the texture handle from the first native pass attachment
+            var textureHandle = passes[0].attachments[0].handle;
+            Assert.AreEqual(renderTargets.extraBuffers[0].handle.index, passes[0].attachments[0].handle.index);
+
+            // Test Index() calculation uses correct MaxVersions for texture type
+            int indexExpected = textureHandle.index * result.contextData.resources.MaxVersions[(int)RenderGraphResourceType.Texture] + textureHandle.version;
+            Assert.AreEqual(result.contextData.resources.Index(textureHandle), indexExpected);
+            Assert.IsTrue(indexExpected < result.contextData.resources.versionedData[(int)RenderGraphResourceType.Texture].Capacity);
+
+            // Test IndexReader() calculation uses correct MaxReaders for texture type
+            int indexReaderExpected = indexExpected * result.contextData.resources.MaxReaders[(int)RenderGraphResourceType.Texture] + 0;
+            Assert.AreEqual(result.contextData.resources.IndexReader(textureHandle, 0), indexReaderExpected);
+            Assert.IsTrue(indexExpected < result.contextData.resources.readerData[(int)RenderGraphResourceType.Texture].Capacity);
         }
 
         [Test]
@@ -1206,7 +1283,7 @@ public void ChangingGlobalStateDisablesCulling()
 
             Assert.IsTrue(firstNativePass.numGraphPasses == 2);
         }
-        
+
         [Test]
         public void GraphPassesDoesNotAlloc()
         {
@@ -1300,7 +1377,7 @@ public void UpdateSubpassAttachmentIndices_WhenDepthAttachmentIsAdded()
                 builder.SetRenderFunc((RenderGraphTestPassData data, RasterGraphContext context) => { });
                 builder.AllowPassCulling(false);
             }
-            
+
             // Render Pass
             //   attachments: [extraBuffers[0], extraBuffers[1]]
             //   subpass 0: color outputs : [0]

Packages/com.unity.render-pipelines.high-definition/Documentation~/canvas-master-stack-reference.md

@@ -62,4 +62,4 @@ The following table describes the Surface options:
 
 [!include[](snippets/shader-properties/surface-options/material-type.md)]
 [!include[](snippets/shader-properties/surface-options/alpha-clipping.md)]
-
+[!include[](snippets/shader-properties/surface-options/disable-color-tint.md)]

Packages/com.unity.render-pipelines.high-definition/Documentation~/snippets/shader-properties/surface-options/disable-color-tint.md

@@ -0,0 +1,6 @@
+<tr>
+<td><strong>Disable Color Tint</strong></td>
+<td>N/A</td>
+<td>N/A</td>
+<td>Prevents Shader Graph tinting the texture with the color of the UI element. If you enable this setting, use a [Vertex Color Node](https://docs.unity3d.com/Packages/com.unity.shadergraph@latest/index.html?preview=1&subfolder=/manual/Vertex-Color-Node.html) to access the color of the UI element.</td>
+</tr>

Packages/com.unity.render-pipelines.high-definition/Editor/RenderPipeline/HDRenderPipelineUI.Skin.cs

@@ -350,8 +350,8 @@ public class Styles
             public static readonly GUIContent volumeProfileLabel = EditorGUIUtility.TrTextContent("Volume Profile", "Settings that will override the values defined in the Default Volume Profile set in the Render Pipeline Global settings. Local Volumes inside scenes may override these settings further.");
             public static System.Lazy<GUIStyle> volumeProfileContextMenuStyle = new(() => new GUIStyle(CoreEditorStyles.contextMenuStyle) { margin = new RectOffset(0, 1, 3, 0) });
 
-            public static readonly GUIContent[] shadowBitDepthNames = { new GUIContent("32 bit"), new GUIContent("16 bit") };
-            public static readonly int[] shadowBitDepthValues = { (int)DepthBits.Depth32, (int)DepthBits.Depth16 };
+            public static readonly GUIContent[] shadowBitDepthNames = { new GUIContent("32 bit"), new GUIContent("16 bit"), new GUIContent("24 bit") };
+            public static readonly int[] shadowBitDepthValues = { (int)DepthBits.Depth32, (int)DepthBits.Depth16, (int)DepthBits.Depth24 };
 
             public static readonly GUIContent gpuResidentDrawerMode = EditorGUIUtility.TrTextContent("GPU Resident Drawer", "Enables draw submission through the GPU Resident Drawer, which can improve CPU performance");
             public static readonly GUIContent smallMeshScreenPercentage = EditorGUIUtility.TrTextContent("Small-Mesh Screen-Percentage", "Default minimum screen percentage (0-20%) gpu-driven Renderers can cover before getting culled. If a Renderer is part of a LODGroup, this will be ignored.");