Updated LW to always use ScreenSpace shadowmap. This is a safe compromise until we can strip multi_compile keywords with a c# api.

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

 
         private static readonly int kMaxVertexLights = 4;
 
-        // We have no good approach exposed to skip shader variants, e.g, ideally we would like to skip _CASCADE for all punctual lights
-        // We combine light and shadow classification keywords to reduce the amount of shader variants.
-        // Lightweight shader library declares defines based on these keywords to avoid having to check them in the shaders
-        // Core.hlsl defines _MAIN_LIGHT_DIRECTIONAL and _MAIN_LIGHT_SPOT (point lights can't be main light)
-        // Shadow.hlsl defines _SHADOWS_ENABLED, _SHADOWS_SOFT, _SHADOWS_CASCADE, _SHADOWS_PERSPECTIVE
-        private static readonly string[] kMainLightKeywords =
-        {
-            "_MAIN_LIGHT_DIRECTIONAL_SHADOW",
-            "_MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE",
-            "_MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT",
-            "_MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT",
-
-            "_MAIN_LIGHT_SPOT_SHADOW",
-            "_MAIN_LIGHT_SPOT_SHADOW_SOFT"
-        };
-
-        private StringBuilder m_MainLightKeywordString = new StringBuilder(43);
-
         private bool m_IsOffscreenCamera;
 
         private Vector4 kDefaultLightPosition = new Vector4(0.0f, 0.0f, 1.0f, 0.0f);
         private bool m_RequireDepthTexture;
         private bool m_RequireCopyColor;
         private bool m_DepthRenderBuffer;
-        private bool m_RequireScreenSpaceShadows;
         private MixedLightingSetup m_MixedLightingSetup;
 
         private const int kDepthStencilBufferBits = 32;
                 LightData lightData;
                 InitializeLightData(visibleLights, out lightData);
 
-                ShadowPass(visibleLights, ref context, ref lightData);
+                bool shadows = ShadowPass(visibleLights, ref context, ref lightData);
-                SetupFrameRenderingConfiguration(out frameRenderingConfiguration, stereoEnabled);
+                SetupFrameRenderingConfiguration(out frameRenderingConfiguration, shadows, stereoEnabled);
                 SetupIntermediateResources(frameRenderingConfiguration, ref context);
 
                 // SetupCameraProperties does the following:
                 if (LightweightUtils.HasFlag(frameRenderingConfiguration, FrameRenderingConfiguration.DepthPrePass))
                 {
                     DepthPass(ref context);
-                    if(m_RequireScreenSpaceShadows) 
+
+                    // Only screen space shadowmap mode is supported.
+                    if (shadows)
-                // Release temporary RT
+                cmd.ReleaseTemporaryRT(m_ScreenSpaceShadowMapRTID);
                 cmd.ReleaseTemporaryRT(CameraRenderTargetID.depthCopy);
                 cmd.ReleaseTemporaryRT(CameraRenderTargetID.depth);
                 cmd.ReleaseTemporaryRT(CameraRenderTargetID.color);
             }
         }
 
-        private void ShadowPass(List<VisibleLight> visibleLights, ref ScriptableRenderContext context, ref LightData lightData)
+        private bool ShadowPass(List<VisibleLight> visibleLights, ref ScriptableRenderContext context, ref LightData lightData)
         {
             if (m_Asset.AreShadowsEnabled() && lightData.mainLightIndex != -1)
             {
                     if (!LightweightUtils.IsSupportedShadowType(mainLight.lightType))
                     {
                         Debug.LogWarning("Only directional and spot shadows are supported by LightweightPipeline.");
-                        return;
+                        return false;
                     }
 
                     // There's no way to map shadow light indices. We need to pass in the original unsorted index.
                     {
                         lightData.shadowMapSampleType = LightShadows.None;
                     }
+
+                    return shadowsRendered;
+
+            return false;
-            if (m_Asset.AreShadowsEnabled() && lightData.mainLightIndex != -1)
-            {
-                CommandBuffer cmd = CommandBufferPool.Get("Collect Shadows");
+            CommandBuffer cmd = CommandBufferPool.Get("Collect Shadows");
-                //Keywords and constants are set up in advance for the collect pass.
-                SetupShadowReceiverConstants(cmd, visibleLights[lightData.mainLightIndex]); 
-                SetMainLightShaderKeywords(cmd, ref lightData, visibleLights);
+            SetupShadowReceiverConstants(cmd, visibleLights[lightData.mainLightIndex]);
+            SetShadowCollectPassKeywords(cmd, ref lightData);
-                cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, m_CurrCamera.pixelWidth, m_CurrCamera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.R8);
-                cmd.Blit(null, m_ScreenSpaceShadowMapRT, m_ScreenSpaceShadowsMaterial);
+            cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, m_CurrCamera.pixelWidth, m_CurrCamera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.R8);
+            cmd.Blit(null, m_ScreenSpaceShadowMapRT, m_ScreenSpaceShadowsMaterial);
-                context.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
-            }
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
         }
 
         private void DepthPass(ref ScriptableRenderContext context)
             }
         }
 
