Merge remote-tracking branch 'origin/LWRP' into LW-DistortionPass

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineAsset.cs

         [SerializeField] private float m_RenderScale = 1.0f;
         [SerializeField] private ShadowType m_ShadowType = ShadowType.HARD_SHADOWS;
         [SerializeField] private ShadowResolution m_ShadowAtlasResolution = ShadowResolution._2048;
-        [SerializeField] private float m_ShadowNearPlaneOffset = 2.0f;
         [SerializeField] private float m_ShadowDistance = 50.0f;
         [SerializeField] private ShadowCascades m_ShadowCascades = ShadowCascades.FOUR_CASCADES;
         [SerializeField] private float m_Cascade2Split = 0.25f;
                 "LightweightAsset.asset", null, null);
         }
 
-
         //[MenuItem("Assets/Create/Rendering/Lightweight Pipeline Resources", priority = CoreUtils.assetCreateMenuPriority1)]
         static void CreateLightweightPipelineResources()
         {
             var instance = CreateInstance<LightweightPipelineEditorResources>();
             AssetDatabase.CreateAsset(instance, string.Format("Assets/{0}.asset", typeof(LightweightPipelineEditorResources).Name));
         }
-
 
         class CreateLightweightPipelineAsset : EndNameEditAction
         {
         private static T LoadResourceFile<T>() where T : ScriptableObject
         {
             T resourceAsset = null;
-            var guids = AssetDatabase.FindAssets(typeof(T).Name + " t:scriptableobject", new []{m_SearchPathProject});
+            var guids = AssetDatabase.FindAssets(typeof(T).Name + " t:scriptableobject", new[] {m_SearchPathProject});
             foreach (string guid in guids)
             {
                 string path = AssetDatabase.GUIDToAssetPath(guid);
         {
             get { return (int)m_ShadowAtlasResolution; }
             private set { m_ShadowAtlasResolution = (ShadowResolution)value; }
-        }
-
-        public float ShadowNearOffset
-        {
-            get { return m_ShadowNearPlaneOffset; }
-            private set { m_ShadowNearPlaneOffset = value; }
         }
 
         public float ShadowDistance

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/LightweightAssetEditor.cs

             public static GUIContent shadowType = new GUIContent("Type",
                     "Global shadow settings. Options are NO_SHADOW, HARD_SHADOWS and SOFT_SHADOWS.");
 
-            public static GUIContent shadowNearPlaneOffset = new GUIContent("Near Plane Offset",
-                    "Offset shadow near plane to account for large triangles being distorted by pancaking.");
-
             public static GUIContent shadowDistante = new GUIContent("Distance", "Max shadow rendering distance.");
 
             public static GUIContent shadowAtlasResolution = new GUIContent("Shadowmap Resolution",
         private SerializedProperty m_RequireOpaqueTextureProp;
         private SerializedProperty m_OpaqueDownsamplingProp;
         private SerializedProperty m_ShadowTypeProp;
-        private SerializedProperty m_ShadowNearPlaneOffsetProp;
         private SerializedProperty m_ShadowDistanceProp;
         private SerializedProperty m_ShadowAtlasResolutionProp;
         private SerializedProperty m_ShadowCascadesProp;
             m_RequireOpaqueTextureProp = serializedObject.FindProperty("m_RequireOpaqueTexture");
             m_OpaqueDownsamplingProp = serializedObject.FindProperty("m_OpaqueDownsampling");
             m_ShadowTypeProp = serializedObject.FindProperty("m_ShadowType");
-            m_ShadowNearPlaneOffsetProp = serializedObject.FindProperty("m_ShadowNearPlaneOffset");
             m_ShadowDistanceProp = serializedObject.FindProperty("m_ShadowDistance");
             m_ShadowAtlasResolutionProp = serializedObject.FindProperty("m_ShadowAtlasResolution");
             m_ShadowCascadesProp = serializedObject.FindProperty("m_ShadowCascades");
             EditorGUI.indentLevel++;
             CoreEditorUtils.DrawPopup(Styles.shadowType, m_ShadowTypeProp, Styles.shadowTypeOptions);
             EditorGUILayout.PropertyField(m_ShadowAtlasResolutionProp, Styles.shadowAtlasResolution);
-            EditorGUILayout.PropertyField(m_ShadowNearPlaneOffsetProp, Styles.shadowNearPlaneOffset);
             m_ShadowDistanceProp.floatValue = Mathf.Max(0.0f, EditorGUILayout.FloatField(Styles.shadowDistante, m_ShadowDistanceProp.floatValue));
             CoreEditorUtils.DrawPopup(Styles.shadowCascades, m_ShadowCascadesProp, Styles.shadowCascadeOptions);
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightConstantBuffer.cs

     {
         public static int _MainLightPosition;
         public static int _MainLightColor;
-        public static int _MainLightDistanceAttenuation;
-        public static int _MainLightSpotDir;
-        public static int _MainLightSpotAttenuation;
         public static int _MainLightCookie;
         public static int _WorldToLight;
 
         public static int _AdditionalLightDistanceAttenuation;
         public static int _AdditionalLightSpotDir;
         public static int _AdditionalLightSpotAttenuation;
+
+        public static int _LightIndexBuffer;
-    public static class ShadowConstantBuffer
+    public static class DirectionalShadowConstantBuffer
     {
         public static int _WorldToShadow;
         public static int _ShadowData;
         public static int _ShadowOffset2;
         public static int _ShadowOffset3;
         public static int _ShadowmapSize;
+    }
+
+    public static class LocalShadowConstantBuffer
+    {
+        public static int _LocalWorldToShadowAtlas;
+        public static int _LocalShadowStrength;
+        public static int _LocalShadowOffset0;
+        public static int _LocalShadowOffset1;
+        public static int _LocalShadowOffset2;
+        public static int _LocalShadowOffset3;
+        public static int _LocalShadowmapSize;
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Text;
 #if UNITY_EDITOR
 using UnityEditor.Experimental.Rendering.LightweightPipeline;
 #endif
 
 namespace UnityEngine.Experimental.Rendering.LightweightPipeline
 {
-    [Serializable]
-    public class ShadowSettings
-    {
-        public bool     enabled;
-        public bool     screenSpace;
-        public int      shadowAtlasWidth;
-        public int      shadowAtlasHeight;
-
-        public float    maxShadowDistance;
-        public int      directionalLightCascadeCount;
-        public Vector3  directionalLightCascades;
-        public float    directionalLightNearPlaneOffset;
-
-        public RenderTextureFormat shadowmapTextureFormat;
-        public RenderTextureFormat screenspaceShadowmapTextureFormat;
-
-        static ShadowSettings defaultShadowSettings = null;
-
-        public static ShadowSettings Default
-        {
-            get
-            {
-                if (defaultShadowSettings == null)
-                {
-                    defaultShadowSettings = new ShadowSettings();
-                    defaultShadowSettings.enabled = true;
-                    defaultShadowSettings.screenSpace = true;
-                    defaultShadowSettings.shadowAtlasHeight = defaultShadowSettings.shadowAtlasWidth = 4096;
-                    defaultShadowSettings.directionalLightCascadeCount = 1;
-                    defaultShadowSettings.directionalLightCascades = new Vector3(0.05F, 0.2F, 0.3F);
-                    defaultShadowSettings.directionalLightNearPlaneOffset = 5;
-                    defaultShadowSettings.maxShadowDistance = 1000.0F;
-                    defaultShadowSettings.shadowmapTextureFormat = RenderTextureFormat.Shadowmap;
-                    defaultShadowSettings.screenspaceShadowmapTextureFormat = RenderTextureFormat.R8;
-                }
-                return defaultShadowSettings;
-            }
-        }
-    }
-
-    public struct ShadowSliceData
-    {
-        public Matrix4x4    shadowTransform;
-        public int          atlasX;
-        public int          atlasY;
-        public int          shadowResolution;
-    }
-
-        public LightShadows shadowMapSampleType;
+        public List<VisibleLight> visibleLights;
+        public List<int> localLightIndices;
     }
 
     public enum MixedLightingSetup
     {
         private readonly LightweightPipelineAsset m_Asset;
 
+        private LightweightShadowPass m_ShadowPass;
+
-        private static readonly int kMaxVisibleLights = 16;
+        private static readonly int kMaxVisibleLocalLights = 16;
-        // Lights are culled per-object. This holds the maximum amount of lights that can be shaded per-object.
-        // The engine fills in the lights indices per-object in unity4_LightIndices0 and unity_4LightIndices1
-        private static readonly int kMaxPerObjectLights = 8;
+        // Lights are culled per-object. In platforms that don't use StructuredBuffer
+        // the engine will set 4 light indices in the following constant unity_4LightIndices0
+        // Additionally the engine set unity_4LightIndices1 but LWRP doesn't use that.
+        private static readonly int kMaxNonIndexedLocalLights = 4;
+        private static readonly int kMaxVertexLights = 4;
-        private static readonly int kMaxVertexLights = 4;
+        private const int kDepthStencilBufferBits = 32;
 
         private static readonly float kRenderScaleThreshold = 0.05f;
 
         private Vector4 kDefaultLightSpotDirection = new Vector4(0.0f, 0.0f, 1.0f, 0.0f);
         private Vector4 kDefaultLightSpotAttenuation = new Vector4(0.0f, 1.0f, 0.0f, 0.0f);
 
-        private Vector4[] m_LightPositions = new Vector4[kMaxVisibleLights];
-        private Vector4[] m_LightColors = new Vector4[kMaxVisibleLights];
-        private Vector4[] m_LightDistanceAttenuations = new Vector4[kMaxVisibleLights];
-        private Vector4[] m_LightSpotDirections = new Vector4[kMaxVisibleLights];
-        private Vector4[] m_LightSpotAttenuations = new Vector4[kMaxVisibleLights];
+        private Vector4[] m_LightPositions = new Vector4[kMaxVisibleLocalLights];
+        private Vector4[] m_LightColors = new Vector4[kMaxVisibleLocalLights];
+        private Vector4[] m_LightDistanceAttenuations = new Vector4[kMaxVisibleLocalLights];
+        private Vector4[] m_LightSpotDirections = new Vector4[kMaxVisibleLocalLights];
+        private Vector4[] m_LightSpotAttenuations = new Vector4[kMaxVisibleLocalLights];
-        private const int kMaxCascades = 4;
-        private int m_ShadowCasterCascadesCount;
-        private int m_ShadowMapRTID;
-        private int m_ScreenSpaceShadowMapRTID;
-        private Matrix4x4[] m_ShadowMatrices = new Matrix4x4[kMaxCascades + 1];
-        private RenderTexture m_ShadowMapRT;
-        private RenderTargetIdentifier m_ScreenSpaceShadowMapRT;
         private RenderTargetIdentifier m_ColorRT;
         private RenderTargetIdentifier m_CopyColorRT;
         private RenderTargetIdentifier m_DepthRT;
         private bool m_DepthRenderBuffer;
         private MixedLightingSetup m_MixedLightingSetup;
 
-        private const int kDepthStencilBufferBits = 32;
-        private const int kShadowBufferBits = 16;
-        private Vector4[] m_DirectionalShadowSplitDistances = new Vector4[kMaxCascades];
-        private Vector4 m_DirectionalShadowSplitRadii;
-
-        private ShadowSettings m_ShadowSettings = ShadowSettings.Default;
-        private ShadowSliceData[] m_ShadowSlices = new ShadowSliceData[kMaxCascades];
+        private ComputeBuffer m_LightIndicesBuffer;
+        private List<int> m_LocalLightIndices;
+        private int m_MaxLocalLightsShadedPerPass;
+        private bool m_UseComputeBuffer;
 
         // Pipeline pass names
         private static readonly ShaderPassName m_DepthPrepass = new ShaderPassName("DepthOnly");
         private PostProcessLayer m_CameraPostProcessLayer;
 
         private CameraComparer m_CameraComparer = new CameraComparer();
-        private LightComparer m_LightComparer = new LightComparer();
-
-        // Maps from sorted light indices to original unsorted. We need this for shadow rendering
-        // and per-object light lists.
-        private List<int> m_SortedLightIndexMap = new List<int>();
-
-        private Dictionary<VisibleLight, int> m_VisibleLightsIDMap = new Dictionary<VisibleLight, int>(new LightEqualityComparer());
-        private Material m_ScreenSpaceShadowsMaterial;
         private Material m_SamplingMaterial;
         private int m_SampleOffset;
         private int m_BlitTexID = Shader.PropertyToID("_BlitTex");
         {
             m_Asset = asset;
 
-            BuildShadowSettings();
             SetRenderingFeatures();
 
             PerFrameBuffer._GlossyEnvironmentColor = Shader.PropertyToID("_GlossyEnvironmentColor");
             PerCameraBuffer._MainLightPosition = Shader.PropertyToID("_MainLightPosition");
             PerCameraBuffer._MainLightColor = Shader.PropertyToID("_MainLightColor");
-            PerCameraBuffer._MainLightDistanceAttenuation = Shader.PropertyToID("_MainLightDistanceAttenuation");
-            PerCameraBuffer._MainLightSpotDir = Shader.PropertyToID("_MainLightSpotDir");
-            PerCameraBuffer._MainLightSpotAttenuation = Shader.PropertyToID("_MainLightSpotAttenuation");
             PerCameraBuffer._MainLightCookie = Shader.PropertyToID("_MainLightCookie");
             PerCameraBuffer._WorldToLight = Shader.PropertyToID("_WorldToLight");
             PerCameraBuffer._AdditionalLightCount = Shader.PropertyToID("_AdditionalLightCount");
             PerCameraBuffer._AdditionalLightSpotDir = Shader.PropertyToID("_AdditionalLightSpotDir");
             PerCameraBuffer._AdditionalLightSpotAttenuation = Shader.PropertyToID("_AdditionalLightSpotAttenuation");
+            PerCameraBuffer._LightIndexBuffer = Shader.PropertyToID("_LightIndexBuffer");
-            ShadowConstantBuffer._WorldToShadow = Shader.PropertyToID("_WorldToShadow");
-            ShadowConstantBuffer._ShadowData = Shader.PropertyToID("_ShadowData");
-            ShadowConstantBuffer._DirShadowSplitSpheres = Shader.PropertyToID("_DirShadowSplitSpheres");
-            ShadowConstantBuffer._DirShadowSplitSphereRadii = Shader.PropertyToID("_DirShadowSplitSphereRadii");
-            ShadowConstantBuffer._ShadowOffset0 = Shader.PropertyToID("_ShadowOffset0");
-            ShadowConstantBuffer._ShadowOffset1 = Shader.PropertyToID("_ShadowOffset1");
-            ShadowConstantBuffer._ShadowOffset2 = Shader.PropertyToID("_ShadowOffset2");
-            ShadowConstantBuffer._ShadowOffset3 = Shader.PropertyToID("_ShadowOffset3");
-            ShadowConstantBuffer._ShadowmapSize = Shader.PropertyToID("_ShadowmapSize");
-
-            m_ShadowMapRTID = Shader.PropertyToID("_ShadowMap");
-            m_ScreenSpaceShadowMapRTID = Shader.PropertyToID("_ScreenSpaceShadowMap");
-
             CameraRenderTargetID.color = Shader.PropertyToID("_CameraColorRT");
             CameraRenderTargetID.copyColor = Shader.PropertyToID("_CameraCopyColorRT");
             CameraRenderTargetID.depth = Shader.PropertyToID("_CameraDepthTexture");
             m_SampleOffset = Shader.PropertyToID("_SampleOffset");
-
-            m_ScreenSpaceShadowMapRT = new RenderTargetIdentifier(m_ScreenSpaceShadowMapRTID);
 
             m_ColorRT = new RenderTargetIdentifier(CameraRenderTargetID.color);
             m_CopyColorRT = new RenderTargetIdentifier(CameraRenderTargetID.copyColor);
 
             m_CopyTextureSupport = SystemInfo.copyTextureSupport;
 
-            for (int i = 0; i < kMaxCascades; ++i)
-                m_DirectionalShadowSplitDistances[i] = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
-            m_DirectionalShadowSplitRadii = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+            // TODO: Profile performance of using ComputeBuffer on mobiles that support it vs
+            // fixed buffer size
+            if (Application.isMobilePlatform || Application.platform == RuntimePlatform.WebGLPlayer)
+                m_UseComputeBuffer = false;
+            else
+                m_UseComputeBuffer = true;
+
+            m_LightIndicesBuffer = null;
+            m_MaxLocalLightsShadedPerPass = m_UseComputeBuffer ? kMaxVisibleLocalLights : kMaxNonIndexedLocalLights;
+            m_LocalLightIndices = new List<int>(m_MaxLocalLightsShadedPerPass);
+
+            m_ShadowPass = new LightweightShadowPass(m_Asset, m_MaxLocalLightsShadedPerPass);
 
             // Let engine know we have MSAA on for cases where we support MSAA backbuffer
             if (QualitySettings.antiAliasing != m_Asset.MSAASampleCount)
             m_BlitQuad = LightweightUtils.CreateQuadMesh(false);
             m_BlitMaterial = CoreUtils.CreateEngineMaterial(m_Asset.BlitShader);
             m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(m_Asset.CopyDepthShader);
-            m_ScreenSpaceShadowsMaterial = CoreUtils.CreateEngineMaterial(m_Asset.ScreenSpaceShadowShader);
             m_SamplingMaterial = CoreUtils.CreateEngineMaterial(m_Asset.SamplingShader);
             m_ErrorMaterial = CoreUtils.CreateEngineMaterial("Hidden/InternalErrorShader");
         }
 #if UNITY_EDITOR
             SceneViewDrawMode.ResetDrawMode();
 #endif
+
+            if (m_LightIndicesBuffer != null)
+            {
+                m_LightIndicesBuffer.Release();
+                m_LightIndicesBuffer = null;
+            }
         }
 
         private void SetRenderingFeatures()
                     continue;
 
                 var cmd = CommandBufferPool.Get("");
-                cullingParameters.shadowDistance = Mathf.Min(m_ShadowSettings.maxShadowDistance,
-                        m_CurrCamera.farClipPlane);
+                cullingParameters.shadowDistance = Mathf.Min(m_ShadowPass.RenderingDistance, m_CurrCamera.farClipPlane);
 
 #if UNITY_EDITOR
                 // Emit scene view UI
                 LightData lightData;
                 InitializeLightData(visibleLights, out lightData);
 
-                bool shadows = ShadowPass(visibleLights, ref context, ref lightData);
+                bool screenspaceShadows = m_ShadowPass.Execute(ref m_CullResults, ref lightData, ref context);
-                SetupFrameRenderingConfiguration(out frameRenderingConfiguration, shadows, stereoEnabled, sceneViewCamera);
-                SetupIntermediateResources(frameRenderingConfiguration, shadows, ref context);
+                SetupFrameRenderingConfiguration(out frameRenderingConfiguration, screenspaceShadows, stereoEnabled, sceneViewCamera);
+                SetupIntermediateResources(frameRenderingConfiguration, screenspaceShadows, ref context);
 
                 // SetupCameraProperties does the following:
                 // Setup Camera RenderTarget and Viewport
                 if (LightweightUtils.HasFlag(frameRenderingConfiguration, FrameRenderingConfiguration.DepthPrePass))
                     DepthPass(ref context, frameRenderingConfiguration);
 
-                if (shadows && m_ShadowSettings.screenSpace)
-                    ShadowCollectPass(visibleLights, ref context, ref lightData, frameRenderingConfiguration);
+                if (screenspaceShadows)
+                    m_ShadowPass.CollectShadows(m_CurrCamera, frameRenderingConfiguration, ref context);
-                ForwardPass(visibleLights, frameRenderingConfiguration, ref context, ref lightData, stereoEnabled);
-
+                ForwardPass(frameRenderingConfiguration, ref lightData, ref context);
 
                 cmd.name = "After Camera Render";
 #if UNITY_EDITOR
-                cmd.ReleaseTemporaryRT(m_ScreenSpaceShadowMapRTID);
+                context.Submit();
+
                 cmd.ReleaseTemporaryRT(CameraRenderTargetID.depthCopy);
                 cmd.ReleaseTemporaryRT(CameraRenderTargetID.depth);
                 cmd.ReleaseTemporaryRT(CameraRenderTargetID.color);
                 context.ExecuteCommandBuffer(cmd);
                 CommandBufferPool.Release(cmd);
 
-                context.Submit();
-
-                if (m_ShadowMapRT)
-                {
-                    RenderTexture.ReleaseTemporary(m_ShadowMapRT);
-                    m_ShadowMapRT = null;
-                }
-            }
-        }
-
-        private bool ShadowPass(List<VisibleLight> visibleLights, ref ScriptableRenderContext context, ref LightData lightData)
-        {
-            m_ShadowMapRT = null;
-            if (m_Asset.AreShadowsEnabled() && lightData.mainLightIndex != -1)
-            {
-                VisibleLight mainLight = visibleLights[lightData.mainLightIndex];
-
-                if (mainLight.light.shadows != LightShadows.None)
-                {
-                    if (!LightweightUtils.IsSupportedShadowType(mainLight.lightType))
-                    {
-                        Debug.LogWarning("Only directional and spot shadows are supported by LightweightPipeline.");
-                        return false;
-                    }
-
-                    // There's no way to map shadow light indices. We need to pass in the original unsorted index.
-                    // If no additional lights then no light sorting is performed and the indices match.
-                    int shadowOriginalIndex = (lightData.totalAdditionalLightsCount > 0) ? GetLightUnsortedIndex(lightData.mainLightIndex) : lightData.mainLightIndex;
-                    bool shadowsRendered = RenderShadows(ref m_CullResults, ref mainLight, shadowOriginalIndex, ref context);
-                    if (shadowsRendered)
-                    {
-                        lightData.shadowMapSampleType = (m_Asset.ShadowSetting != ShadowType.SOFT_SHADOWS) ? LightShadows.Hard : mainLight.light.shadows;
-
-                        // 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.
-                        if (!m_ShadowSettings.screenSpace)
-                            lightData.shadowMapSampleType = LightShadows.Hard;
-                    }
-                    else
-                    {
-                        lightData.shadowMapSampleType = LightShadows.None;
-                    }
+                m_ShadowPass.Dispose(cmd);
-                    return shadowsRendered;
-                }
+                context.Submit();
-
-            return false;
-        }
-
-        private void ShadowCollectPass(List<VisibleLight> visibleLights, ref ScriptableRenderContext context, ref LightData lightData, FrameRenderingConfiguration frameRenderingConfiguration)
-        {
-            CommandBuffer cmd = CommandBufferPool.Get("Collect Shadows");
-
-            SetShadowCollectPassKeywords(cmd, visibleLights[lightData.mainLightIndex], ref lightData);
-
-            // Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that
-            // doesn't like null sources when trying to determine a stereo-ized blit.  So for proper
-            // stereo functionality, we use the screen-space shadow map as the source (until we have
-            // a better solution).
-            // An alternative would be DrawProcedural, but that would require further changes in the shader.
-            cmd.Blit(m_ScreenSpaceShadowMapRT, m_ScreenSpaceShadowMapRT, m_ScreenSpaceShadowsMaterial);
-
-            StartStereoRendering(ref context, frameRenderingConfiguration);
-
-            context.ExecuteCommandBuffer(cmd);
-
-            StopStereoRendering(ref context, frameRenderingConfiguration);
-
-            CommandBufferPool.Release(cmd);
         }
 
         private void DepthPass(ref ScriptableRenderContext context, FrameRenderingConfiguration frameRenderingConfiguration)
                 renderQueueRange = RenderQueueRange.opaque
             };
 
-            StartStereoRendering(ref context, frameRenderingConfiguration);
+            LightweightUtils.StartStereoRendering(m_CurrCamera, ref context, frameRenderingConfiguration);
-            StopStereoRendering(ref context, frameRenderingConfiguration);
+            LightweightUtils.StopStereoRendering(m_CurrCamera, ref context, frameRenderingConfiguration);
         }
 
         private void OpaqueTexturePass(ref ScriptableRenderContext context, FrameRenderingConfiguration frameRenderingConfiguration)
             CommandBufferPool.Release(cmd);
         }
 
-        private void ForwardPass(List<VisibleLight> visibleLights, FrameRenderingConfiguration frameRenderingConfiguration, ref ScriptableRenderContext context, ref LightData lightData, bool stereoEnabled)
+        private void ForwardPass(FrameRenderingConfiguration frameRenderingConfiguration, ref LightData lightData, ref ScriptableRenderContext context)
-            SetupShaderConstants(visibleLights, ref context, ref lightData);
+            SetupShaderConstants(ref lightData, ref context);
 
             RendererConfiguration rendererSettings = GetRendererSettings(ref lightData);
 
             }
         }
 
-        private void BuildShadowSettings()
-        {
-            m_ShadowSettings = ShadowSettings.Default;
-            m_ShadowSettings.screenSpace = SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
-            m_ShadowSettings.directionalLightCascadeCount = (m_ShadowSettings.screenSpace) ? m_Asset.CascadeCount : 1;
-
-            m_ShadowSettings.shadowAtlasWidth = m_Asset.ShadowAtlasResolution;
-            m_ShadowSettings.shadowAtlasHeight = m_Asset.ShadowAtlasResolution;
-            m_ShadowSettings.maxShadowDistance = m_Asset.ShadowDistance;
-            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)
-            {
-                case 1:
-                    m_ShadowSettings.directionalLightCascades = new Vector3(1.0f, 0.0f, 0.0f);
-                    break;
-
-                case 2:
-                    m_ShadowSettings.directionalLightCascades = new Vector3(m_Asset.Cascade2Split, 1.0f, 0.0f);
-                    break;
-
-                default:
-                    m_ShadowSettings.directionalLightCascades = m_Asset.Cascade4Split;
-                    break;
-            }
-        }
-
-        private void SetupFrameRenderingConfiguration(out FrameRenderingConfiguration configuration, bool shadows, bool stereoEnabled, bool sceneViewCamera)
+        private void SetupFrameRenderingConfiguration(out FrameRenderingConfiguration configuration, bool screenspaceShadows, bool stereoEnabled, bool sceneViewCamera)
         {
             configuration = (stereoEnabled) ? FrameRenderingConfiguration.Stereo : FrameRenderingConfiguration.None;
             if (stereoEnabled && XRSettings.eyeTextureDesc.dimension == TextureDimension.Tex2DArray)
             if (sceneViewCamera)
                 m_RequireDepthTexture = true;
 
-            if (shadows)
-            {
-                m_RequireDepthTexture = m_ShadowSettings.screenSpace;
-
-                if (!msaaEnabled)
-                    intermediateTexture = true;
-            }
+            m_RequireDepthTexture = m_RequireDepthTexture || screenspaceShadows;
 
             if (msaaEnabled)
             {
                 // 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 && !shadows)
+                if (!msaaEnabled && !screenspaceShadows)
                 {
                     bool supportsDepthCopy = m_CopyTextureSupport != CopyTextureSupport.None && m_Asset.CopyDepthShader.isSupported;
                     m_DepthRenderBuffer = true;
                 if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.DepthCopy))
                     cmd.GetTemporaryRT(CameraRenderTargetID.depthCopy, depthRTDesc, FilterMode.Bilinear);
 
-                if (shadows && m_ShadowSettings.screenSpace)
-                {
-                    var screenspaceShadowmapDesc = baseDesc;
-                    screenspaceShadowmapDesc.depthBufferBits = 0;
-                    screenspaceShadowmapDesc.colorFormat = m_ShadowSettings.screenspaceShadowmapTextureFormat;
-                    cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, screenspaceShadowmapDesc, FilterMode.Bilinear);
-                }
+                m_ShadowPass.InitializeResources(cmd, baseDesc);
             }
 
             var colorRTDesc = baseDesc;
                 cmd.GetTemporaryRT(CameraRenderTargetID.copyColor, colorRTDesc, FilterMode.Point);
         }
 
-        private void SetupShaderConstants(List<VisibleLight> visibleLights, ref ScriptableRenderContext context, ref LightData lightData)
+        private void SetupShaderConstants(ref LightData lightData, ref ScriptableRenderContext context)
-            SetupShaderLightConstants(cmd, visibleLights, ref lightData);
-            SetShaderKeywords(cmd, ref lightData, visibleLights);
+            SetupShaderLightConstants(cmd, ref lightData);
+            SetShaderKeywords(cmd, ref lightData);
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
         }
