Merge branch 'Unity-2017.3'

SampleScenes/HDTest/GraphicTest/Common/CustomTexture/DistortionMap.shader

-Shader "Hidden/HDRenderPipeline/Test/DistortionMap"{
+Shader "Hidden/HDRenderPipeline/Test/DistortionMap"{
     Properties
     {
         _Size("Size", Float) = 1
                 float2 distortion = s.xy * _DistortionAmplitude;
                 float blur = s.z;
 
-                return float4(distortion, blur, 1.0);
+                return float4(distortion * 0.5 + 0.5, blur, 1.0);
             }
             ENDCG
         }
                 
                 float blur = (min(t, 1-t) * 2);
 
-                return float4(distortion, blur, 1.0);
+                return float4(distortion * 0.5 + 0.5, blur, 1.0);
             }
             ENDCG
         }
 
                 float blur = v;
 
-                return float4(distortion, blur, 1.0);
+                return float4(distortion * 0.5 + 0.5, blur, 1.0);
-}
+}

ScriptableRenderPipeline/Core/CoreUtils.cs

 
     public static class CoreUtils
     {
+        // Note: Color.Black have alpha channel set to 1. Most of the time we want alpha channel set to 0 as we use black to clear render target
+        public static Color clearColorAllBlack { get { return new Color(0f, 0f, 0f, 0f); } }
+
         // Render Target Management.
         public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier buffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
         {
 
         public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier buffer, ClearFlag clearFlag = ClearFlag.None, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
         {
-            SetRenderTarget(cmd, buffer, clearFlag, Color.black, miplevel, cubemapFace);
+            SetRenderTarget(cmd, buffer, clearFlag, clearColorAllBlack, miplevel, cubemapFace);
-            SetRenderTarget(cmd, colorBuffer, depthBuffer, ClearFlag.None, Color.black, miplevel, cubemapFace);
+            SetRenderTarget(cmd, colorBuffer, depthBuffer, ClearFlag.None, clearColorAllBlack, miplevel, cubemapFace);
-            SetRenderTarget(cmd, colorBuffer, depthBuffer, clearFlag, Color.black, miplevel, cubemapFace);
+            SetRenderTarget(cmd, colorBuffer, depthBuffer, clearFlag, clearColorAllBlack, miplevel, cubemapFace);
         }
 
         public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
 
         public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer)
         {
-            SetRenderTarget(cmd, colorBuffers, depthBuffer, ClearFlag.None, Color.black);
+            SetRenderTarget(cmd, colorBuffers, depthBuffer, ClearFlag.None, clearColorAllBlack);
-            SetRenderTarget(cmd, colorBuffers, depthBuffer, clearFlag, Color.black);
+            SetRenderTarget(cmd, colorBuffers, depthBuffer, clearFlag, clearColorAllBlack);
         }
 
         public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor)
         public static void ClearCubemap(CommandBuffer cmd, RenderTargetIdentifier buffer, Color clearColor)
         {
             for(int i = 0; i < 6; ++i)
-                SetRenderTarget(cmd, buffer, ClearFlag.Color, Color.black, 0, (CubemapFace)i);
+                SetRenderTarget(cmd, buffer, ClearFlag.Color, clearColorAllBlack, 0, (CubemapFace)i);
         }
 
         // Draws a full screen triangle as a faster alternative to drawing a full screen quad.
             return mat;
         }
 
+        public static void SetKeyword(CommandBuffer cmd, string keyword, bool state)
+        {
+            if (state)
+                cmd.EnableShaderKeyword(keyword);
+            else
+                cmd.DisableShaderKeyword(keyword);
+        }
+
+        // Caution: such a call should not be use interlaced with command buffer command, as it is immediate
         public static void SetKeyword(Material m, string keyword, bool state)
         {
             if (state)

ScriptableRenderPipeline/Core/ShaderLibrary/Common.hlsl

 #define HALF_PI     1.57079632679
 #define INV_HALF_PI 0.636619772367
 #define INFINITY    asfloat(0x7F800000)
+#define FLT_SMALL   0.0001
+#define LOG2_E      1.44269504089
 
 #define FLT_EPSILON 1.192092896e-07 // Smallest positive number, such that 1.0 + FLT_EPSILON != 1.0
 #define FLT_MIN     1.175494351e-38 // Minimum representable positive floating-point number
     return  saturate(x * FLT_MAX) * 2.0 - 1.0;
 }
 
-// Orthonormalize the basis vectors using the Gram-Schmidt process.
-// We assume that the length of the surface normal is sufficiently close to 1.
-// return orthonormalize tangent
+// Orthonormalizes the tangent frame using the Gram-Schmidt process.
+// We assume that both the tangent and the normal are normalized.
+// Returns the new tangent (the normal is unaffected).
 float3 Orthonormalize(float3 tangent, float3 normal)
 {
     return normalize(tangent - dot(tangent, normal) * normal);

ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl

 // Helper functions
 //-----------------------------------------------------------------------------
 
-// 'NdotV' can become negative for visible pixels due to the perspective projection, normal mapping and decals.
-// This can produce visible artifacts under specular lighting, both direct (overly dark/bright pixels) and indirect (incorrect cubemap direction).
-// One way of avoiding these artifacts is to limit the value of 'NdotV' to a small positive number,
-// and calculate the reflection vector for the cubemap fetch using a normal shifted into view.
-float3 GetViewShiftedNormal(float3 N, float3 V, float NdotV, float minNdotV)
+// Inputs:    normalized normal and view vectors.
+// Outputs:   front-facing normal, and the new non-negative value of the cosine of the view angle.
+// Important: call Orthonormalize() on the tangent and recompute the bitangent afterwards.
+float3 GetViewReflectedNormal(float3 N, float3 V, out float NdotV)
-    if (NdotV < minNdotV)
-    {
-        // We do not renormalize the normal to save a few clock cycles.
-        // The magnitude difference is typically negligible, and the normal is only used to compute
-        // the reflection vector for the IBL cube map fetch (which does not depend on the magnitude).
-        N += (-NdotV + minNdotV) * V;
-    }
+    // Fragments of front-facing geometry can have back-facing normals due to interpolation,
+    // normal mapping and decals. This can cause visible artifacts from both direct (negative or
+    // extremely high values) and indirect (incorrect lookup direction) lighting.
+    // There are several ways to avoid this problem. To list a few:
+    //
+    // 1. Setting { NdotV = max(<N,V>, SMALL_VALUE) }. This effectively removes normal mapping
+    // from the affected fragments, making the surface appear flat.
+    //
+    // 2. Setting { NdotV = abs(<N,V>) }. This effectively reverses the convexity of the surface.
+    // It also reduces light leaking from non-shadow-casting lights. Note that 'NdotV' can still
+    // be 0 in this case.
+    //
+    // It's important to understand that simply changing the value of the cosine is insufficient.
+    // For one, it does not solve the incorrect lookup direction problem, since the normal itself
+    // is not modified. There is a more insidious issue, however. 'NdotV' is a constituent element
+    // of the mathematical system describing the relationships between different vectors - and
+    // not just normal and view vectors, but also light vectors, half vectors, tangent vectors, etc.
+    // Changing only one angle (or its cosine) leaves the system in an inconsistent state, where
+    // certain relationships can take on different values depending on whether 'NdotV' is used
+    // in the calculation or not. Therefore, it is important to change the normal (or another
+    // vector) in order to leave the system in a consistent state.
+    //
+    // We choose to follow the conceptual approach (2) by reflecting the normal around the
+    // (<N,V> = 0) boundary if necessary, as it allows us to preserve some normal mapping details.
+
+    NdotV = dot(N, V);
+
+    N = (NdotV >= 0) ? N : (N - 2 * NdotV * V);
+    NdotV = abs(NdotV);
 
     return N;
 }

ScriptableRenderPipeline/Core/ShaderLibrary/CommonMaterial.hlsl

 // Helper function for anisotropy
 //-----------------------------------------------------------------------------
 
-// Ref: http://blog.selfshadow.com/publications/s2012-shading-course/burley/s2012_pbs_disney_brdf_notes_v3.pdf (in addenda)
-// Convert anisotropic ratio (0->no isotropic; 1->full anisotropy in tangent direction) to roughness
 void ConvertAnisotropyToRoughness(float roughness, float anisotropy, out float roughnessT, out float roughnessB)
 {
     // Use the parametrization of Sony Imageworks.
 // Evaluate Int{0, inf}{2 * Pi * r * R(sqrt(r^2 + d^2))}, where R is the diffusion profile.
 // Note: 'volumeAlbedo' should be premultiplied by 0.25.
 // Ref: Approximate Reflectance Profiles for Efficient Subsurface Scattering by Pixar (BSSRDF only).
-float3 ComputeTransmittance(float3 S, float3 volumeAlbedo, float thickness, float radiusScale)
+float3 ComputeTransmittanceDisney(float3 S, float3 volumeAlbedo, float thickness, float radiusScale)
+#if 0
+#else
+    // Help the compiler.
+    float  k = (-1.0 / 3.0) * LOG2_E;
+    float3 p = (k * thickness) * S;
+    float3 expOneThird = exp2(p);
+#endif
 
     // Premultiply & optimize: T = (1/4 * A) * (e^(-t * S) + 3 * e^(-1/3 * t * S))
     return volumeAlbedo * (expOneThird * expOneThird * expOneThird + 3 * expOneThird);

ScriptableRenderPipeline/Core/ShaderLibrary/EntityLighting.hlsl

 }
 
 // This sample a 3D volume storing SH
-// Volume is store as 3D texture with 4 R, G, B, X set of 4 coefficient store atlas in same 3D texture. X is use for occlusion.
-// TODO: the packing here is inefficient as we will fetch values far away from each other and they may not fit into the cache - Suggest we pack only RGB continuously
+// Volume is store as 3D texture with 4 R, G, B, Occ set of 4 coefficient store atlas in same 3D texture. Occ is use for occlusion.
+// TODO: the packing here is inefficient as we will fetch values far away from each other and they may not fit into the cache - Suggest we pack RGB continuously
-float3 SampleProbeVolumeSH4(TEXTURE3D_ARGS(SHVolumeTexture, SHVolumeSampler), float3 positionWS, float3 normalWS, float4x4 WorldToTexture, 
+float3 SampleProbeVolumeSH4(TEXTURE3D_ARGS(SHVolumeTexture, SHVolumeSampler), float3 positionWS, float3 normalWS, float4x4 WorldToTexture,
                             float transformToLocal, float texelSizeX, float3 probeVolumeMin, float3 probeVolumeSizeInv)
 {
     float3 position = (transformToLocal == 1.0f) ? mul(WorldToTexture, float4(positionWS, 1.0)).xyz : positionWS;
     float4 shAb = SAMPLE_TEXTURE3D(SHVolumeTexture, SHVolumeSampler, texCoord);
 
     return SHEvalLinearL0L1(normalWS, shAr, shAg, shAb);
+}
+
+float4 SampleProbeOcclusion(TEXTURE3D_ARGS(SHVolumeTexture, SHVolumeSampler), float3 positionWS, float4x4 WorldToTexture,
+                            float transformToLocal, float texelSizeX, float3 probeVolumeMin, float3 probeVolumeSizeInv)
+{
+    float3 position = (transformToLocal == 1.0f) ? mul(WorldToTexture, float4(positionWS, 1.0)).xyz : positionWS;
+    float3 texCoord = (position - probeVolumeMin) * probeVolumeSizeInv.xyz;
+
+    // Sample fourth texture in the atlas
+    // We need to compute proper U coordinate to sample.
+    // Clamp the coordinate otherwize we'll have leaking between ShB coefficients and Probe Occlusion(Occ) info
+    texCoord.x = max(texCoord.x * 0.25 + 0.75, 0.75 + 0.5 * texelSizeX);
+
+    return SAMPLE_TEXTURE3D(SHVolumeTexture, SHVolumeSampler, texCoord);
 }
 
 // Following functions are to sample enlighten lightmaps (or lightmaps encoded the same way as our

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

         IndirectDiffuseOcclusionFromSsao,
         IndirectDiffuseGtaoFromSsao,
         IndirectSpecularOcclusionFromSsao,
-        IndirectSpecularGtaoFromSsao   
+        IndirectSpecularGtaoFromSsao
     }
 
     public class DebugDisplaySettings
             VertexNormalWS,
             VertexColor,
             VertexColorAlpha,
-            // caution if you add something here, it must start below
+            Last,
         };
 
         // Number must be contiguous
             None = 0,
-            Depth = DebugViewVarying.VertexColorAlpha + 1,
+            Depth = DebugViewVarying.Last,
+            BakeShadowMask0,
+            BakeShadowMask1,
+            BakeShadowMask2,
+            BakeShadowMask3,
+            Last,
         }
 
         // Number must be contiguous
             None = 0,
-            Tessellation = DebugViewGbuffer.BakeDiffuseLightingWithAlbedoPlusEmissive + 1,
+            Tessellation = DebugViewGbuffer.Last,
             PixelDisplacement,
             VertexDisplacement,
             TessellationDisplacement,

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.hlsl

 #define DEBUGVIEWVARYING_VERTEX_NORMAL_WS (7)
 #define DEBUGVIEWVARYING_VERTEX_COLOR (8)
 #define DEBUGVIEWVARYING_VERTEX_COLOR_ALPHA (9)
+#define DEBUGVIEWVARYING_LAST (10)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewGbuffer:  static fields
 #define DEBUGVIEWGBUFFER_BAKE_DIFFUSE_LIGHTING_WITH_ALBEDO_PLUS_EMISSIVE (11)
+#define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK0 (12)
+#define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK1 (13)
+#define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK2 (14)
+#define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK3 (15)
+#define DEBUGVIEWGBUFFER_LAST (16)
-#define DEBUGVIEWPROPERTIES_TESSELLATION (12)
-#define DEBUGVIEWPROPERTIES_PIXEL_DISPLACEMENT (13)
-#define DEBUGVIEWPROPERTIES_VERTEX_DISPLACEMENT (14)
-#define DEBUGVIEWPROPERTIES_TESSELLATION_DISPLACEMENT (15)
-#define DEBUGVIEWPROPERTIES_DEPTH_OFFSET (16)
-#define DEBUGVIEWPROPERTIES_LIGHTMAP (17)
+#define DEBUGVIEWPROPERTIES_TESSELLATION (16)
+#define DEBUGVIEWPROPERTIES_PIXEL_DISPLACEMENT (17)
+#define DEBUGVIEWPROPERTIES_VERTEX_DISPLACEMENT (18)
+#define DEBUGVIEWPROPERTIES_TESSELLATION_DISPLACEMENT (19)
+#define DEBUGVIEWPROPERTIES_DEPTH_OFFSET (20)
+#define DEBUGVIEWPROPERTIES_LIGHTMAP (21)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.FullScreenDebugMode:  static fields

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewMaterialGBuffer.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #include "../../Core/ShaderLibrary/Common.hlsl"
             #include "../../Core/ShaderLibrary/Color.hlsl"
 
             #include "../Material/Material.hlsl"
 
             DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
+            #ifdef SHADOWS_SHADOWMASK
+            TEXTURE2D(_ShadowMaskTexture);
+            #endif
 
             struct Attributes
             {
 
                 FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
                 BSDFData bsdfData;
-                float3 bakeDiffuseLighting;
-                DECODE_FROM_GBUFFER(gbuffer, 0xFFFFFFFF, bsdfData, bakeDiffuseLighting);
+                BakeLightingData bakeLightingData;
+                DECODE_FROM_GBUFFER(gbuffer, 0xFFFFFFFF, bsdfData, bakeLightingData.bakeDiffuseLighting);
+                #ifdef SHADOWS_SHADOWMASK
+                DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
+                #endif
 
                 // Init to not expected value
                 float3 result = float3(-666.0, 0.0, 0.0);
                 {
                     // TODO: require a remap
                     // TODO: we should not gamma correct, but easier to debug for now without correct high range value
-                    result = bakeDiffuseLighting; needLinearToSRGB = true;
+                    result = bakeLightingData.bakeDiffuseLighting; needLinearToSRGB = true;
+                #ifdef SHADOWS_SHADOWMASK
+                else if (_DebugViewMaterial == DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK0)
+                {
+                    result = bakeLightingData.bakeShadowMask.xxx;
+                }
+                else if (_DebugViewMaterial == DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK1)
+                {
+                    result = bakeLightingData.bakeShadowMask.yyy;
+                }
+                else if (_DebugViewMaterial == DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK2)
+                {
+                    result = bakeLightingData.bakeShadowMask.zzz;
+                }
+                else if (_DebugViewMaterial == DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK3)
+                {
+                    result = bakeLightingData.bakeShadowMask.www;
+                }
+                #endif
 
                 GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB);
 

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

                                 else
                                 {
                                     mat.SetInt("_SubsurfaceProfile" + x, ivalue + 1);
-                                } 
-                                mat.SetInt("_SubsurfaceProfile" + x, ivalue + 1);
+                                }
                             }
                             EditorUtility.SetDirty(mat);
                         }

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
         public int gbufferCount { get; set; }
 
