Merge pull request #1243 from Unity-Technologies/lw/shader-keywords-stripping

Lw/shader keywords stripping

ScriptableRenderPipeline/Core/CoreRP/Utilities/CoreUtils.cs

             };
             return mat;
         }
+        public static bool HasFlag<T>(T mask, T flag) where T : IConvertible
+        {
+            return (mask.ToUInt32(null) & flag.ToUInt32(null)) != 0;
+        }
 
         public static void SetKeyword(CommandBuffer cmd, string keyword, bool state)
         {

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineAsset.cs

 
     public enum ShadowResolution
     {
+        _256 = 256,
         _512 = 512,
         _1024 = 1024,
         _2048 = 2048,
         UnityBuiltinDefault
     }
 
-    public class LightweightPipelineAsset : RenderPipelineAsset
+    public class LightweightPipelineAsset : RenderPipelineAsset, ISerializationCallbackReceiver
-        private const int PACKAGE_MANAGER_PATH_INDEX = 1;
-        [SerializeField] private int kAssetVersion = 2;
+        [SerializeField] private int kAssetVersion = 3;
         [SerializeField] private int m_MaxPixelLights = 4;
         [SerializeField] private bool m_SupportsVertexLight = false;
         [SerializeField] private bool m_RequireDepthTexture = false;
         [SerializeField] private bool m_SupportsHDR = false;
         [SerializeField] private MSAAQuality m_MSAA = MSAAQuality._4x;
         [SerializeField] private float m_RenderScale = 1.0f;
-        [SerializeField] private ShadowType m_ShadowType = ShadowType.HARD_SHADOWS;
+
+        [SerializeField] private bool m_DirectionalShadowsSupported = true;
+        [SerializeField] private bool m_LocalShadowsSupported = true;
+        [SerializeField] private ShadowResolution m_LocalShadowsAtlasResolution = ShadowResolution._512;
+        [SerializeField] private bool m_SoftShadowsSupported = false;
+        // Deprecated
+        [SerializeField] private ShadowType m_ShadowType = ShadowType.HARD_SHADOWS;
 
 #if UNITY_EDITOR
         [NonSerialized]
 #endif
         }
 
-        public bool AreShadowsEnabled()
-        {
-            return ShadowSetting != ShadowType.NO_SHADOW;
-        }
-
-        public float GetAssetVersion()
+        public int GetAssetVersion()
         {
             return kAssetVersion;
         }
         public bool RequireDepthTexture
         {
             get { return m_RequireDepthTexture; }
-            set { m_RequireDepthTexture = value; }
         }
 
         public bool RequireSoftParticles
         public bool RequireOpaqueTexture
         {
             get { return m_RequireOpaqueTexture; }
-            set { m_RequireOpaqueTexture = value; }
-            set { m_OpaqueDownsampling = value; }
         }
 
         public bool SupportsHDR
             set { m_RenderScale = value; }
         }
 
-        public ShadowType ShadowSetting
+        public bool SupportsDirectionalShadows
-            get { return m_ShadowType; }
-            private set { m_ShadowType = value; }
+            get { return m_DirectionalShadowsSupported; }
-        public int ShadowAtlasResolution
+        public int DirectionalShadowAtlasResolution
-            private set { m_ShadowAtlasResolution = (ShadowResolution)value; }
-            private set { m_ShadowDistance = value; }
+            set { m_ShadowDistance = value; }
         }
 
         public int CascadeCount
         public float Cascade2Split
         {
             get { return m_Cascade2Split; }
-            private set { m_Cascade2Split = value; }
-            private set { m_Cascade4Split = value; }
+        }
+
+        public bool SupportsLocalShadows
+        {
+            get { return m_LocalShadowsSupported; }
+        }
+
+        public int LocalShadowAtlasResolution
+        {
+            get { return (int)m_LocalShadowsAtlasResolution; }
+        }
+        public bool SupportsSoftShadows
+        {
+            get { return m_SoftShadowsSupported; }
         }
 
         public override Material GetDefaultMaterial()
         public Shader SamplingShader
         {
             get { return resources != null ? resources.SamplingShader : null; }
+        }
+
+        public void OnBeforeSerialize()
+        {
+        }
+
+        public void OnAfterDeserialize()
+        {
+            if (kAssetVersion < 3)
+            {
+                kAssetVersion = 3;
+                m_SoftShadowsSupported = (m_ShadowType == ShadowType.SOFT_SHADOWS);
+            }
         }
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/LightweightAssetEditor.cs

             public static GUIContent requireOpaqueTexture = new GUIContent("Opaque Texture", "If enabled the pipeline will copy the screen to texture after opaque objects are drawn. For transparent objects this can be bound in shaders as _CameraOpaqueTexture.");
 
             public static GUIContent opaqueDownsampling = new GUIContent("Opaque Downsampling", "The downsampling method that is used for the opaque texture");
+            public static GUIContent hdrContent = new GUIContent("HDR", "Controls the global HDR settings.");
+            public static GUIContent msaaContent = new GUIContent("Anti Aliasing (MSAA)", "Controls the global anti aliasing settings.");
-            public static GUIContent shadowType = new GUIContent("Type",
-                    "Global shadow settings. Options are NO_SHADOW, HARD_SHADOWS and SOFT_SHADOWS.");
+
+            public static GUIContent supportsSoftShadows = new GUIContent("Soft Shadows", "If enabled pipeline will perform shadow filtering. Otherwise all lights that cast shadows will fallback to perform a single shadow sample.");
+            public static GUIContent supportsDirectionalShadows = new GUIContent("Directional Shadows", "If enabled shadows will be supported for directional lights.");
-            public static GUIContent shadowDistante = new GUIContent("Distance", "Max shadow rendering distance.");
+            public static GUIContent shadowDistance = new GUIContent("Distance", "Max shadow rendering distance.");
-            public static GUIContent shadowAtlasResolution = new GUIContent("Shadowmap Resolution",
-                    "Resolution of shadow map texture. If cascades are enabled, cascades will be packed into an atlas and this setting controls the max shadows atlas resolution.");
+            public static GUIContent directionalShadowAtlasResolution = new GUIContent("Atlas Resolution",
+                    "Resolution of the directional shadow map texture. If cascades are enabled, cascades will be packed into an atlas and this setting controls the max shadows atlas resolution.");
 
             public static GUIContent shadowCascades = new GUIContent("Cascades",
                     "Number of cascades used in directional lights shadows");
 