-            int visibleLightsCount = Math.Min(visibleLights.Count, m_Asset.MaxPixelLights);
-            m_SortedLightIndexMap.Clear();
+            m_LocalLightIndices.Clear();
+            for (int i = 0; i < visibleLights.Count; ++i)
+            {
+                if (visibleLights[i].lightType != LightType.Directional)
+                    m_LocalLightIndices.Add(i);
+
+                if (m_LocalLightIndices.Count >= m_MaxLocalLightsShadedPerPass)
+                    break;
+            }
-            lightData.shadowMapSampleType = LightShadows.None;
+            // Clear to default all light constant data
+            for (int i = 0; i < kMaxVisibleLocalLights; ++i)
+                InitializeLightConstants(visibleLights, -1, out m_LightPositions[i],
+                    out m_LightColors[i],
+                    out m_LightDistanceAttenuations[i],
+                    out m_LightSpotDirections[i],
+                    out m_LightSpotAttenuations[i]);
-            if (visibleLightsCount <= 1)
-                lightData.mainLightIndex = GetMainLight(visibleLights);
-            else
-                lightData.mainLightIndex = SortLights(visibleLights);
+            int visibleLightsCount = Math.Min(visibleLights.Count, m_Asset.MaxPixelLights);
+            lightData.mainLightIndex = GetMainLight(visibleLights);
-            int additionalPixelLightsCount = visibleLightsCount - mainLightPresent;
-            int vertexLightCount = (m_Asset.SupportsVertexLight) ? Math.Min(visibleLights.Count, kMaxPerObjectLights) - additionalPixelLightsCount - mainLightPresent : 0;
+            int additionalPixelLightsCount = Math.Min(visibleLightsCount - mainLightPresent, m_MaxLocalLightsShadedPerPass);
+            int vertexLightCount = (m_Asset.SupportsVertexLight) ? Math.Min(visibleLights.Count, m_MaxLocalLightsShadedPerPass) - additionalPixelLightsCount : 0;
+            lightData.visibleLights = visibleLights;
+            lightData.localLightIndices = m_LocalLightIndices;
-        }
-        private int SortLights(List<VisibleLight> visibleLights)
-        {
-            int totalVisibleLights = visibleLights.Count;
-
-            m_VisibleLightsIDMap.Clear();
-            for (int i = 0; i < totalVisibleLights; ++i)
-                m_VisibleLightsIDMap.Add(visibleLights[i], i);
+            if (lightData.totalAdditionalLightsCount > 0)
+            {
+                int[] perObjectLightIndexMap = m_CullResults.GetLightIndexMap();
+                int directionalLightCount = 0;
-            // Sorts light so we have all directionals first, then local lights.
-            // Directionals are sorted further by shadow, cookie and intensity
-            // Locals are sorted further by shadow, cookie and distance to camera
-            m_LightComparer.CurrCamera = m_CurrCamera;
-            visibleLights.Sort(m_LightComparer);
+                // Disable all directional lights from the perobject light indices
+                for (int i = 0; i < visibleLights.Count; ++i)
+                {
+                    VisibleLight light = visibleLights[i];
+                    if (light.lightType == LightType.Directional)
+                        perObjectLightIndexMap[i] = -1;
+                    else
+                        perObjectLightIndexMap[i] -= directionalLightCount;
+                }
+                m_CullResults.SetLightIndexMap(perObjectLightIndexMap);
-            for (int i = 0; i < totalVisibleLights; ++i)
-                m_SortedLightIndexMap.Add(m_VisibleLightsIDMap[visibleLights[i]]);
+                // if not using a compute buffer, engine will set indices in 2 vec4 constants
+                // unity_4LightIndices0 and unity_4LightIndices1
+                if (m_UseComputeBuffer)
+                {
+                    int lightIndicesCount = m_CullResults.GetLightIndicesCount();
+                    if (lightIndicesCount > 0)
+                    {
+                        if (m_LightIndicesBuffer == null)
+                        {
+                            m_LightIndicesBuffer = new ComputeBuffer(lightIndicesCount, sizeof(int));
+                        }
+                        else if (m_LightIndicesBuffer.count < lightIndicesCount)
+                        {
+                            m_LightIndicesBuffer.Release();
+                            m_LightIndicesBuffer = new ComputeBuffer(lightIndicesCount, sizeof(int));
+                        }
-            return GetMainLight(visibleLights);
+                        m_CullResults.FillLightIndices(m_LightIndicesBuffer);
+                    }
+                }
+            }
-        // How main light is decided:
-        // If shadows enabled, main light is always a shadow casting light. Directional has priority over local lights.
-        // Otherwise directional lights have priority based on cookie support and intensity
+        // Main Light is always a directional light
-            bool shadowsEnabled = m_Asset.AreShadowsEnabled();
-            int brighestDirectionalIndex = -1;
             for (int i = 0; i < totalVisibleLights; ++i)
             {
                 VisibleLight currLight = visibleLights[i];
                 // In this case we either have no main light or already found it.
                 if (currLight.light == null)
                     break;
-
-                // Shadow lights are sorted by type (directional > puctual) and intensity
-                // The first shadow light we find in the list is the main light
-                if (shadowsEnabled && currLight.light.shadows != LightShadows.None && LightweightUtils.IsSupportedShadowType(currLight.lightType))
-                    return i;
-                if (currLight.lightType == LightType.Directional && brighestDirectionalIndex == -1)
-                    brighestDirectionalIndex = i;
+                if (currLight.lightType == LightType.Directional)
+                    return i;
-            return brighestDirectionalIndex;
+            return -1;
         }
 
         private void InitializeLightConstants(List<VisibleLight> lights, int lightIndex, out Vector4 lightPos, out Vector4 lightColor, out Vector4 lightDistanceAttenuation, out Vector4 lightSpotDir,
             Shader.SetGlobalVector(PerCameraBuffer._ScaledScreenParams, new Vector4(cameraWidth, cameraHeight, 1.0f + 1.0f / cameraWidth, 1.0f + 1.0f / cameraHeight));
         }
 
-        private void SetupShaderLightConstants(CommandBuffer cmd, List<VisibleLight> lights, ref LightData lightData)
+        private void SetupShaderLightConstants(CommandBuffer cmd, ref LightData lightData)
-            SetupMainLightConstants(cmd, lights, lightData.mainLightIndex);
-            SetupAdditionalListConstants(cmd, lights, ref lightData);
+            SetupMainLightConstants(cmd, ref lightData);
+            SetupAdditionalListConstants(cmd, ref lightData);
-        private void SetupMainLightConstants(CommandBuffer cmd, List<VisibleLight> lights, int lightIndex)
+        private void SetupMainLightConstants(CommandBuffer cmd, ref LightData lightData)
-            InitializeLightConstants(lights, lightIndex, out lightPos, out lightColor, out lightDistanceAttenuation, out lightSpotDir, out lightSpotAttenuation);
+            List<VisibleLight> lights = lightData.visibleLights;
+            InitializeLightConstants(lightData.visibleLights, lightData.mainLightIndex, out lightPos, out lightColor, out lightDistanceAttenuation, out lightSpotDir, out lightSpotAttenuation);
-            if (lightIndex >= 0)
+            if (lightData.mainLightIndex >= 0)
-                LightType mainLightType = lights[lightIndex].lightType;
-                Light mainLight = lights[lightIndex].light;
+                VisibleLight mainLight = lights[lightData.mainLightIndex];
+                Light mainLightRef = mainLight.light;
-                if (LightweightUtils.IsSupportedCookieType(mainLightType) && mainLight.cookie != null)
+                if (LightweightUtils.IsSupportedCookieType(mainLight.lightType) && mainLightRef.cookie != null)
-                    LightweightUtils.GetLightCookieMatrix(lights[lightIndex], out lightCookieMatrix);
-                    cmd.SetGlobalTexture(PerCameraBuffer._MainLightCookie, mainLight.cookie);
+                    LightweightUtils.GetLightCookieMatrix(mainLight, out lightCookieMatrix);
+                    cmd.SetGlobalTexture(PerCameraBuffer._MainLightCookie, mainLightRef.cookie);
-            cmd.SetGlobalVector(PerCameraBuffer._MainLightPosition, lightPos);
+            cmd.SetGlobalVector(PerCameraBuffer._MainLightPosition, new Vector4(lightPos.x, lightPos.y, lightPos.z, lightDistanceAttenuation.w));
-            cmd.SetGlobalVector(PerCameraBuffer._MainLightDistanceAttenuation, lightDistanceAttenuation);
-            cmd.SetGlobalVector(PerCameraBuffer._MainLightSpotDir, lightSpotDir);
-            cmd.SetGlobalVector(PerCameraBuffer._MainLightSpotAttenuation, lightSpotAttenuation);
-        private void SetupAdditionalListConstants(CommandBuffer cmd, List<VisibleLight> lights, ref LightData lightData)
+        private void SetupAdditionalListConstants(CommandBuffer cmd, ref LightData lightData)
-            int additionalLightIndex = 0;
-
+            List<VisibleLight> lights = lightData.visibleLights;
-                // We need to update per-object light list with the proper map to our global additional light buffer
-                // First we initialize all lights in the map to -1 to tell the system to discard main light index and
-                // remaining lights in the scene that don't fit the max additional light buffer (kMaxVisibileAdditionalLights)
-                int[] perObjectLightIndexMap = m_CullResults.GetLightIndexMap();
-                for (int i = 0; i < lights.Count; ++i)
-                    perObjectLightIndexMap[i] = -1;
-
-                for (int i = 0; i < lights.Count && additionalLightIndex < kMaxVisibleLights; ++i)
+                int localLightsCount = 0;
+                for (int i = 0; i < lights.Count && localLightsCount < kMaxVisibleLocalLights; ++i)
-                    if (i != lightData.mainLightIndex)
+                    VisibleLight light = lights[i];
+                    if (light.lightType != LightType.Directional)
-                        // The engine performs per-object light culling and initialize 8 light indices into two vec4 constants unity_4LightIndices0 and unity_4LightIndices1.
-                        // In the shader we iterate over each visible light using the indices provided in these constants to index our global light buffer
-                        // ex: first light position would be m_LightPosisitions[unity_4LightIndices[0]];
-
-                        // However since we sorted the lights we need to tell the engine how to map the original/unsorted indices to our global buffer
-                        // We do it by settings the perObjectLightIndexMap to the appropriate additionalLightIndex.
-                        perObjectLightIndexMap[GetLightUnsortedIndex(i)] = additionalLightIndex;
-                        InitializeLightConstants(lights, i, out m_LightPositions[additionalLightIndex],
-                            out m_LightColors[additionalLightIndex],
-                            out m_LightDistanceAttenuations[additionalLightIndex],
-                            out m_LightSpotDirections[additionalLightIndex],
-                            out m_LightSpotAttenuations[additionalLightIndex]);
-                        additionalLightIndex++;
+                        InitializeLightConstants(lights, i, out m_LightPositions[localLightsCount],
+                            out m_LightColors[localLightsCount],
+                            out m_LightDistanceAttenuations[localLightsCount],
+                            out m_LightSpotDirections[localLightsCount],
+                            out m_LightSpotAttenuations[localLightsCount]);
+                        localLightsCount++;
-                m_CullResults.SetLightIndexMap(perObjectLightIndexMap);
+
+                // if not using a compute buffer, engine will set indices in 2 vec4 constants
+                // unity_4LightIndices0 and unity_4LightIndices1
+                if (m_UseComputeBuffer)
+                    cmd.SetGlobalBuffer("_LightIndexBuffer", m_LightIndicesBuffer);
-
-                // Clear to default all light cosntant data
-                for (int i = 0; i < kMaxVisibleLights; ++i)
-                    InitializeLightConstants(lights, -1, out m_LightPositions[additionalLightIndex],
-                            out m_LightColors[additionalLightIndex],
-                            out m_LightDistanceAttenuations[additionalLightIndex],
-                            out m_LightSpotDirections[additionalLightIndex],
-                            out m_LightSpotAttenuations[additionalLightIndex]);
             }
 
             cmd.SetGlobalVectorArray(PerCameraBuffer._AdditionalLightPosition, m_LightPositions);
             cmd.SetGlobalVectorArray(PerCameraBuffer._AdditionalLightSpotAttenuation, m_LightSpotAttenuations);
         }
 
-        private void SetupShadowCasterConstants(CommandBuffer cmd, ref VisibleLight visibleLight, Matrix4x4 proj, float cascadeResolution)
-        {
-            Light light = visibleLight.light;
-            float bias = 0.0f;
-            float normalBias = 0.0f;
-
-            // Use same kernel radius as built-in pipeline so we can achieve same bias results
-            // with the default light bias parameters.
-            const float kernelRadius = 3.65f;
-
-            if (visibleLight.lightType == LightType.Directional)
-            {
-                // Scale bias by cascade's world space depth range.
-                // Directional shadow lights have orthogonal projection.
-                // proj.m22 = -2 / (far - near) since the projection's depth range is [-1.0, 1.0]
-                // In order to be correct we should multiply bias by 0.5 but this introducing aliasing along cascades more visible.
-                float sign = (SystemInfo.usesReversedZBuffer) ? 1.0f : -1.0f;
-                bias = light.shadowBias * proj.m22 * sign;
-
-                // Currently only square POT cascades resolutions are used.
-                // We scale normalBias
-                double frustumWidth = 2.0 / (double)proj.m00;
-                double frustumHeight = 2.0 / (double)proj.m11;
-                float texelSizeX = (float)(frustumWidth / (double)cascadeResolution);
-                float texelSizeY = (float)(frustumHeight / (double)cascadeResolution);
-                float texelSize = Mathf.Max(texelSizeX, texelSizeY);
-
-                // Since we are applying normal bias on caster side we want an inset normal offset
-                // thus we use a negative normal bias.
-                normalBias = -light.shadowNormalBias * texelSize * kernelRadius;
-            }
-            else if (visibleLight.lightType == LightType.Spot)
-            {
-                float sign = (SystemInfo.usesReversedZBuffer) ? -1.0f : 1.0f;
-                bias = light.shadowBias * sign;
-                normalBias = 0.0f;
-            }
-            else
-            {
-                Debug.LogWarning("Only spot and directional shadow casters are supported in lightweight pipeline");
-            }
-
-            Vector3 lightDirection = -visibleLight.localToWorld.GetColumn(2);
-            cmd.SetGlobalVector("_ShadowBias", new Vector4(bias, normalBias, 0.0f, 0.0f));
-            cmd.SetGlobalVector("_LightDirection", new Vector4(lightDirection.x, lightDirection.y, lightDirection.z, 0.0f));
-        }
-
-        private void SetupShadowReceiverConstants(CommandBuffer cmd, VisibleLight shadowLight, ref ScriptableRenderContext context)
+        private void SetShaderKeywords(CommandBuffer cmd, ref LightData lightData)
-            Light light = shadowLight.light;
-
-            int cascadeCount = m_ShadowCasterCascadesCount;
-            for (int i = 0; i < kMaxCascades; ++i)
-                m_ShadowMatrices[i] = (cascadeCount >= i) ? m_ShadowSlices[i].shadowTransform : Matrix4x4.identity;
-
-            // We setup and additional a no-op WorldToShadow matrix in the last index
-            // because the ComputeCascadeIndex function in Shadows.hlsl can return an index
-            // out of bounds. (position not inside any cascade) and we want to avoid branching
-            Matrix4x4 noOpShadowMatrix = Matrix4x4.zero;
-            noOpShadowMatrix.m33 = (SystemInfo.usesReversedZBuffer) ? 1.0f : 0.0f;
-            m_ShadowMatrices[kMaxCascades] = noOpShadowMatrix;
-
-            float invShadowResolution = 1.0f / m_Asset.ShadowAtlasResolution;
-            float invHalfShadowResolution = 0.5f * invShadowResolution;
-            cmd.Clear();
-            cmd.SetGlobalTexture(m_ShadowMapRTID, m_ShadowMapRT);
-            cmd.SetGlobalMatrixArray(ShadowConstantBuffer._WorldToShadow, m_ShadowMatrices);
-            cmd.SetGlobalVector(ShadowConstantBuffer._ShadowData, new Vector4(light.shadowStrength, 0.0f, 0.0f, 0.0f));
-            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._ShadowmapSize, new Vector4(invShadowResolution, invShadowResolution, m_Asset.ShadowAtlasResolution, m_Asset.ShadowAtlasResolution));
-            context.ExecuteCommandBuffer(cmd);
-        }
+            List<VisibleLight> visibleLights = lightData.visibleLights;
+            int mainLightIndex = lightData.mainLightIndex;
-        private void SetShaderKeywords(CommandBuffer cmd, ref LightData lightData, List<VisibleLight> visibleLights)
-        {
-            int mainLightIndex = lightData.mainLightIndex;
-            //TIM: Not used in shader for V1 to reduce keywords
-            CoreUtils.SetKeyword(cmd, "_MAIN_LIGHT_DIRECTIONAL", mainLightIndex == -1 || visibleLights[mainLightIndex].lightType == LightType.Directional);
-            //TIM: Not used in shader for V1 to reduce keywords
-            CoreUtils.SetKeyword(cmd, "_MAIN_LIGHT_SPOT", mainLightIndex != -1 && visibleLights[mainLightIndex].lightType == LightType.Spot);
+            bool shadowsEnabled = m_ShadowPass.HasDirectionalShadowmap || m_ShadowPass.HasLocalLightsShadowmap;
+            CoreUtils.SetKeyword(cmd, "_SHADOWS_ENABLED", shadowsEnabled);
-            //TIM: Not used in shader for V1 to reduce keywords
-            CoreUtils.SetKeyword(cmd, "_SHADOWS_ENABLED", lightData.shadowMapSampleType != LightShadows.None);
+            // 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);
 
             //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);
             CoreUtils.SetKeyword(cmd, "SOFTPARTICLES_ON", m_RequireDepthTexture && m_Asset.RequireSoftParticles);
         }
 
