Merge branch 'Unity-2017.3' of https://github.com/Unity-Technologies/ScriptableRenderLoop into Unity-2017.3

ScriptableRenderPipeline/Core/Debugging/DebugActionManager.cs

             persistent.repeatMode = DebugActionRepeatMode.Never;
             AddAction(DebugAction.MakePersistent, persistent);
 
-            AddAction(DebugAction.MoveVertical, new DebugActionDesc { axisTrigger = kDPadVertical, repeatMode = DebugActionRepeatMode.Delay, repeatDelay = 0.2f });
-            AddAction(DebugAction.MoveHorizontal, new DebugActionDesc { axisTrigger = kDPadHorizontal, repeatMode = DebugActionRepeatMode.Delay, repeatDelay = 0.2f });
+            AddAction(DebugAction.MoveVertical, new DebugActionDesc { axisTrigger = kDPadVertical, repeatMode = DebugActionRepeatMode.Delay, repeatDelay = 0.4f });
+            AddAction(DebugAction.MoveHorizontal, new DebugActionDesc { axisTrigger = kDPadHorizontal, repeatMode = DebugActionRepeatMode.Delay, repeatDelay = 0.4f });
         }
 
         DebugActionManager()

ScriptableRenderPipeline/Core/Debugging/DebugItemHandler.cs

         public abstract bool OnEditorGUIImpl();
         public void OnEditorGUI()
         {
+            if (m_DebugItem.runtimeOnly)
+                return;
+
             if(OnEditorGUIImpl())
             {
                 DebugMenuUI.changed = true;

ScriptableRenderPipeline/Core/Debugging/DebugPanel.cs

     [Flags]
     public enum DebugItemFlag
     {
-        None,
-        DynamicDisplay,
-        EditorOnly
+        None = 0,
+        DynamicDisplay = 1 << 0,
+        EditorOnly = 1 << 1,
+        RuntimeOnly = 1 << 2
     }
 
     public class DebugItem
         public DebugItemHandler handler         { get { return m_Handler; } }
         public DebugItemFlag    flags           { get { return m_Flags; } }
         public bool             readOnly        { get { return m_Setter == null; } }
+        public bool             editorOnly      { get { return (flags & DebugItemFlag.EditorOnly) != 0; } }
+        public bool             runtimeOnly     { get { return (flags & DebugItemFlag.RuntimeOnly) != 0; } }
 
         public DebugItem(string name, string panelName, Type type, Func<object> getter, Action<object> setter, DebugItemFlag flags = DebugItemFlag.None, DebugItemHandler handler = null)
         {

ScriptableRenderPipeline/Core/Debugging/DebugPanelUI.cs

             for (int i = 0; i < m_DebugPanel.itemCount; i++)
             {
                 DebugItem item = m_DebugPanel.GetDebugItem(i);
-                if(!((item.flags & DebugItemFlag.EditorOnly) != 0))
+#if UNITY_EDITOR
+                // We don't want runtime only items even in the "player" debug menu if we are in the editor.
+                if (item.runtimeOnly)
+                    continue;
+#endif
+                if(!item.editorOnly)
                 {
                     DebugItemHandler handler = item.handler; // Should never be null, we have at least the default handler
                     m_ItemsUI.Add(handler.BuildGUI(parent));

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

             public readonly GUIContent renderingSettingsLabel = new GUIContent("Rendering Settings");
             public readonly GUIContent useForwardRenderingOnly = new GUIContent("Use Forward Rendering Only");
             public readonly GUIContent useDepthPrepassWithDeferredRendering = new GUIContent("Use Depth Prepass with Deferred rendering");
+            public readonly GUIContent renderAlphaTestOnlyInDeferredPrepass = new GUIContent("Alpha Test only");
 
             // Texture Settings
             public readonly GUIContent textureSettings = new GUIContent("Texture Settings");
 
             // Tile pass Settings
             public readonly GUIContent tileLightLoopSettings = new GUIContent("Tile Light Loop Settings");
-            public readonly GUIContent enableTileAndCluster = new GUIContent("Enable tile/clustered", "Toggle");
-            public readonly GUIContent enableComputeLightEvaluation = new GUIContent("Enable Compute Light Evaluation", "Toggle");
-            public readonly GUIContent enableComputeLightVariants = new GUIContent("Enable Compute Light Variants", "Toggle");
-            public readonly GUIContent enableComputeMaterialVariants = new GUIContent("Enable Compute Material Variants", "Toggle");
-            public readonly GUIContent enableClustered = new GUIContent("Enable clustered", "Toggle");
-            public readonly GUIContent enableFptlForOpaqueWhenClustered = new GUIContent("Enable Fptl For Opaque When Clustered", "Toggle");
-            public readonly GUIContent enableBigTilePrepass = new GUIContent("Enable big tile prepass", "Toggle");
-            public readonly GUIContent tileDebugByCategory = new GUIContent("Enable Debug By Category", "Toggle");
+            public readonly GUIContent enableTileAndCluster = new GUIContent("Enable tile/clustered");
+            public readonly GUIContent enableComputeLightEvaluation = new GUIContent("Enable Compute Light Evaluation");
+            public readonly GUIContent enableComputeLightVariants = new GUIContent("Enable Compute Light Variants");
+            public readonly GUIContent enableComputeMaterialVariants = new GUIContent("Enable Compute Material Variants");
+            public readonly GUIContent enableClustered = new GUIContent("Enable clustered");
+            public readonly GUIContent enableFptlForOpaqueWhenClustered = new GUIContent("Enable Fptl For Opaque When Clustered");
+            public readonly GUIContent enableBigTilePrepass = new GUIContent("Enable big tile prepass");
+            public readonly GUIContent tileDebugByCategory = new GUIContent("Enable Debug By Category");
 
             // Sky Settings
             public readonly GUIContent skyParams = new GUIContent("Sky Settings");
         // Rendering Settings
         SerializedProperty m_RenderingUseForwardOnly = null;
         SerializedProperty m_RenderingUseDepthPrepass = null;
+        SerializedProperty m_RenderingUseDepthPrepassAlphaTestOnly = null;
 
         // Subsurface Scattering Settings
         // Old SSS Model >>>
             // Rendering settings
             m_RenderingUseForwardOnly = FindProperty(x => x.renderingSettings.useForwardRenderingOnly);
             m_RenderingUseDepthPrepass = FindProperty(x => x.renderingSettings.useDepthPrepassWithDeferredRendering);
+            m_RenderingUseDepthPrepassAlphaTestOnly = FindProperty(x => x.renderingSettings.renderAlphaTestOnlyInDeferredPrepass);
 
             // Subsurface Scattering Settings
             // Old SSS Model >>>
             if (!m_RenderingUseForwardOnly.boolValue) // If we are deferred
             {
                 EditorGUILayout.PropertyField(m_RenderingUseDepthPrepass, styles.useDepthPrepassWithDeferredRendering);
+                if(m_RenderingUseDepthPrepass.boolValue)
+                {
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.PropertyField(m_RenderingUseDepthPrepassAlphaTestOnly, styles.renderAlphaTestOnlyInDeferredPrepass);
+                    EditorGUI.indentLevel--;
+                }
             }
 
             EditorGUI.indentLevel--;

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

     {
         public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
         public bool useDepthPrepassWithDeferredRendering = false;
+        public bool renderAlphaTestOnlyInDeferredPrepass = false;
 
         // We have to fall back to forward-only rendering when scene view is using wireframe rendering mode --
         // as rendering everything in wireframe + deferred do not play well together
             All      = 255                   // 0xFF - 8 bit
         }
 
+        RenderStateBlock m_DepthStateOpaque;
+        RenderStateBlock m_DepthStateOpaqueWithPrepass;
+
         // Detect when windows size is changing
         int m_CurrentWidth;
         int m_CurrentHeight;
         // Debugging
         MaterialPropertyBlock m_SharedPropertyBlock = new MaterialPropertyBlock();
         DebugDisplaySettings m_DebugDisplaySettings = new DebugDisplaySettings();
-        static DebugDisplaySettings s_NeutraDebugDisplaySettings = new DebugDisplaySettings();
+        static DebugDisplaySettings s_NeutralDebugDisplaySettings = new DebugDisplaySettings();
         DebugDisplaySettings m_CurrentDebugDisplaySettings = null;
 
         private int m_DebugFullScreenTempRT;
 
             m_DebugDisplaySettings.RegisterDebug();
             m_DebugFullScreenTempRT = HDShaderIDs._DebugFullScreenTexture;
+
+            InitializeRenderStateBlocks();
+
+            RegisterDebug();
+        }
+
+        void RegisterDebug()
+        {
+            // These need to be Runtime Only because those values are hold by the HDRenderPipeline asset so if user change them through the editor debug menu they might change the value in the asset without noticing it.
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Forward Only", () => (bool)m_Asset.renderingSettings.useForwardRenderingOnly, (value) => m_Asset.renderingSettings.useForwardRenderingOnly = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Deferred Depth Prepass", () => (bool)m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering, (value) => m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Deferred Depth Prepass ATest Only", () => (bool)m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass, (value) => m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass = (bool)value, DebugItemFlag.RuntimeOnly);
+
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Tile/Cluster", () => (bool)m_Asset.tileSettings.enableTileAndCluster, (value) => m_Asset.tileSettings.enableTileAndCluster = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Big Tile", () => (bool)m_Asset.tileSettings.enableBigTilePrepass, (value) => m_Asset.tileSettings.enableBigTilePrepass = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Cluster", () => (bool)m_Asset.tileSettings.enableClustered, (value) => m_Asset.tileSettings.enableClustered = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Compute Lighting", () => (bool)m_Asset.tileSettings.enableComputeLightEvaluation, (value) => m_Asset.tileSettings.enableComputeLightEvaluation = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Light Classification", () => (bool)m_Asset.tileSettings.enableComputeLightVariants, (value) => m_Asset.tileSettings.enableComputeLightVariants = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Material Classification", () => (bool)m_Asset.tileSettings.enableComputeMaterialVariants, (value) => m_Asset.tileSettings.enableComputeMaterialVariants = (bool)value, DebugItemFlag.RuntimeOnly);
         }
 
         void InitializeDebugMaterials()
             // <<< Old SSS Model
         }
 
+        void InitializeRenderStateBlocks()
+        {
+            m_DepthStateOpaque.depthState = new DepthState(true, CompareFunction.LessEqual);
+            m_DepthStateOpaque.mask = RenderStateMask.Depth;
+            // When doing a prepass, we don't need to write the depth anymore.
+            // Moreover, we need to use DepthEqual because for alpha tested materials we don't do the clip in the shader anymore (otherwise HiZ does not work on PS4)
+            m_DepthStateOpaqueWithPrepass.depthState = new DepthState(false, CompareFunction.Equal);
+            m_DepthStateOpaqueWithPrepass.mask = RenderStateMask.Depth;
+        }
+
         public void OnSceneLoad()
         {
             // Recreate the textures which went NULL
             if (camera.cameraType == CameraType.Reflection || camera.cameraType == CameraType.Preview)
             {
                 // Neutral allow to disable all debug settings
-                m_CurrentDebugDisplaySettings = s_NeutraDebugDisplaySettings;
+                m_CurrentDebugDisplaySettings = s_NeutralDebugDisplaySettings;
             }
             else
             {
             renderContext.Submit();
         }
 
-        void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName passName, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null)
+        void RenderOpaqueRenderList(CullResults             cull,
+                                    Camera                  camera,
+                                    ScriptableRenderContext renderContext,
+                                    CommandBuffer           cmd, 
+                                    ShaderPassName          passName,
+                                    RendererConfiguration   rendererConfiguration = 0,
+                                    RenderQueueRange?       renderQueueRange = null,
+                                    RenderStateBlock?       stateBlock = null,
+                                    Material                overrideMaterial = null)
-            RenderOpaqueRenderList(cull, camera, renderContext, cmd, new ShaderPassName[] { passName }, rendererConfiguration, overrideMaterial);
+            RenderOpaqueRenderList(cull, camera, renderContext, cmd, new ShaderPassName[] { passName }, rendererConfiguration, renderQueueRange, stateBlock, overrideMaterial);
-        void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName[] passNames, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null)
+        void RenderOpaqueRenderList(CullResults             cull,
+                                    Camera                  camera,
+                                    ScriptableRenderContext renderContext,
+                                    CommandBuffer           cmd,
+                                    ShaderPassName[]        passNames, 
+                                    RendererConfiguration   rendererConfiguration = 0,
+                                    RenderQueueRange?       renderQueueRange = null, 
+                                    RenderStateBlock?       stateBlock = null, 
+                                    Material                overrideMaterial = null)
         {
             if (!m_CurrentDebugDisplaySettings.renderingDebugSettings.displayOpaqueObjects)
                 return;
                 drawSettings.SetOverrideMaterial(overrideMaterial, 0);
             }
 
-            var filterSettings = new FilterRenderersSettings(true) {renderQueueRange = RenderQueueRange.opaque};
-            renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
+            var filterSettings = new FilterRenderersSettings(true) {renderQueueRange = renderQueueRange == null ? RenderQueueRange.opaque : renderQueueRange.Value };
+            if(stateBlock == null)
+                renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
+            else
+                renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, stateBlock.Value);
-        void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName passName, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null)
+
+        void RenderTransparentRenderList(   CullResults             cull,
+                                            Camera                  camera,
+                                            ScriptableRenderContext renderContext, 
+                                            CommandBuffer           cmd, 
+                                            ShaderPassName          passName,
+                                            RendererConfiguration   rendererConfiguration = 0, 
+                                            RenderStateBlock?       stateBlock = null,
+                                            Material                overrideMaterial = null)
-            RenderTransparentRenderList(cull, camera, renderContext, cmd, new ShaderPassName[] { passName }, rendererConfiguration, overrideMaterial);
+            RenderTransparentRenderList(cull, camera, renderContext, cmd, new ShaderPassName[] { passName }, rendererConfiguration, stateBlock, overrideMaterial);
-        void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName[] passNames, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null)
+        void RenderTransparentRenderList(   CullResults             cull, 
+                                            Camera                  camera, 
+                                            ScriptableRenderContext renderContext, 
+                                            CommandBuffer           cmd,
+                                            ShaderPassName[]        passNames, 
+                                            RendererConfiguration   rendererConfiguration = 0,             
+                                            RenderStateBlock?       stateBlock = null,
+                                            Material                overrideMaterial = null)
         {
             if (!m_CurrentDebugDisplaySettings.renderingDebugSettings.displayTransparentObjects)
                 return;
             }
 
             var filterSettings = new FilterRenderersSettings(true) {renderQueueRange = RenderQueueRange.transparent};