-        int[] m_IDs = new int[k_MaxGbuffer];
-        RenderTextureFormat[] m_Formats = new RenderTextureFormat[k_MaxGbuffer];
-        RenderTextureReadWrite[] m_sRGBWrites = new RenderTextureReadWrite[k_MaxGbuffer];
-        public void SetBufferDescription(int index, string stringId, RenderTextureFormat inFormat, RenderTextureReadWrite inSRGBWrite)
+        public void InitGBuffers(int width, int height, RenderPipelineMaterial deferredMaterial, bool enableBakeShadowMask, CommandBuffer cmd)
-            m_IDs[index] = Shader.PropertyToID(stringId);
-            m_RTIDs[index] = new RenderTargetIdentifier(m_IDs[index]);
-            m_Formats[index] = inFormat;
-            m_sRGBWrites[index] = inSRGBWrite;
-        }
+            // Init Gbuffer description
+            gbufferCount = deferredMaterial.GetMaterialGBufferCount();
+            RenderTextureFormat[] rtFormat;
+            RenderTextureReadWrite[] rtReadWrite;
+            deferredMaterial.GetMaterialGBufferDescription(out rtFormat, out rtReadWrite);
+
+            for (int gbufferIndex = 0; gbufferIndex < gbufferCount; ++gbufferIndex)
+            {
+                cmd.GetTemporaryRT(HDShaderIDs._GBufferTexture[gbufferIndex], width, height, 0, FilterMode.Point, rtFormat[gbufferIndex], rtReadWrite[gbufferIndex]);
+                m_RTIDs[gbufferIndex] = new RenderTargetIdentifier(HDShaderIDs._GBufferTexture[gbufferIndex]);
+            }
-        public void InitGBuffers(int width, int height, CommandBuffer cmd)
-        {
-            for (int index = 0; index < gbufferCount; index++)
+            if (enableBakeShadowMask)
-                cmd.GetTemporaryRT(m_IDs[index], width, height, 0, FilterMode.Point, m_Formats[index], m_sRGBWrites[index]);
+                cmd.GetTemporaryRT(HDShaderIDs._ShadowMaskTexture, width, height, 0, FilterMode.Point, Builtin.GetShadowMaskBufferFormat(), Builtin.GetShadowMaskBufferReadWrite());
+                m_RTIDs[gbufferCount++] = new RenderTargetIdentifier(HDShaderIDs._ShadowMaskTexture);
+            }
+
+            if (ShaderConfig.s_VelocityInGbuffer == 1)
+            {
+                // If velocity is in GBuffer then it is in the last RT. Assign a different name to it.
+                cmd.GetTemporaryRT(HDShaderIDs._VelocityTexture, width, height, 0, FilterMode.Point, Builtin.GetVelocityBufferFormat(), Builtin.GetVelocityBufferReadWrite());
+                m_RTIDs[gbufferCount++] = new RenderTargetIdentifier(HDShaderIDs._VelocityTexture);
+            // TODO: check with THomas or Tim if wa can simply return m_ColorMRTs with null for extra RT
             if (m_ColorMRTs == null || m_ColorMRTs.Length != gbufferCount)
                 m_ColorMRTs = new RenderTargetIdentifier[gbufferCount];
 
 
         readonly GBufferManager m_GbufferManager = new GBufferManager();
 
+        // Renderer Bake configuration can vary depends on if shadow mask is enabled or no
+        RendererConfiguration m_currentRendererConfigurationBakedLighting = HDUtils.k_RendererConfigurationBakedLighting;
         Material m_CopyStencilForSplitLighting;
         Material m_CopyStencilForRegularLighting;
         GPUCopy m_GPUCopy;
 
         // Debug material
         Material m_DebugViewMaterialGBuffer;
+        Material m_DebugViewMaterialGBufferShadowMask;
+        Material m_currentDebugViewMaterialGBuffer;
         Material m_DebugDisplayLatlong;
         Material m_DebugFullScreen;
         Material m_ErrorMaterial;
         // Old SSS Model >>>
         readonly int m_CameraFilteringBuffer;
         // <<< Old SSS Model
+        readonly int m_ShadowMaskBuffer;
         readonly int m_VelocityBuffer;
         readonly int m_DistortionBuffer;
         readonly int m_GaussianPyramidColorBuffer;
         RenderTargetIdentifier m_CameraStencilBufferCopyRT;
         RenderTargetIdentifier m_HTileRT;
 
-        // The pass "SRPDefaultUnlit" is a fallback to legacy unlit rendering and is required to support unity 2d + unity UI that render in the scene.
+        // The pass "SRPDefaultUnlit" is a fall back to legacy unlit rendering and is required to support unity 2d + unity UI that render in the scene.
         ShaderPassName[] m_ForwardAndForwardOnlyPassNames = { new ShaderPassName(), new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName};
         ShaderPassName[] m_ForwardOnlyPassNames = { new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName};
         ShaderPassName[] m_DepthOnlyAndDepthForwardOnlyPassNames = { HDShaderPassNames.s_DepthForwardOnlyName, HDShaderPassNames.s_DepthOnlyName };
 
             InitializeDebugMaterials();
 
-            // Init Gbuffer description
-            m_GbufferManager.gbufferCount = m_DeferredMaterial.GetMaterialGBufferCount();
-            RenderTextureFormat[] rtFormat;
-            RenderTextureReadWrite[] rtReadWrite;
-            m_DeferredMaterial.GetMaterialGBufferDescription(out rtFormat, out rtReadWrite);
-
-            for (int gbufferIndex = 0; gbufferIndex < m_GbufferManager.gbufferCount; ++gbufferIndex)
-            {
-                m_GbufferManager.SetBufferDescription(gbufferIndex, "_GBufferTexture" + gbufferIndex, rtFormat[gbufferIndex], rtReadWrite[gbufferIndex]);
-            }
-
-            if (ShaderConfig.s_VelocityInGbuffer == 1)
-            {
-                // If velocity is in GBuffer then it is in the last RT. Assign a different name to it.
-                m_GbufferManager.SetBufferDescription(m_GbufferManager.gbufferCount, "_VelocityTexture", Builtin.GetVelocityBufferFormat(), Builtin.GetVelocityBufferReadWrite());
-                m_GbufferManager.gbufferCount++;
-            }
             m_VelocityBufferRT = new RenderTargetIdentifier(m_VelocityBuffer);
 
             m_DistortionBuffer = HDShaderIDs._DistortionTexture;
         void InitializeDebugMaterials()
         {
             m_DebugViewMaterialGBuffer = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugViewMaterialGBufferShader);
+            m_DebugViewMaterialGBufferShadowMask = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugViewMaterialGBufferShader);
+            m_DebugViewMaterialGBufferShadowMask.EnableKeyword("SHADOWS_SHADOWMASK");
             m_DebugDisplayLatlong = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugDisplayLatlongShader);
             m_DebugFullScreen = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugFullScreenShader);
             m_ErrorMaterial = CoreUtils.CreateEngineMaterial("Hidden/InternalErrorShader");
             m_MaterialList.ForEach(material => material.Cleanup());
 
             CoreUtils.Destroy(m_DebugViewMaterialGBuffer);
+            CoreUtils.Destroy(m_DebugViewMaterialGBufferShadowMask);
             CoreUtils.Destroy(m_DebugDisplayLatlong);
             CoreUtils.Destroy(m_DebugFullScreen);
             CoreUtils.Destroy(m_ErrorMaterial);
             m_ShadowSettings.directionalLightNearPlaneOffset = commonSettings.shadowNearPlaneOffset;
         }
 
+        public void ConfigureForShadowMask(bool enableBakeShadowMask, CommandBuffer cmd)
+        {
+            // Globally enable (for GBuffer shader and forward lit (opaque and transparent) the keyword SHADOWS_SHADOWMASK
+            CoreUtils.SetKeyword(cmd, "SHADOWS_SHADOWMASK", enableBakeShadowMask);
+
+            // Configure material to use depends on shadow mask option
+            m_currentRendererConfigurationBakedLighting = enableBakeShadowMask ? HDUtils.k_RendererConfigurationBakedLightingWithShadowMask : HDUtils.k_RendererConfigurationBakedLighting;
+            m_currentDebugViewMaterialGBuffer = enableBakeShadowMask ? m_DebugViewMaterialGBufferShadowMask : m_DebugViewMaterialGBuffer;
+        }
+
         CullResults m_CullResults;
         public override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
         {
                 return;
             }
 
-            InitAndClearBuffer(hdCamera, cmd);
+            // Note: Legacy Unity behave like this for ShadowMask
+            // When you select ShadowMask in Lighting panel it recompile shaders on the fly with the SHADOW_MASK keyword.
+            // However there is no C# function that we can query to know what mode have been select in Lighting Panel and it will be wrong anyway. Lighting Panel setup what will be the next bake mode. But until light is bake, it is wrong.
+            // Currently to know if you need shadow mask you need to go through all visible lights (of CullResult), check the LightBakingOutput struct and look at lightmapBakeType/mixedLightingMode. If one light have shadow mask bake mode, then you need shadow mask features (i.e extra Gbuffer).
+            // It mean that when we build a standalone player, if we detect a light with bake shadow mask, we generate all shader variant (with and without shadow mask) and at runtime, when a bake shadow mask light is visible, we dynamically allocate an extra GBuffer and switch the shader.
+            // So the first thing to do is to go through all the light: PrepareLightsForGPU
+            bool enableBakeShadowMask = m_LightLoop.PrepareLightsForGPU(m_ShadowSettings, m_CullResults, camera);
+            ConfigureForShadowMask(enableBakeShadowMask, cmd);
+
+            InitAndClearBuffer(hdCamera, enableBakeShadowMask, cmd);
 
             RenderDepthPrepass(m_CullResults, camera, renderContext, cmd);
 
                         }
                     }
 
-                    m_LightLoop.PrepareLightsForGPU(m_ShadowSettings, m_CullResults, camera);
                     m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
 
                     cmd.GetTemporaryRT(m_DeferredShadowBuffer, camera.pixelWidth, camera.pixelHeight, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1 , true);
                                          bool                    preRefractionQueue = false)
         {
             m_SinglePassName[0] = passName;
-            RenderTransparentRenderList(cull, camera, renderContext, cmd, m_SinglePassName, 
+            RenderTransparentRenderList(cull, camera, renderContext, cmd, m_SinglePassName,
                 rendererConfiguration, stateBlock, overrideMaterial, preRefractionQueue);
         }
 
 
             var filterSettings = new FilterRenderersSettings(true)
             {
-                renderQueueRange = preRefractionQueue 
-                    ? k_RenderQueue_PreRefraction 
+                renderQueueRange = preRefractionQueue
+                    ? k_RenderQueue_PreRefraction
                     : k_RenderQueue_Transparent
             };
 
                 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.s_GBufferDebugDisplayName, HDUtils.k_RendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
+                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferDebugDisplayName, m_currentRendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
                 }
                 else
                 {
                         var rangeOpaqueAlphaTest   = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
 
                         // When using depth prepass for opaque alpha test only we need to use regular depth test for normal opaque objects.
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, HDUtils.k_RendererConfigurationBakedLighting, rangeOpaqueNoAlphaTest, m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, rangeOpaqueNoAlphaTest, m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferWithPrepassName, HDUtils.k_RendererConfigurationBakedLighting, rangeOpaqueAlphaTest, m_DepthStateOpaqueWithPrepass);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferWithPrepassName, m_currentRendererConfigurationBakedLighting, rangeOpaqueAlphaTest, m_DepthStateOpaqueWithPrepass);
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, HDUtils.k_RendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
                     }
                 }
             }
                 {
                     using (new ProfilingSample(cmd, "DebugViewMaterialGBuffer"))
                     {
-                        CoreUtils.DrawFullScreen(cmd, m_DebugViewMaterialGBuffer, m_CameraColorBufferRT);
+                        CoreUtils.DrawFullScreen(cmd, m_currentDebugViewMaterialGBuffer, m_CameraColorBufferRT);
-                    CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.All, Color.black);
+                    CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.All, CoreUtils.clearColorAllBlack);
-                    RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDebugDisplayName, HDUtils.k_RendererConfigurationBakedLighting);
+                    RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDebugDisplayName, m_currentRendererConfigurationBakedLighting);
-                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDebugDisplayName, HDUtils.k_RendererConfigurationBakedLighting);
+                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDebugDisplayName, m_currentRendererConfigurationBakedLighting);
                 }
             }
 
                 {
                     var passNames = m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() ? m_ForwardAndForwardOnlyPassNames : m_ForwardOnlyPassNames;
                     // Forward opaque material always have a prepass (whether or not we use deferred, whether or not there is option like alpha test only) so we pass the right depth state here.
-                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, passNames, HDUtils.k_RendererConfigurationBakedLighting, null, m_DepthStateOpaqueWithPrepass);
+                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, passNames, m_currentRendererConfigurationBakedLighting, null, m_DepthStateOpaqueWithPrepass);
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardAndForwardOnlyPassNames, HDUtils.k_RendererConfigurationBakedLighting, preRefractionQueue: pass == ForwardPass.PreRefraction);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardAndForwardOnlyPassNames, m_currentRendererConfigurationBakedLighting, preRefractionQueue: pass == ForwardPass.PreRefraction);
                 }
             }
         }
                 }
                 else
                 {
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardErrorPassNames, 0, 
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardErrorPassNames, 0,
                         null, m_ErrorMaterial, pass == ForwardPass.PreRefraction);
                 }
             }
             }
         }
 
-        void InitAndClearBuffer(HDCamera camera, CommandBuffer cmd)
+        void InitAndClearBuffer(HDCamera camera, bool enableBakeShadowMask, CommandBuffer cmd)
         {
             using (new ProfilingSample(cmd, "InitAndClearBuffer"))
             {
                     // End
 
                     if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
-                        m_GbufferManager.InitGBuffers(w, h, cmd);
+                        m_GbufferManager.InitGBuffers(w, h, m_DeferredMaterial, enableBakeShadowMask, cmd);
 
                     CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.Depth);
                 }
                 {
-                    CoreUtils.SetRenderTarget(cmd, m_CameraSssDiffuseLightingBufferRT, ClearFlag.Color, Color.black);
+                    CoreUtils.SetRenderTarget(cmd, m_CameraSssDiffuseLightingBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
                 }
 
                 // Old SSS Model >>>
                     using (new ProfilingSample(cmd, "Clear SSS filtering target"))
                     {
-                        CoreUtils.SetRenderTarget(cmd, m_CameraFilteringBuffer, ClearFlag.Color, Color.black);
+                        CoreUtils.SetRenderTarget(cmd, m_CameraFilteringBuffer, ClearFlag.Color, CoreUtils.clearColorAllBlack);
                     }
                 }
                 // <<< Old SSS Model
                     using (new ProfilingSample(cmd, "Clear stencil texture"))
                     {
-                        CoreUtils.SetRenderTarget(cmd, m_CameraStencilBufferCopyRT, ClearFlag.Color, Color.black);
+                        CoreUtils.SetRenderTarget(cmd, m_CameraStencilBufferCopyRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
                     }
                 }
 
                     {
-                        CoreUtils.SetRenderTarget(cmd, m_HTileRT, ClearFlag.Color, Color.black);
+                        CoreUtils.SetRenderTarget(cmd, m_HTileRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
-                // TEMP: As we are in development and have not all the setup pass we still clear the color in emissive buffer and gbuffer, but this will be removed later.
+                // TODO: As we are in development and have not all the setup pass we still clear the color in emissive buffer and gbuffer, but this will be removed later.
-                    CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.Color, Color.black);
+                    CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
                 }
 
                 // Clear GBuffers
                     {
-                        CoreUtils.SetRenderTarget(cmd, m_GbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.Color, Color.black);
+                        CoreUtils.SetRenderTarget(cmd, m_GbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
                     }
                 }
                 // END TEMP

ScriptableRenderPipeline/HDRenderPipeline/HDStringConstants.cs

         public static readonly int _CameraFilteringBuffer          = Shader.PropertyToID("_CameraFilteringTexture");
         public static readonly int _IrradianceSource               = Shader.PropertyToID("_IrradianceSource");
 
+        public static readonly int[] _GBufferTexture =
+        {
+            Shader.PropertyToID("_GBufferTexture0"),
+            Shader.PropertyToID("_GBufferTexture1"),
+            Shader.PropertyToID("_GBufferTexture2"),
+            Shader.PropertyToID("_GBufferTexture3"),
+            Shader.PropertyToID("_GBufferTexture4"),
+            Shader.PropertyToID("_GBufferTexture5"),
+            Shader.PropertyToID("_GBufferTexture6"),
+            Shader.PropertyToID("_GBufferTexture7")
+        };
+
+        public static readonly int _ShadowMaskTexture = Shader.PropertyToID("_ShadowMaskTexture");
         public static readonly int _DistortionTexture = Shader.PropertyToID("_DistortionTexture");
         public static readonly int _GaussianPyramidColorTexture = Shader.PropertyToID("_GaussianPyramidColorTexture");
         public static readonly int _DepthPyramidTexture = Shader.PropertyToID("_PyramidDepthTexture");
         public static readonly int _Source4 = Shader.PropertyToID("_Source4");
         public static readonly int _Result1 = Shader.PropertyToID("_Result1");
 
