Merge branch 'master' of https://github.com/Unity-Technologies/ScriptableRenderLoop into reduce-gc

# Conflicts:
#	Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/MultiplePointLights.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.12731749, g: 0.13414757, b: 0.1210787, a: 1}
+  m_IndirectSpecularColor: {r: 0.12732536, g: 0.13415334, b: 0.121077195, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
     m_PVRDirectSampleCount: 32
     m_PVRSampleCount: 500
     m_PVRBounces: 2
-    m_PVRFiltering: 0
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
-    m_PVRFilteringAtrousColorSigma: 1
-    m_PVRFilteringAtrousNormalSigma: 1
-    m_PVRFilteringAtrousPositionSigma: 1
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
   m_LightingDataAsset: {fileID: 0}
   m_UseShadowmask: 1
 --- !u!196 &4
   m_Script: {fileID: 11500000, guid: c20dfc007a9a74ad8a2bfd0d59abe398, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  renderPipeline: {fileID: 0}
+  renderPipeline: {fileID: 11400000, guid: e6987eea1dd29074597d54ed91a54a26, type: 2}
   cameraToUse: {fileID: 232121474}
   hdr: 0
   width: 1280

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/Shaders/LDPipe_LitShaderMaps.unity

     m_PVRDirectSampleCount: 32
     m_PVRSampleCount: 500
     m_PVRBounces: 2
-    m_PVRFiltering: 0
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
-    m_PVRFilteringAtrousColorSigma: 1
-    m_PVRFilteringAtrousNormalSigma: 1
-    m_PVRFilteringAtrousPositionSigma: 1
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
   m_LightingDataAsset: {fileID: 0}
   m_UseShadowmask: 1
 --- !u!196 &4
   m_Father: {fileID: 0}
   m_RootOrder: 3
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &222008785
-GameObject:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 222008789}
-  - component: {fileID: 222008788}
-  - component: {fileID: 222008787}
-  - component: {fileID: 222008786}
-  m_Layer: 0
-  m_Name: Quad (1)
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!23 &222008786
-MeshRenderer:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 222008785}
-  m_Enabled: 1
-  m_CastShadows: 1
-  m_ReceiveShadows: 1
-  m_DynamicOccludee: 1
-  m_MotionVectors: 1
-  m_LightProbeUsage: 1
-  m_ReflectionProbeUsage: 1
-  m_Materials:
-  - {fileID: 2100000, guid: 96f2a4d5f3b72eb468a638a4bed6ca76, type: 2}
-  m_StaticBatchInfo:
-    firstSubMesh: 0
-    subMeshCount: 0
-  m_StaticBatchRoot: {fileID: 0}
-  m_ProbeAnchor: {fileID: 0}
-  m_LightProbeVolumeOverride: {fileID: 0}
-  m_ScaleInLightmap: 1
-  m_PreserveUVs: 1
-  m_IgnoreNormalsForChartDetection: 0
-  m_ImportantGI: 0
-  m_SelectedEditorRenderState: 3
-  m_MinimumChartSize: 4
-  m_AutoUVMaxDistance: 0.5
-  m_AutoUVMaxAngle: 89
-  m_LightmapParameters: {fileID: 0}
-  m_SortingLayerID: 0
-  m_SortingLayer: 0
-  m_SortingOrder: 0
---- !u!64 &222008787
-MeshCollider:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 222008785}
-  m_Material: {fileID: 0}
-  m_IsTrigger: 0
-  m_Enabled: 1
-  serializedVersion: 2
-  m_Convex: 0
-  m_InflateMesh: 0
-  m_SkinWidth: 0.01
-  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!33 &222008788
-MeshFilter:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 222008785}
-  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!4 &222008789
-Transform:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 222008785}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0.68, y: 0.041, z: -2.541}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_RootOrder: 11
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &316403771
 GameObject:
   m_ObjectHideFlags: 0
   m_Children: []
   m_Father: {fileID: 0}
   m_RootOrder: 7
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &576034924
-GameObject:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 576034928}
-  - component: {fileID: 576034927}
-  - component: {fileID: 576034926}
-  - component: {fileID: 576034925}
-  m_Layer: 0
-  m_Name: Quad
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!23 &576034925
-MeshRenderer:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 576034924}
-  m_Enabled: 1
-  m_CastShadows: 1
-  m_ReceiveShadows: 1
-  m_DynamicOccludee: 1
-  m_MotionVectors: 1
-  m_LightProbeUsage: 1
-  m_ReflectionProbeUsage: 1
-  m_Materials:
-  - {fileID: 2100000, guid: f51bbc8f90c3bf54588afe5d142636b3, type: 2}
-  m_StaticBatchInfo:
-    firstSubMesh: 0
-    subMeshCount: 0
-  m_StaticBatchRoot: {fileID: 0}
-  m_ProbeAnchor: {fileID: 0}
-  m_LightProbeVolumeOverride: {fileID: 0}
-  m_ScaleInLightmap: 1
-  m_PreserveUVs: 1
-  m_IgnoreNormalsForChartDetection: 0
-  m_ImportantGI: 0
-  m_SelectedEditorRenderState: 3
-  m_MinimumChartSize: 4
-  m_AutoUVMaxDistance: 0.5
-  m_AutoUVMaxAngle: 89
-  m_LightmapParameters: {fileID: 0}
-  m_SortingLayerID: 0
-  m_SortingLayer: 0
-  m_SortingOrder: 0
---- !u!64 &576034926
-MeshCollider:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 576034924}
-  m_Material: {fileID: 0}
-  m_IsTrigger: 0
-  m_Enabled: 1
-  serializedVersion: 2
-  m_Convex: 0
-  m_InflateMesh: 0
-  m_SkinWidth: 0.01
-  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!33 &576034927
-MeshFilter:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 576034924}
-  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!4 &576034928
-Transform:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 576034924}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: -0.504, y: 0.041, z: -2.541}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_RootOrder: 10
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &952102529
 GameObject:

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 
 // ----------------------------------------------------------------------------
 
-// TODO: move this to constant buffer by Pass
+CBUFFER_START(UnityPerPass)
 float4   _ScreenSize;
 float4x4 _ViewProjMatrix; // Looks like using UNITY_MATRIX_VP in pixel shader doesn't work ??? need to setup my own...
 float4x4 _PrevViewProjMatrix;
+CBUFFER_END
 
 float4x4 GetWorldToViewMatrix()
 {

Assets/ScriptableRenderPipeline/LightweightPipeline.meta

 fileFormatVersion: 2
-guid: 7a2706b41ea31e54d9e4ca93be22278a
+guid: 4923a4700d4d643a9a862a74e04870b3
 folderAsset: yes
 timeCreated: 1481548458
 licenseType: Pro

Assets/ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetInspector.cs

 
             public static GUIContent shadowDistante = new GUIContent("Shadow Distance", "Max shadow drawing distance");
 
-            public static GUIContent shadowMinBias = new GUIContent("Shadow Min Normal Bias Offset", "Minimum value of normal bias offset applied");
-            public static GUIContent shadowBias = new GUIContent("Shadow Normal Bias", "Normal bias offset value.");
-
             public static GUIContent shadowAtlasResolution = new GUIContent("Shadow Map Resolution",
                     "Resolution of shadow map texture. If cascades are enabled all cascades will be packed into this texture resolution.");
 
             EditorGUILayout.PropertyField(m_ShadowTypeProp, Styles.shadowType);
             EditorGUILayout.PropertyField(m_ShadowAtlasResolutionProp, Styles.shadowAtlasResolution);
             EditorGUILayout.PropertyField(m_ShadowNearPlaneOffsetProp, Styles.shadowNearPlaneOffset);
-            EditorGUILayout.PropertyField(m_ShadowMinNormalBiasProperty, Styles.shadowMinBias);
-            EditorGUILayout.PropertyField(m_ShadowNormalBiasProperty, Styles.shadowBias);
             EditorGUILayout.PropertyField(m_ShadowDistanceProp, Styles.shadowDistante);
             EditorGUILayout.PropertyField(m_ShadowCascadesProp, Styles.shadowCascades);
 

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

     {
         public int pixelLightsCount;
         public int vertexLightsCount;
+        public int shadowLightIndex;
+        public bool shadowsRendered;
     }
 
     public class LightweightPipeline : RenderPipeline
         private static readonly int kMaxCascades = 4;
         private int m_ShadowCasterCascadesCount = kMaxCascades;
         private int m_ShadowMapProperty;
-        private int m_ShadowLightIndex = -1;
-        private int m_DepthBufferBits = 24;
+        private int m_DepthBufferBits = 16;
         private Vector4[] m_DirectionalShadowSplitDistances = new Vector4[kMaxCascades];
 
         private ShadowSettings m_ShadowSettings = ShadowSettings.Default;
                 if (!CullResults.GetCullingParameters(camera, out cullingParameters))
                     continue;
 
-                cullingParameters.shadowDistance = m_ShadowSettings.maxShadowDistance;
+                cullingParameters.shadowDistance = Mathf.Min(m_ShadowSettings.maxShadowDistance, camera.farClipPlane);
                 CullResults.Cull(ref cullingParameters, context,ref m_CullResults);
 
                 VisibleLight[] visibleLights = m_CullResults.visibleLights.ToArray();
 
                 // Render Shadow Map
-                bool shadowsRendered = false;
-                InitializeMainShadowLightIndex(visibleLights);
-                if (m_ShadowLightIndex > -1)
-                    shadowsRendered = RenderShadows(ref m_CullResults, ref visibleLights[m_ShadowLightIndex], ref context);
+                if (lightData.shadowLightIndex > -1) 
+                    lightData.shadowsRendered = RenderShadows(ref m_CullResults, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, ref context);
 
                 // Setup camera matrices and RT
                 context.SetupCameraProperties(camera);
                 CommandBufferPool.Release(cmd);
 
                 // Setup light and shadow shader constants
-                SetupLightShaderVariables(visibleLights, ref m_CullResults, ref context, ref lightData);
-                if (shadowsRendered)
-                    SetupShadowShaderVariables(ref context, m_ShadowCasterCascadesCount);
+                SetupShaderLightConstants(visibleLights, ref lightData, ref m_CullResults, ref context);
+                if (lightData.shadowsRendered)
+                    SetupShadowShaderConstants(ref context, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, m_ShadowCasterCascadesCount);
+                SetShaderKeywords(ref lightData, ref context);
 
                 RendererConfiguration configuration = RendererConfiguration.PerObjectReflectionProbes;
                 if (m_Asset.EnableLightmap)
             lightData.pixelLightsCount = Mathf.Min(lightsCount, m_Asset.MaxSupportedPixelLights);
             lightData.vertexLightsCount = (m_Asset.SupportsVertexLight) ? Mathf.Min(lightsCount - lightData.pixelLightsCount, kMaxVertexLights) : 0;
             lightData.isSingleDirectionalLight = lightData.pixelLightsCount == 1 && lightData.vertexLightsCount == 0 && lights[0].lightType == LightType.Directional;
+
+            // Directional light path can handle unlit.
+            if (lightsCount == 0)
+                lightData.isSingleDirectionalLight = true;
+            
+            lightData.shadowsRendered = false;
+
+            InitializeMainShadowLightIndex(lights, out lightData.shadowLightIndex);
         }
 
         private void FillLightIndices(ref CullResults cullResults, int visibleLightsCount)
             cullResults.FillLightIndices(m_LightIndexListBuffer);
         }
 
-        private void SetupLightShaderVariables(VisibleLight[] lights, ref CullResults cullResults, ref ScriptableRenderContext context, ref LightData lightData)
+        private void SetupShaderLightConstants(VisibleLight[] lights, ref LightData lightData, ref CullResults cullResults, ref ScriptableRenderContext context)
+        {
+            if (lights.Length == 0)
+                return;
+
+            if (lightData.isSingleDirectionalLight) 
+                SetupShaderSingleDirectionalLightConstants(ref lights [0], ref context);
+            else
+                SetupShaderLightListConstants(lights, lightData.pixelLightsCount, ref cullResults, ref context);
+        }
+
+        private void SetupShaderSingleDirectionalLightConstants(ref VisibleLight light, ref ScriptableRenderContext context)
-            int maxLights = 1;
-            if (!lightData.isSingleDirectionalLight)
-            {
-                FillLightIndices(ref cullResults, lights.Length);
-                maxLights = Math.Min(kMaxVisibleLights, lights.Length);
-            }
+            Vector4 lightDir = -light.localToWorld.GetColumn(2);
+             
+            CommandBuffer cmd = new CommandBuffer() { name = "SetupLightConstants" };
+            cmd.SetGlobalVector("_LightPosition0", new Vector4(lightDir.x, lightDir.y, lightDir.z, 0.0f));
+            cmd.SetGlobalColor("_LightColor0", light.finalColor);
+            context.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+        }
+
+        // TODO: Perform tests on light lights memory pattern access (SOA vs AOS vs Swizzling)
+        private void SetupShaderLightListConstants(VisibleLight[] lights, int pixelLightsCount, ref CullResults cullResults, ref ScriptableRenderContext context)
+        {
+            FillLightIndices(ref cullResults, lights.Length);
+            int maxLights = Math.Min(kMaxVisibleLights, lights.Length);
-            for (int i = 0; i < maxLights; ++i)
+            for (int i = 0; i < maxLights; ++i) 
-                VisibleLight currLight = lights[i];
-                if (currLight.lightType == LightType.Directional)
+                VisibleLight currLight = lights [i];
+                if (currLight.lightType == LightType.Directional) 
-                    Vector4 dir = -currLight.localToWorld.GetColumn(2);
-                    m_LightPositions[i] = new Vector4(dir.x, dir.y, dir.z, 0.0f);
-                }
-                else
+                    Vector4 dir = -currLight.localToWorld.GetColumn (2);
+                    m_LightPositions [i] = new Vector4 (dir.x, dir.y, dir.z, 0.0f);
+                } 
+                else 
-                    Vector4 pos = currLight.localToWorld.GetColumn(3);
-                    m_LightPositions[i] = new Vector4(pos.x, pos.y, pos.z, 1.0f);
+                    Vector4 pos = currLight.localToWorld.GetColumn (3);
+                    m_LightPositions [i] = new Vector4 (pos.x, pos.y, pos.z, 1.0f);
                 }
 
                 m_LightColors[i] = currLight.finalColor;
 
-                if (currLight.lightType == LightType.Spot)
+                if (currLight.lightType == LightType.Spot) 
-                    Vector4 dir = currLight.localToWorld.GetColumn(2);
-                    m_LightSpotDirections[i] = new Vector4(-dir.x, -dir.y, -dir.z, 0.0f);
+                    Vector4 dir = currLight.localToWorld.GetColumn (2);
+                    m_LightSpotDirections [i] = new Vector4 (-dir.x, -dir.y, -dir.z, 0.0f);
-                    float cosOuterAngle = Mathf.Cos(spotAngle * 0.5f);
-                    float cosInneAngle = Mathf.Cos(spotAngle * 0.25f);
+                    float cosOuterAngle = Mathf.Cos (spotAngle * 0.5f);
+                    float cosInneAngle = Mathf.Cos (spotAngle * 0.25f);
-                    m_LightAttenuations[i] = new Vector4(cosOuterAngle,
-                            Mathf.Approximately(angleRange, 0.0f) ? 1.0f : angleRange, quadAtten, rangeSq);
-                }
+                    m_LightAttenuations [i] = new Vector4 (cosOuterAngle,
+                        Mathf.Approximately (angleRange, 0.0f) ? 1.0f : angleRange, quadAtten, rangeSq);
+                } 
-                    m_LightSpotDirections[i] = new Vector4(0.0f, 0.0f, 1.0f, 0.0f) ;
-                    m_LightAttenuations[i] = new Vector4(-1.0f, 1.0f, quadAtten, rangeSq);
+                    m_LightSpotDirections [i] = new Vector4 (0.0f, 0.0f, 1.0f, 0.0f);
+                    m_LightAttenuations [i] = new Vector4 (-1.0f, 1.0f, quadAtten, rangeSq);
-            cmd.SetGlobalVectorArray("globalLightPos", m_LightPositions);
-            cmd.SetGlobalVectorArray("globalLightColor", m_LightColors);
-            cmd.SetGlobalVectorArray("globalLightAtten", m_LightAttenuations);
-            cmd.SetGlobalVectorArray("globalLightSpotDir", m_LightSpotDirections);
-            if (!lightData.isSingleDirectionalLight)
-                cmd.SetGlobalBuffer("globalLightIndexList", m_LightIndexListBuffer);
-            cmd.SetGlobalVector("globalLightData", new Vector4(lightData.pixelLightsCount, m_ShadowLightIndex, m_Asset.ShadowMinNormalBias, m_Asset.ShadowNormalBias));
-            SetShaderKeywords(cmd, lightData.isSingleDirectionalLight, lightData.vertexLightsCount > 0);
+            cmd.SetGlobalVector("globalLightCount", new Vector4 (pixelLightsCount, 0.0f, 0.0f, 0.0f));
+            cmd.SetGlobalVectorArray ("globalLightPos", m_LightPositions);
+            cmd.SetGlobalVectorArray ("globalLightColor", m_LightColors);
+            cmd.SetGlobalVectorArray ("globalLightAtten", m_LightAttenuations);
+            cmd.SetGlobalVectorArray ("globalLightSpotDir", m_LightSpotDirections);
+            cmd.SetGlobalBuffer("globalLightIndexList", m_LightIndexListBuffer);
-        private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, ref ScriptableRenderContext context)
+        private void SetShaderKeywords(ref LightData lightData, ref ScriptableRenderContext context)
+        {
+            CommandBuffer cmd = new CommandBuffer() { name = "SetShaderKeywords" };
+            SetShaderKeywords(cmd, lightData.shadowsRendered, lightData.isSingleDirectionalLight, lightData.vertexLightsCount > 0);
+            context.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+        }
+
+        private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, int shadowLightIndex, ref ScriptableRenderContext context)
         {
             m_ShadowCasterCascadesCount = m_ShadowSettings.directionalLightCascadeCount;
 
             int shadowResolution = GetMaxTileResolutionInAtlas(m_ShadowSettings.shadowAtlasWidth, m_ShadowSettings.shadowAtlasHeight, m_ShadowCasterCascadesCount);
 
             Bounds bounds;
-            if (!cullResults.GetShadowCasterBounds(m_ShadowLightIndex, out bounds))
+            if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
                 return false;
 
             var setRenderTargetCommandBuffer = CommandBufferPool.Get();
 
             float shadowNearPlane = m_Asset.ShadowNearOffset;
             Vector3 splitRatio = m_ShadowSettings.directionalLightCascades;
-            Vector3 lightDir = Vector3.Normalize(shadowLight.light.transform.forward);
-            var settings = new DrawShadowsSettings(cullResults, m_ShadowLightIndex);
+            var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
-                needRendering = cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(m_ShadowLightIndex, out view, out proj,
+                needRendering = cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(shadowLightIndex, out view, out proj,
                         out settings.splitData);
 
                 if (!needRendering)
-                RenderShadowSlice(ref context, lightDir, 0, proj, view, settings);
+                RenderShadowSlice(ref context, 0, proj, view, settings);
-                    needRendering = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(m_ShadowLightIndex,
+                    needRendering = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(shadowLightIndex,
                             cascadeIdx, m_ShadowCasterCascadesCount, splitRatio, shadowResolution, shadowNearPlane, out view, out proj,
                             out settings.splitData);
 
                         return false;
 
                     SetupShadowSliceTransform(cascadeIdx, shadowResolution, proj, view);
-                    RenderShadowSlice(ref context, lightDir, cascadeIdx, proj, view, settings);
+                    RenderShadowSlice(ref context, cascadeIdx, proj, view, settings);
                 }
             }
             else
             m_ShadowSlices[cascadeIndex].shadowTransform = matTile * matScaleBias * proj * view;
         }
 
-        private void RenderShadowSlice(ref ScriptableRenderContext context, Vector3 lightDir, int cascadeIndex,
+        private void RenderShadowSlice(ref ScriptableRenderContext context, int cascadeIndex,
             Matrix4x4 proj, Matrix4x4 view, DrawShadowsSettings settings)
         {
             var buffer = CommandBufferPool.Get("Prepare Shadowmap Slice");
             return resolution;
         }
 
-        private void SetupShadowShaderVariables(ref ScriptableRenderContext context, int cascadeCount)
+        private void SetupShadowShaderConstants(ref ScriptableRenderContext context, ref VisibleLight shadowLight, int shadowLightIndex, int cascadeCount)
+            Vector3 shadowLightDir = Vector3.Normalize(shadowLight.localToWorld.GetColumn(2));
+
+            // TODO: multiplying by 0.1 to get similar results to Unity vanilla shadow bias
+            float bias = shadowLight.light.shadowBias * 0.1f;
+            float normalBias = shadowLight.light.shadowNormalBias;
             float shadowResolution = m_ShadowSlices[0].shadowResolution;
 
             const int maxShadowCascades = 4;
             var setupShadow = CommandBufferPool.Get("SetupShadowShaderConstants");
             setupShadow.SetGlobalMatrixArray("_WorldToShadow", shadowMatrices);
             setupShadow.SetGlobalVectorArray("_DirShadowSplitSpheres", m_DirectionalShadowSplitDistances);
+            setupShadow.SetGlobalVector("_ShadowLightDirection", new Vector4(-shadowLightDir.x, -shadowLightDir.y, -shadowLightDir.z, 0.0f));
+            setupShadow.SetGlobalVector("_ShadowData", new Vector4(shadowLightIndex, bias, normalBias, 0.0f));
-        private void SetShaderKeywords(CommandBuffer cmd, bool singleDirecitonal, bool vertexLightSupport)
+        private void SetShaderKeywords(CommandBuffer cmd, bool renderShadows, bool singleDirecitonal, bool vertexLightSupport)
         {
             if (vertexLightSupport)
                 cmd.EnableShaderKeyword("_VERTEX_LIGHTS");
             for (int i = 0; i < shadowKeywords.Length; ++i)
                 cmd.DisableShaderKeyword(shadowKeywords[i]);
 
-            if (m_ShadowLightIndex != -1 && m_Asset.CurrShadowType != ShadowType.NO_SHADOW)
+            if (renderShadows && m_Asset.CurrShadowType != ShadowType.NO_SHADOW)
             {
                 int keywordIndex = (int)m_Asset.CurrShadowType - 1;
                 if (m_Asset.CascadeCount > 1)
                 cmd.DisableShaderKeyword("_LIGHT_PROBES_ON");
         }
 
-        private void InitializeMainShadowLightIndex(VisibleLight[] lights)
+        private void InitializeMainShadowLightIndex(VisibleLight[] lights, out int shadowIndex)
-            m_ShadowLightIndex = -1;
+            shadowIndex = -1;
             float maxIntensity = -1;
             for (int i = 0; i < lights.Length; ++i)
             {
-                    m_ShadowLightIndex = i;
+                    shadowIndex = i;
                     maxIntensity = light.intensity;
                 }
             }
         {
             return (type == LightType.Directional || type == LightType.Spot);
         }
-
     }
 }

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_ShadowAtlasResolution: 1024
   m_ShadowNearPlaneOffset: 2
   m_ShadowDistance: 50