-        private void SetupFrameRenderingConfiguration(out FrameRenderingConfiguration configuration, bool stereoEnabled)
+        private void SetupFrameRenderingConfiguration(out FrameRenderingConfiguration configuration, bool shadows, bool stereoEnabled)
         {
             configuration = (stereoEnabled) ? FrameRenderingConfiguration.Stereo : FrameRenderingConfiguration.None;
             if (stereoEnabled && XRSettings.eyeTextureDesc.dimension == TextureDimension.Tex2DArray)
                 }
             }
 
-            m_RequireScreenSpaceShadows = m_Asset.CascadeCount > 1;
-            if (m_RequireScreenSpaceShadows)
+            if (shadows)
-                if(!msaaEnabled) 
+                if (!msaaEnabled)
                     intermediateTexture = true;
             }
 
                 // If msaa is enabled we don't use a depth renderbuffer as we might not have support to Texture2DMS to resolve depth.
                 // Instead we use a depth prepass and whenever depth is needed we use the 1 sample depth from prepass.
                 // Screen space shadows require depth before opaque shading.
-                if (!msaaEnabled && !m_RequireScreenSpaceShadows)
+                if (!msaaEnabled && !shadows)
                 {
                     bool supportsDepthCopy = m_CopyTextureSupport != CopyTextureSupport.None && m_Asset.CopyDepthShader.isSupported;
                     m_DepthRenderBuffer = true;
                     configuration |= FrameRenderingConfiguration.DepthPrePass;
                 }
             }
-          
+
             Rect cameraRect = m_CurrCamera.rect;
             if (!(Math.Abs(cameraRect.x) > 0.0f || Math.Abs(cameraRect.y) > 0.0f || Math.Abs(cameraRect.width) < 1.0f || Math.Abs(cameraRect.height) < 1.0f))
                 configuration |= FrameRenderingConfiguration.DefaultViewport;
             // Main light has an optimized shader path for main light. This will benefit games that only care about a single light.
             // Lightweight pipeline also supports only a single shadow light, if available it will be the main light.
             SetupMainLightConstants(cmd, lights, lightData.mainLightIndex);
-            if (lightData.shadowMapSampleType != LightShadows.None && !m_RequireScreenSpaceShadows)
-                SetupShadowReceiverConstants(cmd, lights[lightData.mainLightIndex]);
-
             SetupAdditionalListConstants(cmd, lights, ref lightData);
         }
 
             cmd.SetGlobalVectorArray(ShadowConstantBuffer._DirShadowSplitSpheres, m_DirectionalShadowSplitDistances);
             cmd.SetGlobalVector(ShadowConstantBuffer._DirShadowSplitSphereRadii, m_DirectionalShadowSplitRadii);
             cmd.SetGlobalVector(ShadowConstantBuffer._ShadowOffset0, new Vector4(-invHalfShadowResolution, -invHalfShadowResolution, 0.0f, 0.0f));
-            cmd.SetGlobalVector(ShadowConstantBuffer._ShadowOffset1, new Vector4( invHalfShadowResolution, -invHalfShadowResolution, 0.0f, 0.0f));
-            cmd.SetGlobalVector(ShadowConstantBuffer._ShadowOffset2, new Vector4(-invHalfShadowResolution,  invHalfShadowResolution, 0.0f, 0.0f));
-            cmd.SetGlobalVector(ShadowConstantBuffer._ShadowOffset3, new Vector4( invHalfShadowResolution,  invHalfShadowResolution, 0.0f, 0.0f));
+            cmd.SetGlobalVector(ShadowConstantBuffer._ShadowOffset1, new Vector4(invHalfShadowResolution, -invHalfShadowResolution, 0.0f, 0.0f));
+            cmd.SetGlobalVector(ShadowConstantBuffer._ShadowOffset2, new Vector4(-invHalfShadowResolution, invHalfShadowResolution, 0.0f, 0.0f));
+            cmd.SetGlobalVector(ShadowConstantBuffer._ShadowOffset3, new Vector4(invHalfShadowResolution, invHalfShadowResolution, 0.0f, 0.0f));
-            cmd.SetGlobalVectorArray(ShadowConstantBuffer._FrustumCorners, m_RequireScreenSpaceShadows ? LightweightUtils.GetFarPlaneCorners(m_CurrCamera) : new Vector4[4] );
+            cmd.SetGlobalVectorArray(ShadowConstantBuffer._FrustumCorners, LightweightUtils.GetFarPlaneCorners(m_CurrCamera));
         }
 
         private void SetShaderKeywords(CommandBuffer cmd, ref LightData lightData, List<VisibleLight> visibleLights)
-            if(!m_RequireScreenSpaceShadows) 
-                SetMainLightShaderKeywords(cmd, ref lightData, visibleLights);
-
+            int mainLightIndex = lightData.mainLightIndex;
+            CoreUtils.SetKeyword(cmd, "_MAIN_LIGHT_DIRECTIONAL", mainLightIndex == -1 || visibleLights[mainLightIndex].lightType == LightType.Directional);
+            CoreUtils.SetKeyword(cmd, "_MAIN_LIGHT_SPOT", mainLightIndex != -1 && visibleLights[mainLightIndex].lightType == LightType.Spot);
+            CoreUtils.SetKeyword(cmd, "_SHADOWS_ENABLED", lightData.shadowMapSampleType != LightShadows.None);
+            CoreUtils.SetKeyword(cmd, "_MAIN_LIGHT_COOKIE", mainLightIndex != -1 && LightweightUtils.IsSupportedCookieType(visibleLights[mainLightIndex].lightType) && visibleLights[mainLightIndex].light.cookie != null);
             CoreUtils.SetKeyword(cmd, "_ADDITIONAL_LIGHTS", lightData.totalAdditionalLightsCount > 0);
             CoreUtils.SetKeyword(cmd, "_MIXED_LIGHTING_SUBTRACTIVE", m_MixedLightingSetup == MixedLightingSetup.Subtractive);
             CoreUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightsCount > 0);
             CoreUtils.SetKeyword(cmd, "FOG_EXP2", exponentialFogModeEnabled);
         }
 
-        private void SetMainLightShaderKeywords(CommandBuffer cmd, ref LightData lightData, List<VisibleLight> visibleLights)
+        private void SetShadowCollectPassKeywords(CommandBuffer cmd, ref LightData lightData)
-            int mainLightIndex = lightData.mainLightIndex;
-
-            for (int i = 0; i < kMainLightKeywords.Length; ++i)
-                cmd.DisableShaderKeyword(kMainLightKeywords[i]);
-
-            if (mainLightIndex != -1 && (lightData.shadowMapSampleType != LightShadows.None))
-            {
-                m_MainLightKeywordString.Length = 0;
-                m_MainLightKeywordString.Append("_MAIN_LIGHT");
-                LightType mainLightType = visibleLights[mainLightIndex].lightType;
-                if (mainLightType == LightType.Directional)
-                {
-                    m_MainLightKeywordString.Append("_DIRECTIONAL_SHADOW");
-                    if (m_Asset.CascadeCount > 1)
-                        m_MainLightKeywordString.Append("_CASCADE");
-                }
-                else
-                {
-                    m_MainLightKeywordString.Append("_SPOT_SHADOW");
-                }
-
-                if (lightData.shadowMapSampleType == LightShadows.Soft)
-                    m_MainLightKeywordString.Append("_SOFT");
-                string keyword = m_MainLightKeywordString.ToString();
-                cmd.EnableShaderKeyword(keyword);
-            }
-
-            CoreUtils.SetKeyword(cmd, "_MAIN_LIGHT_COOKIE", mainLightIndex != -1 && LightweightUtils.IsSupportedCookieType(visibleLights[mainLightIndex].lightType) && visibleLights[mainLightIndex].light.cookie != null);
+            CoreUtils.SetKeyword(cmd, "_SHADOWS_SOFT", lightData.shadowMapSampleType == LightShadows.Soft);
+            CoreUtils.SetKeyword(cmd, "_SHADOWS_CASCADE", lightData.shadowMapSampleType != LightShadows.None && m_Asset.CascadeCount > 1);
         }
 
         private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, int shadowLightIndex, ref ScriptableRenderContext context)

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Core.hlsl

 #include "Input.hlsl"
 
 ///////////////////////////////////////////////////////////////////////////////
-// Light Classification defines                                              //
-//                                                                           //
-// In order to reduce shader variations main light keywords were combined    //
-// here we define main light type keywords.                                  //
-// Main light is either a shadow casting light or the brighest directional.  //
-// Lightweight pipeline doesn't support point light shadows so they can't be //
-// classified as main light.                                                 //
-///////////////////////////////////////////////////////////////////////////////
-#if defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW) || defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE) || defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT) || defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT)
-#define _MAIN_LIGHT_DIRECTIONAL
-#endif
-
-#if defined(_MAIN_LIGHT_SPOT_SHADOW) || defined(_MAIN_LIGHT_SPOT_SHADOW_SOFT)
-#define _MAIN_LIGHT_SPOT
-#endif
-
-// In case no shadow casting light we classify main light as directional
-#if !defined(_MAIN_LIGHT_DIRECTIONAL) && !defined(_MAIN_LIGHT_SPOT)
-#define _MAIN_LIGHT_DIRECTIONAL
-#endif
-
 #ifdef _NORMALMAP
     #define OUTPUT_NORMAL(IN, OUT) OutputTangentToWorld(IN.tangent, IN.normal, OUT.tangent, OUT.binormal, OUT.normal)
 #else
     return normalize(mul(normalTangent, tangentToWorld));
 }
 
-float4 ComputeScreenPos(float4 pos)
+// TODO: A similar function should be already available in SRP lib on master. Use that instead
+float4 ComputeScreenPos(float4 positionCS)
-    float4 o = pos * 0.5f;
+    float4 o = positionCS * 0.5f;
-    o.zw = pos.zw;
+    o.zw = positionCS.zw;
     return o;
 }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

     InitializeBRDFData(albedo, metallic, specular, smoothness, alpha, brdfData);
 
     Light mainLight = GetMainLight(inputData.positionWS);
-    mainLight.attenuation *= RealtimeShadowAttenuation(inputData.positionWS, inputData.shadowCoord);
+
+#ifdef _SHADOWS_ENABLED
+    mainLight.attenuation *= RealtimeShadowAttenuation(inputData.shadowCoord);
+#endif
 
     MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, half4(0, 0, 0, 0));
     half3 color = GlobalIllumination(brdfData, inputData.bakedGI, occlusion, inputData.normalWS, inputData.viewDirectionWS);
 half4 LightweightFragmentBlinnPhong(InputData inputData, half3 diffuse, half4 specularGloss, half shininess, half3 emission, half alpha)
 {
     Light mainLight = GetMainLight(inputData.positionWS);
-    mainLight.attenuation *= RealtimeShadowAttenuation(inputData.positionWS, inputData.shadowCoord);
+#ifdef _SHADOWS_ENABLED
+    mainLight.attenuation *= RealtimeShadowAttenuation(inputData.shadowCoord);
+#endif
     MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, half4(0, 0, 0, 0));
 
     half3 attenuatedLightColor = mainLight.color * mainLight.attenuation;

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

     half fogFactor = ComputeFogFactor(o.clipPos.z);
     o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
 
-#if defined(_SHADOWS_ENABLED)
-    #if defined(_SHADOWS_CASCADE) //Assume screen space shadows when cascades enabled
+#ifdef _SHADOWS_ENABLED
-    #else
-    o.shadowCoord = ComputeShadowCoord(o.posWS.xyz);
-    #endif
 #endif
 
     return o;

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Shadows.hlsl

 
 #define MAX_SHADOW_CASCADES 4
 
-///////////////////////////////////////////////////////////////////////////////
-// Light Classification shadow defines                                       //
-//                                                                           //
-// In order to reduce shader variations main light keywords were combined    //
-// here we define shadow keywords.                                           //
-///////////////////////////////////////////////////////////////////////////////
-#if defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW) || defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE) || defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT) || defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT) || defined(_MAIN_LIGHT_SPOT_SHADOW) || defined(_MAIN_LIGHT_SPOT_SHADOW_SOFT)
-    #define _SHADOWS_ENABLED
-#endif
-
-#if defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT) || defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT) || defined(_MAIN_LIGHT_SPOT_SHADOW_SOFT)
-    #define _SHADOWS_SOFT
-#endif
-
-#if defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE) || defined(_MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT)
-    #define _SHADOWS_CASCADE
-#endif
-
-#if defined(_MAIN_LIGHT_SPOT_SHADOW) || defined(_MAIN_LIGHT_SPOT_SHADOW_SOFT)
-    #define _SHADOWS_PERSPECTIVE
-#endif
-
 TEXTURE2D(_ScreenSpaceShadowMap);
 SAMPLER(sampler_ScreenSpaceShadowMap);
 
 float4      _FrustumCorners[4];
 CBUFFER_END
 
+half GetShadowStrength()
+{
+    return _ShadowData.x;
+}
+
-    shadowCoord.xyz = shadowCoord.xyz / shadowCoord.w;
-    return SAMPLE_TEXTURE2D(_ScreenSpaceShadowMap, sampler_ScreenSpaceShadowMap, shadowCoord.xy).x;
+    shadowCoord.xy = shadowCoord.xy / shadowCoord.w;
+    half attenuation = SAMPLE_TEXTURE2D(_ScreenSpaceShadowMap, sampler_ScreenSpaceShadowMap, shadowCoord.xy).x;
+
+    // Apply shadow strength
+    return LerpWhiteTo(attenuation, GetShadowStrength());
-inline half SampleShadowmap(float4 shadowCoord)
+inline real SampleShadowmap(float4 shadowCoord)
-#if defined(_SHADOWS_PERSPECTIVE)
-#endif
-    half attenuation;
+    real attenuation;
-        half4 attenuation4;
+        real4 attenuation4;
         attenuation4.x = SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, shadowCoord.xyz + _ShadowOffset0.xyz);
         attenuation4.y = SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, shadowCoord.xyz + _ShadowOffset1.xyz);
         attenuation4.z = SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, shadowCoord.xyz + _ShadowOffset2.xyz);
     attenuation = SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, shadowCoord.xyz);
 #endif
 
-    // Apply shadow strength
-    attenuation = LerpWhiteTo(attenuation, _ShadowData.x);
-
     // Shadow coords that fall out of the light frustum volume must always return attenuation 1.0
     // TODO: We can set shadowmap sampler to clamptoborder when we don't have a shadow atlas and avoid xy coord bounds check
     return (shadowCoord.x <= 0 || shadowCoord.x >= 1 || shadowCoord.y <= 0 || shadowCoord.y >= 1 || shadowCoord.z >= 1) ? 1.0 : attenuation;
     return mul(_WorldToShadow[0], float4(positionWS, 1.0));
 }
 
-half GetShadowStrength()
-{
-    return _ShadowData.x;
-}
-
-half RealtimeShadowAttenuation(float3 positionWS)
+half RealtimeShadowAttenuation(float4 shadowCoord)
-#if !defined(_SHADOWS_ENABLED)
-    return 1.0;
-#endif
-
-    float4 shadowCoord = ComputeShadowCoord(positionWS);
-    return SampleShadowmap(shadowCoord);
-}
-
-half RealtimeShadowAttenuation(float3 positionWS, float4 shadowCoord)
-{
-#if !defined(_SHADOWS_ENABLED)
-    return 1.0;
-#endif
-
-#ifdef _SHADOWS_CASCADE //Assume screen space shadows when cascades are enabled
-#else
-    return SampleShadowmap(shadowCoord);
-#endif
 }
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader

 {
     SubShader
     {
-        Tags {}
+        Tags{ "RenderPipeline" = "LightweightPipeline" }
 
         HLSLINCLUDE
 
             ZTest Always ZWrite Off
 
             HLSLPROGRAM
-
-            // -------------------------------------
-            // We have no good approach exposed to skip shader variants, e.g, ideally we would like to skip _CASCADE for all puctual lights
-            // Lightweight combines light classification and shadows keywords to reduce shader variants.
-            // Lightweight shader library declares defines based on these keywords to avoid having to check them in the shaders
-            // Core.hlsl defines _MAIN_LIGHT_DIRECTIONAL and _MAIN_LIGHT_SPOT (point lights can't be main light)
-            // Shadow.hlsl defines _SHADOWS_ENABLED, _SHADOWS_SOFT, _SHADOWS_CASCADE, _SHADOWS_PERSPECTIVE
-            #pragma multi_compile _ _MAIN_LIGHT_DIRECTIONAL_SHADOW _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE _MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT _MAIN_LIGHT_SPOT_SHADOW _MAIN_LIGHT_SPOT_SHADOW_SOFT
+            #pragma multi_compile _ _SHADOWS_SOFT
+            #pragma multi_compile _ _SHADOWS_CASCADE
             
             #pragma vertex   Vertex
             #pragma fragment Fragment
-}
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

 
             // -------------------------------------
             // Lightweight Pipeline keywords
-            // We have no good approach exposed to skip shader variants, e.g, ideally we would like to skip _CASCADE for all puctual lights
-            // Lightweight combines light classification and shadows keywords to reduce shader variants.
-            // Lightweight shader library declares defines based on these keywords to avoid having to check them in the shaders
-            // Core.hlsl defines _MAIN_LIGHT_DIRECTIONAL and _MAIN_LIGHT_SPOT (point lights can't be main light)
-            // Shadow.hlsl defines _SHADOWS_ENABLED, _SHADOWS_SOFT, _SHADOWS_CASCADE, _SHADOWS_PERSPECTIVE
-            #pragma multi_compile _ _MAIN_LIGHT_DIRECTIONAL_SHADOW _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE _MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT _MAIN_LIGHT_SPOT_SHADOW _MAIN_LIGHT_SPOT_SHADOW_SOFT
+            #pragma multi_compile _MAIN_LIGHT_DIRECTIONAL _MAIN_LIGHT_SPOT
+            #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _MAIN_LIGHT_COOKIE
             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

 
             // -------------------------------------
             // Lightweight Pipeline keywords
-            // We have no good approach exposed to skip shader variants, e.g, ideally we would like to skip _CASCADE for all puctual lights
-            // Lightweight combines light classification and shadows keywords to reduce shader variants.
-            // Lightweight shader library declares defines based on these keywords to avoid having to check them in the shaders
-            // Core.hlsl defines _MAIN_LIGHT_DIRECTIONAL and _MAIN_LIGHT_SPOT (point lights can't be main light)
-            // Shadow.hlsl defines _SHADOWS_ENABLED, _SHADOWS_SOFT, _SHADOWS_CASCADE, _SHADOWS_PERSPECTIVE
-            #pragma multi_compile _ _MAIN_LIGHT_DIRECTIONAL_SHADOW _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE _MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT _MAIN_LIGHT_SPOT_SHADOW _MAIN_LIGHT_SPOT_SHADOW_SOFT
+            #pragma multi_compile _MAIN_LIGHT_DIRECTIONAL _MAIN_LIGHT_SPOT
+            #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _MAIN_LIGHT_COOKIE
             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardTerrain.shader

 
             // -------------------------------------
             // Lightweight Pipeline keywords
-            // We have no good approach exposed to skip shader variants, e.g, ideally we would like to skip _CASCADE for all puctual lights
-            // Lightweight combines light classification and shadows keywords to reduce shader variants.
-            // Lightweight shader library declares defines based on these keywords to avoid having to check them in the shaders
-            // Core.hlsl defines _MAIN_LIGHT_DIRECTIONAL and _MAIN_LIGHT_SPOT (point lights can't be main light)
-            // Shadow.hlsl defines _SHADOWS_ENABLED, _SHADOWS_SOFT, _SHADOWS_CASCADE, _SHADOWS_PERSPECTIVE
-            #pragma multi_compile _ _MAIN_LIGHT_DIRECTIONAL_SHADOW _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE _MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT _MAIN_LIGHT_SPOT_SHADOW _MAIN_LIGHT_SPOT_SHADOW_SOFT
+            #pragma multi_compile _MAIN_LIGHT_DIRECTIONAL _MAIN_LIGHT_SPOT
+            #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _MAIN_LIGHT_COOKIE
             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS