[2023.3][URP] Improve shader coverage and small fixes

When [UUM-64447](https://jira.unity3d.com/browse/UUM-64447) was investigated it was discovered that URP's testing was missing some shader variant combinations to properly detect the issues that appeared there.

This PR improves testing for:
- Depth textures
- Depth Normal textures
- SSAO

Testing added with this PR:
- Dept, Normals and SSAO textures when rendering transparent objects
- SSAO Blue noise method
- SSAO texture and final results (previously only SSAO Texture)
- Various Alpha Clip, Normal, Parallax and detail combinations in URP Shaders

It also fixes small issues that were uncovered as the test were being made:
- Fixes an issue with depth normals texture when using deferred with scene and game window open.
- SSAO was not working when running on GLES3 and deferred was selected in as the rendering mode. The issue was that deferred is not supported on GLES and the check in SSAO didn't use the actual rendering mode.
- Particles Unlit incorrectly set the DepthNormals pass to not be supported on GLES3 and OpenGL.

Author: ellioman

Packages/com.unity.render-pipelines.universal/Runtime/Passes/ScreenSpaceAmbientOcclusionPass.cs

@@ -9,7 +9,7 @@ internal class ScreenSpaceAmbientOcclusionPass : ScriptableRenderPass
         // Properties
         private bool isRendererDeferred => m_Renderer != null
                                            && m_Renderer is UniversalRenderer
-                                           && ((UniversalRenderer)m_Renderer).renderingModeRequested == RenderingMode.Deferred;
+                                           && ((UniversalRenderer)m_Renderer).renderingModeActual == RenderingMode.Deferred;
 
         // Private Variables
         private readonly bool m_SupportsR8RenderTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.R8);
@@ -46,6 +46,7 @@ internal class ScreenSpaceAmbientOcclusionPass : ScriptableRenderPass
         private static readonly int s_CameraViewProjectionsID = Shader.PropertyToID("_CameraViewProjections");
         private static readonly int s_CameraViewTopLeftCornerID = Shader.PropertyToID("_CameraViewTopLeftCorner");
         private static readonly int s_CameraDepthTextureID = Shader.PropertyToID("_CameraDepthTexture");
+        private static readonly int s_CameraNormalsTextureID = Shader.PropertyToID("_CameraNormalsTexture");
 
         private static readonly int[] m_BilateralTexturesIndices            = { 0, 1, 2, 3 };
         private static readonly ShaderPasses[] m_BilateralPasses            = { ShaderPasses.BilateralBlurHorizontal, ShaderPasses.BilateralBlurVertical, ShaderPasses.BilateralBlurFinal };
@@ -253,21 +254,30 @@ private void SetupKeywordsAndParameters(ref ScreenSpaceAmbientOcclusionSettings
             {
                 m_BlueNoiseTextureIndex = (m_BlueNoiseTextureIndex + 1) % m_BlueNoiseTextures.Length;
                 Texture2D noiseTexture = m_BlueNoiseTextures[m_BlueNoiseTextureIndex];
-
-                m_Material.SetTexture(s_BlueNoiseTextureID, noiseTexture);
-                m_Material.SetVector(s_SSAOBlueNoiseParamsID, new Vector4(
-                    cameraData.pixelWidth / (float)noiseTexture.width, // X Scale
-                    cameraData.pixelHeight / (float)noiseTexture.height, // Y Scale
+                Vector4 blueNoiseParams = new Vector4(
+                    cameraData.pixelWidth / (float)m_BlueNoiseTextures[m_BlueNoiseTextureIndex].width, // X Scale
+                    cameraData.pixelHeight / (float)m_BlueNoiseTextures[m_BlueNoiseTextureIndex].height, // Y Scale
                     Random.value, // X Offset
                     Random.value // Y Offset
-                ));
+                );
+
+                // For testing we use a single blue noise texture and a single set of blue noise params.
+                #if UNITY_INCLUDE_TESTS
+                    noiseTexture = m_BlueNoiseTextures[0];
+                    blueNoiseParams.z = 1;
+                    blueNoiseParams.w = 1;
+                #endif
+
+                m_Material.SetTexture(s_BlueNoiseTextureID, noiseTexture);
+                m_Material.SetVector(s_SSAOBlueNoiseParamsID, blueNoiseParams);
             }
 
             // Setting keywords can be somewhat expensive on low-end platforms.
             // Previous params are cached to avoid setting the same keywords every frame.
             SSAOMaterialParams matParams = new SSAOMaterialParams(ref settings, cameraData.camera.orthographic);
-            bool ssaoParamsDirty = !m_SSAOParamsPrev.Equals(ref matParams);
-            if (!ssaoParamsDirty)
+            bool ssaoParamsDirty = !m_SSAOParamsPrev.Equals(ref matParams);    // Checks if the parameters have changed.
+            bool isParamsPropertySet = m_Material.HasProperty(s_SSAOParamsID); // Checks if the parameters have been set on the material.
+            if (!ssaoParamsDirty && isParamsPropertySet)
                 return;
 
             m_SSAOParamsPrev = matParams;
@@ -299,6 +309,7 @@ private class SSAOPassData
             internal TextureHandle finalTexture;
             internal TextureHandle blurTexture;
             internal TextureHandle cameraDepthTexture;
+            internal TextureHandle cameraNormalsTexture;
         }
 
         private void InitSSAOPassData(ref SSAOPassData data)
@@ -355,7 +366,10 @@ public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer
                     builder.UseTexture(cameraDepthTexture, AccessFlags.Read);
 
                 if (m_CurrentSettings.Source == ScreenSpaceAmbientOcclusionSettings.DepthSource.DepthNormals && cameraNormalsTexture.IsValid())
+                {
                     builder.UseTexture(cameraNormalsTexture, AccessFlags.Read);
+                    passData.cameraNormalsTexture = cameraNormalsTexture;
+                }
 
                 // The global SSAO texture only needs to be set if After Opaque is disabled...
                 if (!passData.afterOpaque && finalTexture.IsValid())
@@ -376,6 +390,12 @@ public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer
                     if (data.cameraColor.IsValid())
                         PostProcessUtils.SetSourceSize(cmd, data.cameraColor);
 
+                    if (data.cameraDepthTexture.IsValid())
+                        data.material.SetTexture(s_CameraDepthTextureID, data.cameraDepthTexture);
+
+                    if (data.cameraNormalsTexture.IsValid())
+                        data.material.SetTexture(s_CameraNormalsTextureID, data.cameraNormalsTexture);
+
                     // AO Pass
                     Blitter.BlitCameraTexture(cmd, data.AOTexture, data.AOTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, data.material,  (int) ShaderPasses.AmbientOcclusion);
 

Packages/com.unity.render-pipelines.universal/Shaders/Particles/ParticlesUnlit.shader

@@ -184,8 +184,7 @@ Shader "Universal Render Pipeline/Particles/Unlit"
             Cull[_Cull]
 
             HLSLPROGRAM
-            #pragma exclude_renderers gles3 glcore
-            #pragma target 4.5
+            #pragma target 2.0
 
             // -------------------------------------
             // Shader Stages

Tests/SRPTests/Packages/com.unity.testing.urp/Scripts/Runtime/OutputTextureFeature.cs

@@ -10,6 +10,7 @@ public class OutputTextureFeature : ScriptableRendererFeature
     public ScriptableRenderPassInput inputRequirement;
     public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRendering;
     public int renderPassEventAdjustment = 0;
+    public Vector4 outputAdjustParams = new Vector4(0, 0, 1, 1);
 
     private Material m_Material;
     private OutputTexturePass m_OutputTexturePassPass;
@@ -35,7 +36,7 @@ public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingD
             m_Material = new Material(shader);
         }
         m_OutputTexturePassPass.renderPassEvent = renderPassEvent + renderPassEventAdjustment;
-        m_OutputTexturePassPass.Setup(renderer, m_Material, inputRequirement);
+        m_OutputTexturePassPass.Setup(renderer, m_Material, inputRequirement, outputAdjustParams);
         renderer.EnqueuePass(m_OutputTexturePassPass);
     }
 
@@ -50,17 +51,19 @@ class OutputTexturePass : ScriptableRenderPass
         private ScriptableRenderer m_Renderer;
         private ProfilingSampler m_ProfilingSampler;
         private PassData m_PassData;
+        public Vector4 m_OutputAdjustParams;
 
         public OutputTexturePass(string profilerTag)
         {
             m_ProfilingSampler = new ProfilingSampler(profilerTag);
             m_PassData = new PassData();
         }
 
-        public void Setup(ScriptableRenderer renderer, Material material, ScriptableRenderPassInput inputRequirement)
+        public void Setup(ScriptableRenderer renderer, Material material, ScriptableRenderPassInput inputRequirement, Vector4 outputAdjustParams)
         {
             m_Material = material;
             m_Renderer = renderer;
+            m_OutputAdjustParams = outputAdjustParams;
             ConfigureInput(inputRequirement);
         }
 
@@ -86,6 +89,7 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
             CoreUtils.SetRenderTarget(cmd, m_Renderer.cameraColorTargetHandle, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.None, Color.clear);
             m_PassData.profilingSampler = m_ProfilingSampler;
             m_PassData.material = m_Material;
+            m_PassData.outputAdjust = m_OutputAdjustParams;
             ExecutePass(m_PassData, CommandBufferHelpers.GetRasterCommandBuffer(cmd));
 
             context.ExecuteCommandBuffer(cmd);
@@ -96,12 +100,15 @@ private class PassData
         {
             internal ProfilingSampler profilingSampler;
             internal Material material;
+            internal Vector4 outputAdjust;
         }
 
+        static readonly int s_OutputAdjustParamsID = Shader.PropertyToID("_OutputAdjustParams");
         private static void ExecutePass(PassData passData, RasterCommandBuffer cmd)
         {
             using (new ProfilingScope(cmd, passData.profilingSampler))
             {
+                passData.material.SetVector(s_OutputAdjustParamsID, passData.outputAdjust);
                 Blitter.BlitTexture(cmd, Vector2.one, passData.material, 0);
             }
         }
@@ -119,6 +126,7 @@ public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer
 
                 passData.profilingSampler = m_ProfilingSampler;
                 passData.material = m_Material;
+                passData.outputAdjust = m_OutputAdjustParams;
 
                 builder.SetRenderFunc((PassData data, RasterGraphContext rgContext) =>
                 {

Tests/SRPTests/Packages/com.unity.testing.urp/Shaders/OutputDepthNormalsTexture.shader

@@ -12,22 +12,41 @@ Shader "Hidden/Test/OutputDepthNormalsTexture"
             ZWrite Off
             Cull Off
 
-
             HLSLPROGRAM
             #pragma vertex Vert
             #pragma fragment Fragment
 
             #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
             #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareOpaqueTexture.hlsl"
             #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
 
+            float4 _OutputAdjustParams;
+
             half4 Fragment(Varyings input) : SV_Target
             {
                 UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
                 float2 normalizedScreenSpaceUV = input.texcoord;
 
-                float3 normals = SampleSceneNormals(normalizedScreenSpaceUV);
-                return half4(normals,1);
+                float2 adjustedUV = normalizedScreenSpaceUV;
+                adjustedUV.x -= _OutputAdjustParams.x;
+                adjustedUV.x *= _OutputAdjustParams.z;
+                adjustedUV.y -= _OutputAdjustParams.y;
+                adjustedUV.y *= _OutputAdjustParams.w;
+
+                if (   normalizedScreenSpaceUV.x > (_OutputAdjustParams.x)
+                    && normalizedScreenSpaceUV.y > (_OutputAdjustParams.y)
+                    && normalizedScreenSpaceUV.x < (_OutputAdjustParams.x + (1.0 / _OutputAdjustParams.z))
+                    && normalizedScreenSpaceUV.y < (_OutputAdjustParams.y + (1.0 / _OutputAdjustParams.w)))
+                {
+                    float3 normals = SampleSceneNormals(normalizedScreenSpaceUV);
+                    return half4(normals,1);
+                }
+                else
+                {
+                    return half4(SampleSceneColor(normalizedScreenSpaceUV), 1.0);
+                }
             }
             ENDHLSL
         }

Tests/SRPTests/Packages/com.unity.testing.urp/Shaders/OutputDepthTexture.shader

@@ -12,26 +12,46 @@ Shader "Hidden/Test/OutputDepthTexture"
             ZWrite Off
             Cull Off
 
-
             HLSLPROGRAM
             #pragma vertex Vert
             #pragma fragment Fragment
 
             #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
             #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
             #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareOpaqueTexture.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
+
+            float4 _OutputAdjustParams;
 
             half4 Fragment(Varyings input) : SV_Target
             {
                 UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
                 float2 normalizedScreenSpaceUV = input.texcoord;
 
-                float depth = SampleSceneDepth(normalizedScreenSpaceUV);
-                #if !UNITY_REVERSED_Z
-                    depth = 1.0 - depth;
-                #endif
+                float2 adjustedUV = normalizedScreenSpaceUV;
+                adjustedUV.x -= _OutputAdjustParams.x;
+                adjustedUV.x *= _OutputAdjustParams.z;
+
+                adjustedUV.y -= _OutputAdjustParams.y;
+                adjustedUV.y *= _OutputAdjustParams.w;
+
+                if (   normalizedScreenSpaceUV.x > (_OutputAdjustParams.x)
+                    && normalizedScreenSpaceUV.y > (_OutputAdjustParams.y)
+                    && normalizedScreenSpaceUV.x < (_OutputAdjustParams.x + (1.0 / _OutputAdjustParams.z))
+                    && normalizedScreenSpaceUV.y < (_OutputAdjustParams.y + (1.0 / _OutputAdjustParams.w)))
+                {
+                    float depth = SampleSceneDepth(normalizedScreenSpaceUV);
+                    #if !UNITY_REVERSED_Z
+                        depth = 1.0 - depth;
+                    #endif
 
-                return half4(depth, depth, depth, 1);
+                    return half4(depth, depth, depth, 1);
+                }
+                else
+                {
+                    return half4(SampleSceneColor(normalizedScreenSpaceUV), 1.0);
+                }
             }
             ENDHLSL
         }

Tests/SRPTests/Packages/com.unity.testing.urp/Shaders/OutputSSAOTexture.shader

@@ -12,7 +12,6 @@ Shader "Hidden/Test/OutputSSAO"
             ZWrite Off
             Cull Off
 
-
             HLSLPROGRAM
             #pragma vertex Vert
             #pragma fragment Fragment
@@ -21,14 +20,34 @@ Shader "Hidden/Test/OutputSSAO"
             #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
             #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
             #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareOpaqueTexture.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
+
+            float4 _OutputAdjustParams;
 
             half4 Fragment(Varyings input) : SV_Target
             {
                 UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
                 float2 normalizedScreenSpaceUV = input.texcoord;
 
-                half ssao = SampleAmbientOcclusion(normalizedScreenSpaceUV);
-                return half4(ssao, ssao, ssao, 1);
+                float2 adjustedUV = normalizedScreenSpaceUV;
+                adjustedUV.x -= _OutputAdjustParams.x;
+                adjustedUV.x *= _OutputAdjustParams.z;
+                adjustedUV.y -= _OutputAdjustParams.y;
+                adjustedUV.y *= _OutputAdjustParams.w;
+
+                if (   normalizedScreenSpaceUV.x > (_OutputAdjustParams.x)
+                    && normalizedScreenSpaceUV.y > (_OutputAdjustParams.y)
+                    && normalizedScreenSpaceUV.x < (_OutputAdjustParams.x + (1.0 / _OutputAdjustParams.z))
+                    && normalizedScreenSpaceUV.y < (_OutputAdjustParams.y + (1.0 / _OutputAdjustParams.w)))
+                {
+                    half ssao = SampleAmbientOcclusion(adjustedUV);
+                    return half4(ssao, ssao, ssao, 1.0);
+                }
+                else
+                {
+                    return half4(SampleSceneColor(normalizedScreenSpaceUV), 1.0);
+                }
             }
             ENDHLSL
         }

Tests/SRPTests/Projects/UniversalGraphicsTest_Foundation/Assets/CommonAssets/SharedMaterials/SHARED_MAT_UnlitClean.mat renamed to Tests/SRPTests/Projects/UniversalGraphicsTest_Foundation/Assets/CommonAssets/SharedMaterials/Floor.mat

@@ -7,7 +7,7 @@ Material:
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_Name: SHARED_MAT_UnlitClean
+  m_Name: Floor
   m_Shader: {fileID: 4800000, guid: 650dd9526735d5b46b79224bc6e94025, type: 3}
   m_Parent: {fileID: 0}
   m_ModifiedSerializedProperties: 0
@@ -99,6 +99,7 @@ Material:
         m_Offset: {x: 0, y: 0}
     m_Ints: []
     m_Floats:
+    - _AddPrecomputedVelocity: 0
     - _AlphaClip: 0
     - _AlphaToMask: 0
     - _BillboardKwToggle: 0
@@ -158,17 +159,18 @@ Material:
     - _WorkflowMode: 1
     - _ZWrite: 1
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 0.5377358, g: 0.5377358, b: 0.5377358, a: 1}
     - _BaseColorAddSubDiff: {r: 0, g: 0, b: 0, a: 0}
     - _CameraFadeParams: {r: 0, g: 0, b: 0, a: 0}
-    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.53773576, g: 0.53773576, b: 0.53773576, a: 1}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _HueVariation: {r: 1, g: 0.5, b: 0, a: 0.1}
     - _HueVariationColor: {r: 1, g: 0.5, b: 0, a: 0.1}
     - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
     - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
     - _SubsurfaceColor: {r: 1, g: 1, b: 1, a: 1}
   m_BuildTextureStacks: []
+  m_AllowLocking: 1
 --- !u!114 &6695259532888533033
 MonoBehaviour:
   m_ObjectHideFlags: 11