-            public static GUIContent hdrContent = new GUIContent("HDR", "Controls the global HDR settings.");
-            public static GUIContent msaaContent = new GUIContent("Anti Aliasing (MSAA)", "Controls the global anti aliasing settings.");
+            public static GUIContent supportsLocalShadows = new GUIContent("Local Shadows", "If enabled shadows will be supported for spot lights.");
+
+            public static GUIContent localShadowsAtlasResolution = new GUIContent("Atlas Resolution",
+                    "All local lights are packed into a single atlas. This setting controls the atlas size.");
-            public static string[] shadowTypeOptions = {"No Shadows", "Hard Shadows", "Hard and Soft Shadows"};
             public static string[] shadowCascadeOptions = {"No Cascades", "Two Cascades", "Four Cascades"};
             public static string[] opaqueDownsamplingOptions = {"None", "2x (Bilinear)", "4x (Box)", "4x (Bilinear)"};
         }
         private SerializedProperty m_RequireSoftParticlesProp;
         private SerializedProperty m_RequireOpaqueTextureProp;
         private SerializedProperty m_OpaqueDownsamplingProp;
-        private SerializedProperty m_ShadowTypeProp;
+        private SerializedProperty m_HDR;
+        private SerializedProperty m_MSAA;
+
+        private SerializedProperty m_SoftShadowsSupportedProp;
+        private SerializedProperty m_DirectionalShadowsSupportedProp;
-        private SerializedProperty m_ShadowAtlasResolutionProp;
+        private SerializedProperty m_DirectionalShadowAtlasResolutionProp;
-        private SerializedProperty m_HDR;
-        private SerializedProperty m_MSAA;
+        private SerializedProperty m_LocalShadowSupportedProp;
+        private SerializedProperty m_LocalShadowsAtlasResolutionProp;
 
         void OnEnable()
         {
             m_RequireSoftParticlesProp = serializedObject.FindProperty("m_RequireSoftParticles");
             m_RequireOpaqueTextureProp = serializedObject.FindProperty("m_RequireOpaqueTexture");
             m_OpaqueDownsamplingProp = serializedObject.FindProperty("m_OpaqueDownsampling");
-            m_ShadowTypeProp = serializedObject.FindProperty("m_ShadowType");
+            m_HDR = serializedObject.FindProperty("m_SupportsHDR");
+            m_MSAA = serializedObject.FindProperty("m_MSAA");
+
+            m_DirectionalShadowsSupportedProp = serializedObject.FindProperty("m_DirectionalShadowsSupported");
-            m_ShadowAtlasResolutionProp = serializedObject.FindProperty("m_ShadowAtlasResolution");
+            m_DirectionalShadowAtlasResolutionProp = serializedObject.FindProperty("m_ShadowAtlasResolution");
-            m_HDR = serializedObject.FindProperty("m_SupportsHDR");
-            m_MSAA = serializedObject.FindProperty("m_MSAA");
+            m_LocalShadowSupportedProp = serializedObject.FindProperty("m_LocalShadowsSupported");
+            m_LocalShadowsAtlasResolutionProp = serializedObject.FindProperty("m_LocalShadowsAtlasResolution");
+            m_SoftShadowsSupportedProp = serializedObject.FindProperty("m_SoftShadowsSupported");
 
             m_ShowSoftParticles.valueChanged.AddListener(Repaint);
             m_ShowSoftParticles.value = m_RequireSoftParticlesProp.boolValue;
                     CoreEditorUtils.DrawPopup(content, prop, options);
         }
 
-        public override void OnInspectorGUI()
+        void DrawRenderingSettings()
-            serializedObject.Update();
-
-            UpdateAnimationValues();
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(Styles.renderingLabel, EditorStyles.boldLabel);
             EditorGUI.indentLevel++;
             EditorGUI.indentLevel--;
             EditorGUILayout.Space();
             EditorGUILayout.Space();
