Fixed some issues with multiple shadow casting lights.

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightConstantBuffer.cs

 
     public static class LocalShadowConstantBuffer
     {
-        public static int _LocalWorldToShadow;
+        public static int _LocalWorldToShadowAtlas;
         public static int _LocalShadowData;
         public static int _LocalShadowOffset0;
         public static int _LocalShadowOffset1;

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

             int vertexLightsCount = lightData.totalAdditionalLightsCount - lightData.pixelAdditionalLightsCount;
 
             CoreUtils.SetKeyword(cmd, "_SHADOWS_ENABLED", m_ShadowPass.HasDirectionalShadowmap);
-            CoreUtils.SetKeyword(cmd, "_LOCAL_SHADOWS_ENABLED", m_ShadowPass.HasLocalLightsShadowmap);
+
+            // 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.HasLocalLightsShadowmap);
+            //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);

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightShadowPass.cs

             DirectionalShadowConstantBuffer._ShadowOffset3 = Shader.PropertyToID("_ShadowOffset3");
             DirectionalShadowConstantBuffer._ShadowmapSize = Shader.PropertyToID("_ShadowmapSize");
 
-            LocalShadowConstantBuffer._LocalWorldToShadow = Shader.PropertyToID("_LocalWorldToShadowAtlas");
+            LocalShadowConstantBuffer._LocalWorldToShadowAtlas = Shader.PropertyToID("_LocalWorldToShadowAtlas");
             LocalShadowConstantBuffer._LocalShadowData = Shader.PropertyToID("_LocalShadowData");
             LocalShadowConstantBuffer._LocalShadowOffset0 = Shader.PropertyToID("_LocalShadowOffset0");
             LocalShadowConstantBuffer._LocalShadowOffset1 = Shader.PropertyToID("_LocalShadowOffset1");
 
             m_LocalShadowmapQuality = (LightShadows)Math.Min(shadowSampling, (int)m_ShadowSettings.shadowType);
             context.ExecuteCommandBuffer(cmd);
-            cmd.Clear();
+            CommandBufferPool.Release(cmd);
         }
 
         private Matrix4x4 GetShadowTransform(Matrix4x4 proj, Matrix4x4 view)
             float invHalfShadowAtlasHeight = 0.5f * invShadowAtlasHeight;
 
             cmd.SetGlobalTexture(m_LocalShadowmapID, m_LocalShadowmapTexture);
-            cmd.SetGlobalMatrixArray(LocalShadowConstantBuffer._LocalWorldToShadow, m_LocalShadowMatrices);
+            cmd.SetGlobalMatrixArray(LocalShadowConstantBuffer._LocalWorldToShadowAtlas, m_LocalShadowMatrices);
             cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowData, new Vector4(m_LocalShadowStrength[0], m_LocalShadowStrength[1], m_LocalShadowStrength[2], m_LocalShadowStrength[3]));
             cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset0, new Vector4(-invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
             cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset1, new Vector4( invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

 // Abstraction over Light shading data.
 struct Light
 {
+    int     index;
     half3   direction;
     half3   color;
     half    attenuation;
 
 Light GetMainLight()
 {
-    Light light;
+    Light light = (Light)0;
     light.direction = _MainLightPosition.xyz;
     light.attenuation = 1.0;
     light.subtractiveModeAttenuation = _MainLightPosition.w;
     half4 directionAndRealtimeAttenuation = GetLightDirectionAndAttenuation(lightInput, positionWS);
 
     Light light;
+    light.index = lightIndex;
     light.direction = directionAndRealtimeAttenuation.xyz;
     light.attenuation = directionAndRealtimeAttenuation.w;
     light.subtractiveModeAttenuation = lightInput.distanceAttenuation.w;
     {
         half index = half(i);
         Light light = GetLight(index, inputData.positionWS);
-        light.attenuation *= LocalLightRealtimeShadowAttenuation(index, 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);

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Shadows.hlsl

 
 struct ShadowSamplingData
 {
-    half shadowStrength;
     half4 shadowOffset0;
     half4 shadowOffset1;
     half4 shadowOffset2;
 ShadowSamplingData GetMainLightShadowSamplingData()
 {
     ShadowSamplingData shadowSamplingData;
-    shadowSamplingData.shadowStrength = _ShadowData.x;
     shadowSamplingData.shadowOffset0 = _ShadowOffset0;
     shadowSamplingData.shadowOffset1 = _ShadowOffset1;
     shadowSamplingData.shadowOffset2 = _ShadowOffset2;
 ShadowSamplingData GetLocalLightShadowSamplingData()
 {
     ShadowSamplingData shadowSamplingData;
-    shadowSamplingData.shadowStrength = _LocalShadowData.x;
     shadowSamplingData.shadowOffset0 = _LocalShadowOffset0;
     shadowSamplingData.shadowOffset1 = _LocalShadowOffset1;
     shadowSamplingData.shadowOffset2 = _LocalShadowOffset2;
 }
 
-inline half SampleScreenSpaceShadowMap(float4 shadowCoord)
+half GetMainLightShadowStrength()
+{
+    return _ShadowData.x;
+}
+
+half GetLocalLightShadowStrenth(int lightIndex)
+{
+    return _LocalShadowData[lightIndex];
+}
+
+half SampleScreenSpaceShadowMap(float4 shadowCoord)
 {
     shadowCoord.xy /= shadowCoord.w;
 
     return attenuation;
 }
 
-inline real SampleShadowmap(float4 shadowCoord, TEXTURE2D_SHADOW_ARGS(ShadowMap, sampler_ShadowMap), ShadowSamplingData samplingData, float isMainLight = 0.0)
+real SampleShadowmap(float4 shadowCoord, TEXTURE2D_SHADOW_ARGS(ShadowMap, sampler_ShadowMap), ShadowSamplingData samplingData, half shadowStrength)
-    if (isMainLight == 0.0)
-        shadowCoord.xyz /= shadowCoord.w;
+    shadowCoord.xyz /= shadowCoord.w;
 
     real attenuation;
 
     attenuation = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz);
 #endif
 
-    // Apply shadow strength
-    attenuation = LerpWhiteTo(attenuation, samplingData.shadowStrength);
+    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 SampleScreenSpaceShadowMap(shadowCoord);
 #else
     ShadowSamplingData shadowSamplingData = GetMainLightShadowSamplingData();
-    return SampleShadowmap(shadowCoord, TEXTURE2D_PARAM(_ShadowMap, sampler_ShadowMap), shadowSamplingData, 1.0);
+    half shadowStrength = GetMainLightShadowStrength();
+    return SampleShadowmap(shadowCoord, TEXTURE2D_PARAM(_ShadowMap, sampler_ShadowMap), shadowSamplingData, shadowStrength);
 #endif
 
 }
 #else
     float4 shadowCoord = mul(_LocalWorldToShadowAtlas[lightIndex], float4(positionWS, 1.0));
     ShadowSamplingData shadowSamplingData = GetLocalLightShadowSamplingData();
-    return SampleShadowmap(shadowCoord, TEXTURE2D_PARAM(_LocalShadowMapAtlas, sampler_LocalShadowMapAtlas), shadowSamplingData, 0.0);
+    half shadowStrength = GetLocalLightShadowStrenth(lightIndex);
+    return SampleShadowmap(shadowCoord, TEXTURE2D_PARAM(_LocalShadowMapAtlas, sampler_LocalShadowMapAtlas), shadowSamplingData, shadowStrength);
 #endif
 }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader

 
             // Screenspace shadowmap is only used for directional lights which use orthogonal projection.
             ShadowSamplingData shadowSamplingData = GetMainLightShadowSamplingData();
-            return SampleShadowmap(coords, TEXTURE2D_PARAM(_ShadowMap, sampler_ShadowMap), shadowSamplingData, 1.0);
+            half shadowStrength = GetMainLightShadowStrength();
+            return SampleShadowmap(coords, TEXTURE2D_PARAM(_ShadowMap, sampler_ShadowMap), shadowSamplingData, shadowStrength);
         }
 
         ENDHLSL