-        private void SetShadowCollectPassKeywords(CommandBuffer cmd, VisibleLight shadowLight, ref LightData lightData)
-        {
-            bool cascadeShadows = shadowLight.lightType == LightType.Directional && m_Asset.CascadeCount > 1;
-            CoreUtils.SetKeyword(cmd, "_SHADOWS_SOFT", lightData.shadowMapSampleType == LightShadows.Soft);
-            CoreUtils.SetKeyword(cmd, "_SHADOWS_CASCADE", cascadeShadows);
-        }
-
-        private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, int shadowLightIndex, ref ScriptableRenderContext context)
-        {
-            m_ShadowCasterCascadesCount = m_ShadowSettings.directionalLightCascadeCount;
-
-            if (shadowLight.lightType == LightType.Spot)
-                m_ShadowCasterCascadesCount = 1;
-
-            int shadowResolution = GetMaxTileResolutionInAtlas(m_ShadowSettings.shadowAtlasWidth, m_ShadowSettings.shadowAtlasHeight, m_ShadowCasterCascadesCount);
-
-            Bounds bounds;
-            if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
-                return false;
-
-            float shadowNearPlane = m_Asset.ShadowNearOffset;
-
-            Matrix4x4 view, proj;
-            var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
-            bool success = false;
-
-            var cmd = CommandBufferPool.Get("Prepare Shadowmap");
-            RenderTextureDescriptor shadowmapDescriptor = new RenderTextureDescriptor(m_ShadowSettings.shadowAtlasWidth,
-                m_ShadowSettings.shadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, kShadowBufferBits);
-            shadowmapDescriptor.shadowSamplingMode = ShadowSamplingMode.CompareDepths;
-            m_ShadowMapRT = RenderTexture.GetTemporary(shadowmapDescriptor);
-            m_ShadowMapRT.filterMode = FilterMode.Bilinear;
-            m_ShadowMapRT.wrapMode = TextureWrapMode.Clamp;
-
-            // LightweightPipeline.SetRenderTarget is meant to be used with camera targets, not shadowmaps
-            CoreUtils.SetRenderTarget(cmd, m_ShadowMapRT, ClearFlag.Depth, CoreUtils.ConvertSRGBToActiveColorSpace(m_CurrCamera.backgroundColor));
-
-            if (shadowLight.lightType == LightType.Spot)
-            {
-                success = cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(shadowLightIndex, out view, out proj,
-                        out settings.splitData);
-
-                if (success)
-                {
-                    SetupShadowCasterConstants(cmd, ref shadowLight, proj, shadowResolution);
-                    SetupShadowSliceTransform(0, shadowResolution, proj, view);
-                    RenderShadowSlice(cmd, ref context, 0, proj, view, settings);
-                }
-            }
-            else if (shadowLight.lightType == LightType.Directional)
-            {
-                for (int cascadeIdx = 0; cascadeIdx < m_ShadowCasterCascadesCount; ++cascadeIdx)
-                {
-                    success = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(shadowLightIndex,
-                            cascadeIdx, m_ShadowCasterCascadesCount, m_ShadowSettings.directionalLightCascades, shadowResolution, shadowNearPlane, out view, out proj,
-                            out settings.splitData);
-
-                    float cullingSphereRadius = settings.splitData.cullingSphere.w;
-                    m_DirectionalShadowSplitDistances[cascadeIdx] = settings.splitData.cullingSphere;
-                    m_DirectionalShadowSplitRadii[cascadeIdx] = cullingSphereRadius * cullingSphereRadius;
-
-                    if (!success)
-                        break;
-
-                    SetupShadowCasterConstants(cmd, ref shadowLight, proj, shadowResolution);
-                    SetupShadowSliceTransform(cascadeIdx, shadowResolution, proj, view);
-                    RenderShadowSlice(cmd, ref context, cascadeIdx, proj, view, settings);
-                }
-            }
-            else
-            {
-                Debug.LogWarning("Only spot and directional shadow casters are supported in lightweight pipeline");
-            }
-
-            if (success)
-                SetupShadowReceiverConstants(cmd, shadowLight, ref context);
-
-            CommandBufferPool.Release(cmd);
-            return success;
-        }
-
-        private void SetupShadowSliceTransform(int cascadeIndex, int shadowResolution, Matrix4x4 proj, Matrix4x4 view)
-        {
-            if (cascadeIndex >= kMaxCascades)
-            {
-                Debug.LogError(String.Format("{0} is an invalid cascade index. Maximum of {1} cascades", cascadeIndex, kMaxCascades));
-                return;
-            }
-
-            int atlasX = (cascadeIndex % 2) * shadowResolution;
-            int atlasY = (cascadeIndex / 2) * shadowResolution;
-            float atlasWidth = (float)m_ShadowSettings.shadowAtlasWidth;
-            float atlasHeight = (float)m_ShadowSettings.shadowAtlasHeight;
-
-            // Currently CullResults ComputeDirectionalShadowMatricesAndCullingPrimitives doesn't
-            // apply z reversal to projection matrix. We need to do it manually here.
-            if (SystemInfo.usesReversedZBuffer)
-            {
-                proj.m20 = -proj.m20;
-                proj.m21 = -proj.m21;
-                proj.m22 = -proj.m22;
-                proj.m23 = -proj.m23;
-            }
-
-            Matrix4x4 worldToShadow = proj * view;
-
-            var textureScaleAndBias = Matrix4x4.identity;
-            textureScaleAndBias.m00 = 0.5f;
-            textureScaleAndBias.m11 = 0.5f;
-            textureScaleAndBias.m22 = 0.5f;
-            textureScaleAndBias.m03 = 0.5f;
-            textureScaleAndBias.m23 = 0.5f;
-            textureScaleAndBias.m13 = 0.5f;
-
-            // Apply texture scale and offset to save a MAD in shader.
-            worldToShadow = textureScaleAndBias * worldToShadow;
-
-            var cascadeAtlas = Matrix4x4.identity;
-            cascadeAtlas.m00 = (float)shadowResolution / atlasWidth;
-            cascadeAtlas.m11 = (float)shadowResolution / atlasHeight;
-            cascadeAtlas.m03 = (float)atlasX / atlasWidth;
-            cascadeAtlas.m13 = (float)atlasY / atlasHeight;
-
-            // Apply cascade scale and offset
-            worldToShadow = cascadeAtlas * worldToShadow;
-
-            m_ShadowSlices[cascadeIndex].atlasX = atlasX;
-            m_ShadowSlices[cascadeIndex].atlasY = atlasY;
-            m_ShadowSlices[cascadeIndex].shadowResolution = shadowResolution;
-            m_ShadowSlices[cascadeIndex].shadowTransform = worldToShadow;
-        }
-
-        private void RenderShadowSlice(CommandBuffer cmd, ref ScriptableRenderContext context, int cascadeIndex,
-            Matrix4x4 proj, Matrix4x4 view, DrawShadowsSettings settings)
-        {
-            cmd.SetViewport(new Rect(m_ShadowSlices[cascadeIndex].atlasX, m_ShadowSlices[cascadeIndex].atlasY,
-                    m_ShadowSlices[cascadeIndex].shadowResolution, m_ShadowSlices[cascadeIndex].shadowResolution));
-            cmd.EnableScissorRect(new Rect(m_ShadowSlices[cascadeIndex].atlasX + 4, m_ShadowSlices[cascadeIndex].atlasY + 4,
-                m_ShadowSlices[cascadeIndex].shadowResolution - 8, m_ShadowSlices[cascadeIndex].shadowResolution - 8));
-
-            cmd.SetViewProjectionMatrices(view, proj);
-            context.ExecuteCommandBuffer(cmd);
-            cmd.Clear();
-            context.DrawShadows(ref settings);
-            cmd.DisableScissorRect();
-            context.ExecuteCommandBuffer(cmd);
-            cmd.Clear();
-        }
-
-        private int GetMaxTileResolutionInAtlas(int atlasWidth, int atlasHeight, int tileCount)
-        {
-            int resolution = Mathf.Min(atlasWidth, atlasHeight);
-            if (tileCount > Mathf.Log(resolution))
-            {
-                Debug.LogError(
-                    String.Format(
-                        "Cannot fit {0} tiles into current shadowmap atlas of size ({1}, {2}). ShadowMap Resolution set to zero.",
-                        tileCount, atlasWidth, atlasHeight));
-                return 0;
-            }
-
-            int currentTileCount = atlasWidth / resolution * atlasHeight / resolution;
-            while (currentTileCount < tileCount)
-            {
-                resolution = resolution >> 1;
-                currentTileCount = atlasWidth / resolution * atlasHeight / resolution;
-            }
-            return resolution;
-        }
-
-            StartStereoRendering(ref context, renderingConfig);
+            LightweightUtils.StartStereoRendering(m_CurrCamera, ref context, renderingConfig);
 
             CommandBuffer cmd = CommandBufferPool.Get("SetCameraRenderTarget");
             bool intermediateTexture = LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.IntermediateTexture);
 
         private float GetScaledCameraWidth(Camera camera)
         {
-            return (float) camera.pixelWidth * GetRenderScale();
+            return (float)camera.pixelWidth * GetRenderScale();
-            return (float) camera.pixelHeight * GetRenderScale();
+            return (float)camera.pixelHeight * GetRenderScale();
         }
 
         private RendererConfiguration GetRendererSettings(ref LightData lightData)
-                settings |= RendererConfiguration.PerObjectLightIndices8;
-            return settings;
-        }
-
-        private void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorRT, ClearFlag clearFlag = ClearFlag.None)
-        {
-            int depthSlice = (m_IntermediateTextureArray) ? -1 : 0;
-            CoreUtils.SetRenderTarget(cmd, colorRT, clearFlag, CoreUtils.ConvertSRGBToActiveColorSpace(m_CurrCamera.backgroundColor), 0, CubemapFace.Unknown, depthSlice);
-        }
-
-        private void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorRT, RenderTargetIdentifier depthRT, ClearFlag clearFlag = ClearFlag.None)
-        {
-            if (depthRT == BuiltinRenderTextureType.None || !m_DepthRenderBuffer)
-                SetRenderTarget(cmd, colorRT, clearFlag);
-                return;
+                if (m_UseComputeBuffer)
+                    settings |= RendererConfiguration.ProvideLightIndices;
+                else
+                    settings |= RendererConfiguration.PerObjectLightIndices8;
-
-            int depthSlice = (m_IntermediateTextureArray) ? -1 : 0;
-            CoreUtils.SetRenderTarget(cmd, colorRT, depthRT, clearFlag, CoreUtils.ConvertSRGBToActiveColorSpace(m_CurrCamera.backgroundColor), 0, CubemapFace.Unknown, depthSlice);
+            return settings;
         }
 
         private void RenderPostProcess(CommandBuffer cmd, RenderTargetIdentifier source, RenderTargetIdentifier dest, bool opaqueOnly)
                 m_CameraPostProcessLayer.Render(m_PostProcessRenderContext);
         }
 
-        private int GetLightUnsortedIndex(int index)
+        private void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorRT, ClearFlag clearFlag = ClearFlag.None)
+        {
+            int depthSlice = (m_IntermediateTextureArray) ? -1 : 0;
+            CoreUtils.SetRenderTarget(cmd, colorRT, clearFlag, CoreUtils.ConvertSRGBToActiveColorSpace(m_CurrCamera.backgroundColor), 0, CubemapFace.Unknown, depthSlice);
+        }
+
+        private void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorRT, RenderTargetIdentifier depthRT, ClearFlag clearFlag = ClearFlag.None)
-            return (index < m_SortedLightIndexMap.Count) ? m_SortedLightIndexMap[index] : index;
+            if (depthRT == BuiltinRenderTextureType.None || !m_DepthRenderBuffer)
+            {
+                SetRenderTarget(cmd, colorRT, clearFlag);
+                return;
+            }
+
+            int depthSlice = (m_IntermediateTextureArray) ? -1 : 0;
+            CoreUtils.SetRenderTarget(cmd, colorRT, depthRT, clearFlag, CoreUtils.ConvertSRGBToActiveColorSpace(m_CurrCamera.backgroundColor), 0, CubemapFace.Unknown, depthSlice);
         }
 
         private void Blit(CommandBuffer cmd, FrameRenderingConfiguration renderingConfig, RenderTargetIdentifier sourceRT, RenderTargetIdentifier destRT, Material material = null)
                 cmd.CopyTexture(sourceRT, destRT);
             else
                 cmd.Blit(sourceRT, destRT, copyMaterial);
-        }
-
-        private void StartStereoRendering(ref ScriptableRenderContext context, FrameRenderingConfiguration renderingConfiguration)
-        {
-            if (LightweightUtils.HasFlag(renderingConfiguration, FrameRenderingConfiguration.Stereo))
-                context.StartMultiEye(m_CurrCamera);
-        }
-
-        private void StopStereoRendering(ref ScriptableRenderContext context, FrameRenderingConfiguration renderingConfiguration)
-        {
-            if (LightweightUtils.HasFlag(renderingConfiguration, FrameRenderingConfiguration.Stereo))
-                context.StopMultiEye(m_CurrCamera);
         }
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipelineUtils.cs

         }
     }
 
-    public class LightComparer : IComparer<VisibleLight>
-    {
-        public Camera CurrCamera { get; set; }
-
-        public int Compare(VisibleLight lhs, VisibleLight rhs)
-        {
-            Light lhsLight = lhs.light;
-            Light rhsLight = rhs.light;
-
-            // Particle Lights have the Light reference set to null
-            // They are at the end of the priority
-            if (lhsLight == null) return 1;
-            if (rhsLight == null) return -1;
-
-            // Prioritize lights marked as important
-            if (lhsLight.renderMode != rhsLight.renderMode)
-            {
-                if (lhsLight.renderMode == LightRenderMode.ForcePixel) return -1;
-                if (rhsLight.renderMode == LightRenderMode.ForcePixel) return 1;
-            }
-
-            // Prioritize Directional Lights
-            if (lhs.lightType != rhs.lightType)
-            {
-                if (lhs.lightType == LightType.Directional) return -1;
-                if (rhs.lightType == LightType.Directional) return 1;
-            }
-
-            // Prioritize Shadows Lights Soft > Hard > None
-            if (lhsLight.shadows != rhsLight.shadows)
-                return (int)rhsLight.shadows - (int)lhsLight.shadows;
-
-            // Prioritize lights with cookies
-            if (lhsLight.cookie != rhsLight.cookie)
-                return (lhsLight.cookie != null) ? -1 : 1;
-
-            // If directional sort by intensity
-            if (lhs.lightType == LightType.Directional)
-            {
-                return (int)(rhsLight.intensity * 100.0f) - (int)(lhsLight.intensity * 100.0f);
-            }
-
-            // Punctual lights are sorted per-object by the engine based on distance to object center + luminance
-            // Here we sort globally the light list per camera distance to fit the closest lights in the global light buffer
-            // Check MAX_VISIBLE_LIGHTS in the LightweightLighting.cginc to see the max global buffer list size
-            int lhsDistance = (int)(SquaredDistanceToCamera(lhsLight.transform.position) * 100.0f);
-            int rhsDistance = (int)(SquaredDistanceToCamera(rhsLight.transform.position) * 100.0f);
-            int result = lhsDistance - rhsDistance;
-            return result;
-        }
-
-        public float SquaredDistanceToCamera(Vector3 lightPos)
-        {
-            Vector3 lightCameraVector = lightPos - CurrCamera.transform.position;
-            return Vector3.Dot(lightCameraVector, lightCameraVector);
-        }
-    }
-
-    public class LightEqualityComparer : IEqualityComparer<VisibleLight>
-    {
-        public bool Equals(VisibleLight x, VisibleLight y)
-        {
-            if (x.light == null && y.light == null)
-                return true;
-
-            if (x.light == null || y.light == null)
-                return false;
-
-            return x.light.GetInstanceID() == y.light.GetInstanceID();
-        }
-
-        public int GetHashCode(VisibleLight obj)
-        {
-            if (obj.light == null) // Particle light weirdness
-                return obj.GetHashCode();
-
-            return obj.light.GetInstanceID();
-        }
-    }
-
     [Flags]
     public enum FrameRenderingConfiguration
     {
 
     public static class LightweightUtils
     {
+        public static void StartStereoRendering(Camera camera, ref ScriptableRenderContext context, FrameRenderingConfiguration renderingConfiguration)
+        {
+            if (HasFlag(renderingConfiguration, FrameRenderingConfiguration.Stereo))
+                context.StartMultiEye(camera);
+        }
+
+        public static void StopStereoRendering(Camera camera, ref ScriptableRenderContext context, FrameRenderingConfiguration renderingConfiguration)
+        {
+            if (HasFlag(renderingConfiguration, FrameRenderingConfiguration.Stereo))
+                context.StopMultiEye(camera);
+        }
+
         public static void GetLightCookieMatrix(VisibleLight light, out Matrix4x4 cookieMatrix)
         {
             cookieMatrix = Matrix4x4.Inverse(light.localToWorld);

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Input.hlsl

 
 #define MAX_VISIBLE_LIGHTS 16
 
+// Must match check of use compute buffer in LightweightPipeline.cs
+// GLES check here because of WebGL 1.0 support
+// TODO: check performance of using StructuredBuffer on mobile as well
+#if defined(SHADER_API_MOBILE) || defined(SHADER_API_GLES)
+#define USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA 0
+#else
+#define USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA 1
+#endif
+
 struct InputData
 {
     float3  positionWS;
 CBUFFER_START(_PerCamera)
 float4 _MainLightPosition;
 half4 _MainLightColor;
-half4 _MainLightDistanceAttenuation;
-half4 _MainLightSpotDir;
-half4 _MainLightSpotAttenuation;
 float4x4 _WorldToLight;
 
 half4 _AdditionalLightCount;
 
 float4 _ScaledScreenParams;
 CBUFFER_END
+
+StructuredBuffer<int> _LightIndexBuffer;
 
 #define UNITY_MATRIX_M     unity_ObjectToWorld
 #define UNITY_MATRIX_I_M   unity_WorldToObject

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurfaceSimple.hlsl

 {
     half4 specularGloss = half4(0.0h, 0.0h, 0.0h, 1.0h);
 #ifdef _SPECGLOSSMAP
-    specularGloss = SAMPLE_TEXTURE2D(TEXTURE2D_PARAM(specGlossMap, sampler_specGlossMap), uv);
+    specularGloss = SAMPLE_TEXTURE2D(specGlossMap, sampler_specGlossMap, uv);
 #elif defined(_SPECULAR_COLOR)
     specularGloss = specColor;
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

 #include "Core.hlsl"
 #include "Shadows.hlsl"
 
-#ifdef NO_ADDITIONAL_LIGHTS
-#undef _ADDITIONAL_LIGHTS
-#endif
-
 // If lightmap is not defined than we evaluate GI (ambient + probes) from SH
 // We might do it fully or partially in vertex to save shader ALU
 #if !defined(LIGHTMAP_ON)
 // Abstraction over Light shading data.
 struct Light
 {
+    int     index;
     half3   direction;
     half3   color;
     half    attenuation;
     // We use a shared distance attenuation for additional directional and puctual lights
     // for directional lights attenuation will be 1
     half quadFalloff = distanceAttenuation.x;
-    half denom = distanceSqr * quadFalloff + 1.0;
-    half lightAtten = 1.0 / denom;
+    half denom = distanceSqr * quadFalloff + 1.0h;
+    half lightAtten = 1.0h / denom;
 
     // We need to smoothly fade attenuation to light range. We start fading linearly at 80% of light range
     // Therefore:
 {
     half4 directionAndAttenuation = GetLightDirectionAndAttenuation(lightInput, positionWS);
 
-    // Cookies are only computed for main light
-    directionAndAttenuation.w *= CookieAttenuation(positionWS);
+    // Cookies disabled for now due to amount of shader variants
+    //directionAndAttenuation.w *= CookieAttenuation(positionWS);
 
     return directionAndAttenuation;
 }
 ///////////////////////////////////////////////////////////////////////////////
 
-Light GetMainLight(float3 positionWS)
+Light GetMainLight()
-    LightInput lightInput;
-    lightInput.position = _MainLightPosition;
-    lightInput.color = _MainLightColor.rgb;
-    lightInput.distanceAttenuation = _MainLightDistanceAttenuation;
-    lightInput.spotDirection = _MainLightSpotDir;
-    lightInput.spotAttenuation = _MainLightSpotAttenuation;
-
-    half4 directionAndRealtimeAttenuation = GetMainLightDirectionAndAttenuation(lightInput, positionWS);
-
-    light.direction = directionAndRealtimeAttenuation.xyz;
-    light.attenuation = directionAndRealtimeAttenuation.w;
-    light.subtractiveModeAttenuation = lightInput.distanceAttenuation.w;
-    light.color = lightInput.color;
+    light.index = 0;
+    light.direction = _MainLightPosition.xyz;
+    light.attenuation = 1.0;
+    light.subtractiveModeAttenuation = _MainLightPosition.w;
+    light.color = _MainLightColor.rgb;
-Light GetLight(int i, float3 positionWS)
+Light GetLight(half i, float3 positionWS)
-    half4 indices = (i < 4) ? unity_4LightIndices0 : unity_4LightIndices1;
-    int index = (i < 4) ? i : i - 4;
-    int lightIndex = indices[index];
+
+#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
+    int lightIndex = _LightIndexBuffer[unity_LightIndicesOffsetAndCount.x + i];
+#else
+    // The following code is more optimal than indexing unity_4LightIndices0.
+    // Conditional moves are branch free even on mali-400
+    half i_rem = (i < 2.0h) ? i : i - 2.0h;
+    half2 lightIndex2 = (i < 2.0h) ? unity_4LightIndices0.xy : unity_4LightIndices0.zw;
+    int lightIndex = (i_rem < 1.0h) ? lightIndex2.x : lightIndex2.y;
+#endif
+
+    // The following code will turn into a branching madhouse on platforms that don't support
+    // dynamic indexing. Ideally we need to configure light data at a cluster of
+    // objects granularity level. We will only be able to do that when scriptable culling kicks in.
+    // TODO: Use StructuredBuffer on PC/Console and profile access speed on mobile that support it.
     lightInput.position = _AdditionalLightPosition[lightIndex];
     lightInput.color = _AdditionalLightColor[lightIndex].rgb;
     lightInput.distanceAttenuation = _AdditionalLightDistanceAttenuation[lightIndex];
     half4 directionAndRealtimeAttenuation = GetLightDirectionAndAttenuation(lightInput, positionWS);
 
     Light light;
+    light.index = lightIndex;
     light.direction = directionAndRealtimeAttenuation.xyz;
     light.attenuation = directionAndRealtimeAttenuation.w;
     light.subtractiveModeAttenuation = lightInput.distanceAttenuation.w;
 
 half GetPixelLightCount()
 {
+    // TODO: we need to expose in SRP api an ability for the pipeline cap the amount of lights
+    // in the culling. This way we could do the loop branch with an uniform
+    // This would be helpful to support baking exceeding lights in SH as well
     return min(_AdditionalLightCount.x, unity_LightIndicesOffsetAndCount.y);
 }
 
 
     // 1) Gives good estimate of illumination as if light would've been shadowed during the bake.
     // We only subtract the main direction light. This is accounted in the contribution term below.
-    half shadowStrength = GetShadowStrength();
-    half contributionTerm = saturate(dot(mainLight.direction, normalWS)) * (1.0 - _MainLightPosition.w);
+    half shadowStrength = _ShadowData.x;
+    half contributionTerm = saturate(dot(mainLight.direction, normalWS));
     half3 lambert = mainLight.color * contributionTerm;
     half3 estimatedLightContributionMaskedByInverseOfShadow = lambert * (1.0 - mainLight.attenuation);
     half3 subtractedLightmap = bakedGI - estimatedLightContributionMaskedByInverseOfShadow;
     BRDFData brdfData;
     InitializeBRDFData(albedo, metallic, specular, smoothness, alpha, brdfData);
 
-    Light mainLight = GetMainLight(inputData.positionWS);
-
-    mainLight.attenuation *= RealtimeShadowAttenuation(inputData.shadowCoord);
+    Light mainLight = GetMainLight();
+    mainLight.attenuation = MainLightRealtimeShadowAttenuation(inputData.shadowCoord);
 
     MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, half4(0, 0, 0, 0));
     half3 color = GlobalIllumination(brdfData, inputData.bakedGI, occlusion, inputData.normalWS, inputData.viewDirectionWS);
     for (int i = 0; i < pixelLightCount; ++i)
     {
         Light light = GetLight(i, inputData.positionWS);
+        light.attenuation *= LocalLightRealtimeShadowAttenuation(light.index, inputData.positionWS);
         color += LightingPhysicallyBased(brdfData, light, inputData.normalWS, inputData.viewDirectionWS);
     }
 #endif
 
 half4 LightweightFragmentBlinnPhong(InputData inputData, half3 diffuse, half4 specularGloss, half shininess, half3 emission, half alpha)
 {
-    Light mainLight = GetMainLight(inputData.positionWS);
-    mainLight.attenuation *= RealtimeShadowAttenuation(inputData.shadowCoord);
+    Light mainLight = GetMainLight();
+    mainLight.attenuation = MainLightRealtimeShadowAttenuation(inputData.shadowCoord);
     MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, half4(0, 0, 0, 0));
 
     half3 attenuatedLightColor = mainLight.color * mainLight.attenuation;
     for (int i = 0; i < pixelLightCount; ++i)
     {
         Light light = GetLight(i, inputData.positionWS);
+        light.attenuation *= LocalLightRealtimeShadowAttenuation(light.index, inputData.positionWS);
         half3 attenuatedLightColor = light.color * light.attenuation;
         diffuseColor += LightingLambert(attenuatedLightColor, light.direction, inputData.normalWS);
         specularColor += LightingSpecular(attenuatedLightColor, light.direction, inputData.normalWS, inputData.viewDirectionWS, specularGloss, shininess);
     half3 fullDiffuse = diffuseColor + inputData.vertexLighting;
     half3 finalColor = fullDiffuse * diffuse + emission;
-    
+
 #if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
     finalColor += specularColor;
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

-#ifndef LIGHTWEIGHT_PASS_LIT_INCLUDED
-#define LIGHTWEIGHT_PASS_LIT_INCLUDED
-
-#include "LWRP/ShaderLibrary/Lighting.hlsl"
-
-struct LightweightVertexInput
-{
-    float4 vertex : POSITION;
-    float3 normal : NORMAL;
-    float4 tangent : TANGENT;
-    float2 texcoord : TEXCOORD0;
-    float2 lightmapUV : TEXCOORD1;
-    UNITY_VERTEX_INPUT_INSTANCE_ID
-};
-
-struct LightweightVertexOutput
-{
-    float2 uv                       : TEXCOORD0;
-    DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
-    float3 posWS                    : TEXCOORD2;
-
-#ifdef _NORMALMAP
-    half4 normal                    : TEXCOORD3;    // xyz: normal, w: viewDir.x
-    half4 tangent                   : TEXCOORD4;    // xyz: tangent, w: viewDir.y
-    half4 binormal                  : TEXCOORD5;    // xyz: binormal, w: viewDir.z
-#else
-    half3  normal                   : TEXCOORD3;
-    half3 viewDir                   : TEXCOORD4;
-#endif
-
-    half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
-
-#ifdef _SHADOWS_ENABLED
-    float4 shadowCoord              : TEXCOORD7;
-#endif
-
-    float4 clipPos                  : SV_POSITION;
-    UNITY_VERTEX_INPUT_INSTANCE_ID
-    UNITY_VERTEX_OUTPUT_STEREO
-};
-
-void InitializeInputData(LightweightVertexOutput IN, half3 normalTS, out InputData inputData)
-{
-    inputData = (InputData)0;
-
-    inputData.positionWS = IN.posWS;
-
-#ifdef _NORMALMAP
-    half3 viewDir = half3(IN.normal.w, IN.tangent.w, IN.binormal.w);
-    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent.xyz, IN.binormal.xyz, IN.normal.xyz);
-#else
-    half3 viewDir = IN.viewDir;
-    inputData.normalWS = FragmentNormalWS(IN.normal);
-#endif
-
-    inputData.viewDirectionWS = FragmentViewDirWS(viewDir);
-#ifdef _SHADOWS_ENABLED
-    inputData.shadowCoord = IN.shadowCoord;
-#else
-    inputData.shadowCoord = float4(0, 0, 0, 0);
-#endif
-    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
-    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
-    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//                  Vertex and Fragment functions                            //
-///////////////////////////////////////////////////////////////////////////////
-
-// Used in Standard (Physically Based) shader
-LightweightVertexOutput LitPassVertex(LightweightVertexInput v)
-{
-    LightweightVertexOutput o = (LightweightVertexOutput)0;
-
-    UNITY_SETUP_INSTANCE_ID(v);
-    UNITY_TRANSFER_INSTANCE_ID(v, o);
-    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
-
-    o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
-
-    float3 posWS = TransformObjectToWorld(v.vertex.xyz);
-    o.clipPos = TransformWorldToHClip(posWS);
-
-    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - posWS);
-
-#ifdef _NORMALMAP
-    o.normal.w = viewDir.x;
-    o.tangent.w = viewDir.y;
-    o.binormal.w = viewDir.z;
-#else
-    o.viewDir = viewDir;
-#endif
-
-    // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
-    OUTPUT_NORMAL(v, o);
-
-    // We either sample GI from lightmap or SH.
-    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
-    // see DECLARE_LIGHTMAP_OR_SH macro.
-    // The following funcions initialize the correct variable with correct data
-    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
-    OUTPUT_SH(o.normal.xyz, o.vertexSH);
-
-    half3 vertexLight = VertexLighting(posWS, o.normal.xyz);
-    half fogFactor = ComputeFogFactor(o.clipPos.z);
-    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
-
-#ifdef _SHADOWS_ENABLED
-#if SHADOWS_SCREEN
-    o.shadowCoord = ComputeShadowCoord(o.clipPos);
-#else
-    o.shadowCoord = TransformWorldToShadowCoord(posWS);
-#endif
-#endif
-
-    o.posWS = posWS;
-
-    return o;
-}
-
-// Used in Standard (Physically Based) shader
-half4 LitPassFragment(LightweightVertexOutput IN) : SV_Target
-{
-    UNITY_SETUP_INSTANCE_ID(IN);
-
-    SurfaceData surfaceData;
-    InitializeStandardLitSurfaceData(IN.uv, surfaceData);
-
-    InputData inputData;
-    InitializeInputData(IN, surfaceData.normalTS, inputData);
-
-    half4 color = LightweightFragmentPBR(inputData, surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha);
-
-    ApplyFog(color.rgb, inputData.fogCoord);
-    return color;
-}
-
-#endif
+#ifndef LIGHTWEIGHT_PASS_LIT_INCLUDED
+#define LIGHTWEIGHT_PASS_LIT_INCLUDED
+
+#include "LWRP/ShaderLibrary/Lighting.hlsl"
+
+struct LightweightVertexInput
+{
+    float4 vertex : POSITION;
+    float3 normal : NORMAL;
+    float4 tangent : TANGENT;
+    float2 texcoord : TEXCOORD0;
+    float2 lightmapUV : TEXCOORD1;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct LightweightVertexOutput
+{
+    float2 uv                       : TEXCOORD0;
+    DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
+
+#ifdef _ADDITIONAL_LIGHTS
+    float3 posWS                    : TEXCOORD2;
+#endif
+
+#ifdef _NORMALMAP
+    half4 normal                    : TEXCOORD3;    // xyz: normal, w: viewDir.x
+    half4 tangent                   : TEXCOORD4;    // xyz: tangent, w: viewDir.y
+    half4 binormal                  : TEXCOORD5;    // xyz: binormal, w: viewDir.z
+#else
+    half3  normal                   : TEXCOORD3;
+    half3 viewDir                   : TEXCOORD4;
+#endif
+
+    half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
+
+#ifdef _SHADOWS_ENABLED
+    float4 shadowCoord              : TEXCOORD7;
+#endif
+
+    float4 clipPos                  : SV_POSITION;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+    UNITY_VERTEX_OUTPUT_STEREO
+};
+
+void InitializeInputData(LightweightVertexOutput IN, half3 normalTS, out InputData inputData)
+{
+    inputData = (InputData)0;
+
+#ifdef _ADDITIONAL_LIGHTS
+    inputData.positionWS = IN.posWS;
+#endif
+
+#ifdef _NORMALMAP
+    half3 viewDir = half3(IN.normal.w, IN.tangent.w, IN.binormal.w);
+    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent.xyz, IN.binormal.xyz, IN.normal.xyz);
+#else
+    half3 viewDir = IN.viewDir;
+    inputData.normalWS = FragmentNormalWS(IN.normal);
+#endif
+
+    inputData.viewDirectionWS = FragmentViewDirWS(viewDir);
+#ifdef _SHADOWS_ENABLED
+    inputData.shadowCoord = IN.shadowCoord;
+#else
+    inputData.shadowCoord = float4(0, 0, 0, 0);
+#endif
+    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
+    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
+    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//                  Vertex and Fragment functions                            //
+///////////////////////////////////////////////////////////////////////////////
+
+// Used in Standard (Physically Based) shader
+LightweightVertexOutput LitPassVertex(LightweightVertexInput v)
+{
+    LightweightVertexOutput o = (LightweightVertexOutput)0;
+
+    UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+    o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
+
+    float3 posWS = TransformObjectToWorld(v.vertex.xyz);
+    o.clipPos = TransformWorldToHClip(posWS);
+
+    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - posWS);
+
+#ifdef _NORMALMAP
+    o.normal.w = viewDir.x;
+    o.tangent.w = viewDir.y;
+    o.binormal.w = viewDir.z;
+#else
+    o.viewDir = viewDir;
+#endif
+
+    // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
+    OUTPUT_NORMAL(v, o);
+
+    // We either sample GI from lightmap or SH.
+    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
+    // see DECLARE_LIGHTMAP_OR_SH macro.
+    // The following funcions initialize the correct variable with correct data
+    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
+    OUTPUT_SH(o.normal.xyz, o.vertexSH);
+
+    half3 vertexLight = VertexLighting(posWS, o.normal.xyz);
+    half fogFactor = ComputeFogFactor(o.clipPos.z);
+    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
+
+#ifdef _SHADOWS_ENABLED
+#if SHADOWS_SCREEN
+    o.shadowCoord = ComputeShadowCoord(o.clipPos);
+#else
+    o.shadowCoord = TransformWorldToShadowCoord(posWS);
+#endif
+#endif
+
+#ifdef _ADDITIONAL_LIGHTS
+    o.posWS = posWS;
+#endif
+
+    return o;
+}
+
+// Used in Standard (Physically Based) shader
+half4 LitPassFragment(LightweightVertexOutput IN) : SV_Target
+{
+    UNITY_SETUP_INSTANCE_ID(IN);
+
+    SurfaceData surfaceData;
+    InitializeStandardLitSurfaceData(IN.uv, surfaceData);
+
+    InputData inputData;
+    InitializeInputData(IN, surfaceData.normalTS, inputData);
+
+    half4 color = LightweightFragmentPBR(inputData, surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha);
+
+    ApplyFog(color.rgb, inputData.fogCoord);
+    return color;
+}
+
+#endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLitSimple.hlsl

-#ifndef LIGHTWEIGHT_PASS_LIT_INCLUDED
-#define LIGHTWEIGHT_PASS_LIT_INCLUDED
-
-#include "LWRP/ShaderLibrary/Lighting.hlsl"
-
-struct LightweightVertexInput
-{
-    float4 vertex : POSITION;
-    float3 normal : NORMAL;
-    float4 tangent : TANGENT;
-    float2 texcoord : TEXCOORD0;
-    float2 lightmapUV : TEXCOORD1;
-    UNITY_VERTEX_INPUT_INSTANCE_ID
-};
-
-struct LightweightVertexOutput
-{
-    float2 uv                       : TEXCOORD0;
-    DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
-
-    float4 posWSShininess           : TEXCOORD2;    // xyz: posWS, w: Shininess * 128
-
-#ifdef _NORMALMAP
-    half4 normal                    : TEXCOORD3;    // xyz: normal, w: viewDir.x
-    half4 tangent                   : TEXCOORD4;    // xyz: tangent, w: viewDir.y
-    half4 binormal                  : TEXCOORD5;    // xyz: binormal, w: viewDir.z
-#else
-    half3  normal                   : TEXCOORD3;
-    half3 viewDir                   : TEXCOORD4;
-#endif
-
-    half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
-
-#ifdef _SHADOWS_ENABLED
-    float4 shadowCoord              : TEXCOORD7;
-#endif
-
-    float4 clipPos                  : SV_POSITION;
-    UNITY_VERTEX_INPUT_INSTANCE_ID
-    UNITY_VERTEX_OUTPUT_STEREO
-};
-
-void InitializeInputData(LightweightVertexOutput IN, half3 normalTS, out InputData inputData)
-{
-    inputData.positionWS = IN.posWSShininess.xyz;
-
-#ifdef _NORMALMAP
-    half3 viewDir = half3(IN.normal.w, IN.tangent.w, IN.binormal.w);
-    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent.xyz, IN.binormal.xyz, IN.normal.xyz);
-#else
-    half3 viewDir = IN.viewDir;
-    inputData.normalWS = FragmentNormalWS(IN.normal);
-#endif
-
-    inputData.viewDirectionWS = FragmentViewDirWS(viewDir);
-#ifdef _SHADOWS_ENABLED
-    inputData.shadowCoord = IN.shadowCoord;
-#else
-    inputData.shadowCoord = float4(0, 0, 0, 0);
-#endif
-    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
-    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
-    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//                  Vertex and Fragment functions                            //
-///////////////////////////////////////////////////////////////////////////////
-
-// Used in Standard (Simple Lighting) shader
-LightweightVertexOutput LitPassVertexSimple(LightweightVertexInput v)
-{
-    LightweightVertexOutput o = (LightweightVertexOutput)0;
-
-    UNITY_SETUP_INSTANCE_ID(v);
-    UNITY_TRANSFER_INSTANCE_ID(v, o);
-    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
-
-    o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
-
-    o.posWSShininess.xyz = TransformObjectToWorld(v.vertex.xyz);
-    o.posWSShininess.w = _Shininess * 128.0;
-    o.clipPos = TransformWorldToHClip(o.posWSShininess.xyz);
-
-    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - o.posWSShininess.xyz);
-
-#ifdef _NORMALMAP
-    o.normal.w = viewDir.x;
-    o.tangent.w = viewDir.y;
-    o.binormal.w = viewDir.z;
-#else
-    o.viewDir = viewDir;
-#endif
-
-    // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
-    OUTPUT_NORMAL(v, o);
-
-    // We either sample GI from lightmap or SH.
-    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
-    // see DECLARE_LIGHTMAP_OR_SH macro.
-    // The following funcions initialize the correct variable with correct data
-    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
-    OUTPUT_SH(o.normal.xyz, o.vertexSH);
-
-    half3 vertexLight = VertexLighting(o.posWSShininess.xyz, o.normal.xyz);
-    half fogFactor = ComputeFogFactor(o.clipPos.z);
-    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
-
-#ifdef _SHADOWS_ENABLED
-#if SHADOWS_SCREEN
-    o.shadowCoord = ComputeShadowCoord(o.clipPos);
-#else
-    o.shadowCoord = TransformWorldToShadowCoord(o.posWSShininess.xyz);
-#endif
-#endif
-
-    return o;
-}
-
-// Used for StandardSimpleLighting shader
-half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
-{
-    UNITY_SETUP_INSTANCE_ID(IN);
-
-    float2 uv = IN.uv;
-    half4 diffuseAlpha = SampleAlbedoAlpha(uv, TEXTURE2D_PARAM(_MainTex, sampler_MainTex));
-    half3 diffuse = diffuseAlpha.rgb * _Color.rgb;
-
-    half alpha = diffuseAlpha.a * _Color.a;
-    AlphaDiscard(alpha, _Cutoff);
-#ifdef _ALPHAPREMULTIPLY_ON
-    diffuse *= alpha;
-#endif
-
-    half3 normalTS = SampleNormal(uv, TEXTURE2D_PARAM(_BumpMap, sampler_BumpMap));
-    half3 emission = SampleEmission(uv, _EmissionColor.rgb, TEXTURE2D_PARAM(_EmissionMap, sampler_EmissionMap));
-    half4 specularGloss = SampleSpecularGloss(uv, diffuseAlpha.a, _SpecColor, TEXTURE2D_PARAM(_SpecGlossMap, sampler_SpecGlossMap));
-    half shininess = IN.posWSShininess.w;
-
-    InputData inputData;
-    InitializeInputData(IN, normalTS, inputData);
-
-    return LightweightFragmentBlinnPhong(inputData, diffuse, specularGloss, shininess, emission, alpha);
-};
-
-#endif
+#ifndef LIGHTWEIGHT_PASS_LIT_INCLUDED
+#define LIGHTWEIGHT_PASS_LIT_INCLUDED
+
+#include "LWRP/ShaderLibrary/Lighting.hlsl"
+
+struct LightweightVertexInput
+{
+    float4 vertex : POSITION;
+    float3 normal : NORMAL;
+    float4 tangent : TANGENT;
+    float2 texcoord : TEXCOORD0;
+    float2 lightmapUV : TEXCOORD1;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct LightweightVertexOutput
+{
+    float2 uv                       : TEXCOORD0;
+    DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
+
+    float4 posWSShininess           : TEXCOORD2;    // xyz: posWS, w: Shininess * 128
+
+#ifdef _NORMALMAP
+    half4 normal                    : TEXCOORD3;    // xyz: normal, w: viewDir.x
+    half4 tangent                   : TEXCOORD4;    // xyz: tangent, w: viewDir.y
+    half4 binormal                  : TEXCOORD5;    // xyz: binormal, w: viewDir.z
+#else
+    half3  normal                   : TEXCOORD3;
+    half3 viewDir                   : TEXCOORD4;
+#endif
+
+    half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
+
+#ifdef _SHADOWS_ENABLED
+    float4 shadowCoord              : TEXCOORD7;
+#endif
+
+    float4 clipPos                  : SV_POSITION;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+    UNITY_VERTEX_OUTPUT_STEREO
+};
+
+void InitializeInputData(LightweightVertexOutput IN, half3 normalTS, out InputData inputData)
+{
+    inputData.positionWS = IN.posWSShininess.xyz;
+
+#ifdef _NORMALMAP
+    half3 viewDir = half3(IN.normal.w, IN.tangent.w, IN.binormal.w);
+    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent.xyz, IN.binormal.xyz, IN.normal.xyz);
+#else
+    half3 viewDir = IN.viewDir;
+    inputData.normalWS = FragmentNormalWS(IN.normal);
+#endif
+
+    inputData.viewDirectionWS = FragmentViewDirWS(viewDir);
+#ifdef _SHADOWS_ENABLED
+    inputData.shadowCoord = IN.shadowCoord;
+#else
+    inputData.shadowCoord = float4(0, 0, 0, 0);
+#endif
+    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
+    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
+    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//                  Vertex and Fragment functions                            //
+///////////////////////////////////////////////////////////////////////////////
+
+// Used in Standard (Simple Lighting) shader
+LightweightVertexOutput LitPassVertexSimple(LightweightVertexInput v)
+{
+    LightweightVertexOutput o = (LightweightVertexOutput)0;
+
+    UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+    o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
+
+    o.posWSShininess.xyz = TransformObjectToWorld(v.vertex.xyz);
+    o.posWSShininess.w = _Shininess * 128.0;
+    o.clipPos = TransformWorldToHClip(o.posWSShininess.xyz);
+
+    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - o.posWSShininess.xyz);
+
+#ifdef _NORMALMAP
+    o.normal.w = viewDir.x;
+    o.tangent.w = viewDir.y;
+    o.binormal.w = viewDir.z;
+#else
+    o.viewDir = viewDir;
+#endif
+
+    // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
+    OUTPUT_NORMAL(v, o);
+
+    // We either sample GI from lightmap or SH.
+    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
+    // see DECLARE_LIGHTMAP_OR_SH macro.
+    // The following funcions initialize the correct variable with correct data
+    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
+    OUTPUT_SH(o.normal.xyz, o.vertexSH);
+
+    half3 vertexLight = VertexLighting(o.posWSShininess.xyz, o.normal.xyz);
+    half fogFactor = ComputeFogFactor(o.clipPos.z);
+    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
+
+#ifdef _SHADOWS_ENABLED
+#if SHADOWS_SCREEN
+    o.shadowCoord = ComputeShadowCoord(o.clipPos);
+#else
+    o.shadowCoord = TransformWorldToShadowCoord(o.posWSShininess.xyz);
+#endif
+#endif
+
+    return o;
+}
+
+// Used for StandardSimpleLighting shader
+half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
+{
+    UNITY_SETUP_INSTANCE_ID(IN);
+
+    float2 uv = IN.uv;
+    half4 diffuseAlpha = SampleAlbedoAlpha(uv, TEXTURE2D_PARAM(_MainTex, sampler_MainTex));
+    half3 diffuse = diffuseAlpha.rgb * _Color.rgb;
+
+    half alpha = diffuseAlpha.a * _Color.a;
+    AlphaDiscard(alpha, _Cutoff);
+#ifdef _ALPHAPREMULTIPLY_ON
+    diffuse *= alpha;
+#endif
+
+    half3 normalTS = SampleNormal(uv, TEXTURE2D_PARAM(_BumpMap, sampler_BumpMap));
+    half3 emission = SampleEmission(uv, _EmissionColor.rgb, TEXTURE2D_PARAM(_EmissionMap, sampler_EmissionMap));
+    half4 specularGloss = SampleSpecularGloss(uv, diffuseAlpha.a, _SpecColor, TEXTURE2D_PARAM(_SpecGlossMap, sampler_SpecGlossMap));
+    half shininess = IN.posWSShininess.w;
+
+    InputData inputData;
+    InitializeInputData(IN, normalTS, inputData);
+
+    return LightweightFragmentBlinnPhong(inputData, diffuse, specularGloss, shininess, emission, alpha);
+};
+
+#endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLitSimple.hlsl.meta

-fileFormatVersion: 2
-guid: ee447e65526c7db45a978c16b28827a9
-timeCreated: 1488965025
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: ee447e65526c7db45a978c16b28827a9
+timeCreated: 1488965025
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Shadows.hlsl

 TEXTURE2D_SHADOW(_ShadowMap);
 SAMPLER_CMP(sampler_ShadowMap);
 
-CBUFFER_START(_ShadowBuffer)
+TEXTURE2D_SHADOW(_LocalShadowMapAtlas);
+SAMPLER_CMP(sampler_LocalShadowMapAtlas);
+
+CBUFFER_START(_DirectionalShadowBuffer)
 // Last cascade is initialized with a no-op matrix. It always transforms
 // shadow coord to half(0, 0, NEAR_PLANE). We use this trick to avoid
 // branching since ComputeCascadeIndex can return cascade index = MAX_SHADOW_CASCADES
 float4      _ShadowmapSize; // (xy: 1/width and 1/height, zw: width and height)
 CBUFFER_END
 
+CBUFFER_START(_LocalShadowBuffer)
+float4x4    _LocalWorldToShadowAtlas[4];
+half        _LocalShadowStrength[4];
+half4       _LocalShadowOffset0;
+half4       _LocalShadowOffset1;
+half4       _LocalShadowOffset2;
+half4       _LocalShadowOffset3;
+float4      _LocalShadowmapSize; // (xy: 1/width and 1/height, zw: width and height)
+CBUFFER_END
+
 #if UNITY_REVERSED_Z
 #define BEYOND_SHADOW_FAR(shadowCoord) shadowCoord.z <= UNITY_RAW_FAR_CLIP_VALUE
 #else
-half GetShadowStrength()
+struct ShadowSamplingData
+{
+    half4 shadowOffset0;
+    half4 shadowOffset1;
+    half4 shadowOffset2;
+    half4 shadowOffset3;
+    float4 shadowmapSize;
+};
+
+ShadowSamplingData GetMainLightShadowSamplingData()
+{
+    ShadowSamplingData shadowSamplingData;
+    shadowSamplingData.shadowOffset0 = _ShadowOffset0;
+    shadowSamplingData.shadowOffset1 = _ShadowOffset1;
+    shadowSamplingData.shadowOffset2 = _ShadowOffset2;
+    shadowSamplingData.shadowOffset3 = _ShadowOffset3;
+    shadowSamplingData.shadowmapSize = _ShadowmapSize;
+    return shadowSamplingData;
+}
+
+ShadowSamplingData GetLocalLightShadowSamplingData()
+{
+    ShadowSamplingData shadowSamplingData;
+    shadowSamplingData.shadowOffset0 = _LocalShadowOffset0;
+    shadowSamplingData.shadowOffset1 = _LocalShadowOffset1;
+    shadowSamplingData.shadowOffset2 = _LocalShadowOffset2;
+    shadowSamplingData.shadowOffset3 = _LocalShadowOffset3;
+    shadowSamplingData.shadowmapSize = _LocalShadowmapSize;
+    return shadowSamplingData;
+}
+
+half GetMainLightShadowStrength()
-inline half SampleScreenSpaceShadowMap(float4 shadowCoord)
+half GetLocalLightShadowStrenth(int lightIndex)
+{
+    return _LocalShadowStrength[lightIndex];
+}
+
+half SampleScreenSpaceShadowMap(float4 shadowCoord)
 {
     shadowCoord.xy /= shadowCoord.w;
 
     return attenuation;
 }
 
-inline real SampleShadowmap(float4 shadowCoord)
+real SampleShadowmap(float4 shadowCoord, TEXTURE2D_SHADOW_ARGS(ShadowMap, sampler_ShadowMap), ShadowSamplingData samplingData, half shadowStrength)
 {
     shadowCoord.xyz /= shadowCoord.w;
 
     #ifdef SHADER_API_MOBILE
         // 4-tap hardware comparison
         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);
-        attenuation4.w = SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, shadowCoord.xyz + _ShadowOffset3.xyz);
+        attenuation4.x = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz + samplingData.shadowOffset0.xyz);
+        attenuation4.y = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz + samplingData.shadowOffset1.xyz);
+        attenuation4.z = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz + samplingData.shadowOffset2.xyz);
+        attenuation4.w = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz + samplingData.shadowOffset3.xyz);
-            SampleShadow_ComputeSamples_Tent_7x7(_ShadowmapSize, shadowCoord.xy, fetchesWeights, fetchesUV);
+            SampleShadow_ComputeSamples_Tent_7x7(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));
-            attenuation += fetchesWeights[2]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[2].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[3]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[3].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[4]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[4].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[5]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[5].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[6]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[6].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[7]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[7].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[8]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[8].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[9]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[9].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[10] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[10].xy, shadowCoord.z));
-            attenuation += fetchesWeights[11] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[11].xy, shadowCoord.z));
-            attenuation += fetchesWeights[12] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[12].xy, shadowCoord.z));
-            attenuation += fetchesWeights[13] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[13].xy, shadowCoord.z));
-            attenuation += fetchesWeights[14] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[14].xy, shadowCoord.z));
-            attenuation += fetchesWeights[15] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[15].xy, shadowCoord.z));
+            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));
+            attenuation += fetchesWeights[2]  * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[2].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[3]  * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[3].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[4]  * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[4].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[5]  * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[5].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[6]  * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[6].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[7]  * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[7].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[8]  * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[8].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[9]  * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[9].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[10] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[10].xy, shadowCoord.z));
+            attenuation += fetchesWeights[11] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[11].xy, shadowCoord.z));
+            attenuation += fetchesWeights[12] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[12].xy, shadowCoord.z));
+            attenuation += fetchesWeights[13] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[13].xy, shadowCoord.z));
+            attenuation += fetchesWeights[14] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[14].xy, shadowCoord.z));
+            attenuation += fetchesWeights[15] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[15].xy, shadowCoord.z));
-            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));
-            attenuation += fetchesWeights[2] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[2].xy, shadowCoord.z));
-            attenuation += fetchesWeights[3] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[3].xy, shadowCoord.z));
-            attenuation += fetchesWeights[4] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[4].xy, shadowCoord.z));
-            attenuation += fetchesWeights[5] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[5].xy, shadowCoord.z));
-            attenuation += fetchesWeights[6] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[6].xy, shadowCoord.z));
-            attenuation += fetchesWeights[7] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[7].xy, shadowCoord.z));
-            attenuation += fetchesWeights[8] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[8].xy, shadowCoord.z));
+            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));
+            attenuation += fetchesWeights[2] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[2].xy, shadowCoord.z));
+            attenuation += fetchesWeights[3] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[3].xy, shadowCoord.z));
+            attenuation += fetchesWeights[4] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[4].xy, shadowCoord.z));
+            attenuation += fetchesWeights[5] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[5].xy, shadowCoord.z));
+            attenuation += fetchesWeights[6] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[6].xy, shadowCoord.z));
+            attenuation += fetchesWeights[7] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[7].xy, shadowCoord.z));
+            attenuation += fetchesWeights[8] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[8].xy, shadowCoord.z));
-    attenuation = SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, shadowCoord.xyz);
+    attenuation = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz);
-#if SHADER_HINT_NICE_QUALITY
-    // Apply shadow strength
-    attenuation = LerpWhiteTo(attenuation, GetShadowStrength());
-#endif
+    attenuation = LerpWhiteTo(attenuation, shadowStrength);
-inline half ComputeCascadeIndex(float3 positionWS)
+half ComputeCascadeIndex(float3 positionWS)
 {
     // TODO: profile if there's a performance improvement if we avoid indexing here
     float3 fromCenter0 = positionWS.xyz - _DirShadowSplitSpheres[0].xyz;
     return ComputeScreenPos(clipPos);
 }
 
-half RealtimeShadowAttenuation(float4 shadowCoord)
+half MainLightRealtimeShadowAttenuation(float4 shadowCoord)
-#ifndef _SHADOWS_ENABLED
-    return 1.0h;
-#endif
-
-#if defined(NO_SHADOWS)
+#if defined(NO_SHADOWS) || !defined(_SHADOWS_ENABLED)
+    ShadowSamplingData shadowSamplingData = GetMainLightShadowSamplingData();
+    half shadowStrength = GetMainLightShadowStrength();
+    return SampleShadowmap(shadowCoord, TEXTURE2D_PARAM(_ShadowMap, sampler_ShadowMap), shadowSamplingData, shadowStrength);
+#endif
-    return SampleShadowmap(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)
+    return 1.0h;
+#else
+    float4 shadowCoord = mul(_LocalWorldToShadowAtlas[lightIndex], float4(positionWS, 1.0));
+    ShadowSamplingData shadowSamplingData = GetLocalLightShadowSamplingData();
+    half shadowStrength = GetLocalLightShadowStrenth(lightIndex);
+    return SampleShadowmap(shadowCoord, TEXTURE2D_PARAM(_LocalShadowMapAtlas, sampler_LocalShadowMapAtlas), shadowSamplingData, shadowStrength);
 #endif
 }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader

         {
             UNITY_SETUP_INSTANCE_ID(i);
 #if !defined(UNITY_STEREO_INSTANCING_ENABLED)
-            // Completely unclear why i.stereoTargetEyeIndex doesn't work here, considering 
+            // Completely unclear why i.stereoTargetEyeIndex doesn't work here, considering
             // this has to be correct in order for the texture array slices to be rasterized to
             // We can limit this workaround to stereo instancing for now.
             UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
             //Fetch shadow coordinates for cascade.
             float4 coords  = TransformWorldToShadowCoord(wpos);
 
-            return SampleShadowmap(coords);
+            // Screenspace shadowmap is only used for directional lights which use orthogonal projection.
+            ShadowSamplingData shadowSamplingData = GetMainLightShadowSamplingData();
+            half shadowStrength = GetMainLightShadowStrength();
+            return SampleShadowmap(coords, TEXTURE2D_PARAM(_ShadowMap, sampler_ShadowMap), shadowSamplingData, shadowStrength);
-        {           
+        {
             ZTest Always
             ZWrite Off
             Cull Off
             #pragma multi_compile _ _SHADOWS_CASCADE
-            
+
             #pragma vertex   Vertex
             #pragma fragment Fragment
             ENDHLSL

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

             #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
+
             // -------------------------------------
             // Unity defined keywords
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesSimpleLighting.shader

 
             #define BUMP_SCALE_NOT_SUPPORTED 1
             #define NO_SHADOWS 1
-            
+
             #include "LWRP/ShaderLibrary/Particles.hlsl"
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

             #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
+
             // -------------------------------------
             // Unity defined keywords
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightShadowPass.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.LightweightPipeline
+{
+    [Serializable]
+    public class ShadowSettings
+    {
+        public LightShadows directionalShadowQuality;
+        public bool screenSpace;
+        public int directionalShadowAtlasWidth;
+        public int directionalShadowAtlasHeight;
+        public LightShadows localLightsShadowQuality;
+        public int localShadowAtlasWidth;
+        public int localShadowAtlasHeight;
+        public int bufferBitCount;
+
+        public float maxShadowDistance;
+        public int directionalLightCascadeCount;
+        public Vector3 directionalLightCascades;
+
+        public RenderTextureFormat shadowmapTextureFormat;
+        public RenderTextureFormat screenspaceShadowmapTextureFormat;
+
+        static ShadowSettings defaultShadowSettings = null;
+
+        public static ShadowSettings Default
+        {
+            get
+            {
+                if (defaultShadowSettings == null)
+                {
+                    defaultShadowSettings = new ShadowSettings();
+                    defaultShadowSettings.directionalShadowQuality = LightShadows.None;
+                    defaultShadowSettings.screenSpace = true;
+                    defaultShadowSettings.directionalShadowAtlasHeight = defaultShadowSettings.directionalShadowAtlasWidth = 2048;
+                    defaultShadowSettings.localLightsShadowQuality = LightShadows.None;
+                    defaultShadowSettings.localShadowAtlasWidth = 512;
+                    defaultShadowSettings.localShadowAtlasHeight = 512;
+                    defaultShadowSettings.bufferBitCount = 16;
+                    defaultShadowSettings.directionalLightCascadeCount = 1;
+                    defaultShadowSettings.directionalLightCascades = new Vector3(0.05F, 0.2F, 0.3F);
+                    defaultShadowSettings.shadowmapTextureFormat = RenderTextureFormat.Shadowmap;
+                    defaultShadowSettings.screenspaceShadowmapTextureFormat = RenderTextureFormat.R8;
+                }
+                return defaultShadowSettings;
+            }
+        }
+    }
+
+    public struct ShadowSliceData
+    {
+        public Matrix4x4 shadowTransform;
+        public int offsetX;
+        public int offsetY;
+        public int resolution;
+
+        public void Clear()
+        {
+            shadowTransform = Matrix4x4.identity;
+            offsetX = offsetY = 0;
+            resolution = 1024;
+        }
+    }
+
+    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 RequireScreenSpaceShadowmap { get { return IsDirectionalShadowsEnabled && m_ShadowSettings.screenSpace; } }
+        public bool HasDirectionalShadowmap { get { return m_DirectionalShadowmapQuality != LightShadows.None; } }
+        public bool HasLocalLightsShadowmap { get { return m_LocalShadowmapQuality != LightShadows.None; } }
+
+        public float RenderingDistance { get { return m_ShadowSettings.maxShadowDistance; } }
+
+        private const int kMaxCascades = 4;
+
+        private int m_ShadowCasterCascadesCount;
+        private int m_DirectionalShadowmapID;
+        private int m_LocalShadowmapID;
+        private int m_ScreenSpaceShadowmapID;
+
+        private ShadowSettings m_ShadowSettings = ShadowSettings.Default;
+
+        private Material m_ScreenSpaceShadowsMaterial;
+
+        private RenderTexture m_DirectionalShadowmapTexture;
+        private RenderTexture m_LocalShadowmapTexture;
+        private RenderTargetIdentifier m_ScreenSpaceShadowmapTexture;
+
+        private RenderTextureDescriptor m_DirectionalShadowmapDescriptor;
+        private RenderTextureDescriptor m_LocalShadowmapDescriptor;
+
+        private LightShadows m_DirectionalShadowmapQuality;
+        private LightShadows m_LocalShadowmapQuality;
+
+        private Matrix4x4[] m_DirectionalShadowMatrices;
+        private ShadowSliceData[] m_CascadeSlices;
+        private Vector4[] m_CascadeSplitDistances;
+        private Vector4 m_CascadeSplitRadii;
+
+        private Matrix4x4[] m_LocalShadowMatrices;
+        private ShadowSliceData[] m_LocalLightSlices;
+        private float[] m_LocalShadowStrength;
+
+        public LightweightShadowPass(LightweightPipelineAsset pipelineAsset, int maxLocalLightsCount)
+        {
+            BuildShadowSettings(pipelineAsset);
+
+            m_DirectionalShadowMatrices = new Matrix4x4[kMaxCascades + 1];
+            m_CascadeSlices = new ShadowSliceData[kMaxCascades];
+            m_CascadeSplitDistances = new Vector4[kMaxCascades];
+
+            m_LocalShadowMatrices = new Matrix4x4[maxLocalLightsCount];
+            m_LocalLightSlices = new ShadowSliceData[maxLocalLightsCount];
+            m_LocalShadowStrength = new float[maxLocalLightsCount];
+
+            DirectionalShadowConstantBuffer._WorldToShadow = Shader.PropertyToID("_WorldToShadow");
+            DirectionalShadowConstantBuffer._ShadowData = Shader.PropertyToID("_ShadowData");
+            DirectionalShadowConstantBuffer._DirShadowSplitSpheres = Shader.PropertyToID("_DirShadowSplitSpheres");
+            DirectionalShadowConstantBuffer._DirShadowSplitSphereRadii = Shader.PropertyToID("_DirShadowSplitSphereRadii");
+            DirectionalShadowConstantBuffer._ShadowOffset0 = Shader.PropertyToID("_ShadowOffset0");
+            DirectionalShadowConstantBuffer._ShadowOffset1 = Shader.PropertyToID("_ShadowOffset1");
+            DirectionalShadowConstantBuffer._ShadowOffset2 = Shader.PropertyToID("_ShadowOffset2");
+            DirectionalShadowConstantBuffer._ShadowOffset3 = Shader.PropertyToID("_ShadowOffset3");
+            DirectionalShadowConstantBuffer._ShadowmapSize = Shader.PropertyToID("_ShadowmapSize");
+
+            LocalShadowConstantBuffer._LocalWorldToShadowAtlas = Shader.PropertyToID("_LocalWorldToShadowAtlas");
+            LocalShadowConstantBuffer._LocalShadowStrength = Shader.PropertyToID("_LocalShadowStrength");
+            LocalShadowConstantBuffer._LocalShadowOffset0 = Shader.PropertyToID("_LocalShadowOffset0");
+            LocalShadowConstantBuffer._LocalShadowOffset1 = Shader.PropertyToID("_LocalShadowOffset1");
+            LocalShadowConstantBuffer._LocalShadowOffset2 = Shader.PropertyToID("_LocalShadowOffset2");
+            LocalShadowConstantBuffer._LocalShadowOffset3 = Shader.PropertyToID("_LocalShadowOffset3");
+            LocalShadowConstantBuffer._LocalShadowmapSize = Shader.PropertyToID("_LocalShadowmapSize");
+
+            m_DirectionalShadowmapID = Shader.PropertyToID("_ShadowMap");
+            m_LocalShadowmapID = Shader.PropertyToID("_LocalShadowMapAtlas");
+            m_ScreenSpaceShadowmapID = Shader.PropertyToID("_ScreenSpaceShadowMap");
+            m_ScreenSpaceShadowmapTexture = new RenderTargetIdentifier(m_ScreenSpaceShadowmapID);
+
+            m_DirectionalShadowmapDescriptor = new RenderTextureDescriptor(m_ShadowSettings.directionalShadowAtlasWidth,
+                    m_ShadowSettings.directionalShadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, m_ShadowSettings.bufferBitCount);
+
+            m_LocalShadowmapDescriptor = new RenderTextureDescriptor(m_ShadowSettings.localShadowAtlasWidth,
+                    m_ShadowSettings.localShadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, m_ShadowSettings.bufferBitCount);
+
+            m_ScreenSpaceShadowsMaterial = CoreUtils.CreateEngineMaterial(pipelineAsset.ScreenSpaceShadowShader);
+
+            Clear();
+        }
+
+        public void InitializeResources(CommandBuffer cmd, RenderTextureDescriptor renderTextureDesc)
+        {
+            if (RequireScreenSpaceShadowmap)
+            {
+                renderTextureDesc.depthBufferBits = 0;
+                renderTextureDesc.colorFormat = m_ShadowSettings.screenspaceShadowmapTextureFormat;
+                cmd.GetTemporaryRT(m_ScreenSpaceShadowmapID, renderTextureDesc, FilterMode.Bilinear);
+            }
+        }
+
+        public void Dispose(CommandBuffer cmd)
+        {
+            cmd.ReleaseTemporaryRT(m_ScreenSpaceShadowmapID);
+
+            if (m_DirectionalShadowmapTexture)
+            {
+                RenderTexture.ReleaseTemporary(m_DirectionalShadowmapTexture);
+                m_DirectionalShadowmapTexture = null;
+            }
+
+            if (m_LocalShadowmapTexture)
+            {
+                RenderTexture.ReleaseTemporary(m_LocalShadowmapTexture);
+                m_LocalShadowmapTexture = null;
+            }
+        }
+
+        public bool Execute(ref CullResults cullResults, ref LightData lightData, ref ScriptableRenderContext context)
+        {
+            Clear();
+
+            bool directionalShadowmapRendered = false;
+            if (IsDirectionalShadowsEnabled)
+                directionalShadowmapRendered = RenderDirectionalCascadeShadowmap(ref cullResults, ref lightData, ref context);
+
+            if (IsLocalShadowsEnabled)
+                RenderLocalShadowmapAtlas(ref cullResults, ref lightData, ref context);
+
+            return directionalShadowmapRendered && m_ShadowSettings.screenSpace;
+        }
+
+        public void CollectShadows(Camera camera, FrameRenderingConfiguration frameRenderingConfiguration, ref ScriptableRenderContext context)
+        {
+            CommandBuffer cmd = CommandBufferPool.Get("Collect Shadows");
+
+            SetShadowCollectPassKeywords(cmd);
+
+            // Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that
+            // doesn't like null sources when trying to determine a stereo-ized blit.  So for proper
+            // stereo functionality, we use the screen-space shadow map as the source (until we have
+            // a better solution).
+            // An alternative would be DrawProcedural, but that would require further changes in the shader.
+            cmd.Blit(m_ScreenSpaceShadowmapTexture, m_ScreenSpaceShadowmapTexture, m_ScreenSpaceShadowsMaterial);
+
+            LightweightUtils.StartStereoRendering(camera, ref context, frameRenderingConfiguration);
+
+            context.ExecuteCommandBuffer(cmd);
+
+            LightweightUtils.StopStereoRendering(camera, ref context, frameRenderingConfiguration);
+
+            CommandBufferPool.Release(cmd);
+        }
+
+        private void BuildShadowSettings(LightweightPipelineAsset pipelineAsset)
+        {
+            bool isOpenGLES2 = SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES2;
+            bool supportsLocalShadows = Application.isMobilePlatform || Application.platform == RuntimePlatform.WebGLPlayer;
+
+            m_ShadowSettings = ShadowSettings.Default;
+            m_ShadowSettings.directionalShadowQuality = (LightShadows)pipelineAsset.ShadowSetting;
+
+            // Until we can have keyword stripping forcing single cascade hard shadows on gles2
+            m_ShadowSettings.screenSpace = !isOpenGLES2;
+            m_ShadowSettings.directionalLightCascadeCount = (isOpenGLES2) ? 1 : pipelineAsset.CascadeCount;
+
+            m_ShadowSettings.directionalShadowAtlasWidth = pipelineAsset.ShadowAtlasResolution;
+            m_ShadowSettings.directionalShadowAtlasHeight = pipelineAsset.ShadowAtlasResolution;
+            m_ShadowSettings.maxShadowDistance = pipelineAsset.ShadowDistance;
+            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)
+            {
+                case 1:
+                    m_ShadowSettings.directionalLightCascades = new Vector3(1.0f, 0.0f, 0.0f);
+                    break;
+
+                case 2:
+                    m_ShadowSettings.directionalLightCascades = new Vector3(pipelineAsset.Cascade2Split, 1.0f, 0.0f);
+                    break;
+
+                default:
+                    m_ShadowSettings.directionalLightCascades = pipelineAsset.Cascade4Split;
+                    break;
+            }
+
+            // Until we can have keyword stripping we disable local light shadows on mobile
+            m_ShadowSettings.localLightsShadowQuality = (supportsLocalShadows) ? LightShadows.Hard : LightShadows.None;
+        }
+
+        private void Clear()
+        {
+            m_DirectionalShadowmapTexture = null;
+            m_LocalShadowmapTexture = null;
+            m_DirectionalShadowmapQuality = LightShadows.None;
+            m_LocalShadowmapQuality = LightShadows.None;
+
+            for (int i = 0; i < m_DirectionalShadowMatrices.Length; ++i)
+                m_DirectionalShadowMatrices[i] = Matrix4x4.identity;
+
+            for (int i = 0; i < m_LocalShadowMatrices.Length; ++i)
+                m_LocalShadowMatrices[i] = Matrix4x4.identity;
+
+            for (int i = 0; i < m_CascadeSplitDistances.Length; ++i)
+                m_CascadeSplitDistances[i] = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+
+            m_CascadeSplitRadii = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+
+            for (int i = 0; i < m_CascadeSlices.Length; ++i)
+                m_CascadeSlices[i].Clear();
+
+            for (int i = 0; i < m_LocalLightSlices.Length; ++i)
+                m_LocalLightSlices[i].Clear();
+
+            for (int i = 0; i < m_LocalShadowStrength.Length; ++i)
+                m_LocalShadowStrength[i] = 0.0f;
+        }
+
+        private void SetShadowCollectPassKeywords(CommandBuffer cmd)
+        {
+            CoreUtils.SetKeyword(cmd, "_SHADOWS_SOFT", m_DirectionalShadowmapQuality == LightShadows.Soft);
+            CoreUtils.SetKeyword(cmd, "_SHADOWS_CASCADE", m_ShadowSettings.directionalLightCascadeCount > 1);
+        }
+
+        private bool RenderDirectionalCascadeShadowmap(ref CullResults cullResults, ref LightData lightData, ref ScriptableRenderContext context)
+        {
+            int shadowLightIndex = lightData.mainLightIndex;
+            if (shadowLightIndex == -1)
+                return false;
+
+            VisibleLight shadowLight = lightData.visibleLights[shadowLightIndex];
+            Light light = shadowLight.light;
+            Debug.Assert(shadowLight.lightType == LightType.Directional);
+
+            if (light.shadows == LightShadows.None)
+                return false;
+
+            CommandBuffer cmd = CommandBufferPool.Get("Prepare Directional Shadowmap");
+            m_ShadowCasterCascadesCount = m_ShadowSettings.directionalLightCascadeCount;
+
+            int shadowResolution = GetMaxTileResolutionInAtlas(m_ShadowSettings.directionalShadowAtlasWidth, m_ShadowSettings.directionalShadowAtlasHeight, m_ShadowCasterCascadesCount);
+            float shadowNearPlane = light.shadowNearPlane;
+
+            Bounds bounds;
+            if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
+                return false;
+
+            Matrix4x4 view, proj;
+            var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
+
+            m_DirectionalShadowmapTexture = RenderTexture.GetTemporary(m_DirectionalShadowmapDescriptor);
+            m_DirectionalShadowmapTexture.filterMode = FilterMode.Bilinear;
+            m_DirectionalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
+
+            CoreUtils.SetRenderTarget(cmd, m_DirectionalShadowmapTexture, ClearFlag.Depth);
+
+            bool success = false;
+            for (int cascadeIndex = 0; cascadeIndex < m_ShadowCasterCascadesCount; ++cascadeIndex)
+            {
+                success = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(shadowLightIndex,
+                        cascadeIndex, m_ShadowCasterCascadesCount, m_ShadowSettings.directionalLightCascades, shadowResolution, shadowNearPlane, out view, out proj,
+                        out settings.splitData);
+
+                float cullingSphereRadius = settings.splitData.cullingSphere.w;
+                m_CascadeSplitDistances[cascadeIndex] = settings.splitData.cullingSphere;
+                m_CascadeSplitRadii[cascadeIndex] = cullingSphereRadius * cullingSphereRadius;
+
+                if (!success)
+                    break;
+
+                m_CascadeSlices[cascadeIndex].offsetX = (cascadeIndex % 2) * shadowResolution;
+                m_CascadeSlices[cascadeIndex].offsetY = (cascadeIndex / 2) * shadowResolution;
+                m_CascadeSlices[cascadeIndex].resolution = shadowResolution;
+                m_CascadeSlices[cascadeIndex].shadowTransform = GetShadowTransform(proj, view);
+
+                // If we have shadow cascades baked into the atlas we bake cascade transform
+                // in each shadow matrix to save shader ALU and L/S
+                if (m_ShadowCasterCascadesCount > 1)
+                    ApplySliceTransform(ref m_CascadeSlices[cascadeIndex], m_ShadowSettings.directionalShadowAtlasWidth, m_ShadowSettings.directionalShadowAtlasHeight);
+
+                SetupShadowCasterConstants(cmd, ref shadowLight, proj, shadowResolution);
+                RenderShadowSlice(cmd, ref context, ref m_CascadeSlices[cascadeIndex], proj, view, settings);
+            }
+
+            if (success)
+            {
+                m_DirectionalShadowmapQuality = (m_ShadowSettings.directionalShadowQuality != LightShadows.Soft) ? LightShadows.Hard : light.shadows;
+
+                // 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.
+                if (!m_ShadowSettings.screenSpace)
+                    m_DirectionalShadowmapQuality = LightShadows.Hard;
+
+                SetupDirectionalShadowReceiverConstants(cmd, shadowLight, ref context);
+            }
+
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+            return success;
+        }
+
+        private void RenderLocalShadowmapAtlas(ref CullResults cullResults, ref LightData lightData, ref ScriptableRenderContext context)
+        {
+            List<int> localLightIndices = lightData.localLightIndices;
+            List<VisibleLight> visibleLights = lightData.visibleLights;
+
+            int shadowCastingLightsCount = 0;
+            int localLightsCount = localLightIndices.Count;
+            for (int i = 0; i < localLightsCount; ++i)
+            {
+                VisibleLight shadowLight = visibleLights[localLightIndices[i]];
+
+                if (shadowLight.lightType == LightType.Spot && shadowLight.light.shadows != LightShadows.None)
+                    shadowCastingLightsCount++;
+            }
+
+            if (shadowCastingLightsCount == 0)
+                return;
+
+            CommandBuffer cmd = CommandBufferPool.Get("Prepare Local Lights Shadowmap");
+            Matrix4x4 view, proj;
+            Bounds bounds;
+
+            // TODO: Add support to point light shadows. We make a simplification here that only works
+            // for spot lights and with max spot shadows per pass.
+            int atlasWidth = m_ShadowSettings.localShadowAtlasWidth;
+            int atlasHeight = m_ShadowSettings.localShadowAtlasHeight;
+            int sliceResolution = GetMaxTileResolutionInAtlas(atlasWidth, atlasHeight, shadowCastingLightsCount);
+            int shadowSampling = 0;
+
+            m_LocalShadowmapTexture = RenderTexture.GetTemporary(m_LocalShadowmapDescriptor);
+            m_LocalShadowmapTexture.filterMode = FilterMode.Bilinear;
+            m_LocalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
+
+            CoreUtils.SetRenderTarget(cmd, m_LocalShadowmapTexture, ClearFlag.Depth);
+
+            for (int i = 0; i < localLightsCount; ++i)
+            {
+                int shadowLightIndex = localLightIndices[i];
+                VisibleLight shadowLight = visibleLights[shadowLightIndex];
+                Light light = shadowLight.light;
+
+                // TODO: Add support to point light shadows
+                if (shadowLight.lightType != LightType.Spot || shadowLight.light.shadows == LightShadows.None)
+                    continue;
+
+                if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
+                    continue;
+
+                var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
+
+                if (cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(shadowLightIndex, out view, out proj, out settings.splitData))
+                {
+                    // This way of computing the shadow slice only work for spots and with most 4 shadow casting lights per pass
+                    // Change this when point lights are supported.
+                    Debug.Assert(localLightsCount <= 4 && shadowLight.lightType == LightType.Spot);
+
+                    // TODO: We need to pass bias and scale list to shader to be able to support multiple
+                    // shadow casting local lights.
+                    m_LocalLightSlices[i].offsetX = (i % 2) * sliceResolution;
+                    m_LocalLightSlices[i].offsetY = (i / 2) * sliceResolution;
+                    m_LocalLightSlices[i].resolution = sliceResolution;
+                    m_LocalLightSlices[i].shadowTransform = GetShadowTransform(proj, view);
+
+                    if (shadowCastingLightsCount > 1)
+                        ApplySliceTransform(ref m_LocalLightSlices[i], atlasWidth, atlasHeight);
+
+                    SetupShadowCasterConstants(cmd, ref shadowLight, proj, sliceResolution);
+                    RenderShadowSlice(cmd, ref context, ref m_LocalLightSlices[i], proj, view, settings);
+                    m_LocalShadowStrength[i] = light.shadowStrength;
+                    shadowSampling = Math.Max(shadowSampling, (int)light.shadows);
+                }
+            }
+
+            SetupLocalLightsShadowReceiverConstants(cmd, ref context);
+
+            m_LocalShadowmapQuality = (LightShadows)Math.Min(shadowSampling, (int)m_ShadowSettings.directionalShadowQuality);
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+        }
+
+        private Matrix4x4 GetShadowTransform(Matrix4x4 proj, Matrix4x4 view)
+        {
+            // Currently CullResults ComputeDirectionalShadowMatricesAndCullingPrimitives doesn't
+            // apply z reversal to projection matrix. We need to do it manually here.
+            if (SystemInfo.usesReversedZBuffer)
+            {
+                proj.m20 = -proj.m20;
+                proj.m21 = -proj.m21;
+                proj.m22 = -proj.m22;
+                proj.m23 = -proj.m23;
+            }
+
+            Matrix4x4 worldToShadow = proj * view;
+
+            var textureScaleAndBias = Matrix4x4.identity;
+            textureScaleAndBias.m00 = 0.5f;
+            textureScaleAndBias.m11 = 0.5f;
+            textureScaleAndBias.m22 = 0.5f;
+            textureScaleAndBias.m03 = 0.5f;
+            textureScaleAndBias.m23 = 0.5f;
+            textureScaleAndBias.m13 = 0.5f;
+
+            // Apply texture scale and offset to save a MAD in shader.
+            return textureScaleAndBias * worldToShadow;
+        }
+
+        private void ApplySliceTransform(ref ShadowSliceData shadowSliceData, int atlasWidth, int atlasHeight)
+        {
+            Matrix4x4 sliceTransform = Matrix4x4.identity;
+            float oneOverAtlasWidth = 1.0f / atlasWidth;
+            float oneOverAtlasHeight = 1.0f / atlasHeight;
+            sliceTransform.m00 = shadowSliceData.resolution * oneOverAtlasWidth;
+            sliceTransform.m11 = shadowSliceData.resolution * oneOverAtlasHeight;
+            sliceTransform.m03 = shadowSliceData.offsetX * oneOverAtlasWidth;
+            sliceTransform.m13 = shadowSliceData.offsetY * oneOverAtlasHeight;
+
+            // Apply shadow slice scale and offset
+            shadowSliceData.shadowTransform = sliceTransform * shadowSliceData.shadowTransform;
+        }
+
+        private void RenderShadowSlice(CommandBuffer cmd, ref ScriptableRenderContext context, ref ShadowSliceData shadowSliceData,
+            Matrix4x4 proj, Matrix4x4 view, DrawShadowsSettings settings)
+        {
+            cmd.SetViewport(new Rect(shadowSliceData.offsetX, shadowSliceData.offsetY, shadowSliceData.resolution, shadowSliceData.resolution));
+            cmd.EnableScissorRect(new Rect(shadowSliceData.offsetX + 4, shadowSliceData.offsetY + 4, shadowSliceData.resolution - 8, shadowSliceData.resolution - 8));
+
+            cmd.SetViewProjectionMatrices(view, proj);
+            context.ExecuteCommandBuffer(cmd);
+            cmd.Clear();
+            context.DrawShadows(ref settings);
+            cmd.DisableScissorRect();
+            context.ExecuteCommandBuffer(cmd);
+            cmd.Clear();
+        }
+
+        private int GetMaxTileResolutionInAtlas(int atlasWidth, int atlasHeight, int tileCount)
+        {
+            int resolution = Mathf.Min(atlasWidth, atlasHeight);
+            if (tileCount > Mathf.Log(resolution))
+            {
+                Debug.LogError(
+                    String.Format(
+                        "Cannot fit {0} tiles into current shadowmap atlas of size ({1}, {2}). ShadowMap Resolution set to zero.",
+                        tileCount, atlasWidth, atlasHeight));
+                return 0;
+            }
+
+            int currentTileCount = atlasWidth / resolution * atlasHeight / resolution;
+            while (currentTileCount < tileCount)
+            {
+                resolution = resolution >> 1;
+                currentTileCount = atlasWidth / resolution * atlasHeight / resolution;
+            }
+            return resolution;
+        }
+
+        private void SetupShadowCasterConstants(CommandBuffer cmd, ref VisibleLight visibleLight, Matrix4x4 proj, float cascadeResolution)
+        {
+            Light light = visibleLight.light;
+            float bias = 0.0f;
+            float normalBias = 0.0f;
+
+            // Use same kernel radius as built-in pipeline so we can achieve same bias results
+            // with the default light bias parameters.
+            const float kernelRadius = 3.65f;
+
+            if (visibleLight.lightType == LightType.Directional)
+            {
+                // Scale bias by cascade's world space depth range.
+                // Directional shadow lights have orthogonal projection.
+                // proj.m22 = -2 / (far - near) since the projection's depth range is [-1.0, 1.0]
+                // In order to be correct we should multiply bias by 0.5 but this introducing aliasing along cascades more visible.
+                float sign = (SystemInfo.usesReversedZBuffer) ? 1.0f : -1.0f;
+                bias = light.shadowBias * proj.m22 * sign;
+
+                // Currently only square POT cascades resolutions are used.
+                // We scale normalBias
+                double frustumWidth = 2.0 / (double)proj.m00;
+                double frustumHeight = 2.0 / (double)proj.m11;
+                float texelSizeX = (float)(frustumWidth / (double)cascadeResolution);
+                float texelSizeY = (float)(frustumHeight / (double)cascadeResolution);
+                float texelSize = Mathf.Max(texelSizeX, texelSizeY);
+
+                // Since we are applying normal bias on caster side we want an inset normal offset
+                // thus we use a negative normal bias.
+                normalBias = -light.shadowNormalBias * texelSize * kernelRadius;
+            }
+            else if (visibleLight.lightType == LightType.Spot)
+            {
+                float sign = (SystemInfo.usesReversedZBuffer) ? -1.0f : 1.0f;
+                bias = light.shadowBias * sign;
+                normalBias = 0.0f;
+            }
+            else
+            {
+                Debug.LogWarning("Only spot and directional shadow casters are supported in lightweight pipeline");
+            }
+
+            Vector3 lightDirection = -visibleLight.localToWorld.GetColumn(2);
+            cmd.SetGlobalVector("_ShadowBias", new Vector4(bias, normalBias, 0.0f, 0.0f));
+            cmd.SetGlobalVector("_LightDirection", new Vector4(lightDirection.x, lightDirection.y, lightDirection.z, 0.0f));
+        }
+
+        private void SetupDirectionalShadowReceiverConstants(CommandBuffer cmd, VisibleLight shadowLight, ref ScriptableRenderContext context)
+        {
+            Light light = shadowLight.light;
+
+            int cascadeCount = m_ShadowCasterCascadesCount;
+            for (int i = 0; i < kMaxCascades; ++i)
+                m_DirectionalShadowMatrices[i] = (cascadeCount >= i) ? m_CascadeSlices[i].shadowTransform : Matrix4x4.identity;
+
+            // We setup and additional a no-op WorldToShadow matrix in the last index
+            // because the ComputeCascadeIndex function in Shadows.hlsl can return an index
+            // out of bounds. (position not inside any cascade) and we want to avoid branching
+            Matrix4x4 noOpShadowMatrix = Matrix4x4.zero;
+            noOpShadowMatrix.m33 = (SystemInfo.usesReversedZBuffer) ? 1.0f : 0.0f;
+            m_DirectionalShadowMatrices[kMaxCascades] = noOpShadowMatrix;
+
+            float invShadowAtlasWidth = 1.0f / m_ShadowSettings.directionalShadowAtlasWidth;
+            float invShadowAtlasHeight = 1.0f / m_ShadowSettings.directionalShadowAtlasHeight;
+            float invHalfShadowAtlasWidth = 0.5f * invShadowAtlasWidth;
+            float invHalfShadowAtlasHeight = 0.5f * invShadowAtlasHeight;
+            cmd.SetGlobalTexture(m_DirectionalShadowmapID, m_DirectionalShadowmapTexture);
+            cmd.SetGlobalMatrixArray(DirectionalShadowConstantBuffer._WorldToShadow, m_DirectionalShadowMatrices);
+            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowData, new Vector4(light.shadowStrength, 0.0f, 0.0f, 0.0f));
+            cmd.SetGlobalVectorArray(DirectionalShadowConstantBuffer._DirShadowSplitSpheres, m_CascadeSplitDistances);
+            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._DirShadowSplitSphereRadii, m_CascadeSplitRadii);
+            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset0, new Vector4(-invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset1, new Vector4(invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset2, new Vector4(-invHalfShadowAtlasWidth,  invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset3, new Vector4(invHalfShadowAtlasWidth,  invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowmapSize, new Vector4(invShadowAtlasWidth, invShadowAtlasHeight,
+                    m_ShadowSettings.directionalShadowAtlasWidth, m_ShadowSettings.directionalShadowAtlasHeight));
+            context.ExecuteCommandBuffer(cmd);
+            cmd.Clear();
+        }
+
+        private void SetupLocalLightsShadowReceiverConstants(CommandBuffer cmd, ref ScriptableRenderContext context)
+        {
+            for (int i = 0; i < m_LocalLightSlices.Length; ++i)
+                m_LocalShadowMatrices[i] = m_LocalLightSlices[i].shadowTransform;
+
+            float invShadowAtlasWidth = 1.0f / m_ShadowSettings.localShadowAtlasWidth;
+            float invShadowAtlasHeight = 1.0f / m_ShadowSettings.localShadowAtlasHeight;
+            float invHalfShadowAtlasWidth = 0.5f * invShadowAtlasWidth;
+            float invHalfShadowAtlasHeight = 0.5f * invShadowAtlasHeight;
+
+            cmd.SetGlobalTexture(m_LocalShadowmapID, m_LocalShadowmapTexture);
+            cmd.SetGlobalMatrixArray(LocalShadowConstantBuffer._LocalWorldToShadowAtlas, m_LocalShadowMatrices);
+            cmd.SetGlobalFloatArray(LocalShadowConstantBuffer._LocalShadowStrength, m_LocalShadowStrength);
+            cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset0, new Vector4(-invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset1, new Vector4(invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset2, new Vector4(-invHalfShadowAtlasWidth,  invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset3, new Vector4(invHalfShadowAtlasWidth,  invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowmapSize, new Vector4(invShadowAtlasWidth, invShadowAtlasHeight,
+                    m_ShadowSettings.localShadowAtlasWidth, m_ShadowSettings.localShadowAtlasHeight));
+            context.ExecuteCommandBuffer(cmd);
+            cmd.Clear();
+        }
+    };
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightShadowPass.cs.meta

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