+        }
+        void DrawShadowSettings()
+        {
-            CoreEditorUtils.DrawPopup(Styles.shadowType, m_ShadowTypeProp, Styles.shadowTypeOptions);
-            EditorGUILayout.PropertyField(m_ShadowAtlasResolutionProp, Styles.shadowAtlasResolution);
-            m_ShadowDistanceProp.floatValue = Mathf.Max(0.0f, EditorGUILayout.FloatField(Styles.shadowDistante, m_ShadowDistanceProp.floatValue));
-            CoreEditorUtils.DrawPopup(Styles.shadowCascades, m_ShadowCascadesProp, Styles.shadowCascadeOptions);
+
+            EditorGUILayout.PropertyField(m_DirectionalShadowsSupportedProp, Styles.supportsDirectionalShadows);
+            bool directionalShadows = m_DirectionalShadowsSupportedProp.boolValue;
+            if (directionalShadows)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_DirectionalShadowAtlasResolutionProp, Styles.directionalShadowAtlasResolution);
+                m_ShadowDistanceProp.floatValue = Mathf.Max(0.0f,
+                        EditorGUILayout.FloatField(Styles.shadowDistance, m_ShadowDistanceProp.floatValue));
+                CoreEditorUtils.DrawPopup(Styles.shadowCascades, m_ShadowCascadesProp, Styles.shadowCascadeOptions);
+
+                ShadowCascades cascades = (ShadowCascades)m_ShadowCascadesProp.intValue;
+                if (cascades == ShadowCascades.FOUR_CASCADES)
+                    CoreEditorUtils.DrawCascadeSplitGUI<Vector3>(ref m_ShadowCascade4SplitProp);
+                else if (cascades == ShadowCascades.TWO_CASCADES)
+                    CoreEditorUtils.DrawCascadeSplitGUI<float>(ref m_ShadowCascade2SplitProp);
+
+                EditorGUI.indentLevel--;
+                EditorGUILayout.Space();
+            }
+
+            EditorGUILayout.PropertyField(m_LocalShadowSupportedProp, Styles.supportsLocalShadows);
+            bool localShadows = m_LocalShadowSupportedProp.boolValue;
+            if (localShadows)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_LocalShadowsAtlasResolutionProp, Styles.localShadowsAtlasResolution);
+                EditorGUI.indentLevel--;
+                EditorGUILayout.Space();
+            }
-            ShadowCascades cascades = (ShadowCascades)m_ShadowCascadesProp.intValue;
-            if (cascades == ShadowCascades.FOUR_CASCADES)
-                CoreEditorUtils.DrawCascadeSplitGUI<Vector3>(ref m_ShadowCascade4SplitProp);
-            else if (cascades == ShadowCascades.TWO_CASCADES)
-                CoreEditorUtils.DrawCascadeSplitGUI<float>(ref m_ShadowCascade2SplitProp);
+            if (directionalShadows || localShadows)
+                EditorGUILayout.PropertyField(m_SoftShadowsSupportedProp, Styles.supportsSoftShadows);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            UpdateAnimationValues();
+            DrawRenderingSettings();
+            DrawShadowSettings();
 
             serializedObject.ApplyModifiedProperties();
         }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRExtraPasses.template

 Pass
 {
+    Name "ShadowCaster"
 	Tags{"LightMode" = "ShadowCaster"}
 
 	ZWrite On
 
 Pass
 {
+    Name "DepthOnly"
 	Tags{"LightMode" = "DepthOnly"}
 
 	ZWrite On
 // This pass it not used during regular rendering, only for lightmap baking.
 Pass
 {
+    Name "Meta"
 	Tags{"LightMode" = "Meta"}
 
 	Cull Off

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRForwardPass.template

 Pass
 {
+    Name "StandardLit"
 	Tags{"LightMode" = "LightweightForward"}
 	${Tags}
 	${Blending}
 	#pragma multi_compile _ _VERTEX_LIGHTS
 	#pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
 	#pragma multi_compile _ _SHADOWS_ENABLED
+    #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+    #pragma multi_compile _ _SHADOWS_SOFT
 
 	// -------------------------------------
 	// Unity defined keywords

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitExtraPasses.template

 
 Pass
 {
+    Name "DepthOnly"
 	Tags{"LightMode" = "DepthOnly"}
 
 	ZWrite On

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitPass.template

 Pass
 {
+    Name "StandardUnlit"
 	Tags{"LightMode" = "LightweightForward"}
 	${Tags}
 	${Blending}

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

         public static int opaque;
     }
 
-    public class LightweightPipeline : RenderPipeline
+    public partial class LightweightPipeline : RenderPipeline
     {
         private readonly LightweightPipelineAsset m_Asset;
 
             m_Asset = asset;
 
             SetRenderingFeatures();
+            SetPipelineCapabilities(asset);
 
             PerFrameBuffer._GlossyEnvironmentColor = Shader.PropertyToID("_GlossyEnvironmentColor");
             PerFrameBuffer._SubtractiveShadowColor = Shader.PropertyToID("_SubtractiveShadowColor");
         {
             var opaqueScaler = m_OpaqueScalerValues[(int)m_Asset.OpaqueDownsampling];
             RenderTextureDescriptor opaqueDesc = CreateRTDesc(frameRenderingConfiguration, opaqueScaler);
-            
+
-            switch(m_Asset.OpaqueDownsampling)
+            switch (m_Asset.OpaqueDownsampling)
             {
                 case Downsampling.None:
                     cmd.Blit(m_CurrCameraColorRT, CameraRenderTargetID.opaque);
 
         private void SetShaderKeywords(CommandBuffer cmd, ref LightData lightData)
         {
-            List<VisibleLight> visibleLights = lightData.visibleLights;
-            int mainLightIndex = lightData.mainLightIndex;
-
-            bool shadowsEnabled = m_ShadowPass.HasDirectionalShadowmap || m_ShadowPass.HasLocalLightsShadowmap;
-            CoreUtils.SetKeyword(cmd, "_SHADOWS_ENABLED", shadowsEnabled);
+            CoreUtils.SetKeyword(cmd, LightweightKeywords.AdditionalLightsText, lightData.totalAdditionalLightsCount > 0);
+            CoreUtils.SetKeyword(cmd, LightweightKeywords.MixedLightingSubtractiveText, m_MixedLightingSetup == MixedLightingSetup.Subtractive);
+            CoreUtils.SetKeyword(cmd, LightweightKeywords.VertexLightsText, vertexLightsCount > 0);
-            // TODO: Currently we are shading same keyword for directional and local lights
-            // When we have ability to strip keywords we can use the one below instead
-            //CoreUtils.SetKeyword(cmd, "_SHADOWS_ENABLED", m_ShadowPass.HasDirectionalShadowmap);
-            //CoreUtils.SetKeyword(cmd, "_LOCAL_SHADOWS_ENABLED", m_ShadowPass.HasLocalLightsShadowmap);
+            // TODO: We have to discuss cookie approach on LWRP.
+            // CoreUtils.SetKeyword(cmd, LightweightKeywords.MainLightCookieText, mainLightIndex != -1 && LightweightUtils.IsSupportedCookieType(visibleLights[mainLightIndex].lightType) && visibleLights[mainLightIndex].light.cookie != null);
-            //TIM: Not used in shader for V1 to reduce keywords
-            CoreUtils.SetKeyword(cmd, "_MAIN_LIGHT_COOKIE", mainLightIndex != -1 && LightweightUtils.IsSupportedCookieType(visibleLights[mainLightIndex].lightType) && visibleLights[mainLightIndex].light.cookie != null);
+            bool anyShadowsEnabled = m_ShadowPass.IsDirectionalShadowsEnabled || m_ShadowPass.IsLocalShadowsEnabled;
+            CoreUtils.SetKeyword(cmd, LightweightKeywords.DirectionalShadowsText, m_ShadowPass.DirectionalShadowsRendered);
+            CoreUtils.SetKeyword(cmd, LightweightKeywords.LocalShadowsText, m_ShadowPass.LocalShadowsRendered);
+            CoreUtils.SetKeyword(cmd, LightweightKeywords.SoftShadowsText, m_ShadowPass.IsSoftShadowsEnabled && anyShadowsEnabled);
-            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);
+            // TODO: Remove this. legacy particles support will be removed from Unity in 2018.3. This should be a shader_feature instead with prop exposed in the Standard particles shader.
             CoreUtils.SetKeyword(cmd, "SOFTPARTICLES_ON", m_RequireDepthTexture && m_Asset.RequireSoftParticles);
         }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightShadowPass.cs

     [Serializable]
     public class ShadowSettings
     {
-        public LightShadows directionalShadowQuality;
+        public bool supportsDirectionalShadows;
-        public LightShadows localLightsShadowQuality;
+        public float maxShadowDistance;
+        public int directionalLightCascadeCount;
+        public Vector3 directionalLightCascades;
+        public bool supportsLocalShadows;
+        public bool supportsSoftShadows;
-        public float maxShadowDistance;
-        public int directionalLightCascadeCount;
-        public Vector3 directionalLightCascades;
-
         public RenderTextureFormat shadowmapTextureFormat;
         public RenderTextureFormat screenspaceShadowmapTextureFormat;
 
                 if (defaultShadowSettings == null)
                 {
                     defaultShadowSettings = new ShadowSettings();
-                    defaultShadowSettings.directionalShadowQuality = LightShadows.None;
+                    defaultShadowSettings.supportsDirectionalShadows = true;
-                    defaultShadowSettings.localLightsShadowQuality = LightShadows.None;
+                    defaultShadowSettings.directionalLightCascadeCount = 1;
+                    defaultShadowSettings.directionalLightCascades = new Vector3(0.067f, 0.2f, 0.467f);
+                    defaultShadowSettings.supportsLocalShadows = true;
-                    defaultShadowSettings.directionalLightCascadeCount = 1;
-                    defaultShadowSettings.directionalLightCascades = new Vector3(0.05F, 0.2F, 0.3F);
+                    defaultShadowSettings.supportsSoftShadows = false;
                 }
                 return defaultShadowSettings;
             }
 
     public class LightweightShadowPass
     {
-        public bool IsDirectionalShadowsEnabled { get { return m_ShadowSettings.directionalShadowQuality != LightShadows.None; } }
-        public bool IsLocalShadowsEnabled { get { return m_ShadowSettings.localLightsShadowQuality != LightShadows.None; }}
+        public bool IsDirectionalShadowsEnabled { get { return m_ShadowSettings.supportsDirectionalShadows; } }
+        public bool IsLocalShadowsEnabled { get { return m_ShadowSettings.supportsLocalShadows; } }
-        public bool HasDirectionalShadowmap { get { return m_DirectionalShadowmapQuality != LightShadows.None; } }
-        public bool HasLocalLightsShadowmap { get { return m_LocalShadowmapQuality != LightShadows.None; } }
+        public bool DirectionalShadowsRendered { get { return m_DirectionalShadowmapQuality != LightShadows.None; } }
+        public bool LocalShadowsRendered { get { return m_LocalShadowmapQuality != LightShadows.None; } }
+        public bool IsSoftShadowsEnabled { get { return m_ShadowSettings.supportsSoftShadows; } }
 
         public float RenderingDistance { get { return m_ShadowSettings.maxShadowDistance; } }
 
         {
             // Until we can have keyword stripping forcing single cascade hard shadows on gles2
             bool supportsScreenSpaceShadows = SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
-            bool supportsLocalShadows = Application.isMobilePlatform || Application.platform == RuntimePlatform.WebGLPlayer;
-            m_ShadowSettings.directionalShadowQuality = (LightShadows)pipelineAsset.ShadowSetting;
-
-            m_ShadowSettings.screenSpace = supportsScreenSpaceShadows;
+            m_ShadowSettings.supportsDirectionalShadows = pipelineAsset.SupportsDirectionalShadows;
+            m_ShadowSettings.screenSpace = m_ShadowSettings.supportsDirectionalShadows && supportsScreenSpaceShadows;
-            m_ShadowSettings.directionalShadowAtlasWidth = pipelineAsset.ShadowAtlasResolution;
-            m_ShadowSettings.directionalShadowAtlasHeight = pipelineAsset.ShadowAtlasResolution;
+            m_ShadowSettings.directionalShadowAtlasWidth = pipelineAsset.DirectionalShadowAtlasResolution;
+            m_ShadowSettings.directionalShadowAtlasHeight = pipelineAsset.DirectionalShadowAtlasResolution;
-            m_ShadowSettings.shadowmapTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Shadowmap)
-                ? RenderTextureFormat.Shadowmap
-                : RenderTextureFormat.Depth;
-
-            m_ShadowSettings.screenspaceShadowmapTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.R8)
-                ? RenderTextureFormat.R8
-                : RenderTextureFormat.ARGB32;
 
             switch (m_ShadowSettings.directionalLightCascadeCount)
             {
                     break;
             }
 
-            // Until we can have keyword stripping we disable local light shadows on mobile
-            m_ShadowSettings.localLightsShadowQuality = (supportsLocalShadows) ? LightShadows.Hard : LightShadows.None;
+            m_ShadowSettings.supportsLocalShadows = pipelineAsset.SupportsLocalShadows;
+            m_ShadowSettings.localShadowAtlasWidth = m_ShadowSettings.localShadowAtlasHeight = pipelineAsset.LocalShadowAtlasResolution;
+            m_ShadowSettings.supportsSoftShadows = pipelineAsset.SupportsSoftShadows;
+
+            m_ShadowSettings.bufferBitCount = 16;
+
+            m_ShadowSettings.shadowmapTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Shadowmap)
+                ? RenderTextureFormat.Shadowmap
+                : RenderTextureFormat.Depth;
+
+            m_ShadowSettings.screenspaceShadowmapTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.R8)
+                ? RenderTextureFormat.R8
+                : RenderTextureFormat.ARGB32;
         }
 
         private void Clear()
 
         private void SetShadowCollectPassKeywords(CommandBuffer cmd)
         {
-            CoreUtils.SetKeyword(cmd, "_SHADOWS_SOFT", m_DirectionalShadowmapQuality == LightShadows.Soft);
-            CoreUtils.SetKeyword(cmd, "_SHADOWS_CASCADE", m_ShadowSettings.directionalLightCascadeCount > 1);
+            CoreUtils.SetKeyword(cmd, LightweightKeywords.SoftShadowsText, m_DirectionalShadowmapQuality == LightShadows.Soft);
+            CoreUtils.SetKeyword(cmd, LightweightKeywords.CascadeShadowsText, m_ShadowSettings.directionalLightCascadeCount > 1);
         }
 
         private bool RenderDirectionalCascadeShadowmap(ref CullResults cullResults, ref LightData lightData, ref ScriptableRenderContext context)
 
             if (success)
             {
-                m_DirectionalShadowmapQuality = (m_ShadowSettings.directionalShadowQuality != LightShadows.Soft) ? LightShadows.Hard : light.shadows;
+                m_DirectionalShadowmapQuality = (IsSoftShadowsEnabled) ? light.shadows : LightShadows.Hard;
 
                 // In order to avoid shader variants explosion we only do hard shadows when sampling shadowmap in the lit pass.
                 // GLES2 platform is forced to hard single cascade shadows.
 
             SetupLocalLightsShadowReceiverConstants(cmd, ref context);
 
-            m_LocalShadowmapQuality = (LightShadows)Math.Min(shadowSampling, (int)m_ShadowSettings.directionalShadowQuality);
+            m_LocalShadowmapQuality = (IsSoftShadowsEnabled) ? (LightShadows)shadowSampling : LightShadows.Hard;
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
         }

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Shadows.hlsl

         #else
             float fetchesWeights[9];
             float2 fetchesUV[9];
-            SampleShadow_ComputeSamples_Tent_5x5(_ShadowmapSize, shadowCoord.xy, fetchesWeights, fetchesUV);
+            SampleShadow_ComputeSamples_Tent_5x5(samplingData.shadowmapSize, shadowCoord.xy, fetchesWeights, fetchesUV);
 
             attenuation  = fetchesWeights[0] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[0].xy, shadowCoord.z));
             attenuation += fetchesWeights[1] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[1].xy, shadowCoord.z));
 
 half MainLightRealtimeShadowAttenuation(float4 shadowCoord)
 {
-#if defined(NO_SHADOWS) || !defined(_SHADOWS_ENABLED)
+#if !defined(_SHADOWS_ENABLED)
     return 1.0h;
 #elif SHADOWS_SCREEN
     return SampleScreenSpaceShadowMap(shadowCoord);
 
 half LocalLightRealtimeShadowAttenuation(int lightIndex, float3 positionWS)
 {
-// TODO: We can't add more keywords to standard shaders. For now we use
-// same _SHADOWS_ENABLED keywords for local lights. In the future we can use
-// _LOCAL_SHADOWS_ENABLED keyword
-// For now disabling local shadows on mobile until we can get the keyword stripping
-//#if defined(NO_SHADOWS) || !defined(_LOCAL_SHADOWS_ENABLED)
-#if defined(NO_SHADOWS) || !defined(_SHADOWS_ENABLED) || defined(SHADER_API_MOBILE)
+#if !defined(_LOCAL_SHADOWS_ENABLED)
     return 1.0h;
 #else
     float4 shadowCoord = mul(_LocalWorldToShadowAtlas[lightIndex], float4(positionWS, 1.0));

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightBlit.shader

 
         Pass
         {
+            Name "Default"
             Tags { "LightMode" = "LightweightForward"}
 
             ZTest Always ZWrite Off

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightCopyDepth.shader

 {
     SubShader
     {
-        Tags { "RenderType" = "Opaque" "RenderPipeline" = "LightiweightPipeline"}
+        Tags { "RenderType" = "Opaque" "RenderPipeline" = "LightweightPipeline"}
+            Name "Default"
             ZTest Always ZWrite On ColorMask 0
 
             HLSLPROGRAM

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightSampling.shader

         // 0 - Downsample - Box filtering
         Pass
         {
+            Name "Default"
             Tags { "LightMode" = "LightweightForward"}
 
             ZTest Always

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader

 
         Pass
         {
+            Name "Default"
             ZTest Always
             ZWrite Off
             Cull Off

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

         {
             // Lightmode matches the ShaderPassName set in LightweightPipeline.cs. SRPDefaultUnlit and passes with
             // no LightMode tag are also rendered by Lightweight Pipeline
+            Name "StandardLit"
             Tags{"LightMode" = "LightweightForward"}
 
             Blend[_SrcBlend][_DstBlend]
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             #pragma multi_compile _ _SHADOWS_ENABLED
-
-            // TODO: Enabled this when we have C# keyword stripping
-            //#pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _SHADOWS_SOFT
 
             // -------------------------------------
             // Unity defined keywords
 
         Pass
         {
+            Name "ShadowCaster"
             Tags{"LightMode" = "ShadowCaster"}
 
             ZWrite On
 
         Pass
         {
+            Name "DepthOnly"
             Tags{"LightMode" = "DepthOnly"}
 
             ZWrite On
         // This pass it not used during regular rendering, only for lightmap baking.
         Pass
         {
+            Name "Meta"
             Tags{"LightMode" = "Meta"}
 
             Cull Off

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticles.shader

 
         Pass
         {
+            Name "ParticlesLit"
             Tags {"LightMode" = "LightweightForward"}
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma shader_feature _EMISSION
             #pragma shader_feature _FADING_ON
             #pragma shader_feature _REQUIRE_UV2
-
-            #define NO_SHADOWS 1
 
             #include "LWRP/ShaderLibrary/ParticlesPBR.hlsl"
             #include "LWRP/ShaderLibrary/Lighting.hlsl"

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesSimpleLighting.shader

 
         Pass
         {
+            Name "ParticlesLit"
             Tags {"LightMode" = "LightweightForward"}
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma shader_feature _REQUIRE_UV2
 
             #define BUMP_SCALE_NOT_SUPPORTED 1
-            #define NO_SHADOWS 1
 
             #include "LWRP/ShaderLibrary/Particles.hlsl"
             #include "LWRP/ShaderLibrary/Lighting.hlsl"

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesUnlit.shader

 
             Pass
             {
+                Name "ParticlesUnlit"
                 HLSLPROGRAM
                 // Required to compile gles 2.0 with standard srp library
                 #pragma prefer_hlslcc gles
                     half3 diffuse = AlphaModulate(albedo.rgb, albedo.a);
                     half alpha = AlphaBlendAndTest(albedo.a, _Cutoff);
                     half3 emission = SampleEmission(IN, _EmissionColor.rgb, TEXTURE2D_PARAM(_EmissionMap, sampler_EmissionMap));
-                    
+
                     half3 result = diffuse + emission;
                     half fogFactor = IN.posWS.w;
                     ApplyFogColor(result, half3(0, 0, 0), fogFactor);

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

 
         Pass
         {
+            Name "StandardLit"
             Tags { "LightMode" = "LightweightForward" }
 
             // Use same blending / depth states as Standard shader
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             #pragma multi_compile _ _SHADOWS_ENABLED
-
-            // TODO: Enabled this when we have C# keyword stripping
-            //#pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _SHADOWS_SOFT
 
             // -------------------------------------
             // Unity defined keywords
 
         Pass
         {
+            Name "ShadowCaster"
             Tags{"LightMode" = "ShadowCaster"}
 
             ZWrite On
 
         Pass
         {
+            Name "DepthOnly"
             Tags{"LightMode" = "DepthOnly"}
 
             ZWrite On
         // This pass it not used during regular rendering, only for lightmap baking.
         Pass
         {
+            Name "Meta"
             Tags{ "LightMode" = "Meta" }
 
             Cull Off

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardUnlit.shader

 
         Pass
         {
+            Name "StandardUnlit"
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/Terrain/LightweightStandardTerrain.shader

 
         Pass
         {
+            Name "TerrainLit"
             Tags { "LightMode" = "LightweightForward" }
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             #pragma multi_compile _ _SHADOWS_ENABLED
+            #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _SHADOWS_SOFT
 
             // -------------------------------------
             // Unity defined keywords
 
             #pragma multi_compile __ _TERRAIN_NORMAL_MAP
-            
+
             #include "LWRP/ShaderLibrary/Terrain/InputSurfaceTerrain.hlsl"
             #include "LWRP/ShaderLibrary/Terrain/LightweightPassLitTerrain.hlsl"
 
         Pass
         {
+            Name "ShadowCaster"
             Tags{"LightMode" = "ShadowCaster"}
 
             ZWrite On
 
         Pass
         {
+            Name "DepthOnly"
             Tags{"LightMode" = "DepthOnly"}
 
             ZWrite On

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/Terrain/LightweightStandardTerrainAddPass.shader

 
         Pass
         {
+            Name "TerrainAddLit"
             Tags { "LightMode" = "LightweightForward" }
             Blend One One
             HLSLPROGRAM
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             #pragma multi_compile _ _SHADOWS_ENABLED
+            #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _SHADOWS_SOFT
 
             // -------------------------------------
             // Unity defined keywords
 
             #pragma multi_compile __ _TERRAIN_NORMAL_MAP
             #define TERRAIN_SPLAT_ADDPASS 1
-            
+
             #include "LWRP/ShaderLibrary/Terrain/InputSurfaceTerrain.hlsl"
             #include "LWRP/ShaderLibrary/Terrain/LightweightPassLitTerrain.hlsl"
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/Terrain/LightweightStandardTerrainBase.shader

         //  Forward pass. Shades all light in a single pass. GI + emission + Fog
         Pass
         {
+            Name "TerrainBaseLit"
             // Lightmode matches the ShaderPassName set in LightweightPipeline.cs. SRPDefaultUnlit and passes with
             // no LightMode tag are also rendered by Lightweight Pipeline
             Tags{"LightMode" = "LightweightForward"}
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             #pragma multi_compile _ _SHADOWS_ENABLED
-
-            // TODO: Enabled this when we have C# keyword stripping
-            //#pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _SHADOWS_SOFT
 
             // -------------------------------------
             // Unity defined keywords

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/Terrain/LightweightWavingGrass.shader

 // Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
 Shader "Hidden/TerrainEngine/Details/WavingDoublePass" // Has to override the internal shaders so named like this
 {
-    Properties 
+    Properties
     {
         _WavingTint ("Fade Color", Color) = (.7,.6,.5, 0)
         _MainTex ("Base (RGB) Alpha (A)", 2D) = "white" {}
-    SubShader 
+    SubShader
     {
         Tags {"Queue" = "Geometry+200" "RenderType" = "Grass" "IgnoreProjectors" = "True" "RenderPipeline" = "LightweightPipeline" }//"DisableBatching"="True"
         Cull Off
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             #pragma multi_compile _ _SHADOWS_ENABLED
-
-            // TODO: Enabled this when we have C# keyword stripping
-            //#pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _SHADOWS_SOFT
 
             // -------------------------------------
             // Unity defined keywords

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/Terrain/LightweightWavingGrassBillboard.shader

 // Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
 Shader "Hidden/TerrainEngine/Details/BillboardWavingDoublePass" // Has to override the internal shaders so named like this
 {
-    Properties 
+    Properties
     {
         _WavingTint ("Fade Color", Color) = (.7,.6,.5, 0)
         _MainTex ("Base (RGB) Alpha (A)", 2D) = "white" {}
-    SubShader 
+    SubShader
     {
         Tags {"Queue" = "Geometry+200" "RenderType" = "GrassBillBoard" "IgnoreProjectors" = "True" "RenderPipeline" = "LightweightPipeline" }//"DisableBatching"="True"
         Cull Off
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             #pragma multi_compile _ _SHADOWS_ENABLED
-
-            // TODO: Enabled this when we have C# keyword stripping
-            //#pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
+            #pragma multi_compile _ _SHADOWS_SOFT
 
             // -------------------------------------
             // Unity defined keywords

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

 --- !u!114 &11400000
 MonoBehaviour:
   m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
+  m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 0}
   m_Enabled: 1
   m_EditorClassIdentifier: 
-  kAssetVersion: 2
+  kAssetVersion: 3
+  m_RequireOpaqueTexture: 0
+  m_OpaqueDownsampling: 1
-  m_ShadowType: 1
+  m_DirectionalShadowsSupported: 1
-  m_ShadowNearPlaneOffset: 2
+  m_LocalShadowsSupported: 1
+  m_LocalShadowsAtlasResolution: 256
+  m_SoftShadowsSupported: 1
+  m_ShadowType: 0

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderPreprocessor.cs

+//#define LOG_VARIANTS
+//#define LOG_ONLY_LWRP_VARIANTS
+
+using System.Collections.Generic;
+using UnityEditor.Build;
+using UnityEditor.Rendering;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.LightweightPipeline;
+using UnityEngine.Rendering;
+
+namespace UnityEditor.Experimental.Rendering.LightweightPipeline
+{
+    public class ShaderPreprocessor : IPreprocessShaders
+    {
+#if LOG_VARIANTS
+        int m_TotalVariantsInputCount;
+        int m_TotalVariantsOutputCount;
+#endif
+
+        // Multiple callback may be implemented.
+        // The first one executed is the one where callbackOrder is returning the smallest number.
+        public int callbackOrder { get { return 0; } }
+
+        bool StripUnusedShader(PipelineCapabilities capabilities, Shader shader)
+        {
+            if (shader.name.Contains("Debug"))
+                return true;
+
+            if (shader.name.Contains("HDRenderPipeline"))
+                return true;
+
+            if (!CoreUtils.HasFlag(capabilities, PipelineCapabilities.DirectionalShadows) &&
+                shader.name.Contains("ScreenSpaceShadows"))
+                return true;
+
+            return false;
+        }
+
+        bool StripUnusedPass(PipelineCapabilities capabilities, ShaderSnippetData snippetData)
+        {
+            if (snippetData.passType == PassType.Meta)
+                return true;
+
+            if (snippetData.passType == PassType.ShadowCaster)
+                if (!CoreUtils.HasFlag(capabilities, PipelineCapabilities.DirectionalShadows) && !CoreUtils.HasFlag(capabilities, PipelineCapabilities.LocalShadows))
+                    return true;
+
+            return false;
+        }
+
+        bool StripUnusedVariant(PipelineCapabilities capabilities, ShaderCompilerData compilerData)
+        {
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.AdditionalLights) &&
+                !CoreUtils.HasFlag(capabilities, PipelineCapabilities.AdditionalLights))
+                return true;
+
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.VertexLights) &&
+                !CoreUtils.HasFlag(capabilities, PipelineCapabilities.VertexLights))
+                return true;
+
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.DirectionalShadows) &&
+                !CoreUtils.HasFlag(capabilities, PipelineCapabilities.DirectionalShadows))
+                return true;
+
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.LocalShadows) &&
+                !CoreUtils.HasFlag(capabilities, PipelineCapabilities.LocalShadows))
+                return true;
+
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.SoftShadows) &&
+                !CoreUtils.HasFlag(capabilities, PipelineCapabilities.SoftShadows))
+                return true;
+
+            return false;
+        }
+
+        bool StripUnused(PipelineCapabilities capabilities, Shader shader, ShaderSnippetData snippetData, ShaderCompilerData compilerData)
+        {
+            if (StripUnusedShader(capabilities, shader))
+                return true;
+
+            if (StripUnusedPass(capabilities, snippetData))
+                return true;
+
+            if (StripUnusedVariant(capabilities, compilerData))
+                return true;
+
+            return false;
+        }
+
+#if LOG_VARIANTS
+        void LogVariants(Shader shader, ShaderSnippetData snippetData, int prevVariantsCount, int currVariantsCount)
+        {
+#if LOG_ONLY_LWRP_VARIANTS
+            if (shader.name.Contains("LightweightPipeline"))
+#endif
+            {
+                float percentageCurrent = (float)currVariantsCount / (float)prevVariantsCount * 100f;
+                float percentageTotal = (float)m_TotalVariantsOutputCount / (float)m_TotalVariantsInputCount * 100f;
+
+                string result = string.Format("STRIPPING: {0} ({1} pass) ({2}) -" +
+                        " Remaining shader variants = {3}/{4} = {5}% - Total = {6}/{7} = {8}%",
+                        shader.name, snippetData.passName, snippetData.shaderType.ToString(), currVariantsCount,
+                        prevVariantsCount, percentageCurrent, m_TotalVariantsOutputCount, m_TotalVariantsInputCount,
+                        percentageTotal);
+                Debug.Log(result);
+            }
+        }
+
+#endif
+
+        public void OnProcessShader(Shader shader, ShaderSnippetData snippetData, IList<ShaderCompilerData> compilerDataList)
+        {
+            PipelineCapabilities capabilities = UnityEngine.Experimental.Rendering.LightweightPipeline.LightweightPipeline.GetPipelineCapabilities();
+            int prevVariantCount = compilerDataList.Count;
+
+            for (int i = 0; i < compilerDataList.Count; ++i)
+            {
+                if (StripUnused(capabilities, shader, snippetData, compilerDataList[i]))
+                {
+                    compilerDataList.RemoveAt(i);
+                    --i;
+                }
+            }
+
+#if LOG_VARIANTS
+            m_TotalVariantsInputCount += prevVariantCount;
+            m_TotalVariantsOutputCount += compilerDataList.Count;
+
+            LogVariants(shader, snippetData, prevVariantCount, compilerDataList.Count);
+#endif
+        }
+    }
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderPreprocessor.cs.meta

+fileFormatVersion: 2
+guid: 9f7bf504ded5bcb48835f194831914c8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipelineCore.cs

+using System;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.LightweightPipeline
+{
+    [Flags]
+    public enum PipelineCapabilities
+    {
+        AdditionalLights    = (1 << 0),
+        VertexLights        = (1 << 1),
+        DirectionalShadows  = (1 << 2),
+        LocalShadows        = (1 << 3),
+        SoftShadows         = (1 << 4),
+    }
+
+    public class LightweightKeywords
+    {
+        public static readonly string AdditionalLightsText = "_ADDITIONAL_LIGHTS";
+        public static readonly string VertexLightsText = "_VERTEX_LIGHTS";
+        public static readonly string MixedLightingSubtractiveText = "_MIXED_LIGHTING_SUBTRACTIVE";
+        public static readonly string MainLightCookieText = "_MAIN_LIGHT_COOKIE";
+        public static readonly string DirectionalShadowsText = "_SHADOWS_ENABLED";
+        public static readonly string LocalShadowsText = "_LOCAL_SHADOWS_ENABLED";
+        public static readonly string SoftShadowsText = "_SHADOWS_SOFT";
+        public static readonly string CascadeShadowsText = "_SHADOWS_CASCADE";
+
+        public static readonly ShaderKeyword AdditionalLights = new ShaderKeyword(AdditionalLightsText);
+        public static readonly ShaderKeyword VertexLights = new ShaderKeyword(VertexLightsText);
+        public static readonly ShaderKeyword MixedLightingSubtractive = new ShaderKeyword(MixedLightingSubtractiveText);
+        public static readonly ShaderKeyword MainLightCookie = new ShaderKeyword(MainLightCookieText);
+        public static readonly ShaderKeyword DirectionalShadows = new ShaderKeyword(DirectionalShadowsText);
+        public static readonly ShaderKeyword LocalShadows = new ShaderKeyword(LocalShadowsText);
+        public static readonly ShaderKeyword SoftShadows = new ShaderKeyword(SoftShadowsText);
+    }
+
+    public partial class LightweightPipeline
+    {
+        static PipelineCapabilities s_PipelineCapabilities;
+
+        public static PipelineCapabilities GetPipelineCapabilities()
+        {
+            return s_PipelineCapabilities;
+        }
+
+        static void SetPipelineCapabilities(LightweightPipelineAsset pipelineAsset)
+        {
+            s_PipelineCapabilities = 0U;
+
+            if (pipelineAsset.MaxPixelLights > 1 || pipelineAsset.SupportsVertexLight)
+                s_PipelineCapabilities |= PipelineCapabilities.AdditionalLights;
+
+            if (pipelineAsset.SupportsVertexLight)
+                s_PipelineCapabilities |= PipelineCapabilities.VertexLights;
+
+            if (pipelineAsset.SupportsDirectionalShadows)
+                s_PipelineCapabilities |= PipelineCapabilities.DirectionalShadows;
+
+            if (pipelineAsset.SupportsLocalShadows)
+                s_PipelineCapabilities |= PipelineCapabilities.LocalShadows;
+
+            bool anyShadows = pipelineAsset.SupportsDirectionalShadows || pipelineAsset.SupportsLocalShadows;
+            if (pipelineAsset.SupportsSoftShadows && anyShadows)
+                s_PipelineCapabilities |= PipelineCapabilities.SoftShadows;
+        }
+    }
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipelineCore.cs.meta

+fileFormatVersion: 2
+guid: d973de1eba2f6934e9c31429e8e40c09
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: