Added the possibility to do alpha test only depth prepass in deferred.

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 useDepthPrepassWithDeferredRenderingAlphaTestOnly = new GUIContent("Alpha Test only");
 
             // Texture Settings
             public readonly GUIContent textureSettings = new GUIContent("Texture 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.useDepthPrepassWithDeferredRenderingAlphaTestOnly);
 
             // 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.useDepthPrepassWithDeferredRenderingAlphaTestOnly);
+                    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 useDepthPrepassWithDeferredRenderingAlphaTestOnly = 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
             renderContext.Submit();
         }
 
-        void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName passName, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null, RenderStateBlock? stateBlock = 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, stateBlock);
+            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, RenderStateBlock? stateBlock = 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};
+            var filterSettings = new FilterRenderersSettings(true) {renderQueueRange = renderQueueRange == null ? RenderQueueRange.opaque : renderQueueRange.Value };
             if(stateBlock == null)
                 renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
             else
-        void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName passName, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null, RenderStateBlock? stateBlock = 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, stateBlock);
+            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, RenderStateBlock? stateBlock = 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;
             // Note that an object can't be in both list
             bool addForwardOnlyOpaqueDepthPrepass = !m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() && !m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering;
 
+            RenderQueueRange renderQueueRange = RenderQueueRange.opaque;
+            if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() && m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering && m_Asset.renderingSettings.useDepthPrepassWithDeferredRenderingAlphaTestOnly)
+                renderQueueRange = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
+
             if (addDepthPrepass == false && addForwardOnlyOpaqueDepthPrepass == false)
                 return;
 
                 Utilities.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
                 // Note: addDepthPrepass and addForwardOnlyOpaqueDepthPrepass can't be both true at the same time. And if we are here both are not false
-                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
-                ShaderPassName passName = m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled() ? HDShaderPassNames.m_GBufferDebugDisplayName : m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering ? HDShaderPassNames.m_GBufferWithPrepassName :HDShaderPassNames.m_GBufferName;
-                RenderOpaqueRenderList(cull, camera, renderContext, cmd, passName, Utilities.kRendererConfigurationBakedLighting, null, m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering ? m_DepthStateOpaqueWithPrepass : m_DepthStateOpaque);
+                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.useDepthPrepassWithDeferredRenderingAlphaTestOnly ? 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, 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);
                 }
             }
         }