Fix bug where _WRITE_RENDERING_LAYERS is stripped from incorrect pass

Fixed an issue where _WRITE_RENDERING_LAYERS shader variant is stripped from DepthNormal prepass in URP Forward+ when it should not be, resulting in decals not rendering because the rendering layers texture is clear.

https://jira.unity3d.com/browse/UUM-72315

Author: Mikkel Simonsen

Packages/com.unity.render-pipelines.universal/Editor/ShaderBuildPreprocessor.cs

@@ -682,7 +682,11 @@ internal static ShaderFeatures GetSupportedShaderFeaturesFromRendererFeatures(re
                     continue;
 
                 // Rendering Layers...
-                if (rendererRequirements.isUniversalRenderer && rendererFeature.RequireRenderingLayers(isDeferredRenderer, rendererRequirements.needsGBufferAccurateNormals, out RenderingLayerUtils.Event rendererEvent, out _))
+                if (rendererRequirements.isUniversalRenderer &&
+                    RenderingLayerUtils.RequireRenderingLayers(rendererFeatures,
+                        rendererRequirements.renderingMode,
+                        rendererRequirements.needsGBufferAccurateNormals,
+                        rendererRequirements.msaaSampleCount, out RenderingLayerUtils.Event rendererEvent, out _))
                 {
                     usesRenderingLayers = true;
                     RenderingLayerUtils.CombineRendererEvents(isDeferredRenderer, rendererRequirements.msaaSampleCount, rendererEvent, ref renderingLayersEvent);

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

@@ -34,65 +34,34 @@ public static void CombineRendererEvents(bool isDeferred, int msaaSampleCount, E
                 combinedEvent = Combine(combinedEvent, rendererEvent);
         }
 
-        /// <summary>
-        /// Returns True if <see cref="UniversalRendererData"/> will require rendering layers texture.
-        /// </summary>
-        /// <param name="universalRendererData"></param>
-        /// <param name="msaaSampleCount">Event at which rendering layers texture needs to be created</param>
-        /// <param name="combinedEvent">Event at which rendering layers texture needs to be created</param>
-        /// <param name="combinedMaskSize">The mask size of rendering layers texture</param>
-        public static bool RequireRenderingLayers(UniversalRendererData universalRendererData, int msaaSampleCount, out Event combinedEvent, out MaskSize combinedMaskSize)
-        {
-            combinedEvent = Event.Opaque;
-            combinedMaskSize = MaskSize.Bits8;
-
-            bool isDeferred = universalRendererData.renderingMode == RenderingMode.Deferred;
-            bool result = false;
-            foreach (var rendererFeature in universalRendererData.rendererFeatures)
-            {
-                if (rendererFeature.isActive)
-                {
-                    result |= rendererFeature.RequireRenderingLayers(isDeferred, universalRendererData.accurateGbufferNormals, out Event rendererEvent, out MaskSize rendererMaskSize);
-                    combinedEvent = Combine(combinedEvent, rendererEvent);
-                    combinedMaskSize = Combine(combinedMaskSize, rendererMaskSize);
-                }
-            }
-
-            // Rendering layers can not use MSAA resolve, because it encodes integer
-            if (msaaSampleCount > 1 && combinedEvent == Event.Opaque && !isDeferred)
-                combinedEvent = Event.DepthNormalPrePass;
-
-            // Make sure texture has enough bits to encode all rendering layers in urp global settings
-            if (UniversalRenderPipelineGlobalSettings.instance)
-            {
-                int count =  RenderingLayerMask.GetRenderingLayerCount();
-                MaskSize maskSize = GetMaskSize(count);
-                combinedMaskSize = Combine(combinedMaskSize, maskSize);
-            }
-
-            return result;
-        }
-
         /// <summary>
         /// Returns True if <see cref="UniversalRenderer"/> will require rendering layers texture.
         /// </summary>
         /// <param name="universalRenderer"></param>
-        /// <param name="rendererFeatures">Event at which rendering layers texture needs to be created</param>
-        /// <param name="msaaSampleCount">Event at which rendering layers texture needs to be created</param>
+        /// <param name="rendererFeatures">List of renderer features used by the renderer</param>
+        /// <param name="msaaSampleCount">MSAA sample count</param>
         /// <param name="combinedEvent">Event at which rendering layers texture needs to be created</param>
         /// <param name="combinedMaskSize">The mask size of rendering layers texture</param>
         public static bool RequireRenderingLayers(UniversalRenderer universalRenderer, List<ScriptableRendererFeature> rendererFeatures, int msaaSampleCount, out Event combinedEvent, out MaskSize combinedMaskSize)
+        {
+            RenderingMode renderingMode = universalRenderer.renderingModeActual;
+            bool accurateGBufferNormals = universalRenderer.accurateGbufferNormals;
+            return RequireRenderingLayers(rendererFeatures, renderingMode, accurateGBufferNormals, msaaSampleCount,
+                out combinedEvent, out combinedMaskSize);
+        }
+
+        internal static bool RequireRenderingLayers(List<ScriptableRendererFeature> rendererFeatures, RenderingMode renderingMode, bool accurateGbufferNormals, int msaaSampleCount, out Event combinedEvent, out MaskSize combinedMaskSize)
         {
             combinedEvent = Event.Opaque;
             combinedMaskSize = MaskSize.Bits8;
 
-            bool isDeferred = universalRenderer.renderingModeActual == RenderingMode.Deferred;
+            bool isDeferred = renderingMode == RenderingMode.Deferred;
             bool result = false;
             foreach (var rendererFeature in rendererFeatures)
             {
                 if (rendererFeature.isActive)
                 {
-                    result |= rendererFeature.RequireRenderingLayers(isDeferred, universalRenderer.accurateGbufferNormals, out Event rendererEvent, out MaskSize rendererMaskSize);
+                    result |= rendererFeature.RequireRenderingLayers(isDeferred, accurateGbufferNormals, out Event rendererEvent, out MaskSize rendererMaskSize);
                     combinedEvent = Combine(combinedEvent, rendererEvent);
                     combinedMaskSize = Combine(combinedMaskSize, rendererMaskSize);
                 }

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

@@ -675,7 +675,7 @@ void SetupRenderingLayers(int msaaSamples)
             m_RequiresRenderingLayer = RenderingLayerUtils.RequireRenderingLayers(this, rendererFeatures, msaaSamples,
                 out m_RenderingLayersEvent, out m_RenderingLayersMaskSize);
 
-            m_RenderingLayerProvidesRenderObjectPass = m_RequiresRenderingLayer && renderingModeActual == RenderingMode.Forward && m_RenderingLayersEvent == RenderingLayerUtils.Event.Opaque;
+            m_RenderingLayerProvidesRenderObjectPass = m_RequiresRenderingLayer && m_RenderingLayersEvent == RenderingLayerUtils.Event.Opaque;
             m_RenderingLayerProvidesByDepthNormalPass = m_RequiresRenderingLayer && m_RenderingLayersEvent == RenderingLayerUtils.Event.DepthNormalPrePass;
 
             if (m_DeferredLights != null)

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

@@ -814,6 +814,37 @@ public  void TestGetSupportedShaderFeaturesFromRendererFeatures_RenderingLayers(
             actual = m_TestHelper.GetSupportedShaderFeaturesFromRendererFeatures(rendererRequirements);
             expected = ShaderFeatures.DecalGBuffer | ShaderFeatures.DecalNormalBlendLow | ShaderFeatures.DecalLayers | ShaderFeatures.DepthNormalPassRenderingLayers | ShaderFeatures.GBufferWriteRenderingLayers;
             m_TestHelper.AssertShaderFeaturesAndReset(expected, actual);
+
+            // Test with DepthNormal prepass enabled (Is enabled implicitly by SSAO f.ex)
+            ScreenSpaceAmbientOcclusion ssaoFeature = ScriptableObject.CreateInstance<ScreenSpaceAmbientOcclusion>();
+            ssaoFeature.settings = new ScreenSpaceAmbientOcclusionSettings()
+            {
+                AOMethod = ScreenSpaceAmbientOcclusionSettings.AOMethodOptions.BlueNoise,
+                Downsample = false,
+                AfterOpaque = false,
+                Source = ScreenSpaceAmbientOcclusionSettings.DepthSource.DepthNormals,
+                NormalSamples = ScreenSpaceAmbientOcclusionSettings.NormalQuality.Medium,
+                Intensity = 3.0f,
+                DirectLightingStrength = 0.25f,
+                Radius = 0.035f,
+                Samples = ScreenSpaceAmbientOcclusionSettings.AOSampleOption.Medium,
+                BlurQuality = ScreenSpaceAmbientOcclusionSettings.BlurQualityOptions.High,
+                Falloff = 100f,
+            };
+            ssaoFeature.SetActive(true);
+            m_TestHelper.rendererFeatures.Add(ssaoFeature);
+
+            ((DecalRendererFeature)m_TestHelper.rendererFeatures[0]).settings.technique = DecalTechniqueOption.ScreenSpace;
+            ((DecalRendererFeature)m_TestHelper.rendererFeatures[0]).settings.decalLayers = true;
+            rendererRequirements = m_TestHelper.defaultRendererRequirements;
+            rendererRequirements.needsUnusedVariants = false;
+            actual = m_TestHelper.GetSupportedShaderFeaturesFromRendererFeatures(rendererRequirements);
+            expected = ShaderFeatures.ScreenSpaceOcclusion | ShaderFeatures.DecalScreenSpace |
+                       ShaderFeatures.DecalNormalBlendLow | ShaderFeatures.DecalLayers |
+                       ShaderFeatures.DepthNormalPassRenderingLayers;
+            m_TestHelper.AssertShaderFeaturesAndReset(expected, actual);
+
+            m_TestHelper.rendererFeatures.Remove(ssaoFeature);
         }
 
         [Test]