-
-        internal static readonly int _GlobalFog_Extinction       = Shader.PropertyToID("_GlobalFog_Extinction");
-        internal static readonly int _GlobalFog_Scattering       = Shader.PropertyToID("_GlobalFog_Scattering");
-        internal static readonly int _VBufferResolutionAndScale  = Shader.PropertyToID("_VBufferResolutionAndScale");
-        internal static readonly int _VBufferDepthEncodingParams = Shader.PropertyToID("_VBufferDepthEncodingParams");
-        internal static readonly int _VBufferCoordToViewDirWS    = Shader.PropertyToID("_VBufferCoordToViewDirWS");
-        internal static readonly int _VBufferDensity             = Shader.PropertyToID("_VBufferDensity");
-        internal static readonly int _VBufferLighting            = Shader.PropertyToID("_VBufferLighting");
-        internal static readonly int _VBufferLightingPrev        = Shader.PropertyToID("_VBufferLightingPrev");
+        public static readonly int _GlobalFog_Extinction       = Shader.PropertyToID("_GlobalFog_Extinction");
+        public static readonly int _GlobalFog_Scattering       = Shader.PropertyToID("_GlobalFog_Scattering");
+        public static readonly int _VBufferResolutionAndScale  = Shader.PropertyToID("_VBufferResolutionAndScale");
+        public static readonly int _VBufferDepthEncodingParams = Shader.PropertyToID("_VBufferDepthEncodingParams");
+        public static readonly int _VBufferCoordToViewDirWS    = Shader.PropertyToID("_VBufferCoordToViewDirWS");
+        public static readonly int _VBufferDensity             = Shader.PropertyToID("_VBufferDensity");
+        public static readonly int _VBufferLighting            = Shader.PropertyToID("_VBufferLighting");
+        public static readonly int _VBufferLightingPrev        = Shader.PropertyToID("_VBufferLightingPrev");
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDUtils.cs

     public class HDUtils
     {
         public const RendererConfiguration k_RendererConfigurationBakedLighting = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume;
+        public const RendererConfiguration k_RendererConfigurationBakedLightingWithShadowMask = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume;
 
         public static List<RenderPipelineMaterial> GetRenderPipelineMaterialList()
         {

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.shader

 
             // Split lighting is utilized during the SSS pass.
             #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
-
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
             #pragma multi_compile _ DEBUG_DISPLAY
 
             //-------------------------------------------------------------------------------------
             DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
         #ifdef VOLUMETRIC_LIGHTING_ENABLED
             TEXTURE3D(_VBufferLighting);
+        #endif
+        #ifdef SHADOWS_SHADOWMASK
+            TEXTURE2D(_ShadowMaskTexture);
         #endif
 
             struct Attributes
 
                 FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
                 BSDFData bsdfData;
-                float3 bakeDiffuseLighting;
-                DECODE_FROM_GBUFFER(gbuffer, MATERIAL_FEATURE_MASK_FLAGS, bsdfData, bakeDiffuseLighting);
+                BakeLightingData bakeLightingData;
+                DECODE_FROM_GBUFFER(gbuffer, MATERIAL_FEATURE_MASK_FLAGS, bsdfData, bakeLightingData.bakeDiffuseLighting);
+                #ifdef SHADOWS_SHADOWMASK
+                DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
+                #endif
-                LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, LIGHT_FEATURE_MASK_FLAGS_OPAQUE, diffuseLighting, specularLighting);
+                LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, LIGHT_FEATURE_MASK_FLAGS_OPAQUE, diffuseLighting, specularLighting);
 
             #ifdef VOLUMETRIC_LIGHTING_ENABLED
                 float4 volumetricLighting = GetInScatteredRadianceAndTransmittance(posInput.positionSS,

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs

 
         public Vector3 up;      // Rescaled by (2 / shapeWidth)
         public float diffuseScale;
+
+        public bool dynamicShadowCasterOnly; // Use with ShadowMask feature
+        public Vector2 fadeDistanceScaleAndBias; // Use with ShadowMask feature
+        public float unused0;
+
+        public Vector4 shadowMaskSelector; // Use with ShadowMask feature
     };
 
     [GenerateHLSL]
         public float angleScale;  // Spot light
         public float angleOffset; // Spot light
         public float shadowDimmer;
-        public int unused0;
+        public bool dynamicShadowCasterOnly; // Use with ShadowMask feature
+
+        public Vector4 shadowMaskSelector; // Use with ShadowMask feature
     };
 
 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs.hlsl

     float specularScale;
     float3 up;
     float diffuseScale;
+    bool dynamicShadowCasterOnly;
+    float2 fadeDistanceScaleAndBias;
+    float unused0;
+    float4 shadowMaskSelector;
 };
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.LightData
     float angleScale;
     float angleOffset;
     float shadowDimmer;
-    int unused0;
+    bool dynamicShadowCasterOnly;
+    float4 shadowMaskSelector;
 };
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.EnvLightData
 {
 	return value.diffuseScale;
 }
+bool GetDynamicShadowCasterOnly(DirectionalLightData value)
+{
+	return value.dynamicShadowCasterOnly;
+}
+float2 GetFadeDistanceScaleAndBias(DirectionalLightData value)
+{
+	return value.fadeDistanceScaleAndBias;
+}
+float GetUnused0(DirectionalLightData value)
+{
+	return value.unused0;
+}
+float4 GetShadowMaskSelector(DirectionalLightData value)
+{
+	return value.shadowMaskSelector;
+}
 
 //
 // Accessors for UnityEngine.Experimental.Rendering.HDPipeline.LightData
 {
 	return value.shadowDimmer;
 }
