Clean/update for distortion + add a transparent depth prepass

- Rename All ForwardDisplayDebug to ForwardDebugDisplay
- Clean/factor code for distortion and SetEnablePass
- Add support for a RenderTransparentDepthPrepass (can be use for hair)
- Distortion pass is now consider as always a separate pass (no MRT
during particles rendering)

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
                 RenderGaussianPyramidColor(camera, cmd);
 
+                // Do a depth pre-pass for transparent objects that want it that will fill the depth buffer to reduce the overdraw (typical usage is hair rendering)
+                RenderTransparentDepthPrepass(m_CullResults, camera, renderContext, cmd);
+
                 // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
                 RenderForward(m_CullResults, camera, renderContext, cmd, false);
                 RenderForwardError(m_CullResults, camera, renderContext, cmd, false);
                 {
                     CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.All, Color.black);
                     // Render Opaque forward
-                    RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDisplayDebugName, HDUtils.k_RendererConfigurationBakedLighting);
+                    RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDebugDisplayName, HDUtils.k_RendererConfigurationBakedLighting);
-                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDisplayDebugName, HDUtils.k_RendererConfigurationBakedLighting);
+                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDebugDisplayName, HDUtils.k_RendererConfigurationBakedLighting);
                 }
             }
 
             string profileName;
             if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
             {
-                passName = addForwardPass ? HDShaderPassNames.s_ForwardDisplayDebugName :  HDShaderPassNames.s_ForwardOnlyOpaqueDisplayDebugName;
-                profileName = addForwardPass ? (renderOpaque ? "Forward Opaque Display Debug" : "Forward Transparent Display Debug") :  "ForwardOnlyOpaqueDisplayDebug";
+                passName = addForwardPass ? HDShaderPassNames.s_ForwardDebugDisplayName : HDShaderPassNames.s_ForwardOnlyOpaqueDebugDisplayName;
+                profileName = addForwardPass ? (renderOpaque ? "Forward Opaque Debug Display" : "Forward Transparent Debug Display") : "ForwardOnlyOpaqueDebugDisplay";
             }
             else
             {
                 {
                     RenderTransparentRenderList(cullResults, camera, renderContext, cmd, arrayNames, HDUtils.k_RendererConfigurationBakedLighting);
                 }
+            }
+        }
+
+        void RenderTransparentDepthPrepass(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
+        {
+            using (new ProfilingSample(cmd,"Forward Transparent Depth Prepass"))
+            {
+                CoreUtils.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
+                RenderTransparentRenderList(cullResults, camera, renderContext, cmd, HDShaderPassNames.s_TransparentDepthPrepassName);
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDStringConstants.cs

 {
     public static class HDShaderPassNames
     {
+        // ShaderPass string - use to have consistent name through the code
+        public static readonly string s_EmptyStr = "";
+        public static readonly string s_ForwardStr = "Forward";
+        public static readonly string s_ForwardDebugDisplayStr = "ForwardDebugDisplay";
+        public static readonly string s_DepthOnlyStr = "DepthOnly";
+        public static readonly string s_ForwardOnlyOpaqueDepthOnlyStr = "ForwardOnlyOpaqueDepthOnly";
+        public static readonly string s_ForwardOnlyOpaqueStr = "ForwardOnlyOpaque";
+        public static readonly string s_ForwardOnlyOpaqueDebugDisplayStr = "ForwardOnlyOpaqueDebugDisplay";
+        public static readonly string s_GBufferStr = "GBuffer";
+        public static readonly string s_GBufferWithPrepassStr = "GBufferWithPrepass";
+        public static readonly string s_GBufferDebugDisplayStr = "GBufferDebugDisplay";
+        public static readonly string s_SRPDefaultUnlitStr = "SRPDefaultUnlit";
+        public static readonly string s_MotionVectorsStr = "MotionVectors";
+        public static readonly string s_DistortionVectorsStr = "DistortionVectors";
+        public static readonly string s_TransparentDepthPrepassStr = "TransparentDepthPrepass";
+        public static readonly string s_MetaStr = "Meta";
+        public static readonly string s_ShadowCasterStr = "ShadowCaster";
+
-        public static readonly ShaderPassName s_EmptyName = new ShaderPassName("");
-        public static readonly ShaderPassName s_ForwardName = new ShaderPassName("Forward");
-        public static readonly ShaderPassName s_ForwardDisplayDebugName = new ShaderPassName("ForwardDisplayDebug");
-        public static readonly ShaderPassName s_DepthOnlyName = new ShaderPassName("DepthOnly");
-        public static readonly ShaderPassName s_ForwardOnlyOpaqueDepthOnlyName = new ShaderPassName("ForwardOnlyOpaqueDepthOnly");
-        public static readonly ShaderPassName s_ForwardOnlyOpaqueName = new ShaderPassName("ForwardOnlyOpaque");
-        public static readonly ShaderPassName s_ForwardOnlyOpaqueDisplayDebugName = new ShaderPassName("ForwardOnlyOpaqueDisplayDebug");
-        public static readonly ShaderPassName s_GBufferName = new ShaderPassName("GBuffer");
-        public static readonly ShaderPassName s_GBufferWithPrepassName = new ShaderPassName("GBufferWithPrepass");
-        public static readonly ShaderPassName s_GBufferDebugDisplayName = new ShaderPassName("GBufferDebugDisplay");
-        public static readonly ShaderPassName s_SRPDefaultUnlitName = new ShaderPassName("SRPDefaultUnlit");
-        public static readonly ShaderPassName s_MotionVectorsName = new ShaderPassName("MotionVectors");
-        public static readonly ShaderPassName s_DistortionVectorsName = new ShaderPassName("DistortionVectors");
+        public static readonly ShaderPassName s_EmptyName = new ShaderPassName(s_EmptyStr);
+        public static readonly ShaderPassName s_ForwardName = new ShaderPassName(s_ForwardStr);
+        public static readonly ShaderPassName s_ForwardDebugDisplayName = new ShaderPassName(s_ForwardDebugDisplayStr);
+        public static readonly ShaderPassName s_DepthOnlyName = new ShaderPassName(s_DepthOnlyStr);
+        public static readonly ShaderPassName s_ForwardOnlyOpaqueDepthOnlyName = new ShaderPassName(s_ForwardOnlyOpaqueDepthOnlyStr);
+        public static readonly ShaderPassName s_ForwardOnlyOpaqueName = new ShaderPassName(s_ForwardOnlyOpaqueStr);
+        public static readonly ShaderPassName s_ForwardOnlyOpaqueDebugDisplayName = new ShaderPassName(s_ForwardOnlyOpaqueDebugDisplayStr);
+        public static readonly ShaderPassName s_GBufferName = new ShaderPassName(s_GBufferStr);
+        public static readonly ShaderPassName s_GBufferWithPrepassName = new ShaderPassName(s_GBufferWithPrepassStr);
+        public static readonly ShaderPassName s_GBufferDebugDisplayName = new ShaderPassName(s_GBufferDebugDisplayStr);
+        public static readonly ShaderPassName s_SRPDefaultUnlitName = new ShaderPassName(s_SRPDefaultUnlitStr);
+        public static readonly ShaderPassName s_MotionVectorsName = new ShaderPassName(s_MotionVectorsStr);
+        public static readonly ShaderPassName s_DistortionVectorsName = new ShaderPassName(s_DistortionVectorsStr);
+        public static readonly ShaderPassName s_TransparentDepthPrepassName = new ShaderPassName(s_TransparentDepthPrepassStr);
 
         // Legacy name
         public static readonly ShaderPassName s_AlwaysName = new ShaderPassName("Always");

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

     // #pragma enable_d3d11_debug_symbols
 
     #pragma shader_feature _ALPHATEST_ON
-    #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _DOUBLESIDED_ON
     #pragma shader_feature _PER_PIXEL_DISPLACEMENT
 
         Pass
         {
-            Name "ForwardDisplayDebug" // Name is not used
-            Tags{ "LightMode" = "ForwardDisplayDebug" } // This will be only for transparent object based on the RenderQueue index
+            Name "ForwardDebugDisplay" // Name is not used
+            Tags{ "LightMode" = "ForwardDebugDisplay" } // This will be only for transparent object based on the RenderQueue index
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

     // #pragma enable_d3d11_debug_symbols
 
     #pragma shader_feature _ALPHATEST_ON
-    #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _DOUBLESIDED_ON
     #pragma shader_feature _PER_PIXEL_DISPLACEMENT
 
         Pass
         {
-            Name "ForwardDisplayDebug" // Name is not used
-            Tags{ "LightMode" = "ForwardDisplayDebug" } // This will be only for transparent object based on the RenderQueue index
+            Name "ForwardDebugDisplay" // Name is not used
+            Tags{ "LightMode" = "ForwardDebugDisplay" } // This will be only for transparent object based on the RenderQueue index
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/BaseLitUI.cs

 
         static public void SetupBaseLitMaterialPass(Material material)
         {
-            bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
-            bool distortionOnly = material.GetFloat(kDistortionOnly) > 0.0f;
-
-            if (distortionEnable && distortionOnly)
-            {
-                // Disable all passes except distortion (setup in BaseUnlitUI.cs) and debug passes (to visualize distortion)
-                material.SetShaderPassEnabled("GBuffer", false);
-                material.SetShaderPassEnabled("GBufferDisplayDebug", true);
-                material.SetShaderPassEnabled("Meta", false);
-                material.SetShaderPassEnabled("ShadowCaster", false);
-                material.SetShaderPassEnabled("DepthOnly", false);
-                material.SetShaderPassEnabled("MotionVectors", false);
-                material.SetShaderPassEnabled("Forward", false);
-                material.SetShaderPassEnabled("ForwardDisplayDebug", true);
-            }
-            else
-            {
-                // Enable all passes except distortion (setup in BaseUnlitUI.cs)
-                material.SetShaderPassEnabled("GBuffer", true);
-                material.SetShaderPassEnabled("GBufferDisplayDebug", true);
-                material.SetShaderPassEnabled("Meta", true);
-                material.SetShaderPassEnabled("ShadowCaster", true);
-                material.SetShaderPassEnabled("DepthOnly", true);
-                material.SetShaderPassEnabled("MotionVectors", true);
-                material.SetShaderPassEnabled("Forward", true);
-                material.SetShaderPassEnabled("ForwardDisplayDebug", true);
-            }
+            SetupBaseUnlitMaterialPass(material);
         }
     }
 } // namespace UnityEditor

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

     //-------------------------------------------------------------------------------------
 
     #pragma shader_feature _ALPHATEST_ON
-    #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _DOUBLESIDED_ON
     #pragma shader_feature _PER_PIXEL_DISPLACEMENT
 
         Pass
         {
-            Name "ForwardDisplayDebug" // Name is not used
-            Tags{ "LightMode" = "ForwardDisplayDebug" } // This will be only for transparent object based on the RenderQueue index
+            Name "ForwardDebugDisplay" // Name is not used
+            Tags{ "LightMode" = "ForwardDebugDisplay" } // This will be only for transparent object based on the RenderQueue index
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

 
     builtinData.velocity = float2(0.0, 0.0);
 
-#ifdef _DISTORTION_ON
+#if (SHADERPASS == SHADERPASS_DISTORTION)
     float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb;
     builtinData.distortion = distortion.rg;
     builtinData.distortionBlur = distortion.b;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 // Otherwise those parameters are not bound correctly at runtime.
 // ===========================================================================
 
-#ifndef LAYERED_LIT_SHADER
-
-TEXTURE2D(_DiffuseLightingMap);
-SAMPLER2D(sampler_DiffuseLightingMap);
-
+
+#ifndef LAYERED_LIT_SHADER
+
+TEXTURE2D(_DiffuseLightingMap);
+SAMPLER2D(sampler_DiffuseLightingMap);
 
 TEXTURE2D(_BaseColorMap);
 SAMPLER2D(sampler_BaseColorMap);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

     //-------------------------------------------------------------------------------------
 
     #pragma shader_feature _ALPHATEST_ON
-    #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _DOUBLESIDED_ON
     #pragma shader_feature _PER_PIXEL_DISPLACEMENT
 
         Pass
         {
-            Name "ForwardDisplayDebug" // Name is not used
-            Tags{ "LightMode" = "ForwardDisplayDebug" } // This will be only for transparent object based on the RenderQueue index
+            Name "ForwardDebugDisplay" // Name is not used
+            Tags{ "LightMode" = "ForwardDebugDisplay" } // This will be only for transparent object based on the RenderQueue index
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitDistortionPass.hlsl

 // If we have a layered shader, any UV can be use for this. To reduce the number of variant we groupt UV0/UV1 and UV2/UV3 instead of having variant for UV0/UV1/UV2/UV3
 // When UVX is present, we assume that UVX - 1 ... UV0 is present
 
-#if REQUIRE_UV_FOR_TESSELATION || REQUIRE_TANGENT_TO_WORLD || defined(_ALPHATEST_ON) || defined(_DISTORTION_ON)
+
+#if REQUIRE_UV_FOR_TESSELATION || REQUIRE_TANGENT_TO_WORLD || defined(_ALPHATEST_ON)
     #ifdef LAYERED_LIT_SHADER
     #define ATTRIBUTES_NEED_TEXCOORD1
         #if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
 #define VARYINGS_NEED_TANGENT_TO_WORLD
 #endif
 
-#if REQUIRE_TANGENT_TO_WORLD || defined(_ALPHATEST_ON) || defined(_DISTORTION_ON)
+
+#if REQUIRE_TANGENT_TO_WORLD || defined(_ALPHATEST_ON)
     #ifdef LAYERED_LIT_SHADER
     #define VARYINGS_NEED_TEXCOORD1
         #if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs

 using System;
 using UnityEngine;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
 
             public static GUIContent alphaCutoffEnableText = new GUIContent("Alpha Cutoff Enable", "Threshold for alpha cutoff");
             public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
+            public static GUIContent alphaCutoffShadowText = new GUIContent("Alpha Cutoff Shadow", "Threshold for alpha cutoff in case of shadow pass");
+            public static GUIContent alphaCutoffPrepassText = new GUIContent("Alpha Cutoff Prepass", "Threshold for alpha cutoff in case of depth prepass");
+            public static GUIContent transparentDepthPrepassEnableText = new GUIContent("Enable transparent depth prepass", "It allow to ");	
+
             public static GUIContent doubleSidedEnableText = new GUIContent("Double Sided", "This will render the two face of the objects (disable backface culling) and flip/mirror normal");
             public static GUIContent distortionEnableText = new GUIContent("Distortion", "Enable distortion on this shader");
             public static GUIContent distortionOnlyText = new GUIContent("Distortion Only", "This shader will only be use to render distortion");
         protected const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
         protected MaterialProperty alphaCutoff = null;
         protected const string kAlphaCutoff = "_AlphaCutoff";
+        protected MaterialProperty alphaCutoffShadow = null;
+        protected const string kAlphaCutoffShadow = "_AlphaCutoffShadow";
+        protected MaterialProperty alphaCutoffPrepass = null;
+        protected const string kAlphaCutoffPrepass = "_AlphaCutoffPrepass";
+        protected MaterialProperty transparentDepthPrepassEnable = null;
+        protected const string kTransparentDepthPrepassEnable = "_TransparentDepthPrepassEnable";
         protected MaterialProperty doubleSidedEnable = null;
         protected const string kDoubleSidedEnable = "_DoubleSidedEnable";
         protected MaterialProperty blendMode = null;
             surfaceType = FindProperty(kSurfaceType, props);
             alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
             alphaCutoff = FindProperty(kAlphaCutoff, props);
+
+            alphaCutoffShadow = FindProperty(kAlphaCutoffShadow, props, false);
+            alphaCutoffPrepass = FindProperty(kAlphaCutoffPrepass, props, false);
+            transparentDepthPrepassEnable = FindProperty(kTransparentDepthPrepassEnable, props, false);
+
             doubleSidedEnable = FindProperty(kDoubleSidedEnable, props);
             blendMode = FindProperty(kBlendMode, props);
             distortionEnable = FindProperty(kDistortionEnable, props, false);
 
                     if (distortionEnable.floatValue == 1.0f)
                     {
+                        EditorGUI.indentLevel++;
+                        EditorGUI.indentLevel--;
                     }
                 }
             }
                 m_MaterialEditor.ShaderProperty(alphaCutoff, StylesBaseUnlit.alphaCutoffText);
+
+                if (alphaCutoffShadow != null)
+                {
+                    m_MaterialEditor.ShaderProperty(alphaCutoffShadow, StylesBaseUnlit.alphaCutoffShadowText);
+                }
+
+                if (transparentDepthPrepassEnable != null)
+                {
+                    m_MaterialEditor.ShaderProperty(transparentDepthPrepassEnable, StylesBaseUnlit.transparentDepthPrepassEnableText);
+                    if (transparentDepthPrepassEnable.floatValue == 1.0f)
+                    {
+                        EditorGUI.indentLevel++;
+                        m_MaterialEditor.ShaderProperty(alphaCutoffPrepass, StylesBaseUnlit.alphaCutoffPrepassText);
+                        EditorGUI.indentLevel--;
+                    }
+                }
             }
             // This function must finish with double sided option (see LitUI.cs)
             m_MaterialEditor.ShaderProperty(doubleSidedEnable, StylesBaseUnlit.doubleSidedEnableText);
             SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
 
             if (material.HasProperty(kDistortionEnable))
-            {
-                bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
-                if (distortionEnable)
-                {
-                    material.SetShaderPassEnabled("DistortionVectors", true);
-                }
-                else
-                {
-                    material.SetShaderPassEnabled("DistortionVectors", false);
-                }
-
+            {                
                 bool distortionDepthTest = material.GetFloat(kDistortionDepthTest) > 0.0f;
                 if (distortionDepthTest)
                 {
                 {
                     material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.Always);
                 }
-
-                SetKeyword(material, "_DISTORTION_ON", distortionEnable);
             }
 
             // A material's GI flag internally keeps track of whether emission is enabled at all, it's enabled but has no effect
             if (material.HasProperty(kDistortionEnable))
             {
                 bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
-                bool distortionOnly = material.GetFloat(kDistortionOnly) > 0.0f;
-                if (distortionEnable && distortionOnly)
+                bool distortionOnly = false;
+                if (material.HasProperty(kDistortionOnly))
-                    // Disable all passes except debug material
-                    material.SetShaderPassEnabled("GBuffer", false);
-                    material.SetShaderPassEnabled("DebugViewMaterial", true);
-                    material.SetShaderPassEnabled("Meta", false);
-                    material.SetShaderPassEnabled("ShadowCaster", false);
-                    material.SetShaderPassEnabled("DepthOnly", false);
-                    material.SetShaderPassEnabled("MotionVectors", false);
-                    material.SetShaderPassEnabled("Forward", false);
+                    distortionOnly = material.GetFloat(kDistortionOnly) > 0.0f;
+                }
+
+                // If distortion only is enabled, disable all passes (except distortion and debug)
+                bool enablePass = !(distortionEnable && distortionOnly);
+                
+                // Disable all passes except distortion
+                // Distortion is setup in code above
+                material.SetShaderPassEnabled(HDShaderPassNames.s_ForwardStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_ForwardDebugDisplayStr, true);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_DepthOnlyStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_ForwardOnlyOpaqueDepthOnlyStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_ForwardOnlyOpaqueStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_ForwardOnlyOpaqueDebugDisplayStr, true);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_GBufferStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_GBufferWithPrepassStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_GBufferDebugDisplayStr, true);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_MotionVectorsStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_DistortionVectorsStr, distortionEnable); // note: use distortionEnable
+                material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentDepthPrepassStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_MetaStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_ShadowCasterStr, enablePass);
+            }
+
+            if (material.HasProperty(kTransparentDepthPrepassEnable))
+            {
+                bool depthWriteEnable = (material.GetFloat(kTransparentDepthPrepassEnable) > 0.0f) && ((SurfaceType)material.GetFloat(kSurfaceType) == SurfaceType.Transparent);
+                if (depthWriteEnable)
+                {
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentDepthPrepassStr, true);
-                    material.SetShaderPassEnabled("GBuffer", true);
-                    material.SetShaderPassEnabled("DebugViewMaterial", true);
-                    material.SetShaderPassEnabled("Meta", true);
-                    material.SetShaderPassEnabled("ShadowCaster", true);
-                    material.SetShaderPassEnabled("DepthOnly", true);
-                    material.SetShaderPassEnabled("MotionVectors", true);
-                    material.SetShaderPassEnabled("Forward", true);
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentDepthPrepassStr, false);
                 }
             }
         }
 
                 EditorGUILayout.Space();
                 EditorGUILayout.LabelField(StylesBaseUnlit.advancedText, EditorStyles.boldLabel);
-                // NB renderqueue editor is not shown on purpose: we want to override it based on blend mode
+                // NB RenderQueue editor is not shown on purpose: we want to override it based on blend mode
                 EditorGUI.indentLevel++;
                 m_MaterialEditor.EnableInstancingField();
                 m_MaterialEditor.DoubleSidedGIField();

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader

     //-------------------------------------------------------------------------------------
 
     #pragma shader_feature _ALPHATEST_ON
-    #pragma shader_feature _DISTORTION_ON
     // #pragma shader_feature _DOUBLESIDED_ON - We have no lighting, so no need to have this combination for shader, the option will just disable backface culling
 
     #pragma shader_feature _EMISSIVE_COLOR_MAP
 
         Pass
         {
-            Name "ForwardUnlit"
-            Tags { "LightMode" = "ForwardDisplayDebug" }
+            Name "ForwardDebugDisplay"
+            Tags { "LightMode" = "ForwardDebugDisplay" }
 
             Blend [_SrcBlend] [_DstBlend]
             ZWrite [_ZWrite]
         Pass
         {
             Name "ForwardUnlit"
-            Tags { "LightMode" = "ForwardOnlyOpaqueDisplayDebug" }
+            Tags { "LightMode" = "ForwardOnlyOpaqueDebugDisplay" }
 
             Blend [_SrcBlend] [_DstBlend]
             ZWrite [_ZWrite]

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/UnlitData.hlsl

 
     builtinData.velocity = float2(0.0, 0.0);
 
-#ifdef _DISTORTION_ON
+#if (SHADERPASS == SHADERPASS_DISTORTION)
     float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb;
     builtinData.distortion = distortion.rg;
     builtinData.distortionBlur = distortion.b;

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/VertMesh.hlsl

     output.objectScale = objectScale;
     #endif
     // TODO: TEMP: Velocity has a flow as it doens't have normal. This need to be fix. In the mean time, generate fix normal so compiler doesn't complain - When fix, think to also enable ATTRIBUTES_NEED_NORMAL in LitVelocityPass.hlsl
-    #if SHADERPASS == SHADERPASS_VELOCITY
+    #if (SHADERPASS == SHADERPASS_VELOCITY)
     output.normalWS = float3(0.0, 0.0, 1.0);
     #else
     output.normalWS = normalWS;