-  m_MinShadowNormalBias: 0.0005
-  m_ShadowNormalBias: 0.05
   m_ShadowCascades: 1
   m_Cascade2Split: 0.25
   m_Cascade4Split: {x: 0.067, y: 0.2, z: 0.467}

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.cs

         private static readonly string m_AssetName = "LightweightPipelineAsset.asset";
 
 #if UNITY_EDITOR
-        [UnityEditor.MenuItem("RenderPipeline/LightweightPipeline/Create Pipeline Asset")]
+        [UnityEditor.MenuItem("RenderPipeline/LightweightPipeline/Create Pipeline Asset", false, 15)]
         static void CreateLightweightPipeline()
         {
             var instance = ScriptableObject.CreateInstance<LightweightPipelineAsset>();
         [SerializeField] private ShadowResolution m_ShadowAtlasResolution = ShadowResolution._1024;
         [SerializeField] private float m_ShadowNearPlaneOffset = 2.0f;
         [SerializeField] private float m_ShadowDistance = 50.0f;
-        [SerializeField] private float m_MinShadowNormalBias = 0.0005f;
-        [SerializeField] private float m_ShadowNormalBias = 0.05f;
         [SerializeField] private ShadowCascades m_ShadowCascades = ShadowCascades.NO_CASCADES;
         [SerializeField] private float m_Cascade2Split = 0.25f;
         [SerializeField] private Vector3 m_Cascade4Split = new Vector3(0.067f, 0.2f, 0.467f);
             private set { m_ShadowDistance = value; }
         }
 
-		public float ShadowMinNormalBias
-        {
-            get { return m_MinShadowNormalBias; }
-            private set { m_MinShadowNormalBias = value; }
-        }
-
-        public float ShadowNormalBias
-        {
-            get { return m_ShadowNormalBias; }
-            private set { m_ShadowNormalBias = value; }
-        }
-
-
+       
         public float Cascade2Split
         {
             get { return m_Cascade2Split; }

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipeline.shader

 
 #if defined(_VERTEX_LIGHTS) && !defined(_SINGLE_DIRECTIONAL_LIGHT)
                 half4 diffuseAndSpecular = half4(1.0, 1.0, 1.0, 1.0);
-                int vertexLightStart = unity_LightIndicesOffsetAndCount.x + globalLightData.x;
-                int vertexLightEnd = vertexLightStart + (unity_LightIndicesOffsetAndCount.y - globalLightData.x);
+                int vertexLightStart = unity_LightIndicesOffsetAndCount.x + globalLightCount.x;
+                int vertexLightEnd = vertexLightStart + (unity_LightIndicesOffsetAndCount.y - globalLightCount.x);
-                    half NdotL;
-                    o.fogCoord.yzw += EvaluateOneLight(lightInput, diffuseAndSpecular.rgb, diffuseAndSpecular, normal, o.posWS, o.viewDir.xyz, NdotL);
+                    o.fogCoord.yzw += EvaluateOneLight(lightInput, diffuseAndSpecular.rgb, diffuseAndSpecular, normal, o.posWS, o.viewDir.xyz);
                 }
 #endif
 
 
                 half3 viewDir = i.viewDir.xyz;
 
-                half3 color = half3(0, 0, 0);
-                LightInput lightData;
-                INITIALIZE_LIGHT(lightData, 0);
-                half  NdotL;
-                color = EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir, NdotL);
+                half3 color = EvaluateDirectionalLight(diffuse, specularGloss, normal, _LightPosition0, viewDir) * _LightColor0;
-                float bias = max(globalLightData.z, (1.0 - NdotL) * globalLightData.w);
-                color *= ComputeShadowAttenuation(i, bias);
+                color *= ComputeShadowAttenuation(i, _LightPosition0.xyz);
-                int pixelLightEnd = unity_LightIndicesOffsetAndCount.x + min(globalLightData.x, unity_LightIndicesOffsetAndCount.y);
+                half3 color = half3(0, 0, 0);
+#ifdef _SHADOWS
+                half shadowAttenuation = ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
+#endif
+                int pixelLightEnd = unity_LightIndicesOffsetAndCount.x + min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-                    half NdotL;
-                    color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir, NdotL);
-                    if (lightIndex == globalLightData.y)
-                    {
-                        float bias = max(globalLightData.z, (1.0 - NdotL) * globalLightData.w);
-                        color *= ComputeShadowAttenuation(i, bias);
-                    }
+                    // multiplies shadowAttenuation to avoid branching.
+                    // step will only evaluate to 1 when lightIndex == _ShadowData.x (shadowLightIndex)
+                    half currLightAttenuation = shadowAttenuation * step(abs(lightIndex - _ShadowData.x), 0);
+                    color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir) * currLightAttenuation;
+#else
+                    color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir);
 #endif
                 }
 
 
             float4 vert(float4 pos : POSITION) : SV_POSITION
             {
-            	float4 clipPos = UnityObjectToClipPos(pos);
+                float4 clipPos = UnityObjectToClipPos(pos);
 #if defined(UNITY_REVERSED_Z)
                 clipPos.z = min(clipPos.z, UNITY_NEAR_CLIP_VALUE);
 #else

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipelineCore.cginc

     float4 hpos : SV_POSITION;
 };
 
+// Per object light list data
+#ifndef _SINGLE_DIRECTIONAL_LIGHT
+half4 unity_LightIndicesOffsetAndCount;
+StructuredBuffer<uint> globalLightIndexList;
+
+half4 globalLightCount;
-float4  globalLightData; // x: pixelLightCount, y = shadowLightIndex, z = minShadowNormalBiasOffset, w = shadowNormalBiasOffset
-
-// Per object light list data
-#ifndef _SINGLE_DIRECTIONAL_LIGHT
-half4 unity_LightIndicesOffsetAndCount;
-StructuredBuffer<uint> globalLightIndexList;
+#else
+float4 _LightPosition0;
 #endif
 
 half _Shininess;
 #endif
 }
 