-            renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
+            if(stateBlock == null)
+                renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
+            else
+                renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, stateBlock.Value);
         }
 
         void RenderDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
 
             using (new Utilities.ProfilingSample(addDepthPrepass ? "Depth Prepass" : "Depth Prepass forward opaque ", cmd))
             {
+                // Default depth prepass (forward and deferred) will render all opaque geometry.
+                RenderQueueRange renderQueueRange = RenderQueueRange.opaque;
+                // If we want only alpha tested geometry in prepass for deferred we change the RenderQueueRange
+                if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() && m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering && m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass)
+                    renderQueueRange = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
+
-                RenderOpaqueRenderList(cull, camera, renderContext, cmd, addDepthPrepass ? HDShaderPassNames.m_DepthOnlyName : HDShaderPassNames.m_ForwardOnlyOpaqueDepthOnlyName);
+                RenderOpaqueRenderList(cull, camera, renderContext, cmd, addDepthPrepass ? HDShaderPassNames.m_DepthOnlyName : HDShaderPassNames.m_ForwardOnlyOpaqueDepthOnlyName, 0, renderQueueRange);
             }
         }
 
                 // setup GBuffer for rendering
                 Utilities.SetRenderTarget(cmd, m_gbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT);
                 // render opaque objects into GBuffer