-int GetUnused0(LightData value)
+bool GetDynamicShadowCasterOnly(LightData value)
-	return value.unused0;
+	return value.dynamicShadowCasterOnly;
 }
 float2 GetSize(LightData value)
 {
 float GetMinRoughness(LightData value)
 {
 	return value.minRoughness;
+}
+float4 GetShadowMaskSelector(LightData value)
+{
+	return value.shadowMaskSelector;
 }
 
 //

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Deferred.compute

-#pragma kernel Deferred_Direct_Fptl                          SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl                              USE_FPTL_LIGHTLIST
-#pragma kernel Deferred_Direct_Fptl_DebugDisplay             SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl_DebugDisplay                 USE_FPTL_LIGHTLIST        DEBUG_DISPLAY
-#pragma kernel Deferred_Direct_Clustered                     SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered                         USE_CLUSTERED_LIGHTLIST
-#pragma kernel Deferred_Direct_Clustered_DebugDisplay        SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered_DebugDisplay            USE_CLUSTERED_LIGHTLIST   DEBUG_DISPLAY
+#pragma kernel Deferred_Direct_Fptl                                 SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl                                USE_FPTL_LIGHTLIST
+#pragma kernel Deferred_Direct_Fptl_DebugDisplay                    SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl_DebugDisplay                   USE_FPTL_LIGHTLIST          DEBUG_DISPLAY
+#pragma kernel Deferred_Direct_ShadowMask_Fptl                     SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl                    USE_FPTL_LIGHTLIST          SHADOWS_SHADOWMASK
+#pragma kernel Deferred_Direct_ShadowMask_Fptl_DebugDisplay        SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl_DebugDisplay       USE_FPTL_LIGHTLIST          SHADOWS_SHADOWMASK  DEBUG_DISPLAY
+#pragma kernel Deferred_Direct_Clustered                            SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered                           USE_CLUSTERED_LIGHTLIST
+#pragma kernel Deferred_Direct_Clustered_DebugDisplay               SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered_DebugDisplay              USE_CLUSTERED_LIGHTLIST     DEBUG_DISPLAY
+#pragma kernel Deferred_Direct_ShadowMask_Clustered                SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Clustered               USE_CLUSTERED_LIGHTLIST     SHADOWS_SHADOWMASK
+#pragma kernel Deferred_Direct_ShadowMask_Clustered_DebugDisplay   SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Clustered_DebugDisplay  USE_CLUSTERED_LIGHTLIST     SHADOWS_SHADOWMASK  DEBUG_DISPLAY
+
+// Variant with and without shadowmask
+#pragma kernel Deferred_Indirect_Fptl_Variant0      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant0      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=0
+#pragma kernel Deferred_Indirect_Fptl_Variant1      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant1      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=1
+#pragma kernel Deferred_Indirect_Fptl_Variant2      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant2      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=2
+#pragma kernel Deferred_Indirect_Fptl_Variant3      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant3      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=3
+#pragma kernel Deferred_Indirect_Fptl_Variant4      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant4      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=4
+#pragma kernel Deferred_Indirect_Fptl_Variant5      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant5      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=5
+#pragma kernel Deferred_Indirect_Fptl_Variant6      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant6      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=6
+#pragma kernel Deferred_Indirect_Fptl_Variant7      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant7      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=7
+#pragma kernel Deferred_Indirect_Fptl_Variant8      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant8      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=8
+#pragma kernel Deferred_Indirect_Fptl_Variant9      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant9      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=9
+#pragma kernel Deferred_Indirect_Fptl_Variant10     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant10     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=10
+#pragma kernel Deferred_Indirect_Fptl_Variant11     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant11     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=11
+#pragma kernel Deferred_Indirect_Fptl_Variant12     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant12     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=12
+#pragma kernel Deferred_Indirect_Fptl_Variant13     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant13     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=13
+#pragma kernel Deferred_Indirect_Fptl_Variant14     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant14     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=14
+#pragma kernel Deferred_Indirect_Fptl_Variant15     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant15     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=15
+#pragma kernel Deferred_Indirect_Fptl_Variant16     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant16     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=16
+#pragma kernel Deferred_Indirect_Fptl_Variant17     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant17     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=17
+#pragma kernel Deferred_Indirect_Fptl_Variant18     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant18     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=18
+#pragma kernel Deferred_Indirect_Fptl_Variant19     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant19     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=19
+#pragma kernel Deferred_Indirect_Fptl_Variant20     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant20     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=20
+#pragma kernel Deferred_Indirect_Fptl_Variant21     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant21     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=21
+#pragma kernel Deferred_Indirect_Fptl_Variant22     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant22     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=22
+#pragma kernel Deferred_Indirect_Fptl_Variant23     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant23     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=23
+#pragma kernel Deferred_Indirect_Fptl_Variant24     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant24     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=24
+#pragma kernel Deferred_Indirect_Fptl_Variant25     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant25     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=25
+#pragma kernel Deferred_Indirect_Fptl_Variant26     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant26     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=26
-#pragma kernel Deferred_Indirect_Fptl_Variant0               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant0                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=0
-#pragma kernel Deferred_Indirect_Fptl_Variant1               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant1                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=1
-#pragma kernel Deferred_Indirect_Fptl_Variant2               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant2                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=2
-#pragma kernel Deferred_Indirect_Fptl_Variant3               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant3                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=3
-#pragma kernel Deferred_Indirect_Fptl_Variant4               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant4                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=4
-#pragma kernel Deferred_Indirect_Fptl_Variant5               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant5                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=5
-#pragma kernel Deferred_Indirect_Fptl_Variant6               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant6                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=6
-#pragma kernel Deferred_Indirect_Fptl_Variant7               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant7                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=7
-#pragma kernel Deferred_Indirect_Fptl_Variant8               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant8                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=8
-#pragma kernel Deferred_Indirect_Fptl_Variant9               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant9                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=9
-#pragma kernel Deferred_Indirect_Fptl_Variant10              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant10                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=10
-#pragma kernel Deferred_Indirect_Fptl_Variant11              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant11                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=11
-#pragma kernel Deferred_Indirect_Fptl_Variant12              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant12                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=12
-#pragma kernel Deferred_Indirect_Fptl_Variant13              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant13                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=13
-#pragma kernel Deferred_Indirect_Fptl_Variant14              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant14                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=14
-#pragma kernel Deferred_Indirect_Fptl_Variant15              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant15                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=15
-#pragma kernel Deferred_Indirect_Fptl_Variant16              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant16                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=16
-#pragma kernel Deferred_Indirect_Fptl_Variant17              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant17                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=17
-#pragma kernel Deferred_Indirect_Fptl_Variant18              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant18                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=18
-#pragma kernel Deferred_Indirect_Fptl_Variant19              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant19                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=19
-#pragma kernel Deferred_Indirect_Fptl_Variant20              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant20                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=20
-#pragma kernel Deferred_Indirect_Fptl_Variant21              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant21                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=21
-#pragma kernel Deferred_Indirect_Fptl_Variant22              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant22                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=22
-#pragma kernel Deferred_Indirect_Fptl_Variant23              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant23                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=23
-#pragma kernel Deferred_Indirect_Fptl_Variant24              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant24                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=24
-#pragma kernel Deferred_Indirect_Fptl_Variant25              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant25                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=25
-#pragma kernel Deferred_Indirect_Fptl_Variant26              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant26                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=26
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant0       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant0       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=0
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant1       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant1       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=1
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant2       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant2       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=2
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant3       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant3       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=3
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant4       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant4       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=4
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant5       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant5       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=5
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant6       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant6       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=6
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant7       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant7       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=7
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant8       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant8       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=8
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant9       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant9       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=9
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant10      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant10      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=10
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant11      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant11      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=11
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant12      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant12      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=12
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant13      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant13      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=13
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant14      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant14      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=14
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant15      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant15      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=15
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant16      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant16      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=16
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant17      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant17      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=17
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant18      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant18      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=18
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant19      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant19      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=19
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant20      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant20      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=20
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant21      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant21      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=21
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant22      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant22      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=22
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant23      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant23      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=23
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant24      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant24      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=24
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant25      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant25      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=25
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant26      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant26      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=26
 
 /* Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
 #pragma kernel Deferred_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
 #ifdef VOLUMETRIC_LIGHTING_ENABLED
 TEXTURE3D(_VBufferLighting);
 #endif
+#ifdef SHADOWS_SHADOWMASK
+TEXTURE2D(_ShadowMaskTexture);
+#endif
 
 RWTexture2D<float3> diffuseLightingUAV;
 RWTexture2D<float4> specularLightingUAV;
 CBUFFER_END
 
-#if USE_INDIRECT
+#ifdef USE_INDIRECT
 
 StructuredBuffer<uint> g_TileList;
 // Indirect
 
     FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
     BSDFData bsdfData;
-    float3 bakeDiffuseLighting;
-    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeDiffuseLighting);
+    BakeLightingData bakeLightingData;
+    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeLightingData.bakeDiffuseLighting);
+    #ifdef SHADOWS_SHADOWMASK
+    DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
+    #endif
-    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, featureFlags, diffuseLighting, specularLighting);
+    LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, featureFlags, diffuseLighting, specularLighting);
 
 #ifdef VOLUMETRIC_LIGHTING_ENABLED
     float4 volumetricLighting = GetInScatteredRadianceAndTransmittance(posInput.positionSS,

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             int m_punctualLightCount = 0;
             int m_areaLightCount = 0;
             int m_lightCount = 0;
+            bool m_enableBakeShadowMask = false; // Track if any light require shadow mask. In this case we will need to enable the keyword shadow mask
+            float m_maxShadowDistance = 0.0f; // Save value from shadow settings
 
             private ComputeShader buildScreenAABBShader { get { return m_Resources.buildScreenAABBShader; } }
             private ComputeShader buildPerTileLightListShader { get { return m_Resources.buildPerTileLightListShader; } }
             static int s_BuildDispatchIndirectKernel;
             static int s_BuildMaterialFlagsWriteKernel;
             static int s_BuildMaterialFlagsOrKernel;
+
+
+            static int s_shadeOpaqueDirectShadowMaskClusteredKernel;
+            static int s_shadeOpaqueDirectShadowMaskFptlKernel;
+            static int s_shadeOpaqueDirectShadowMaskClusteredDebugDisplayKernel;
+            static int s_shadeOpaqueDirectShadowMaskFptlDebugDisplayKernel;
+
+            static int[] s_shadeOpaqueIndirectShadowMaskFptlKernels = new int[LightDefinitions.s_NumFeatureVariants];
 
             static int s_deferredDirectionalShadowKernel;
 
                 }
             }
 
-            Material m_DeferredAllMaterialSRT      = null;
-            Material m_DeferredAllMaterialMRT      = null;
+            // Following is an array of material of size eight for all combination of keyword: OUTPUT_SPLIT_LIGHTING - LIGHTLOOP_TILE_PASS - SHADOWS_SHADOWMASK - USE_FPTL_LIGHTLIST/USE_CLUSTERED_LIGHTLIST - DEBUG_DISPLAY
+            Material[, , , ,] m_lightingMaterial;
+            Material m_DebugViewTilesMaterial;
-            Material m_DebugViewTilesMaterial      = null;
-
-            Material m_SingleDeferredMaterialSRT   = null;
-            Material m_SingleDeferredMaterialMRT   = null;
-
-            Light m_CurrentSunLight = null;
+            Light m_CurrentSunLight;
             int m_CurrentSunLightShadowIndex = -1;
 
             public Light GetCurrentSunLight() { return m_CurrentSunLight; }
                 s_shadeOpaqueDirectClusteredDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_Clustered_DebugDisplay");
                 s_shadeOpaqueDirectFptlDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_Fptl_DebugDisplay");
 
+                s_shadeOpaqueDirectShadowMaskClusteredKernel = deferredComputeShader.FindKernel("Deferred_Direct_ShadowMask_Clustered");
+                s_shadeOpaqueDirectShadowMaskFptlKernel = deferredComputeShader.FindKernel("Deferred_Direct_ShadowMask_Fptl");
+                s_shadeOpaqueDirectShadowMaskClusteredDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_ShadowMask_Clustered_DebugDisplay");
+                s_shadeOpaqueDirectShadowMaskFptlDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_ShadowMask_Fptl_DebugDisplay");
+
                 s_deferredDirectionalShadowKernel = deferredDirectionalShadowComputeShader.FindKernel("DeferredDirectionalShadow");
 
                 for (int variant = 0; variant < LightDefinitions.s_NumFeatureVariants; variant++)
                     s_shadeOpaqueIndirectFptlKernels[variant] = deferredComputeShader.FindKernel("Deferred_Indirect_Fptl_Variant" + variant);
+                    s_shadeOpaqueIndirectShadowMaskFptlKernels[variant] = deferredComputeShader.FindKernel("Deferred_Indirect_ShadowMask_Fptl_Variant" + variant);
                 }
 
                 s_LightList = null;
-                m_DeferredAllMaterialSRT = CoreUtils.CreateEngineMaterial(m_Resources.deferredShader);
-                m_DeferredAllMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredAllMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
-                m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
-                m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
-                m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
+                // OUTPUT_SPLIT_LIGHTING - LIGHTLOOP_TILE_PASS - SHADOWS_SHADOWMASK - USE_FPTL_LIGHTLIST/USE_CLUSTERED_LIGHTLIST - DEBUG_DISPLAY
+                m_lightingMaterial = new Material[2, 2, 2, 2, 2];
-                m_DeferredAllMaterialMRT = CoreUtils.CreateEngineMaterial(m_Resources.deferredShader);
-                m_DeferredAllMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredAllMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredAllMaterialMRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.SplitLighting);
-                m_DeferredAllMaterialMRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
-                m_DeferredAllMaterialMRT.SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
-                m_DeferredAllMaterialMRT.SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
-
-                m_SingleDeferredMaterialSRT = CoreUtils.CreateEngineMaterial(m_Resources.deferredShader);
-                m_SingleDeferredMaterialSRT.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
-                m_SingleDeferredMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
-                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
-                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
-                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
+                for (int outputSplitLighting = 0; outputSplitLighting < 2; ++outputSplitLighting)
+                {
+                    for (int lightLoopTilePass = 0; lightLoopTilePass < 2; ++lightLoopTilePass)
+                    {
+                        for (int ShadowMask = 0; ShadowMask < 2; ++ShadowMask)
+                        {
+                            for (int clustered = 0; clustered < 2; ++clustered)
+                            {
+                                for (int debugDisplay = 0; debugDisplay < 2; ++debugDisplay)
+                                {
+                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay] = CoreUtils.CreateEngineMaterial(m_Resources.deferredShader);
+                                    CoreUtils.SetKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "OUTPUT_SPLIT_LIGHTING", outputSplitLighting == 1);
+                                    CoreUtils.SelectKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "LIGHTLOOP_TILE_PASS", "LIGHTLOOP_SINGLE_PASS", lightLoopTilePass == 1);
+                                    CoreUtils.SetKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "SHADOWS_SHADOWMASK", ShadowMask == 1);
+                                    CoreUtils.SelectKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", clustered == 1);
+                                    CoreUtils.SetKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "DEBUG_DISPLAY", debugDisplay == 1);
-                m_SingleDeferredMaterialMRT = CoreUtils.CreateEngineMaterial(m_Resources.deferredShader);
-                m_SingleDeferredMaterialMRT.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
-                m_SingleDeferredMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_SingleDeferredMaterialMRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.SplitLighting);
-                m_SingleDeferredMaterialMRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
-                m_SingleDeferredMaterialMRT.SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
-                m_SingleDeferredMaterialMRT.SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
+                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay].SetInt(HDShaderIDs._StencilRef, outputSplitLighting == 1 ? (int)StencilLightingUsage.SplitLighting : (int)StencilLightingUsage.RegularLighting);
+                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay].SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
+                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay].SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
+                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay].SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
+                                }
+                            }
+                        }
+                    }
+                }
 
                 m_DebugViewTilesMaterial = CoreUtils.CreateEngineMaterial(m_Resources.debugViewTilesShader);
 
                 // enableClustered
                 CoreUtils.SafeRelease(s_GlobalLightListAtomic);
 
-                CoreUtils.Destroy(m_DeferredAllMaterialSRT);
-                CoreUtils.Destroy(m_DeferredAllMaterialMRT);
+                for (int outputSplitLighting = 0; outputSplitLighting < 2; ++outputSplitLighting)
+                {
+                    for (int lightLoopTilePass = 0; lightLoopTilePass < 2; ++lightLoopTilePass)
+                    {
+                        for (int ShadowMask = 0; ShadowMask < 2; ++ShadowMask)
+                        {
+                            for (int clustered = 0; clustered < 2; ++clustered)
+                            {
+                                for (int debugDisplay = 0; debugDisplay < 2; ++debugDisplay)
+                                {
+                                    CoreUtils.Destroy(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay]);
+                                }
+                            }
+                        }
+                    }
+                }
-
-                CoreUtils.Destroy(m_SingleDeferredMaterialSRT);
-                CoreUtils.Destroy(m_SingleDeferredMaterialMRT);
             }
 
             public void NewFrame()
                     m_CurrentSunLight = light.light;
                     m_CurrentSunLightShadowIndex = shadowIdx;
                 }
+
+                // TODO: Currently m_maxShadowDistance is based on shadow settings, but this value is define for a whole level. We should be able to change this value during gameplay
+                float scale;
+                float bias;
+                GetSCaleAndBiasForLinearDistanceFade(m_maxShadowDistance, out scale, out bias);
+                directionalLightData.fadeDistanceScaleAndBias = new Vector2(scale, bias);
+                directionalLightData.shadowMaskSelector = Vector4.zero;
+
+                if (IsBakedShadowMaskLight(light.light))
+                {
+                    directionalLightData.shadowMaskSelector[light.light.bakingOutput.occlusionMaskChannel] = 1.0f;
+                    // TODO: make this option per light, not global
+                    directionalLightData.dynamicShadowCasterOnly = QualitySettings.shadowmaskMode == ShadowmaskMode.Shadowmask;
+                }
+                else
+                {
+                    // use -1 to say that we don't use shadow mask
+                    directionalLightData.shadowMaskSelector.x = -1.0f;
+                    directionalLightData.dynamicShadowCasterOnly = false;
+                }
+
                 m_CurrentSunLight = m_CurrentSunLight == null ? light.light : m_CurrentSunLight;
 
                 m_lightList.directionalLights.Add(directionalLightData);
 
-            float ComputeLinearDistanceFade(float distanceToCamera, float fadeDistance)
+            void GetSCaleAndBiasForLinearDistanceFade(float fadeDistance, out float scale, out float bias)
-                return 1.0f - Mathf.Clamp01((distanceToCamera - distanceFadeNear) / (fadeDistance - distanceFadeNear));
+                scale = 1.0f / (fadeDistance - distanceFadeNear);
+                bias = - distanceFadeNear / (fadeDistance - distanceFadeNear);
+            }
+
+            float ComputeLinearDistanceFade(float distanceToCamera, float fadeDistance)
+            {
+                float scale;
+                float bias;
+                GetSCaleAndBiasForLinearDistanceFade(fadeDistance, out scale, out bias);
+
+                return 1.0f - Mathf.Clamp01(distanceToCamera * scale + bias);
             }
 
             public bool GetLightData(ShadowSettings shadowSettings, Camera camera, GPULightType gpuLightType, VisibleLight light, HDAdditionalLightData additionalLightData, AdditionalShadowData additionalshadowData, int lightIndex)
 
                 // Value of max smoothness is from artists point of view, need to convert from perceptual smoothness to roughness
                 lightData.minRoughness = (1.0f - additionalLightData.maxSmoothness) * (1.0f - additionalLightData.maxSmoothness);
+
+                lightData.shadowMaskSelector = Vector4.zero;
+
+                if (IsBakedShadowMaskLight(light.light))
+                {
+                    lightData.shadowMaskSelector[light.light.bakingOutput.occlusionMaskChannel] = 1.0f;
+                    // TODO: make this option per light, not global
+                    lightData.dynamicShadowCasterOnly = QualitySettings.shadowmaskMode == ShadowmaskMode.Shadowmask;
+                }
+                else
+                {
+                    // use -1 to say that we don't use shadow mask
+                    lightData.shadowMaskSelector.x = -1.0f;
+                    lightData.dynamicShadowCasterOnly = false;
+                }
 
                 m_lightList.lights.Add(lightData);
 
                 m_ShadowMgr.UpdateCullingParameters( ref cullingParams );
             }
 
-            public void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera)
+            public bool IsBakedShadowMaskLight(Light light)
+            {
+                return light.bakingOutput.lightmapBakeType == LightmapBakeType.Mixed &&
+                        light.bakingOutput.mixedLightingMode == MixedLightingMode.Shadowmask &&
+                        light.bakingOutput.occlusionMaskChannel != -1; // We need to have an occlusion mask channel assign, else we have no shadow mask
+            }
+
+            // Return true if BakedShadowMask are enabled
+            public bool PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera)
+                // If any light require it, we need to enabled bake shadow mask feature
+                m_enableBakeShadowMask = false;
+
                 m_lightList.Clear();
 
                 Vector3 camPosWS = camera.transform.position;
                         // Debug.Assert(additionalData == null, "Missing HDAdditionalData on a light - Should have been create by HDLightEditor");
 
                         if (additionalData == null)
-                            return;
+                            return false;
 
                         LightCategory lightCategory = LightCategory.Count;
                         GPULightType gpuLightType = GPULightType.Point;
                         int lightIndex = (int)(sortKey & 0xFFFF);
 
                         var light = cullResults.visibleLights[lightIndex];
+
+                        m_enableBakeShadowMask = m_enableBakeShadowMask || IsBakedShadowMaskLight(light.light);
+
                         var additionalLightData = light.light.GetComponent<HDAdditionalLightData>();
                         var additionalShadowData = light.light.GetComponent<AdditionalShadowData>(); // Can be null
 
                 Debug.Assert(m_lightList.lightVolumes.Count == m_lightCount);
 
                 UpdateDataBuffers();
+
+                m_maxShadowDistance = shadowSettings.maxShadowDistance;
+
+                return m_enableBakeShadowMask;
             }
 
             void VoxelLightListGeneration(CommandBuffer cmd, Camera camera, Matrix4x4 projscr, Matrix4x4 invProjscr, RenderTargetIdentifier cameraDepthBufferRT)
                         cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._GBufferTexture1, HDShaderIDs._GBufferTexture1);
                         cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._GBufferTexture2, HDShaderIDs._GBufferTexture2);
                         cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._GBufferTexture3, HDShaderIDs._GBufferTexture3);
+                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._ShadowMaskTexture, HDShaderIDs._ShadowMaskTexture);
+                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._VelocityTexture, HDShaderIDs._VelocityTexture);
 
                         cmd.DispatchCompute(buildMaterialFlagsShader, buildMaterialFlagsKernel, numTilesX, numTilesY, 1);
                     }
                 m_ShadowMgr.RenderShadows(m_FrameId, renderContext, cmd, cullResults, cullResults.visibleLights);
             }
 
-            private void SetupDebugDisplayMode(bool debugDisplayEnable)
-            {
-                CoreUtils.SetKeyword(m_DeferredAllMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
-                CoreUtils.SetKeyword(m_DeferredAllMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
-                CoreUtils.SetKeyword(m_SingleDeferredMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
-                CoreUtils.SetKeyword(m_SingleDeferredMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
-            }
-
             public void RenderLightingDebug(HDCamera hdCamera, CommandBuffer cmd, RenderTargetIdentifier colorBuffer, DebugDisplaySettings debugDisplaySettings)
             {
                 LightingDebugSettings lightingDebug = debugDisplaySettings.lightingDebugSettings;
                 {
                     var camera = hdCamera.camera;
 
-                    SetupDebugDisplayMode(debugDisplaySettings.IsDebugDisplayEnabled());
-
-                    if (!m_TileSettings.enableTileAndCluster)
-                    {
-                        PushGlobalParams(camera, cmd, null, 0);
-
-                        // This is a debug brute force renderer to debug tile/cluster which render all the lights
-                        if (options.outputSplitLighting)
-                        {
-                            CoreUtils.DrawFullScreen(cmd, m_SingleDeferredMaterialMRT, colorBuffers, depthStencilBuffer);
-                        }
-                        else
-                        {
-                            // If SSS is disable, do lighting for both split lighting and no split lighting
-                            if (!debugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
-                            {
-                                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.NoLighting);
-                                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.NotEqual);
-                            }
-                            else
-                            {
-                                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
-                                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
-                            }
-
-                            CoreUtils.DrawFullScreen(cmd, m_SingleDeferredMaterialSRT, colorBuffers[0], depthStencilBuffer);
-                        }
-                    }
-                    else
+                    // Compute path
+                    if (m_TileSettings.enableTileAndCluster && m_TileSettings.enableComputeLightEvaluation)
                     {
                         int w = camera.pixelWidth;
                         int h = camera.pixelHeight;
 
-                        if (m_TileSettings.enableComputeLightEvaluation)
-                        {
-                            bool enableFeatureVariants = GetFeatureVariantsEnabled(m_TileSettings) && !debugDisplaySettings.IsDebugDisplayEnabled();
+                        bool enableFeatureVariants = GetFeatureVariantsEnabled(m_TileSettings) && !debugDisplaySettings.IsDebugDisplayEnabled();
-                            int numVariants = 1;
-                            if (enableFeatureVariants)
-                                numVariants = LightDefinitions.s_NumFeatureVariants;
+                        int numVariants = 1;
+                        if (enableFeatureVariants)
+                            numVariants = LightDefinitions.s_NumFeatureVariants;
-                            int debugViewMaterial = Shader.GetGlobalInt(HDShaderIDs._DebugViewMaterial);
-                            int debugLightingMode = Shader.GetGlobalInt(HDShaderIDs._DebugLightingMode);
-                            Vector4 debugLightingAlbedo = Shader.GetGlobalVector(HDShaderIDs._DebugLightingAlbedo);
-                            Vector4 debugLightingSmoothness = Shader.GetGlobalVector(HDShaderIDs._DebugLightingSmoothness);
+                        int debugViewMaterial = Shader.GetGlobalInt(HDShaderIDs._DebugViewMaterial);
+                        int debugLightingMode = Shader.GetGlobalInt(HDShaderIDs._DebugLightingMode);
+                        Vector4 debugLightingAlbedo = Shader.GetGlobalVector(HDShaderIDs._DebugLightingAlbedo);
+                        Vector4 debugLightingSmoothness = Shader.GetGlobalVector(HDShaderIDs._DebugLightingSmoothness);
+
+                        Texture ltcData = Shader.GetGlobalTexture(HDShaderIDs._LtcData);
+                        Texture preIntegratedFGD = Shader.GetGlobalTexture(HDShaderIDs._PreIntegratedFGD);
+                        Texture ltcGGXMatrix = Shader.GetGlobalTexture(HDShaderIDs._LtcGGXMatrix);
+                        Texture ltcDisneyDiffuseMatrix = Shader.GetGlobalTexture(HDShaderIDs._LtcDisneyDiffuseMatrix);
+                        Texture ltcMultiGGXFresnelDisneyDiffuse = Shader.GetGlobalTexture(HDShaderIDs._LtcMultiGGXFresnelDisneyDiffuse);
-                            Texture ltcData = Shader.GetGlobalTexture(HDShaderIDs._LtcData);
-                            Texture preIntegratedFGD = Shader.GetGlobalTexture(HDShaderIDs._PreIntegratedFGD);
-                            Texture ltcGGXMatrix = Shader.GetGlobalTexture(HDShaderIDs._LtcGGXMatrix);
-                            Texture ltcDisneyDiffuseMatrix = Shader.GetGlobalTexture(HDShaderIDs._LtcDisneyDiffuseMatrix);
-                            Texture ltcMultiGGXFresnelDisneyDiffuse = Shader.GetGlobalTexture(HDShaderIDs._LtcMultiGGXFresnelDisneyDiffuse);
+                        Matrix4x4 invScrProjection = Shader.GetGlobalMatrix(HDShaderIDs.g_mInvScrProjection);
+                        int useTileLightList = Shader.GetGlobalInt(HDShaderIDs._UseTileLightList);
-                            Matrix4x4 invScrProjection = Shader.GetGlobalMatrix(HDShaderIDs.g_mInvScrProjection);
-                            int useTileLightList = Shader.GetGlobalInt(HDShaderIDs._UseTileLightList);
+                        Vector4 time = Shader.GetGlobalVector(HDShaderIDs._Time);
+                        Vector4 sinTime = Shader.GetGlobalVector(HDShaderIDs._SinTime);
+                        Vector4 cosTime = Shader.GetGlobalVector(HDShaderIDs._CosTime);
+                        Vector4 unity_DeltaTime = Shader.GetGlobalVector(HDShaderIDs.unity_DeltaTime);
+                        int envLightSkyEnabled = Shader.GetGlobalInt(HDShaderIDs._EnvLightSkyEnabled);
+                        Vector4 ambientOcclusionParam = Shader.GetGlobalVector(HDShaderIDs._AmbientOcclusionParam);
-                            Vector4 time = Shader.GetGlobalVector(HDShaderIDs._Time);
-                            Vector4 sinTime = Shader.GetGlobalVector(HDShaderIDs._SinTime);
-                            Vector4 cosTime = Shader.GetGlobalVector(HDShaderIDs._CosTime);
-                            Vector4 unity_DeltaTime = Shader.GetGlobalVector(HDShaderIDs.unity_DeltaTime);
-                            int envLightSkyEnabled = Shader.GetGlobalInt(HDShaderIDs._EnvLightSkyEnabled);
-                            Vector4 ambientOcclusionParam = Shader.GetGlobalVector(HDShaderIDs._AmbientOcclusionParam);
+                        int enableSSSAndTransmission = Shader.GetGlobalInt(HDShaderIDs._EnableSSSAndTransmission);
+                        int texturingModeFlags = Shader.GetGlobalInt(HDShaderIDs._TexturingModeFlags);
+                        int transmissionFlags = Shader.GetGlobalInt(HDShaderIDs._TransmissionFlags);
+                        int useDisneySSS = Shader.GetGlobalInt(HDShaderIDs._UseDisneySSS);
+                        Vector4[] thicknessRemaps = Shader.GetGlobalVectorArray(HDShaderIDs._ThicknessRemaps);
+                        Vector4[] shapeParams = Shader.GetGlobalVectorArray(HDShaderIDs._ShapeParams);
+                        Vector4[] transmissionTints = Shader.GetGlobalVectorArray(HDShaderIDs._TransmissionTints);
+                        Vector4[] halfRcpVariancesAndWeights = Shader.GetGlobalVectorArray(HDShaderIDs._HalfRcpVariancesAndWeights);
-                            int enableSSSAndTransmission = Shader.GetGlobalInt(HDShaderIDs._EnableSSSAndTransmission);
-                            int texturingModeFlags = Shader.GetGlobalInt(HDShaderIDs._TexturingModeFlags);
-                            int transmissionFlags = Shader.GetGlobalInt(HDShaderIDs._TransmissionFlags);
-                            int useDisneySSS = Shader.GetGlobalInt(HDShaderIDs._UseDisneySSS);
-                            Vector4[] thicknessRemaps = Shader.GetGlobalVectorArray(HDShaderIDs._ThicknessRemaps);
-                            Vector4[] shapeParams = Shader.GetGlobalVectorArray(HDShaderIDs._ShapeParams);
-                            Vector4[] transmissionTints = Shader.GetGlobalVectorArray(HDShaderIDs._TransmissionTints);
-                            Vector4[] halfRcpVariancesAndWeights = Shader.GetGlobalVectorArray(HDShaderIDs._HalfRcpVariancesAndWeights);
+                        Texture skyTexture = Shader.GetGlobalTexture(HDShaderIDs._SkyTexture);
+                        float skyTextureMipCount = Shader.GetGlobalFloat(HDShaderIDs._SkyTextureMipCount);
-                            Texture skyTexture = Shader.GetGlobalTexture(HDShaderIDs._SkyTexture);
-                            float skyTextureMipCount = Shader.GetGlobalFloat(HDShaderIDs._SkyTextureMipCount);
+                        for (int variant = 0; variant < numVariants; variant++)
+                        {
+                            int kernel;
-                            for (int variant = 0; variant < numVariants; variant++)
+                            if (enableFeatureVariants)
-                                int kernel;
-
-                                if (enableFeatureVariants)
+                                // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Update the code with following comment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
+                                // kernel = usingFptl ? s_shadeOpaqueIndirectFptlKernels[variant] : s_shadeOpaqueIndirectClusteredKernels[variant];
+                                if (m_enableBakeShadowMask)
+                                    kernel = s_shadeOpaqueIndirectShadowMaskFptlKernels[variant];
+                                else
+                                    kernel = s_shadeOpaqueIndirectFptlKernels[variant];
+                            }
+                            else
+                            {
+                                if (m_enableBakeShadowMask)
-                                    // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
-                                    // kernel = usingFptl ? s_shadeOpaqueIndirectFptlKernels[variant] : s_shadeOpaqueIndirectClusteredKernels[variant];
-                                    kernel = s_shadeOpaqueIndirectFptlKernels[variant];
+                                    if (debugDisplaySettings.IsDebugDisplayEnabled())
+                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlDebugDisplayKernel : s_shadeOpaqueDirectClusteredDebugDisplayKernel;
+                                    else
+                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlKernel : s_shadeOpaqueDirectClusteredKernel;
-                                    {
-                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlDebugDisplayKernel : s_shadeOpaqueDirectClusteredDebugDisplayKernel;
-                                    }
+                                        kernel = usingFptl ? s_shadeOpaqueDirectShadowMaskFptlDebugDisplayKernel : s_shadeOpaqueDirectShadowMaskClusteredDebugDisplayKernel;
-                                    {
-                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlKernel : s_shadeOpaqueDirectClusteredKernel;
-                                    }
+                                        kernel = usingFptl ? s_shadeOpaqueDirectShadowMaskFptlKernel : s_shadeOpaqueDirectShadowMaskClusteredKernel;
+                            }
-                                // Pass global parameters to compute shader
-                                // TODO: get rid of this by making global parameters visible to compute shaders
-                                PushGlobalParams(camera, cmd, deferredComputeShader, kernel);
-                                hdCamera.SetupComputeShader(deferredComputeShader, cmd);
+                            // Pass global parameters to compute shader
+                            // TODO: get rid of this by making global parameters visible to compute shaders
+                            PushGlobalParams(camera, cmd, deferredComputeShader, kernel);
+                            hdCamera.SetupComputeShader(deferredComputeShader, cmd);
-                                // TODO: Update value like in ApplyDebugDisplaySettings() call. Sadly it is high likely that this will not be keep in sync. we really need to get rid of this by making global parameters visible to compute shaders
-                                cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._DebugViewMaterial, debugViewMaterial);
-                                cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._DebugLightingMode, debugLightingMode);
-                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._DebugLightingAlbedo, debugLightingAlbedo);
-                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._DebugLightingSmoothness, debugLightingSmoothness);
+                            // TODO: Update value like in ApplyDebugDisplaySettings() call. Sadly it is high likely that this will not be keep in sync. we really need to get rid of this by making global parameters visible to compute shaders
+                            cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._DebugViewMaterial, debugViewMaterial);
+                            cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._DebugLightingMode, debugLightingMode);
+                            cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._DebugLightingAlbedo, debugLightingAlbedo);
+                            cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._DebugLightingSmoothness, debugLightingSmoothness);
-                                cmd.SetComputeBufferParam(deferredComputeShader, kernel, HDShaderIDs.g_vLightListGlobal, bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
+                            cmd.SetComputeBufferParam(deferredComputeShader, kernel, HDShaderIDs.g_vLightListGlobal, bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._DeferredShadowTexture, deferredShadowTexture);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._DeferredShadowTexture, deferredShadowTexture);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._MainDepthTexture, depthTexture);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._MainDepthTexture, depthTexture);
-                                // TODO: Don't know why but If we use Shader.GetGlobalTexture(HDShaderIDs._GBufferTexture0) instead of HDShaderIDs._GBufferTexture0 the screen start to flicker in SceneView...
-                                // Need to investigate what is happening. But this may be unnecessary as development of SetGlobalTexture for compute shader have begin
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture0, HDShaderIDs._GBufferTexture0);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture1, HDShaderIDs._GBufferTexture1);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture2, HDShaderIDs._GBufferTexture2);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture3, HDShaderIDs._GBufferTexture3);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._AmbientOcclusionTexture, HDShaderIDs._AmbientOcclusionTexture);
+                            // TODO: Don't know why but If we use Shader.GetGlobalTexture(HDShaderIDs._GBufferTexture0) instead of HDShaderIDs._GBufferTexture0 the screen start to flicker in SceneView...
+                            // Need to investigate what is happening. But this may be unnecessary as development of SetGlobalTexture for compute shader have begin
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture0, HDShaderIDs._GBufferTexture0);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture1, HDShaderIDs._GBufferTexture1);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture2, HDShaderIDs._GBufferTexture2);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture3, HDShaderIDs._GBufferTexture3);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._ShadowMaskTexture, HDShaderIDs._ShadowMaskTexture);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._VelocityTexture, HDShaderIDs._VelocityTexture);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._AmbientOcclusionTexture, HDShaderIDs._AmbientOcclusionTexture);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcData, ltcData);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._PreIntegratedFGD, preIntegratedFGD);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcGGXMatrix, ltcGGXMatrix);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcDisneyDiffuseMatrix, ltcDisneyDiffuseMatrix);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcMultiGGXFresnelDisneyDiffuse, ltcMultiGGXFresnelDisneyDiffuse);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcData, ltcData);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._PreIntegratedFGD, preIntegratedFGD);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcGGXMatrix, ltcGGXMatrix);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcDisneyDiffuseMatrix, ltcDisneyDiffuseMatrix);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcMultiGGXFresnelDisneyDiffuse, ltcMultiGGXFresnelDisneyDiffuse);
-                                cmd.SetComputeMatrixParam(deferredComputeShader, HDShaderIDs.g_mInvScrProjection, invScrProjection);
-                                cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._UseTileLightList, useTileLightList);
+                            cmd.SetComputeMatrixParam(deferredComputeShader, HDShaderIDs.g_mInvScrProjection, invScrProjection);
+                            cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._UseTileLightList, useTileLightList);
-                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._Time, time);
-                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._SinTime, sinTime);
-                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._CosTime, cosTime);
-                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs.unity_DeltaTime, unity_DeltaTime);
-                                cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._EnvLightSkyEnabled, envLightSkyEnabled);
-                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._AmbientOcclusionParam, ambientOcclusionParam);
+                            cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._Time, time);
+                            cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._SinTime, sinTime);
+                            cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._CosTime, cosTime);
+                            cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs.unity_DeltaTime, unity_DeltaTime);
+                            cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._EnvLightSkyEnabled, envLightSkyEnabled);
+                            cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._AmbientOcclusionParam, ambientOcclusionParam);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._SkyTexture, skyTexture ? skyTexture : m_DefaultTexture2DArray);
-                                cmd.SetComputeFloatParam(deferredComputeShader, HDShaderIDs._SkyTextureMipCount, skyTextureMipCount);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._SkyTexture, skyTexture ? skyTexture : m_DefaultTexture2DArray);
+                            cmd.SetComputeFloatParam(deferredComputeShader, HDShaderIDs._SkyTextureMipCount, skyTextureMipCount);
-                                // Set SSS parameters.
-                                cmd.SetComputeIntParam(        deferredComputeShader, HDShaderIDs._EnableSSSAndTransmission,   enableSSSAndTransmission);
-                                cmd.SetComputeIntParam(        deferredComputeShader, HDShaderIDs._TexturingModeFlags,         texturingModeFlags);
-                                cmd.SetComputeIntParam(        deferredComputeShader, HDShaderIDs._TransmissionFlags,          transmissionFlags);
-                                cmd.SetComputeIntParam(        deferredComputeShader, HDShaderIDs._UseDisneySSS,               useDisneySSS);
-                                cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._ThicknessRemaps,            thicknessRemaps);
-                                cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._ShapeParams,                shapeParams);
-                                cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._TransmissionTints,          transmissionTints);
-                                cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._HalfRcpVariancesAndWeights, halfRcpVariancesAndWeights);
+                            // Set SSS parameters.
+                            cmd.SetComputeIntParam(        deferredComputeShader, HDShaderIDs._EnableSSSAndTransmission,   enableSSSAndTransmission);
+                            cmd.SetComputeIntParam(        deferredComputeShader, HDShaderIDs._TexturingModeFlags,         texturingModeFlags);
+                            cmd.SetComputeIntParam(        deferredComputeShader, HDShaderIDs._TransmissionFlags,          transmissionFlags);
+                            cmd.SetComputeIntParam(        deferredComputeShader, HDShaderIDs._UseDisneySSS,               useDisneySSS);
+                            cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._ThicknessRemaps,            thicknessRemaps);
+                            cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._ShapeParams,                shapeParams);
+                            cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._TransmissionTints,          transmissionTints);
+                            cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._HalfRcpVariancesAndWeights, halfRcpVariancesAndWeights);
+
+                            if (options.volumetricLightingEnabled)
+                            {
+                                // TODO: enable keyword VOLUMETRIC_LIGHTING_ENABLED.
+                                // TODO: do not use globals, call HDRenderPipeline.SetVolumetricLightingData() instead.
+                                HDRenderPipeline.SetVolumetricLightingDataFromGlobals(cmd, deferredComputeShader, kernel);
+                            }
+                            else
+                            {
+                                // TODO: disable keyword VOLUMETRIC_LIGHTING_ENABLED.
+                                // We should not access any volumetric lighting data in our shaders.
+                            }
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs.specularLightingUAV, colorBuffers[0]);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs.diffuseLightingUAV,  colorBuffers[1]);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs.specularLightingUAV, colorBuffers[0]);
+                            cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs.diffuseLightingUAV,  colorBuffers[1]);
-                                if (options.volumetricLightingEnabled)
-                                {
-                                    // TODO: enable keyword VOLUMETRIC_LIGHTING_ENABLED.
-                                    // TODO: do not use globals, call HDRenderPipeline.SetVolumetricLightingData() instead.
-                                    HDRenderPipeline.SetVolumetricLightingDataFromGlobals(cmd, deferredComputeShader, kernel);
-                                }
-                                else
-                                {
-                                    // TODO: disable keyword VOLUMETRIC_LIGHTING_ENABLED.
-                                    // We should not access any volumetric lighting data in our shaders.
-                                }
+                            // always do deferred lighting in blocks of 16x16 (not same as tiled light size)
-                                if (enableFeatureVariants)
-                                {
-                                    cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs.g_TileListOffset, variant * numTiles);
-                                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, HDShaderIDs.g_TileList, s_TileList);
-                                    cmd.DispatchCompute(deferredComputeShader, kernel, s_DispatchIndirectBuffer, (uint)variant * 3 * sizeof(uint));
-                                }
-                                else
-                                {
-                                    cmd.DispatchCompute(deferredComputeShader, kernel, numTilesX, numTilesY, 1);
-                                }
+                            if (enableFeatureVariants)
+                            {
+                                cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs.g_TileListOffset, variant * numTiles);
+                                cmd.SetComputeBufferParam(deferredComputeShader, kernel, HDShaderIDs.g_TileList, s_TileList);
+                                cmd.DispatchCompute(deferredComputeShader, kernel, s_DispatchIndirectBuffer, (uint)variant * 3 * sizeof(uint));
+                            }
+                            else
+                            {
+                                cmd.DispatchCompute(deferredComputeShader, kernel, numTilesX, numTilesY, 1);
+                    }
+                    else // Pixel shader evaluation
+                    {
+                        // OUTPUT_SPLIT_LIGHTING - LIGHTLOOP_TILE_PASS - SHADOWS_SHADOWMASK - USE_FPTL_LIGHTLIST/USE_CLUSTERED_LIGHTLIST - DEBUG_DISPLAY
+                        Material currentLightingMaterial = m_lightingMaterial[options.outputSplitLighting ? 1 : 0,
+                                                                                m_TileSettings.enableTileAndCluster ? 1 : 0,
+                                                                                m_enableBakeShadowMask ? 1 : 0,
+                                                                                bUseClusteredForDeferred ? 1 : 0,
+                                                                                debugDisplaySettings.IsDebugDisplayEnabled() ? 1 : 0];
+
+                        PushGlobalParams(camera, cmd, null, 0);
+
+                        if (options.outputSplitLighting)
+                        {
+                            CoreUtils.DrawFullScreen(cmd, currentLightingMaterial, colorBuffers, depthStencilBuffer);
+                        }
-                            // Pixel shader evaluation
-                            PushGlobalParams(camera, cmd, null, 0);
-
-                            if (options.outputSplitLighting)
+                            // If SSS is disable, do lighting for both split lighting and no split lighting
+                            // This is for debug purpose, so fine to use immediate material mode here to modify render state
+                            if (!debugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
-                                CoreUtils.SelectKeyword(m_DeferredAllMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                CoreUtils.DrawFullScreen(cmd, m_DeferredAllMaterialMRT, colorBuffers, depthStencilBuffer);
+                                currentLightingMaterial.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.NoLighting);
+                                currentLightingMaterial.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.NotEqual);
-                                // If SSS is disable, do lighting for both split lighting and no split lighting
-                                if (!debugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
-                                {
-                                    m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.NoLighting);
-                                    m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.NotEqual);
-                                }
-                                else
-                                {
-                                    m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
-                                    m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
-                                }
+                                currentLightingMaterial.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
+                                currentLightingMaterial.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
+                            }
-                                CoreUtils.SelectKeyword(m_DeferredAllMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                CoreUtils.DrawFullScreen(cmd, m_DeferredAllMaterialSRT, colorBuffers[0], depthStencilBuffer);
-                            }
+                            CoreUtils.DrawFullScreen(cmd, currentLightingMaterial, colorBuffers[0], depthStencilBuffer);
-                } // TilePass - Deferred Lighting Pass
+                } // End profiling
+
+                // Note: SHADOWS_SHADOWMASK keyword is enabled in HDRenderPipeline.cs ConfigureForShadowMask
 
                 // Note: if we use render opaque with deferred tiling we need to render a opaque depth pass for these opaque objects
                 if (!m_TileSettings.enableTileAndCluster)

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

 #endif // LIGHTLOOP_TILE_PASS
 
 // bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)
-void LightLoop( float3 V, PositionInputs posInput, PreLightData preLightData, BSDFData bsdfData, float3 bakeDiffuseLighting, uint featureFlags,
+void LightLoop( float3 V, PositionInputs posInput, PreLightData preLightData, BSDFData bsdfData, BakeLightingData bakeLightingData, uint featureFlags,
                 out float3 diffuseLighting,
                 out float3 specularLighting)
 {
     {
         for (i = 0; i < _DirectionalLightCount; ++i)
         {
-            DirectLighting lighting = EvaluateBSDF_Directional(context, V, posInput, preLightData, _DirectionalLightDatas[i], bsdfData);
+            DirectLighting lighting = EvaluateBSDF_Directional(context, V, posInput, preLightData, _DirectionalLightDatas[i], bsdfData, bakeLightingData);
             AccumulateDirectLighting(lighting, aggregateLighting);
         }
     }
         for (i = 0; i < punctualLightCount; ++i)
         {
             int punctualIndex = FetchIndex(punctualLightStart, i);
-            DirectLighting lighting = EvaluateBSDF_Punctual(context, V, posInput, preLightData, _LightDatas[punctualIndex], bsdfData, _LightDatas[punctualIndex].lightType);
+            DirectLighting lighting = EvaluateBSDF_Punctual(context, V, posInput, preLightData, _LightDatas[punctualIndex], bsdfData, bakeLightingData, _LightDatas[punctualIndex].lightType);
             AccumulateDirectLighting(lighting, aggregateLighting);
         }
 
         {
-            DirectLighting lighting = EvaluateBSDF_Punctual(context, V, posInput, preLightData, _LightDatas[i], bsdfData, _LightDatas[i].lightType);
+            DirectLighting lighting = EvaluateBSDF_Punctual(context, V, posInput, preLightData, _LightDatas[i], bsdfData, bakeLightingData, _LightDatas[i].lightType);
             AccumulateDirectLighting(lighting, aggregateLighting);
         }
 
 
             while (i < areaLightCount && lightType == GPULIGHTTYPE_LINE)
             {
-                DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, _LightDatas[areaIndex], bsdfData, GPULIGHTTYPE_LINE);
+                DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, _LightDatas[areaIndex], bsdfData, bakeLightingData, GPULIGHTTYPE_LINE);
-                
+
                 i++;
                 areaIndex = i < areaLightCount ? FetchIndex(areaLightStart, i) : 0;
                 lightType = i < areaLightCount ? _LightDatas[areaIndex].lightType : 0xFF;
             {
-                DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, _LightDatas[areaIndex], bsdfData, GPULIGHTTYPE_RECTANGLE);
+                DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, _LightDatas[areaIndex], bsdfData, bakeLightingData, GPULIGHTTYPE_RECTANGLE);
                 AccumulateDirectLighting(lighting, aggregateLighting);
 
                 i++;
 
         for (i = _PunctualLightCount; i < _PunctualLightCount + _AreaLightCount; ++i)
         {
-            DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, _LightDatas[i], bsdfData, _LightDatas[i].lightType);
+            DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, _LightDatas[i], bsdfData, bakeLightingData, _LightDatas[i].lightType);
             AccumulateDirectLighting(lighting, aggregateLighting);
         }
 
 
     // Also Apply indiret diffuse (GI)
     // PostEvaluateBSDF will perform any operation wanted by the material and sum everything into diffuseLighting and specularLighting
-    PostEvaluateBSDF(   context, V, posInput, preLightData, bsdfData, bakeDiffuseLighting, aggregateLighting,
+    PostEvaluateBSDF(   context, V, posInput, preLightData, bsdfData, bakeLightingData, aggregateLighting,
                         diffuseLighting, specularLighting);
 
     ApplyDebug(context, posInput.positionWS, diffuseLighting, specularLighting);

ScriptableRenderPipeline/HDRenderPipeline/Material/Builtin/BuiltinData.cs

             [SurfaceDataAttributes("Bake Diffuse Lighting", false, true)]
             public Vector3 bakeDiffuseLighting; // This is the result of sampling lightmap/lightprobe/proxyvolume
 
+            // Use for float instead of vector4 to ease the debug (no performance impact)
+            // Note: We have no way to remove these value automatically based on either SHADEROPTIONS_BAKED_SHADOW_MASK_ENABLE or s_BakedShadowMaskEnable here. Unless we make two structure... For now always keep this value
+            [SurfaceDataAttributes("Shadow Mask 0")]
+            public float shadowMask0;
+            [SurfaceDataAttributes("Shadow Mask 1")]
+            public float shadowMask1;
+            [SurfaceDataAttributes("Shadow Mask 2")]
+            public float shadowMask2;
+            [SurfaceDataAttributes("Shadow Mask 3")]
+            public float shadowMask3;
+
             [SurfaceDataAttributes("Emissive Color", false, true)]
             public Vector3 emissiveColor;
             [SurfaceDataAttributes("Emissive Intensity")]
             public Vector3 diffuseColor;
             public Vector3 emissiveColor; // HDR value
         };
+
+        public static RenderTextureFormat GetShadowMaskBufferFormat()
+        {
+            return RenderTextureFormat.ARGB32;
+        }
+
+        public static RenderTextureReadWrite GetShadowMaskBufferReadWrite()
+        {
+            return RenderTextureReadWrite.Linear;
+        }
 
         public static RenderTextureFormat GetVelocityBufferFormat()
         {

ScriptableRenderPipeline/HDRenderPipeline/Material/Builtin/BuiltinData.cs.hlsl

 //
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_OPACITY (100)
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING (101)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR (102)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_INTENSITY (103)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY (104)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION (105)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR (106)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET (107)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK0 (102)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK1 (103)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK2 (104)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK3 (105)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR (106)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_INTENSITY (107)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY (108)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION (109)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR (110)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET (111)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Builtin+LightTransportData:  static fields
 {
     float opacity;
     float3 bakeDiffuseLighting;
+    float shadowMask0;
+    float shadowMask1;
+    float shadowMask2;
+    float shadowMask3;
     float3 emissiveColor;
     float emissiveIntensity;
     float2 velocity;
         case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
             result = builtindata.bakeDiffuseLighting;
             needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK0:
+            result = builtindata.shadowMask0.xxx;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK1:
+            result = builtindata.shadowMask1.xxx;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK2:
+            result = builtindata.shadowMask2.xxx;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK3:
+            result = builtindata.shadowMask3.xxx;
             break;
         case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR:
             result = builtindata.emissiveColor;

ScriptableRenderPipeline/HDRenderPipeline/Material/Builtin/BuiltinData.hlsl

 //-----------------------------------------------------------------------------
 // common Encode/Decode functions
 //-----------------------------------------------------------------------------
-
+struct BakeLightingData
+{
+    float3 bakeDiffuseLighting;
+#ifdef SHADOWS_SHADOWMASK
+    float4 bakeShadowMask;
+#endif
+};
 // Guideline for velocity buffer.
 // We support various architecture for HDRenderPipeline
 // - Forward only rendering
 // - Same velocity buffer is use for all scenario, so if deferred define a velocity buffer, the same is reuse for forward case.
 // For these reasons we chose to avoid to pack velocity buffer with anything else in case of PackgbufferInFP16 (and also in case the format change)
 
-// Encode/Decode velocity/distortion in a buffer (either forward of deferred)
+// Encode/Decode shadowmask/velocity/distortion in a buffer (either forward of deferred)
+
+// Design note: We assume that shadowmask/velocity/distortion fit into a single buffer (i.e not spread on several buffer)
+void EncodeShadowMask(float4 shadowMask, out float4 outBuffer)
+{
+    // RT - RGBA
+    outBuffer = shadowMask;
+}
+
+void DecodeShadowMask(float4 inBuffer, out float4 shadowMask)
+{
+    shadowMask = inBuffer;
+}
+
 // Design note: We assume that velocity/distortion fit into a single buffer (i.e not spread on several buffer)
 void EncodeVelocity(float2 velocity, out float4 outBuffer)
 {
         break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET:
         result = builtinData.depthOffset.xxx * 10.0; // * 10 assuming 1 unity is 1m
-        break; 
+        break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION:
         result = float3((builtinData.distortion / (abs(builtinData.distortion) + 1) + 1) * 0.5, 0.5);
         break;

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

     // Note _MATID_STANDARD is not define as there is always the default case "_". We assign default as _MATID_STANDARD, so we never test _MATID_STANDARD
     #pragma shader_feature _ _MATID_SSS
 
-    #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
-    #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
-    #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
     // TODO: We should have this keyword only if VelocityInGBuffer is enable, how to do that ?
 
             HLSLPROGRAM
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #define SHADERPASS SHADERPASS_GBUFFER
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
 
             HLSLPROGRAM
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #define SHADERPASS SHADERPASS_GBUFFER
             #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
             #include "../../ShaderVariables.hlsl"
             }
 
             HLSLPROGRAM
+
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_GBUFFER
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
-            #include "../Lit/ShaderPass/LitMetaPass.hlsl"
+            #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 
 
             HLSLPROGRAM
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+
-            // TEMP until pragma work in include
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-
             #include "../../Lighting/Lighting.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"
             Cull[_CullMode]
 
             HLSLPROGRAM
+
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_FORWARD

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

     // Note _MATID_STANDARD is not define as there is always the default case "_". We assign default as _MATID_STANDARD, so we never test _MATID_STANDARD
     #pragma shader_feature _ _MATID_SSS
 
-    #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
-    #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
-    #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
     // TODO: We should have this keyword only if VelocityInGBuffer is enable, how to do that ?
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #define SHADERPASS SHADERPASS_GBUFFER
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #define SHADERPASS SHADERPASS_GBUFFER
             #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
             #include "../../ShaderVariables.hlsl"
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_GBUFFER
             #include "../../ShaderVariables.hlsl"
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
-            #include "../Lit/ShaderPass/LitMetaPass.hlsl"
+            #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+
-            // TEMP until pragma work in include
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-
             #include "../../Lighting/Lighting.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+
-            // TEMP until pragma work in include
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-
             #include "../../Lighting/Lighting.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

 
         public override int GetMaterialGBufferCount() { return (int)GBufferMaterial.Count; }
 
+        RenderTextureFormat[] m_RTFormat4 = { RenderTextureFormat.ARGB32, RenderTextureFormat.ARGB2101010, RenderTextureFormat.ARGB32, RenderTextureFormat.RGB111110Float };
+        RenderTextureReadWrite[] m_RTReadWrite4 = { RenderTextureReadWrite.sRGB, RenderTextureReadWrite.Linear, RenderTextureReadWrite.Linear, RenderTextureReadWrite.Linear };
+
+        // TODO: Just discovered that Unity doesn't support unsigned 16 RT format.
+        RenderTextureFormat[] m_RTFormat2 = { RenderTextureFormat.ARGBInt, RenderTextureFormat.ARGBInt };
+        RenderTextureReadWrite[] m_RTReadWrite2 = { RenderTextureReadWrite.Linear, RenderTextureReadWrite.Linear };
+
-            RTFormat = new RenderTextureFormat[(int)GBufferMaterial.Count];
-            RTReadWrite = new RenderTextureReadWrite[(int)GBufferMaterial.Count];
-
-                // TODO: Just discovered that Unity doesn't support unsigned 16 RT format.
-                RTFormat[0] = RenderTextureFormat.ARGBInt; RTReadWrite[0] = RenderTextureReadWrite.Linear;
-                RTFormat[1] = RenderTextureFormat.ARGBInt; RTReadWrite[1] = RenderTextureReadWrite.Linear;
+                RTFormat = m_RTFormat2;
+                RTReadWrite = m_RTReadWrite2;
-                RTFormat[0] = RenderTextureFormat.ARGB32; RTReadWrite[0] = RenderTextureReadWrite.sRGB;
-                RTFormat[1] = RenderTextureFormat.ARGB2101010; RTReadWrite[1] = RenderTextureReadWrite.Linear;
-                RTFormat[2] = RenderTextureFormat.ARGB32; RTReadWrite[2] = RenderTextureReadWrite.Linear;
-                RTFormat[3] = RenderTextureFormat.RGB111110Float; RTReadWrite[3] = RenderTextureReadWrite.Linear;
+                RTFormat = m_RTFormat4;
+                RTReadWrite = m_RTReadWrite4;
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 float4 _TransmissionTints[SSS_N_PROFILES];  // RGB = 1/4 * color, A = unused
 CBUFFER_END
 
-// General constant
-#define MIN_N_DOT_V    0.0001               // The minimum value of 'NdotV'
-
 //-----------------------------------------------------------------------------
 // Helper for cheap screen space raycasting
 //-----------------------------------------------------------------------------
 
         if (_UseDisneySSS)
         {
-            bsdfData.transmittance = ComputeTransmittance(_ShapeParams[subsurfaceProfile].rgb,
-                                                          _TransmissionTints[subsurfaceProfile].rgb,
-                                                          bsdfData.thickness, bsdfData.subsurfaceRadius);
+            bsdfData.transmittance = ComputeTransmittanceDisney(_ShapeParams[subsurfaceProfile].rgb,
+                                                                _TransmissionTints[subsurfaceProfile].rgb,
+                                                                bsdfData.thickness, bsdfData.subsurfaceRadius);
         }
         else
         {
 struct PreLightData
 {
     // General
-    float NdotV;                         // Geometric version (could be negative)
+    float NdotV;
 
     // GGX
     float partLambdaV;
     float transmissionSSMipLevel;           // mip level of the screen space gaussian pyramid for rough refraction
 
 #ifdef VOLUMETRIC_LIGHTING_ENABLED
-    float    globalFogExtinction;
+    float globalFogExtinction;
 #endif
 };
 
 {
     PreLightData preLightData;
 
+    float3 N;
+    float  NdotV;
+
+        N     = bsdfData.coatNormalWS;
+        NdotV = saturate(dot(N, V));
+        preLightData.coatNdotV = NdotV;
+
-
-        preLightData.coatNdotV = dot(bsdfData.coatNormalWS, V);
-
-        // In the case of IBL we want  shift a bit the normal that are not toward the viewver to reduce artifact
-        float3 coatIblNormalWS = GetViewShiftedNormal(bsdfData.coatNormalWS, V, preLightData.coatNdotV, MIN_N_DOT_V); // Use non-clamped NdotV
-        preLightData.coatIblDirWS = reflect(-V, coatIblNormalWS);
-
-        float coatNdotV = max(preLightData.coatNdotV, MIN_N_DOT_V); // Use the modified (clamped) version
+        preLightData.coatIblDirWS = reflect(-V, N);
-        float theta = FastACosPos(coatNdotV);
+        float theta = FastACosPos(NdotV);
         float2 uv = LTC_LUT_OFFSET + LTC_LUT_SCALE * float2(0.0, theta * INV_HALF_PI); // Use Roughness of 0.0 for clearCoat roughness
 
                                                                                        // Get the inverse LTC matrix for GGX
         preLightData.ltcClearCoatFresnelTerm = preLightData.coatFresnel0 * ltcClearCoatFresnelMagnitudeDiff + ltcClearCoatFresnelMagnitude;
 
         // TODO: Convert the area light with respect to Fresnel transmission
-        float3 N = bsdfData.coatNormalWS; // TODO : check with Laurentb
-        preLightData.refractV = ClearCoatTransform(V, bsdfData.coatNormalWS, ieta);
+        preLightData.refractV = ClearCoatTransform(V, N, ieta);
-    preLightData.NdotV = dot(bsdfData.normalWS, V); // Store the unaltered (geometric) version
+    N     = bsdfData.normalWS;
+    NdotV = saturate(dot(N, V));
+    preLightData.NdotV = NdotV;
-    // In the case of IBL we want  shift a bit the normal that are not toward the viewver to reduce artifact
-    float3 iblNormalWS = GetViewShiftedNormal(bsdfData.normalWS, V, preLightData.NdotV, MIN_N_DOT_V); // Use non-clamped NdotV
-
-    float NdotV = max(preLightData.NdotV, MIN_N_DOT_V); // Use the modified (clamped) version
 
     // GGX aniso
     if (bsdfData.materialId == MATERIALID_LIT_ANISO && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_ANISO))
         float3 grainDirWS = (bsdfData.anisotropy >= 0) ? bsdfData.bitangentWS : bsdfData.tangentWS;
         // Reduce stretching for (perceptualRoughness < 0.2).
         float  stretch = abs(bsdfData.anisotropy) * saturate(5 * bsdfData.perceptualRoughness);
-        // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NdotV) and use iblNormalWS
+        // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NdotV) and use 'anisoIblNormalWS'
-        float3 anisoIblNormalWS = GetAnisotropicModifiedNormal(grainDirWS, iblNormalWS, V, stretch);
+        float3 anisoIblNormalWS = GetAnisotropicModifiedNormal(grainDirWS, N, V, stretch);
         iblR = reflect(-V, anisoIblNormalWS);
     }
     else // GGX iso
         preLightData.partLambdaV = GetSmithJointGGXPartLambdaV(NdotV, bsdfData.roughness);
-        iblR                     = reflect(-V, iblNormalWS);
+        iblR                     = reflect(-V, N);
     }
 
     float reflectivity;
         float roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
         float shininess = Sqr(preLightData.ieta) * (2.0 / Sqr(roughness) - 2.0);
         roughness = sqrt(2.0 / (shininess + 2.0));
-        preLightData.iblDirWS = GetSpecularDominantDir(iblNormalWS, iblR, roughness, NdotV);
+        preLightData.iblDirWS = GetSpecularDominantDir(N, iblR, roughness, NdotV);
         preLightData.iblMipLevel = PerceptualRoughnessToMipmapLevel(RoughnessToPerceptualRoughness(roughness));
     }
     else
             iblPerceptualRoughness = bsdfData.perceptualRoughness;
         }
 
-        preLightData.iblDirWS    = GetSpecularDominantDir(iblNormalWS, iblR, iblRoughness, NdotV);
+        preLightData.iblDirWS    = GetSpecularDominantDir(N, iblR, iblRoughness, NdotV);
         preLightData.iblMipLevel = PerceptualRoughnessToMipmapLevel(iblPerceptualRoughness);
     }
 
     preLightData.ltcTransformSpecular._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, s_linear_clamp_sampler, uv, LTC_GGX_MATRIX_INDEX, 0);
 
     // Construct a right-handed view-dependent orthogonal basis around the normal
-    preLightData.orthoBasisViewNormal[0] = normalize(V - bsdfData.normalWS * preLightData.NdotV);
-    preLightData.orthoBasisViewNormal[2] = bsdfData.normalWS;
+    preLightData.orthoBasisViewNormal[0] = normalize(V - N * NdotV);
+    preLightData.orthoBasisViewNormal[2] = N;
     preLightData.orthoBasisViewNormal[1] = normalize(cross(preLightData.orthoBasisViewNormal[2], preLightData.orthoBasisViewNormal[0]));
 
     float3 ltcMagnitude = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, s_linear_clamp_sampler, uv, LTC_MULTI_GGX_FRESNEL_DISNEY_DIFFUSE_INDEX, 0).rgb;
         float NdotL = saturate(dot(bsdfData.coatNormalWS, L));
         float NdotV = preLightData.coatNdotV;
         float LdotV = dot(L, V);
-        float invLenLV = rsqrt(abs(2 * LdotV + 2));
+        float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_SMALL));
         float NdotH = saturate((NdotL + NdotV) * invLenLV);
         float LdotH = saturate(invLenLV * LdotV + invLenLV);
 
     float NdotL    = saturate(dot(bsdfData.normalWS, L)); // Must have the same value without the clamp
     float NdotV    = preLightData.NdotV;                  // Get the unaltered (geometric) version
     float LdotV    = dot(L, V);
-    float invLenLV = rsqrt(abs(2 * LdotV + 2));           // invLenLV = rcp(length(L + V))
+    float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_SMALL)); // invLenLV = rcp(length(L + V)) - caution about the case where V and L are opposite, it can happen, use max to avoid this
-    NdotV          = max(NdotV, MIN_N_DOT_V);             // Use the modified (clamped) version
-
     F *= F_Schlick(bsdfData.fresnel0, LdotH);
 
     float DV;
 
 DirectLighting EvaluateBSDF_Directional(    LightLoopContext lightLoopContext,
                                             float3 V, PositionInputs posInput, PreLightData preLightData,
-                                            DirectionalLightData lightData, BSDFData bsdfData)
+                                            DirectionalLightData lightData, BSDFData bsdfData, BakeLightingData bakeLightingData)
 {
     DirectLighting lighting;
     ZERO_INITIALIZE(DirectLighting, lighting);
     float NdotL = dot(bsdfData.normalWS, L);
     float illuminance = saturate(NdotL);
 
-    float shadow     = 1.0;
+    float shadow = 1.0;
+    float shadowMask = 1.0;
+#ifdef SHADOWS_SHADOWMASK
+    // shadowMaskSelector.x is -1 if there is no shadow mask
+    // Note that we override shadow value (in case we don't have any dynamic shadow)
+    shadow = shadowMask = (lightData.shadowMaskSelector.x >= 0.0) ? dot(bakeLightingData.bakeShadowMask, lightData.shadowMaskSelector) : 1.0;
+#endif
 
     [branch] if (lightData.shadowIndex >= 0)
     {
         shadow = LOAD_TEXTURE2D(_DeferredShadowTexture, posInput.unPositionSS).x;
 #endif
-        illuminance *= shadow;
+
+#ifdef SHADOWS_SHADOWMASK
+        float fade = saturate(posInput.depthVS * lightData.fadeDistanceScaleAndBias.x + lightData.fadeDistanceScaleAndBias.y);
+
+        // See comment in EvaluateBSDF_Punctual
+        shadow = lightData.dynamicShadowCasterOnly ? min(shadowMask, shadow) : shadow;
+        shadow = lerp(shadow, shadowMask, fade); // Caution to lerp parameter: fade is the reverse of shadowDimmer
+
+        // Note: There is no shadowDimmer when there is no shadow mask
+#endif
+
+    illuminance *= shadow;
 
     [branch] if (lightData.cookieIndex >= 0)
     {
         illuminance  = Lambert() * wrappedNdotL;
     #else
         float tNdotL = saturate(-NdotL);
-        float  NdotV = max(preLightData.NdotV, MIN_N_DOT_V);
+        float  NdotV = preLightData.NdotV;
         illuminance  = INV_PI * F_Transm_Schlick(0, 0.5, NdotV) * F_Transm_Schlick(0, 0.5, tNdotL) * wrappedNdotL;
     #endif
 
 
 DirectLighting EvaluateBSDF_Punctual(   LightLoopContext lightLoopContext,
                                         float3 V, PositionInputs posInput,
-                                        PreLightData preLightData, LightData lightData, BSDFData bsdfData, int GPULightType)
+                                        PreLightData preLightData, LightData lightData, BSDFData bsdfData, BakeLightingData bakeLightingData, int GPULightType)
 {
     DirectLighting lighting;
     ZERO_INITIALIZE(DirectLighting, lighting);
     lightData.specularScale *= attenuation;
 
     float shadow = 1.0;
+    float shadowMask = 1.0;
+#ifdef SHADOWS_SHADOWMASK
+    // shadowMaskSelector.x is -1 if there is no shadow mask
+    // Note that we override shadow value (in case we don't have any dynamic shadow)
+    shadow = shadowMask = (lightData.shadowMaskSelector.x >= 0.0) ? dot(bakeLightingData.bakeShadowMask, lightData.shadowMaskSelector) : 1.0;
+#endif
 
     [branch] if (lightData.shadowIndex >= 0)
     {
         shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, bsdfData.normalWS, lightData.shadowIndex, L_dist, posInput.unPositionSS);
+#ifdef SHADOWS_SHADOWMASK
+        // Note: Legacy Unity have two shadow mask mode. ShadowMask (ShadowMask contain static objects shadow and ShadowMap contain only dynamic objects shadow, final result is the minimun of both value)
+        // and ShadowMask_Distance (ShadowMask contain static objects shadow and ShadowMap contain everything and is blend with ShadowMask based on distance (Global distance setup in QualitySettigns)).
+        // HDRenderPipeline change this behavior. Only ShadowMask mode is supported but we support both blend with distance AND minimun of both value. Distance is control by light.
+        // The following code do this.
+        // The min handle the case of having only dynamic objects in the ShadowMap
+        // The second case for blend with distance is handled with ShadowDimmer. ShadowDimmer is define manually and by shadowDistance by light.
+        // With distance, ShadowDimmer become one and only the ShadowMask appear, we get the blend with distance behavior.
+        shadow = lightData.dynamicShadowCasterOnly ? min(shadowMask, shadow) : shadow;
+        shadow = lerp(shadowMask, shadow, lightData.shadowDimmer);
+#else
-        illuminance *= shadow;
+#endif
-    float volumetricShadow = Transmittance(OpticalDepthHomogeneous(preLightData.globalFogExtinction, dist));
+    shadow *= Transmittance(OpticalDepthHomogeneous(preLightData.globalFogExtinction, dist));
+#endif
-    // Premultiply.
-    lightData.diffuseScale  *= volumetricShadow;
-    lightData.specularScale *= volumetricShadow;
-#endif
+    illuminance *= shadow;
 
     // Projector lights always have a cookies, so we can perform clipping inside the if().
     [branch] if (lightData.cookieIndex >= 0)
         illuminance  = Lambert() * wrappedNdotL;
     #else
         float tNdotL = saturate(-NdotL);
-        float  NdotV = max(preLightData.NdotV, MIN_N_DOT_V);
+        float  NdotV = preLightData.NdotV;
         illuminance  = INV_PI * F_Transm_Schlick(0, 0.5, NdotV) * F_Transm_Schlick(0, 0.5, tNdotL) * wrappedNdotL;
     #endif
 
 
 DirectLighting EvaluateBSDF_Line(   LightLoopContext lightLoopContext,
                                     float3 V, PositionInputs posInput,
-                                    PreLightData preLightData, LightData lightData, BSDFData bsdfData)
+                                    PreLightData preLightData, LightData lightData, BSDFData bsdfData, BakeLightingData bakeLightingData)
 {
     DirectLighting lighting;
     ZERO_INITIALIZE(DirectLighting, lighting);
                                                         axis, invAspectRatio);
 
     // Terminate if the shaded point is too far away.
-    if (intensity == 0.0) 
+    if (intensity == 0.0)
         return lighting;
 
     lightData.diffuseScale  *= intensity;
 
 DirectLighting EvaluateBSDF_Rect(   LightLoopContext lightLoopContext,
                                     float3 V, PositionInputs posInput,
-                                    PreLightData preLightData, LightData lightData, BSDFData bsdfData)
+                                    PreLightData preLightData, LightData lightData, BSDFData bsdfData, BakeLightingData bakeLightingData)
 {
     DirectLighting lighting;
     ZERO_INITIALIZE(DirectLighting, lighting);
 #endif
 
     // Terminate if the shaded point is too far away.
-    if (intensity == 0.0) 
+    if (intensity == 0.0)
         return lighting;
 
     lightData.diffuseScale  *= intensity;
 
 DirectLighting EvaluateBSDF_Area(   LightLoopContext lightLoopContext,
                                     float3 V, PositionInputs posInput,
-                                    PreLightData preLightData, LightData lightData, BSDFData bsdfData, int GPULightType)
+                                    PreLightData preLightData, LightData lightData, BSDFData bsdfData, BakeLightingData bakeLightingData, int GPULightType)
-        return EvaluateBSDF_Line(lightLoopContext, V, posInput, preLightData, lightData, bsdfData);
+        return EvaluateBSDF_Line(lightLoopContext, V, posInput, preLightData, lightData, bsdfData, bakeLightingData);
-        return EvaluateBSDF_Rect(lightLoopContext, V, posInput, preLightData, lightData, bsdfData);
+        return EvaluateBSDF_Rect(lightLoopContext, V, posInput, preLightData, lightData, bsdfData, bakeLightingData);
     }
 }
 
 
 void PostEvaluateBSDF(  LightLoopContext lightLoopContext,
                         float3 V, PositionInputs posInput,
-                        PreLightData preLightData, BSDFData bsdfData, float3 bakeDiffuseLighting, AggregateLighting lighting,
+                        PreLightData preLightData, BSDFData bsdfData, BakeLightingData bakeLightingData, AggregateLighting lighting,
+    float3 bakeDiffuseLighting = bakeLightingData.bakeDiffuseLighting;
+
     // Use GTAOMultiBounce approximation for ambient occlusion (allow to get a tint from the baseColor)
 #define GTAO_MULTIBOUNCE_APPROX 1
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
     #pragma shader_feature _THICKNESSMAP
     #pragma shader_feature _SPECULARCOLORMAP
-    #pragma shader_feature _TRANSMITTANCECOLORMAP    
+    #pragma shader_feature _TRANSMITTANCECOLORMAP
 
     // Keyword for transparent
     #pragma shader_feature _SURFACE_TYPE_TRANSPARENT
     // Note _MATID_STANDARD is not define as there is always the default case "_". We assign default as _MATID_STANDARD, so we never test _MATID_STANDARD
     #pragma shader_feature _ _MATID_SSS _MATID_ANISO _MATID_SPECULAR _MATID_CLEARCOAT
 
-    #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
-    #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
-    #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
     // TODO: We should have this keyword only if VelocityInGBuffer is enable, how to do that ?
             }
 
             HLSLPROGRAM
+
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
 
             #define SHADERPASS SHADERPASS_GBUFFER
             #include "../../ShaderVariables.hlsl"
 
             HLSLPROGRAM
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #define SHADERPASS SHADERPASS_GBUFFER
             #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
             #include "../../ShaderVariables.hlsl"
             }
 
             HLSLPROGRAM
+
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_GBUFFER
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
-            #include "ShaderPass/LitMetaPass.hlsl"
+            #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 
 
             HLSLPROGRAM
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+
-            // TEMP until pragma work in include
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
 
             HLSLPROGRAM
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+
-            // TEMP until pragma work in include
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

         builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
     }
 
+#ifdef SHADOWS_SHADOWMASK
+    float4 shadowMask = SampleShadowMask(input.positionWS, input.texCoord1);
+    builtinData.shadowMask0 = shadowMask.x;
+    builtinData.shadowMask1 = shadowMask.y;
+    builtinData.shadowMask2 = shadowMask.z;
+    builtinData.shadowMask3 = shadowMask.w;
+#else
+    builtinData.shadowMask0 = 0.0;
+    builtinData.shadowMask1 = 0.0;
+    builtinData.shadowMask2 = 0.0;
+    builtinData.shadowMask3 = 0.0;
+#endif
+
     // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
     builtinData.emissiveIntensity = _EmissiveIntensity; // We still store intensity here so we can reuse it with debug code
 
     builtinData.velocity = float2(0.0, 0.0);
 
 #if (SHADERPASS == SHADERPASS_DISTORTION) || defined(DEBUG_DISPLAY)
-    float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb;
+    float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb * 2.0 - 1.0;
     builtinData.distortion = distortion.rg * _DistortionScale;
     builtinData.distortionBlur = clamp(distortion.b * _DistortionBlurScale, 0.0, 1.0) * (_DistortionBlurRemapMax - _DistortionBlurRemapMin) + _DistortionBlurRemapMin;
 #else
     float3 bentNormalWS;
     float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS, bentNormalTS);
     GetNormalWS(input, V, normalTS, surfaceData.normalWS);
+
+    // Ensure that the normal is front-facing.
+    float NdotV;
+    surfaceData.normalWS = GetViewReflectedNormal(surfaceData.normalWS, V, NdotV);
+
     // Use bent normal to sample GI if available
 #ifdef _BENTNORMALMAP
     GetNormalWS(input, V, bentNormalTS, bentNormalWS);
     // If we have bent normal and ambient occlusion, process a specular occlusion
     surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData);
 #elif defined(_MASKMAP)
-    surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(dot(surfaceData.normalWS, V), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
+    surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(NdotV, surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
 #else
     surfaceData.specularOcclusion = 1.0;
 #endif

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitReference.hlsl

                                     uint sampleCount = 4096)
 {
     float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
-    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
+    float    NdotV        = preLightData.NdotV;
     float3   acc          = float3(0.0, 0.0, 0.0);
 
     // Add some jittering on Hammersley2d
         localToWorld = GetLocalFrame(bsdfData.normalWS);
     }
 
-    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
-    float3   acc          = float3(0.0, 0.0, 0.0);
+    float  NdotV = preLightData.NdotV;
+    float3 acc   = float3(0.0, 0.0, 0.0);
 
     // Add some jittering on Hammersley2d
     float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

     // Note _MATID_STANDARD is not define as there is always the default case "_". We assign default as _MATID_STANDARD, so we never test _MATID_STANDARD
     #pragma shader_feature _ _MATID_SSS _MATID_ANISO _MATID_SPECULAR _MATID_CLEARCOAT
 
-    #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
-    #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
-    #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
     // TODO: We should have this keyword only if VelocityInGBuffer is enable, how to do that ?
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #define SHADERPASS SHADERPASS_GBUFFER
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #define SHADERPASS SHADERPASS_GBUFFER
             #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
             #include "../../ShaderVariables.hlsl"
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_GBUFFER
             #include "../../ShaderVariables.hlsl"
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
-            #include "ShaderPass/LitMetaPass.hlsl"
+            #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+
-            // TEMP until pragma work in include
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
             #pragma hull Hull
             #pragma domain Domain
 
+            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+
-            // TEMP until pragma work in include
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/SubsurfaceScattering.compute

     }
 }
 
-// Computes the value of the integrand over a disk: (2 * PI * r) * KernelVal().
-// N.b.: the returned value is multiplied by 4. It is irrelevant due to weight renormalization.
-float3 KernelValCircle(float r, float3 S)
+// Computes the value of the integrand in polar coordinates: f(r, s) = r * R(r, s).
+// f(r, s) = (Exp[-r * s] + Exp[-r * s / 3]) * (s / (8 * Pi))
+// We can drop the constant (s / (8 * Pi)) due to the subsequent weight renormalization.
+float3 DisneyProfilePolar(float r, float3 S)
+#if 0
-    return /* 0.25 * */ S * (expOneThird + expOneThird * expOneThird * expOneThird);
+#else
+    // Help the compiler.
+    float  k = (-1.0 / 3.0) * LOG2_E;
+    float3 p = (k * r) * S;
+    float3 expOneThird = exp2(p);
+#endif
+    return expOneThird + expOneThird * expOneThird * expOneThird;
-// Computes F(r)/P(r), s.t. r = sqrt(xy^2 + z^2).
+// Computes f(r, s)/p(r, s), s.t. r = sqrt(xy^2 + z^2).
 // Rescaling of the PDF is handled by 'totalWeight'.
 float3 ComputeBilateralWeight(float xy2, float z, float mmPerUnit, float3 S, float rcpPdf)
 {
 #endif
 
 #if SSS_CLAMP_ARTIFACT
-    return saturate(KernelValCircle(r, S) * rcpPdf);
+    return saturate(DisneyProfilePolar(r, S) * rcpPdf);
-    return KernelValCircle(r, S) * rcpPdf;
+    return DisneyProfilePolar(r, S) * rcpPdf;
 #endif
 }
 
 
     float  centerRadius = _FilterKernels[profileID][0][iR];
     float  centerRcpPdf = _FilterKernels[profileID][0][iP];
-    float3 centerWeight = KernelValCircle(centerRadius, shapeParam) * centerRcpPdf;
+    float3 centerWeight = DisneyProfilePolar(centerRadius, shapeParam) * centerRcpPdf;
 
     // Accumulate filtered irradiance and bilateral weights (for renormalization).
     float3 totalIrradiance = centerWeight * centerIrradiance;

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

 #define ATTRIBUTES_NEED_TEXCOORD1
 #define ATTRIBUTES_NEED_COLOR
 
-#if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3) || defined(DYNAMICLIGHTMAP_ON) || defined(DEBUG_DISPLAY)
+#if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3) || defined(DYNAMICLIGHTMAP_ON) || defined(DEBUG_DISPLAY) || (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
 #define ATTRIBUTES_NEED_TEXCOORD2
 #endif
 #if defined(_REQUIRE_UV3) || defined(DEBUG_DISPLAY)

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringSettings.cs

             // We importance sample the color channel with the widest scattering distance.
             float s = Mathf.Min(shapeParam.x, shapeParam.y, shapeParam.z);
 
-            // Importance sample the normalized diffusion profile for the computed value of 's'.
+            // Importance sample the normalized diffuse reflectance profile for the computed value of 's'.
-            // R(r, s)   = s * (Exp[-r * s] + Exp[-r * s / 3]) / (8 * Pi * r)
-            // PDF(r, s) = s * (Exp[-r * s] + Exp[-r * s / 3]) / 4
-            // CDF(r, s) = 1 - 1/4 * Exp[-r * s] - 3/4 * Exp[-r * s / 3]
+            // R[r, phi, s]   = s * (Exp[-r * s] + Exp[-r * s / 3]) / (8 * Pi * r)
+            // PDF[r, phi, s] = r * R[r, phi, s]
+            // CDF[r, s]      = 1 - 1/4 * Exp[-r * s] - 3/4 * Exp[-r * s / 3]
             // ------------------------------------------------------------------------------------
 
             // Importance sample the near field kernel.
-                float r = KernelCdfInverse(p, s);
+                float r = DisneyProfileCdfInverse(p, s);
-                filterKernelNearField[i].y = 1f / KernelPdf(r, s);
+                filterKernelNearField[i].y = 1f / DisneyProfilePdf(r, s);
             }
 
             // Importance sample the far field kernel.
-                float r = KernelCdfInverse(p, s);
+                float r = DisneyProfileCdfInverse(p, s);
-                filterKernelFarField[i].y = 1f / KernelPdf(r, s);
+                filterKernelFarField[i].y = 1f / DisneyProfilePdf(r, s);
             }
 
             maxRadius = filterKernelFarField[SssConstants.SSS_N_SAMPLES_FAR_FIELD - 1].x;
         }
         // <<< Old SSS Model
 
-        static float KernelVal(float r, float s)
+        static float DisneyProfile(float r, float s)
-        // Computes the value of the integrand over a disk: (2 * PI * r) * KernelVal().
-        static float KernelValCircle(float r, float s)
+        static float DisneyProfilePdf(float r, float s)
-            return 0.25f * s * (Mathf.Exp(-r * s) + Mathf.Exp(-r * s * (1.0f / 3.0f)));
+            return r * DisneyProfile(r, s);
-        static float KernelPdf(float r, float s)
-        {
-            return KernelValCircle(r, s);
-        }
-
-        static float KernelCdf(float r, float s)
+        static float DisneyProfileCdf(float r, float s)
-        static float KernelCdfDerivative1(float r, float s)
+        static float DisneyProfileCdfDerivative1(float r, float s)
-        static float KernelCdfDerivative2(float r, float s)
+        static float DisneyProfileCdfDerivative2(float r, float s)
         {
             return (-1.0f / 12.0f) * s * s * Mathf.Exp(-r * s) * (3.0f + Mathf.Exp(r * s * (2.0f / 3.0f)));
         }
-        static float KernelCdfInverse(float p, float s)
+        static float DisneyProfileCdfInverse(float p, float s)
         {
             // Supply the initial guess.
             float r = (Mathf.Pow(10f, p) - 1f) / s;
             {
-                float f0 = KernelCdf(r, s) - p;
-                float f1 = KernelCdfDerivative1(r, s);
-                float f2 = KernelCdfDerivative2(r, s);
+                float f0 = DisneyProfileCdf(r, s) - p;
+                float f1 = DisneyProfileCdfDerivative1(r, s);
+                float f2 = DisneyProfileCdfDerivative2(r, s);
                 float dr = f0 / (f1 * (1f - f0 * f2 / (2f * f1 * f1)));
 
                 if (Mathf.Abs(dr) < t)

ScriptableRenderPipeline/HDRenderPipeline/Material/Material.hlsl

 #define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
 #define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1))
 
-#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
-#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target2
+#ifdef SHADOWS_SHADOWMASK
+    #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target2
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target3
+    #endif
+#else
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target2
+    #endif
 #endif
 
 #elif GBUFFERMATERIAL_COUNT == 3
 #define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
 #define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
 
-
-#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
-#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target3
+#ifdef SHADOWS_SHADOWMASK
+    #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target3
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target4
+    #endif
+#else
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target3
+    #endif
 #endif
 
 #elif GBUFFERMATERIAL_COUNT == 4
 #define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
 #define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3))
 
-#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
-#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target4
+#ifdef SHADOWS_SHADOWMASK
+    #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target4
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target5
+    #endif
+#else
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target4
+    #endif
 #endif
 
 #elif GBUFFERMATERIAL_COUNT == 5
 #define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
 #define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4))
 
-#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
-#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target5
+#ifdef SHADOWS_SHADOWMASK
+    #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target5
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target6
+    #endif
+#else
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target5
+    #endif
+#endif
+
+#elif GBUFFERMATERIAL_COUNT == 6
+
+#define OUTPUT_GBUFFER(NAME)                            \
+        out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
+        out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,    \
+        out GBufferType2 MERGE_NAME(NAME, 2) : SV_Target2,    \
+        out GBufferType3 MERGE_NAME(NAME, 3) : SV_Target3,    \
+        out GBufferType4 MERGE_NAME(NAME, 4) : SV_Target4,    \
+        out GBufferType5 MERGE_NAME(NAME, 5) : SV_Target5
+
+#define DECLARE_GBUFFER_TEXTURE(NAME)   \
+        TEXTURE2D(MERGE_NAME(NAME, 0));  \
+        TEXTURE2D(MERGE_NAME(NAME, 1));  \
+        TEXTURE2D(MERGE_NAME(NAME, 2));  \
+        TEXTURE2D(MERGE_NAME(NAME, 3));  \
+        TEXTURE2D(MERGE_NAME(NAME, 4));  \
+        TEXTURE2D(MERGE_NAME(NAME, 5));
+
+#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2); \
+        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2); \
+        GBufferType4 MERGE_NAME(NAME, 4) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 4), unCoord2); \
+        GBufferType5 MERGE_NAME(NAME, 5) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 5), unCoord2);
+
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), MERGE_NAME(NAME, 5))
+#define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), MERGE_NAME(NAME, 5), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
+#define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), MERGE_NAME(NAME, 5))
+
+#ifdef SHADOWS_SHADOWMASK
+    #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target6
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target7
+    #endif
+#else
+    #if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+    #define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target6
+    #endif
+#endif
+
+#ifdef SHADOWS_SHADOWMASK
+#define ENCODE_SHADOWMASK_INTO_GBUFFER(SHADOWMASK, NAME) EncodeShadowMask(SHADOWMASK, NAME)
+#else
+#define OUTPUT_GBUFFER_SHADOWMASK(NAME)
+#define ENCODE_SHADOWMASK_INTO_GBUFFER(SHADOWMASK, NAME)
 #endif
 
 #if SHADEROPTIONS_VELOCITY_IN_GBUFFER

ScriptableRenderPipeline/HDRenderPipeline/Material/MaterialUtilities.hlsl

 #endif
 }
 
+float4 SampleShadowMask(float3 positionWS, float2 uvStaticLightmap) // normalWS not use for now
+{
+#if defined(LIGHTMAP_ON)
+    float2 uv = uvStaticLightmap * unity_LightmapST.xy + unity_LightmapST.zw;
+    float4 rawOcclusionMask = SAMPLE_TEXTURE2D(unity_ShadowMask, samplerunity_Lightmap, uv); // Reuse sampler from Lightmap
+#else
+    float4 rawOcclusionMask;
+    if (unity_ProbeVolumeParams.x == 1.0)
+    {
+        // TODO: We use GetAbsolutePositionWS(positionWS) to handle the camera relative case here but this should be part of the unity_ProbeVolumeWorldToObject matrix on C++ side (sadly we can't modify it for HDRenderPipeline...)
+        rawOcclusionMask = SampleProbeOcclusion(TEXTURE3D_PARAM(unity_ProbeVolumeSH, samplerunity_ProbeVolumeSH), GetAbsolutePositionWS(positionWS), unity_ProbeVolumeWorldToObject,
+                                                unity_ProbeVolumeParams.y, unity_ProbeVolumeParams.z, unity_ProbeVolumeMin, unity_ProbeVolumeSizeInv);
+    }
+    else
+    {
+        // Note: Default value when the feature is not enabled is float(1.0, 1.0, 1.0, 1.0) in C++
+        rawOcclusionMask = unity_ProbesOcclusion;
+    }
+#endif
+
+    return rawOcclusionMask;
+}
+
 float2 CalculateVelocity(float4 positionCS, float4 previousPositionCS)
 {
     // This test on define is required to remove warning of divide by 0 when initializing empty struct

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

         // Since we don't have those parameters in our shaders we need to provide a "fake" useless version of them with the right values for the GI to work.
         protected static void SetupMainTexForAlphaTestGI(string colorMapPropertyName, string colorPropertyName, Material material)
         {
-            if(material.HasProperty(colorMapPropertyName))
+            if (material.HasProperty(colorMapPropertyName))
-            if(material.HasProperty(colorPropertyName))
+            if (material.HasProperty(colorPropertyName))
-            if(material.HasProperty("_AlphaCutoff")) // Same for all our materials
+            if (material.HasProperty("_AlphaCutoff")) // Same for all our materials
             {
                 var cutoff = material.GetFloat("_AlphaCutoff");
                 material.SetFloat("_Cutoff", cutoff);

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/ShaderPass/UnlitSharePass.hlsl

 
 #define ATTRIBUTES_NEED_TEXCOORD0
 
+#if defined(DEBUG_DISPLAY) || (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
+// For the meta pass with emissive we require UV1 and/or UV2
+#define ATTRIBUTES_NEED_TEXCOORD1
+#define ATTRIBUTES_NEED_TEXCOORD2
+#endif
+
 #if defined(_ENABLE_FOG_ON_TRANSPARENT)
 #define VARYINGS_NEED_POSITION_WS
 #endif

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader

 
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../Material/Material.hlsl"
-            #include "ShaderPass/UnlitMetaPass.hlsl"
+            #include "ShaderPass/UnlitSharePass.hlsl"
             #include "UnlitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/UnlitData.hlsl

 
     builtinData.velocity = float2(0.0, 0.0);
 
+    builtinData.shadowMask0 = 0.0;
+    builtinData.shadowMask1 = 0.0;
+    builtinData.shadowMask2 = 0.0;
+    builtinData.shadowMask3 = 0.0;
+
-    float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb;
+    float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb * 2.0 - 1.0;
     builtinData.distortion = distortion.rg * _DistortionScale;
     builtinData.distortionBlur = clamp(distortion.b * _DistortionBlurScale, 0.0, 1.0) * (_DistortionBlurRemapMax - _DistortionBlurRemapMin) + _DistortionBlurRemapMin;
 #else

ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawTransmittanceGraph.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "../../../Core/ShaderLibrary/CommonMaterial.hlsl"
+            #include "../../../Core/ShaderLibrary/CommonMaterial.hlsl"
             #define USE_LEGACY_UNITY_MATRIX_VARIABLES
             #include "../../ShaderVariables.hlsl"
 
 
                 if (_UseDisneySSS)
                 {
-                    T = ComputeTransmittance(_ShapeParam.rgb, float3(0.25, 0.25, 0.25), d, 1);
+                    T = ComputeTransmittanceDisney(_ShapeParam.rgb, float3(0.25, 0.25, 0.25), d, 1);
                 }
                 else
                 {

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassForward.hlsl

 #endif
         float3 diffuseLighting;
         float3 specularLighting;
-        float3 bakeDiffuseLighting = GetBakedDiffuseLigthing(surfaceData, builtinData, bsdfData, preLightData);
-        LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, featureFlags, diffuseLighting, specularLighting);
-
+        BakeLightingData bakeLightingData;
+        bakeLightingData.bakeDiffuseLighting = GetBakedDiffuseLigthing(surfaceData, builtinData, bsdfData, preLightData);
+#ifdef SHADOWS_SHADOWMASK
+        bakeLightingData.bakeShadowMask = float4(builtinData.shadowMask0, builtinData.shadowMask1, builtinData.shadowMask2, builtinData.shadowMask3);
+#endif
+        LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, featureFlags, diffuseLighting, specularLighting);
         outColor = ApplyBlendMode(diffuseLighting, specularLighting, builtinData.opacity);
         outColor = EvaluateAtmosphericScattering(posInput, outColor);
     }

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassGBuffer.hlsl

 
 void Frag(  PackedVaryingsToPS packedInput,
             OUTPUT_GBUFFER(outGBuffer)
+            OUTPUT_GBUFFER_SHADOWMASK(outShadowMaskBuffer)
             OUTPUT_GBUFFER_VELOCITY(outVelocityBuffer)
             #ifdef _DEPTHOFFSET_ON
             , out float outputDepth : SV_Depth
     float3 bakeDiffuseLighting = GetBakedDiffuseLigthing(surfaceData, builtinData, bsdfData, preLightData);
 
     ENCODE_INTO_GBUFFER(surfaceData, bakeDiffuseLighting, outGBuffer);
+    ENCODE_SHADOWMASK_INTO_GBUFFER(float4(builtinData.shadowMask0, builtinData.shadowMask1, builtinData.shadowMask2, builtinData.shadowMask3), outShadowMaskBuffer);
     ENCODE_VELOCITY_INTO_GBUFFER(builtinData.velocity, outVelocityBuffer);
 
 #ifdef _DEPTHOFFSET_ON

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl

     // OpenGL right now needs to actually use the incoming vertex position
     // so we create a fake dependency on it here that haven't any impact.
     output.vmesh.positionCS = float4(uv * 2.0 - 1.0, inputMesh.positionOS.z > 0 ? 1.0e-4 : 0.0, 1.0);
-    output.vmesh.texCoord0  = inputMesh.uv0;
-    output.vmesh.texCoord1  = inputMesh.uv1;
-    output.vmesh.texCoord2  = inputMesh.uv2;
-    output.vmesh.texCoord3  = inputMesh.uv3;
+#ifdef VARYINGS_NEED_POSITION_WS
+#endif
-#if defined(VARYINGS_NEED_COLOR)
+#ifdef VARYINGS_NEED_TEXCOORD0
+    output.vmesh.texCoord0 = inputMesh.uv0;
+#endif
+#ifdef VARYINGS_NEED_TEXCOORD1
+    output.vmesh.texCoord1 = inputMesh.uv1;
+#endif
+#ifdef VARYINGS_NEED_TEXCOORD2
+    output.vmesh.texCoord2 = inputMesh.uv2;
+#endif
+#ifdef VARYINGS_NEED_TEXCOORD3
+    output.vmesh.texCoord3 = inputMesh.uv3;
+#endif
+#ifdef VARYINGS_NEED_COLOR
     output.vmesh.color = inputMesh.color;
 #endif
 

ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

     float3 unity_ProbeVolumeSizeInv;
     float3 unity_ProbeVolumeMin;
 
+    // This contain occlusion factor from 0 to 1 for dynamic objects (no SH here)
+    float4 unity_ProbesOcclusion;
+
 CBUFFER_END
 
 #if defined(USING_STEREO_MATRICES)
 SAMPLER2D(samplerunity_DynamicLightmap);
 
 TEXTURE2D(unity_DynamicDirectionality);
+
+// We can have shadowMask only if we have lightmap, so no sampler
+TEXTURE2D(unity_ShadowMask);
 
 // TODO: Change code here so probe volume use only one transform instead of all this parameters!
 TEXTURE3D_FLOAT(unity_ProbeVolumeSH);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitMetaPass.hlsl.meta

-fileFormatVersion: 2
-guid: a55741149134f0a4280500a1842a7460
-timeCreated: 1478601047
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

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

-#ifndef SHADERPASS
-#error Undefine_SHADERPASS
-#endif
-
-#define ATTRIBUTES_NEED_TEXCOORD0
-#define ATTRIBUTES_NEED_TEXCOORD1
-#define ATTRIBUTES_NEED_TEXCOORD2
-#define ATTRIBUTES_NEED_TEXCOORD3
-
-#ifdef _VERTEX_WIND
-#define ATTRIBUTES_NEED_COLOR
-#define ATTRIBUTES_NEED_NORMAL
-#endif
-
-#define REQUIRE_VERTEX_COLOR defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))
-
-#if REQUIRE_VERTEX_COLOR
-#define ATTRIBUTES_NEED_COLOR
-#endif
-
-#define VARYINGS_NEED_TEXCOORD0
-#define VARYINGS_NEED_TEXCOORD1
-#define VARYINGS_NEED_TEXCOORD2
-#define VARYINGS_NEED_TEXCOORD3
-
-#define VARYINGS_NEED_POSITION_WS
-
-#if REQUIRE_VERTEX_COLOR
-#define VARYINGS_NEED_COLOR
-#endif
-
-// This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/ShaderPass/UnlitMetaPass.hlsl.meta

-fileFormatVersion: 2
-guid: 34b6e92ecac8a054085e28dc783b1a80
-timeCreated: 1484323639
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/ShaderPass/UnlitMetaPass.hlsl

-#ifndef SHADERPASS
-#error Undefine_SHADERPASS
-#endif
-
-#define ATTRIBUTES_NEED_TEXCOORD0
-#define ATTRIBUTES_NEED_TEXCOORD1
-#define ATTRIBUTES_NEED_TEXCOORD2
-#define ATTRIBUTES_NEED_TEXCOORD3
-
-#define VARYINGS_NEED_TEXCOORD0
-#define VARYINGS_NEED_TEXCOORD1
-#define VARYINGS_NEED_TEXCOORD2
-#define VARYINGS_NEED_TEXCOORD3
-
-#define VARYINGS_NEED_POSITION_WS
-
-// This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"