NativeRenderPass in URP can reach a hard-coded limit that breaks the rendering when using Compatibility Mode

When extending URP with custom renderer features, and Native RenderPass is enabled in the non-RenderGraph pass, the renderer can crash because of a hard-coded value `kRenderPassMaxCount = 20` used by an static array to set his size.

That static array is saving in the index of the render Pass the hash of the render pass. That is causing that when the index of the pass is higher or equal than 20, the array has no place to save the hash of the pass. In fact, most of the places of the array are empty, because the hash is only allocated when the pass is active.
With this change, the static array is changed to a Dictionary with the key as the index of the Pass, and the value as the hash of the Pass, so when the index of the RenderPass is higher than 20 this will no cause an `IndexOutOfBounds` error.

The rest of structures used in the class could still be working without any problem

Jira ticket: [UUM-69943](https://jira.unity3d.com/browse/UUM-69943)

Author: raquelpeces

Packages/com.unity.render-pipelines.universal/Runtime/NativeRenderPass.cs

@@ -3,14 +3,14 @@
 using System.Linq;
 using Unity.Collections;
 using UnityEngine.Experimental.Rendering;
-using UnityEngine.Rendering;
 
 namespace UnityEngine.Rendering.Universal
 {
     public partial class ScriptableRenderer
     {
-        private const int kRenderPassMapSize = 10;
-        private const int kRenderPassMaxCount = 20;
+        // Used "internal" only for testing. This should be private.
+        internal const int kRenderPassMapSize = 10;
+        internal const int kRenderPassMaxCount = 20;
 
         // used to keep track of the index of the last pass when we called BeginSubpass
         private int m_LastBeginSubpassPassIndex = 0;
@@ -96,7 +96,6 @@ internal void SetupNativeRenderPassFrameData(UniversalCameraData cameraData, boo
                 int lastPassIndex = m_ActiveRenderPassQueue.Count - 1;
 
                 // Make sure the list is already sorted!
-
                 m_MergeableRenderPassesMap.Clear();
                 m_RenderPassesAttachmentCount.Clear();
                 uint currentHashIndex = 0;
@@ -105,15 +104,22 @@ internal void SetupNativeRenderPassFrameData(UniversalCameraData cameraData, boo
                 {
                     var renderPass = m_ActiveRenderPassQueue[i];
 
-                    renderPass.renderPassQueueIndex = i;
-
                     // Disable obsolete warning for internal usage
                     #pragma warning disable CS0618
                     bool RPEnabled = IsRenderPassEnabled(renderPass);
                     #pragma warning restore CS0618
                     if (!RPEnabled)
                         continue;
 
+                    // Check if current index pass is higher than the maximum number of passes
+                    if (i >= kRenderPassMaxCount)
+                    {
+                        Debug.LogError($"Exceeded the maximum number of Render Passes (${kRenderPassMaxCount}). Please consider using Render Graph to support a higher number of render passes with Native RenderPass, note support will be enabled by default.");
+                        return;
+                    }
+
+                    renderPass.renderPassQueueIndex = i;
+
                     var rpDesc = InitializeRenderPassDescriptor(cameraData, renderPass);
 
                     Hash128 hash = CreateRenderPassHash(rpDesc, currentHashIndex);
@@ -129,10 +135,8 @@ internal void SetupNativeRenderPassFrameData(UniversalCameraData cameraData, boo
                     else if (m_MergeableRenderPassesMap[hash][GetValidPassIndexCount(m_MergeableRenderPassesMap[hash]) - 1] != (i - 1))
                     {
                         // if the passes are not sequential we want to split the current mergeable passes list. So we increment the hashIndex and update the hash
-
                         currentHashIndex++;
                         hash = CreateRenderPassHash(rpDesc, currentHashIndex);
-
                         m_PassIndexToPassHash[i] = hash;
 
                         m_MergeableRenderPassesMap.Add(hash, m_MergeableRenderPassesMapArrays[m_MergeableRenderPassesMap.Count]);

Packages/com.unity.render-pipelines.universal/Tests/Editor/NativeRenderPassTests.cs

@@ -0,0 +1,131 @@
+using System;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+
+namespace UnityEditor.Rendering.Universal.Tests
+{
+    [TestFixture]
+    class NativeRenderPassTests
+    {
+        internal class TestHelper
+        {
+            internal UniversalRendererData rendererData;
+            internal UniversalCameraData cameraData;
+            internal UniversalRenderPipelineAsset urpAsset;
+            internal ScriptableRenderer scriptableRenderer;
+
+            public TestHelper()
+            {
+                try
+                {
+                    rendererData = ScriptableObject.CreateInstance<UniversalRendererData>();
+                    
+                    urpAsset = UniversalRenderPipelineAsset.Create(rendererData);
+                    urpAsset.name = "TestHelper_URPAsset";
+                    GraphicsSettings.defaultRenderPipeline = urpAsset;
+
+                    scriptableRenderer = urpAsset.GetRenderer(0);
+
+                    cameraData = new UniversalCameraData();
+
+                    ResetData();
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError(e.StackTrace);
+                    Cleanup();
+                }
+            }
+
+            internal void ResetData()
+            {
+                scriptableRenderer.useRenderPassEnabled = true;
+            }
+
+            internal void Cleanup()
+            {
+                ScriptableObject.DestroyImmediate(urpAsset);
+                ScriptableObject.DestroyImmediate(rendererData);
+            }
+        }
+
+        private TestHelper m_TestHelper;
+        
+        private RenderPipelineAsset m_PreviousRenderPipelineAssetGraphicsSettings;
+        private RenderPipelineAsset m_PreviousRenderPipelineAssetQualitySettings;
+        public class TestRenderPassUseNRP : ScriptableRenderPass
+        {
+            public TestRenderPassUseNRP()
+            {
+                // Initialize with this argument to true, to avoid other unrelated errors
+                overrideCameraTarget = true;
+                // Enable the use of Native Render Pass. This is set to true by defalult, but we want to make it explicit
+                useNativeRenderPass = true;
+            }
+        }
+
+        [OneTimeSetUp]
+        public void OneTimeSetup()
+        {
+            m_PreviousRenderPipelineAssetGraphicsSettings = GraphicsSettings.defaultRenderPipeline;
+            m_PreviousRenderPipelineAssetQualitySettings = QualitySettings.renderPipeline;
+            GraphicsSettings.defaultRenderPipeline = null;
+            QualitySettings.renderPipeline = null;
+        }
+
+        [SetUp]
+        public void Setup()
+        {
+            m_TestHelper = new();
+            m_TestHelper.ResetData();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            m_TestHelper.Cleanup();
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+            GraphicsSettings.defaultRenderPipeline = m_PreviousRenderPipelineAssetGraphicsSettings;
+            QualitySettings.renderPipeline = m_PreviousRenderPipelineAssetQualitySettings;
+        }
+
+        public void InitializeRenderPassQueue(ScriptableRenderer renderer, int count)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                renderer.EnqueuePass(new TestRenderPassUseNRP());
+            }
+        }
+
+        [Test]
+        public void UnderLimitRenderPassInNRP()
+        {
+            // Use kRenderPassMaxCount so this is the maximun allowed
+            InitializeRenderPassQueue(m_TestHelper.scriptableRenderer, ScriptableRenderer.kRenderPassMaxCount);
+            // Check that no exception is thrown.
+            Assert.DoesNotThrow(() => m_TestHelper.scriptableRenderer.SetupNativeRenderPassFrameData(m_TestHelper.cameraData, true));
+        }
+
+        [Test]
+        public void OverLimitRenderPassInNRP()
+        {
+            // Increase by one the maximum allowed render passes
+            InitializeRenderPassQueue(m_TestHelper.scriptableRenderer, ScriptableRenderer.kRenderPassMaxCount+1);
+            // Check that a logError is thrown, but no other errors are thrown.
+            m_TestHelper.scriptableRenderer.SetupNativeRenderPassFrameData( m_TestHelper.cameraData, true );
+            LogAssert.Expect($"Exceeded the maximum number of Render Passes (${ScriptableRenderer.kRenderPassMaxCount}). Please consider using Render Graph to support a higher number of render passes with Native RenderPass, note support will be enabled by default.");
+        }
+
+    }
+
+    
+
+}