-                RenderOpaqueRenderList(cull, camera, renderContext, cmd, m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled() ? HDShaderPassNames.m_GBufferDebugDisplayName : HDShaderPassNames.m_GBufferName, Utilities.kRendererConfigurationBakedLighting);
+                if(m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
+                {
+                    // When doing debug display, the shader has the clip instruction regardless of the depth prepass so we can use regular depth test.
+                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.m_GBufferDebugDisplayName, Utilities.kRendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
+                }
+                else
+                {
+                    if(m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering)
+                    {
+                        RenderQueueRange rangeOpaqueNoAlphaTest = new RenderQueueRange { min = (int)RenderQueue.Geometry, max = (int)RenderQueue.AlphaTest - 1 };
+                        RenderQueueRange rangeOpaqueAlphaTest = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
+
+                        // When using depth prepass for alpha test only we need to use regular depth test for normal opaque objects.
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.m_GBufferWithPrepassName, Utilities.kRendererConfigurationBakedLighting, rangeOpaqueNoAlphaTest, m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.m_GBufferWithPrepassName, Utilities.kRendererConfigurationBakedLighting, rangeOpaqueAlphaTest, m_DepthStateOpaqueWithPrepass);
+                    }
+                    else
+                    {
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.m_GBufferName, Utilities.kRendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
+                    }
+                }
             }
         }
 
 
                 if (renderOpaque)
                 {
-                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, arrayNames, Utilities.kRendererConfigurationBakedLighting);
+                    // Forward opaque material always have a prepass (whether or not we use deferred) so we pass the right depth state here.
+                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, arrayNames, Utilities.kRendererConfigurationBakedLighting, null, m_DepthStateOpaqueWithPrepass);
                 }
                 else
                 {
 
                 if (renderOpaque)
                 {
-                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, arrayNames, 0, m_ErrorMaterial);
+                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, arrayNames, 0, null, null, m_ErrorMaterial);
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, arrayNames, 0, m_ErrorMaterial);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, arrayNames, 0, null, m_ErrorMaterial);
                 }
             }
         }

ScriptableRenderPipeline/HDRenderPipeline/HDStringConstants.cs

         internal static readonly ShaderPassName m_ForwardOnlyOpaqueName = new ShaderPassName("ForwardOnlyOpaque");
         internal static readonly ShaderPassName m_ForwardOnlyOpaqueDisplayDebugName = new ShaderPassName("ForwardOnlyOpaqueDisplayDebug");
         internal static readonly ShaderPassName m_GBufferName = new ShaderPassName("GBuffer");
+        internal static readonly ShaderPassName m_GBufferWithPrepassName = new ShaderPassName("GBufferWithPrepass");
         internal static readonly ShaderPassName m_GBufferDebugDisplayName = new ShaderPassName("GBufferDebugDisplay");
         internal static readonly ShaderPassName m_SRPDefaultUnlitName = new ShaderPassName("SRPDefaultUnlit");
         internal static readonly ShaderPassName m_MotionVectorsName = new ShaderPassName("MotionVectors");

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

             ENDHLSL
         }
 
+        // This pass is the same as GBuffer only it does not do alpha test (the clip instruction is removed)
+        // This is due to the fact that on GCN, any shader with a clip instruction cannot benefit from HiZ so when we do a prepass, in order to get the most performance, we need to make a special case in the subsequent GBuffer pass.
+        Pass
+        {
+            Name "GBufferWithPrepass"  // Name is not used
+            Tags { "LightMode" = "GBufferWithPrepass" } // This will be only for opaque object based on the RenderQueue index
+
+            Cull [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
+
+            HLSLPROGRAM
+
+            #define SHADERPASS SHADERPASS_GBUFFER
+            #define _BYPASS_ALPHA_TEST
+            #include "../../ShaderVariables.hlsl"
+            #include "../../Material/Material.hlsl"
+            #include "../Lit/ShaderPass/LitSharePass.hlsl"
+            #include "../Lit/LitData.hlsl"
+            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
+
+            ENDHLSL
+        }
+
         Pass
         {
             Name "GBufferDebugDisplay"  // Name is not used

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

             ENDHLSL
         }
 
+        // This pass is the same as GBuffer only it does not do alpha test (the clip instruction is removed)
+        // This is due to the fact that on GCN, any shader with a clip instruction cannot benefit from HiZ so when we do a prepass, in order to get the most performance, we need to make a special case in the subsequent GBuffer pass.
+        Pass
+        {
+            Name "GBufferWithPrepass"  // Name is not used
+            Tags { "LightMode" = "GBufferWithPrepass" } // This will be only for opaque object based on the RenderQueue index
+
+            Cull [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
+
+            HLSLPROGRAM
+
+            #pragma hull Hull
+            #pragma domain Domain
+
+            #define SHADERPASS SHADERPASS_GBUFFER
+            #define _BYPASS_ALPHA_TEST
+            #include "../../ShaderVariables.hlsl"
+            #include "../../Material/Material.hlsl"
+            #include "../Lit/ShaderPass/LitSharePass.hlsl"
+            #include "../Lit/LitData.hlsl"
+            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
+
+            ENDHLSL
+        }
+
         Pass
         {
             Name "GBufferDebugDisplay"  // Name is not used

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

             ENDHLSL
         }
 
+        // This pass is the same as GBuffer only it does not do alpha test (the clip instruction is removed)
+        // This is due to the fact that on GCN, any shader with a clip instruction cannot benefit from HiZ so when we do a prepass, in order to get the most performance, we need to make a special case in the subsequent GBuffer pass.
+        Pass
+        {
+            Name "GBufferWithPrepass"  // Name is not used
+            Tags { "LightMode" = "GBufferWithPrepass" } // This will be only for opaque object based on the RenderQueue index
+
+            Cull [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
+
+            HLSLPROGRAM
+
+            #define SHADERPASS SHADERPASS_GBUFFER
+            #define _BYPASS_ALPHA_TEST
+            #include "../../ShaderVariables.hlsl"
+            #include "../../Material/Material.hlsl"
+            #include "ShaderPass/LitSharePass.hlsl"
+            #include "LitData.hlsl"
+            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
+
+            ENDHLSL
+        }
+
         Pass
         {
             Name "GBufferDebugDisplay"  // Name is not used

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

 #include "../../../Core/ShaderLibrary/SampleUVMapping.hlsl"
 #include "../MaterialUtilities.hlsl"
 
+void DoAlphaTest(float alpha, float alphaCutoff)
+{
+    // For Deferred:
+    // If we have a prepass, we need to remove the clip from the GBuffer pass (otherwise HiZ does not work on PS4)
+    // For Forward (Full forward or ForwardOnlyOpaque in deferred):
+    // Opaque geometry always has a depth pre-pass so we never want to do the clip here. For transparent we perform the clip as usual.
+    #if ((SHADER_PASS == SHADERPASS_GBUFFER) && !defined(_BYPASS_ALPHA_TEST)) || (SHADER_PASS == SHADERPASS_FORWARD && defined(SURFACE_TYPE_TRANSPARENT))
+        clip(alpha - alphaCutoff);
+    #endif
+}
+
 // TODO: move this function to commonLighting.hlsl once validated it work correctly
 float GetSpecularOcclusionFromBentAO(float3 V, float3 bentNormalWS, SurfaceData surfaceData)
 {
         float verticalDisplacement = maxHeight - height * maxHeight;
         // IDEA: precompute the tiling scale? MOV-MUL vs MOV-MOV-MAX-RCP-MUL.
         float tilingScale = rcp(max(_BaseColorMap0_ST.x, _BaseColorMap0_ST.y));
-        return tilingScale * verticalDisplacement / NdotV;
+        return tilingScale * verticalDisplacement / max(NdotV, 0.001);
     }
 
     return 0.0;
     float alpha = PROP_BLEND_SCALAR(alpha, weights);
 
 #ifdef _ALPHATEST_ON
-    clip(alpha - _AlphaCutoff);
+    DoAlphaTest(alpha, _AlphaCutoff);
 #endif
 
     float3 normalTS;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl

 
     // Perform alha test very early to save performance (a killed pixel will not sample textures)
 #if defined(_ALPHATEST_ON) && !defined(LAYERED_LIT_SHADER)
-    clip(alpha - _AlphaCutoff);
+    DoAlphaTest(alpha, _AlphaCutoff);
 #endif
 
     float3 detailNormalTS = float3(0.0, 0.0, 0.0);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

             ENDHLSL
         }
 
+        // This pass is the same as GBuffer only it does not do alpha test (the clip instruction is removed)
+        // This is due to the fact that on GCN, any shader with a clip instruction cannot benefit from HiZ so when we do a prepass, in order to get the most performance, we need to make a special case in the subsequent GBuffer pass.
+        Pass
+        {
+            Name "GBufferWithPrepass"  // Name is not used
+            Tags { "LightMode" = "GBufferWithPrepass" } // This will be only for opaque object based on the RenderQueue index
+
+            Cull [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
+
+            HLSLPROGRAM
+
+            #pragma hull Hull
+            #pragma domain Domain
+
+            #define SHADERPASS SHADERPASS_GBUFFER
+            #define _BYPASS_ALPHA_TEST
+            #include "../../ShaderVariables.hlsl"
+            #include "../../Material/Material.hlsl"
+            #include "ShaderPass/LitSharePass.hlsl"
+            #include "LitData.hlsl"
+            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
+
+            ENDHLSL
+        }
+
         Pass
         {
             Name "GBufferDebugDisplay"  // Name is not used