-inline half3 EvaluateOneLight(LightInput lightInput, half3 diffuseColor, half4 specularGloss, half3 normal, float3 posWorld, half3 viewDir, out half NdotL)
+inline half3 EvaluateDirectionalLight(half3 diffuseColor, half4 specularGloss, half3 normal, half3 lightDir, half3 viewDir)
+{
+    half NdotL = saturate(dot(normal, lightDir));
+    half3 diffuse = diffuseColor * NdotL;
+
+#if defined(_SPECGLOSSMAP_BASE_ALPHA) || defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR) 
+    half3 halfVec = normalize(lightDir + viewDir);
+    half NdotH = saturate(dot(normal, halfVec));
+    half3 specular = specularGloss.rgb * pow(NdotH, _Shininess * 128.0) * specularGloss.a;
+    return diffuse + specular;
+#else
+    return diffuse;
+#endif
+}
+
+inline half3 EvaluateOneLight(LightInput lightInput, half3 diffuseColor, half4 specularGloss, half3 normal, float3 posWorld, half3 viewDir)
 {
     float3 posToLight = lightInput.pos.xyz;
     posToLight -= posWorld * lightInput.pos.w;
     half cutoff = step(distanceSqr, lightInput.atten.w);
     lightAtten *= cutoff;
 
-    NdotL = saturate(dot(normal, lightDir));
-
-    half3 halfVec = normalize(lightDir + viewDir);
-    half NdotH = saturate(dot(normal, halfVec));
+    half NdotL = saturate(dot(normal, lightDir));
+    half3 halfVec = normalize(lightDir + viewDir);
+    half NdotH = saturate(dot(normal, halfVec));
     half3 specular = specularGloss.rgb * lightColor * pow(NdotH, _Shininess * 128.0) * specularGloss.a;
     return diffuse + specular;
 #else

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipelineShadows.cginc

 float _PCFKernel[8];
 float4x4 _WorldToShadow[MAX_SHADOW_CASCADES];
 float4 _DirShadowSplitSpheres[MAX_SHADOW_CASCADES];
+half4 _ShadowData;
+
+// In case of single directional light, shadow light dir is the same of light dir
+#ifndef _SINGLE_DIRECTIONAL_LIGHT
+half4 _ShadowLightDirection;
+#endif
 
 inline half ShadowAttenuation(float3 shadowCoord)
 {
     float depth = tex2D(_ShadowMap, shadowCoord).r;
+
-    return step(depth, shadowCoord.z);
+    return step(depth - _ShadowData.y, shadowCoord.z);
-    return step(shadowCoord.z, depth);
+    return step(shadowCoord.z, depth + _ShadowData.y);
 #endif
 }
 
     return attenuation * 0.25;
 }
 
-inline half ComputeShadowAttenuation(v2f i, float bias)
+inline half ComputeShadowAttenuation(v2f i, half3 shadowDir)
-    float3 vertexNormal = float3(i.tangentToWorld0.z, i.tangentToWorld1.z, i.tangentToWorld2.z);
+    half3 vertexNormal = half3(i.tangentToWorld0.z, i.tangentToWorld1.z, i.tangentToWorld2.z);
-    float3 vertexNormal = i.normal;
+    half3 vertexNormal = i.normal;
-    float3 offset = vertexNormal * bias;
+
+    half NdotL = dot(vertexNormal, shadowDir);
+    half bias = saturate(1.0 - NdotL) * _ShadowData.z;
+
+    float3 posWorldOffsetNormal = i.posWS + vertexNormal * bias;
-    float3 posWorldOffsetNormal = i.posWS + offset;
-
-    cascadeIndex = ComputeCascadeIndex(i.posWS);
+    cascadeIndex = ComputeCascadeIndex(posWorldOffsetNormal);
     if (cascadeIndex >= MAX_SHADOW_CASCADES)
         return 1.0;
 #endif

Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl

 
 // uniform have _ as prefix + uppercase _LowercaseThenCamelCase
 
+// All uniforms should be in contant buffer (nothing in the global namespace).
+// The reason is that for compute shader we need to guarantee that the layout of CBs is consistent across kernels. Something that we can't control with the global namespace (uniforms get optimized out if not used, modifying the global CBuffer layout per kernel)
+
 // Structure definition that are share between C# and hlsl.
 // These structures need to be align on float4 to respectect various packing rules from sahder language.
 // This mean that these structure need to be padded.