Cast shadows prop removed, we use shadow strenght instead. Reverted changes that removed light type from w position component. We might want it to be generic in case people want to use other shaders with LW.

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

         public int pixelAdditionalLightsCount;
         public int totalAdditionalLightsCount;
         public int mainLightIndex;
-        public int localShadowMask;
         public List<VisibleLight> visibleLights;
         public List<int> localLightIndices;
     }
 
             // Clear to default all light constant data
             for (int i = 0; i < kMaxVisibleLights; ++i)
-                InitializeLightConstants(visibleLights, -1, false, out m_LightPositions[i],
+                InitializeLightConstants(visibleLights, -1, out m_LightPositions[i],
                     out m_LightColors[i],
                     out m_LightDistanceAttenuations[i],
                     out m_LightSpotDirections[i],
 
             lightData.pixelAdditionalLightsCount = additionalPixelLightsCount;
             lightData.totalAdditionalLightsCount = additionalPixelLightsCount + vertexLightCount;
-            lightData.localShadowMask = 0x0;
             lightData.visibleLights = visibleLights;
             lightData.localLightIndices = m_LocalLightIndices;
 
             return -1;
         }
 
-        private void InitializeLightConstants(List<VisibleLight> lights, int lightIndex, bool castShadows, out Vector4 lightPos, out Vector4 lightColor, out Vector4 lightDistanceAttenuation, out Vector4 lightSpotDir,
+        private void InitializeLightConstants(List<VisibleLight> lights, int lightIndex, out Vector4 lightPos, out Vector4 lightColor, out Vector4 lightDistanceAttenuation, out Vector4 lightSpotDir,
             out Vector4 lightSpotAttenuation)
         {
             lightPos = kDefaultLightPosition;
                 return;
 
             VisibleLight lightData = lights[lightIndex];
-            float castShadowsProp = castShadows ? 1.0f : 0.0f;
-                lightPos = new Vector4(dir.x, dir.y, dir.z, castShadowsProp);
+                lightPos = new Vector4(dir.x, dir.y, dir.z, 0.0f);
-                lightPos = new Vector4(pos.x, pos.y, pos.z, castShadowsProp);
+                lightPos = new Vector4(pos.x, pos.y, pos.z, 1.0f);
             }
 
             // VisibleLight.finalColor already returns color in active color space
         {
             Vector4 lightPos, lightColor, lightDistanceAttenuation, lightSpotDir, lightSpotAttenuation;
             List<VisibleLight> lights = lightData.visibleLights;
-            InitializeLightConstants(lightData.visibleLights, lightData.mainLightIndex, m_ShadowPass.HasDirectionalShadowmap, out lightPos, out lightColor, out lightDistanceAttenuation, out lightSpotDir, out lightSpotAttenuation);
+            InitializeLightConstants(lightData.visibleLights, lightData.mainLightIndex, out lightPos, out lightColor, out lightDistanceAttenuation, out lightSpotDir, out lightSpotAttenuation);
 
             if (lightData.mainLightIndex >= 0)
             {
                     else
                     {
                         perObjectLightIndexMap[i] -= directionalLightCount;
-                        bool castShadows = (lightData.localShadowMask & (1 << i)) != 0 &&
-                                           lightData.localLightIndices.Contains(i);
-                        InitializeLightConstants(lights, i, castShadows, out m_LightPositions[localLightsCount],
+                        InitializeLightConstants(lights, i, out m_LightPositions[localLightsCount],
                             out m_LightColors[localLightsCount],
                             out m_LightDistanceAttenuations[localLightsCount],
                             out m_LightSpotDirections[localLightsCount],

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightShadowPass.cs

                     RenderShadowSlice(cmd, ref context, ref m_LocalLightSlices[i], proj, view, settings);
                     m_LocalShadowStrength[i] = light.shadowStrength;
                     shadowSampling = Math.Max(shadowSampling, (int)light.shadows);
-                    lightData.localShadowMask |= (1 << shadowLightIndex);
                 }
             }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

     half3   color;
     half    attenuation;
     half    subtractiveModeAttenuation;
-    half    castShadows;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 half4 GetLightDirectionAndAttenuation(LightInput lightInput, float3 positionWS)
 {
     half4 directionAndAttenuation;
-    float3 posToLightVec = lightInput.position.xyz - positionWS;
+    float3 posToLightVec = lightInput.position.xyz - positionWS.xyz * lightInput.position.w;
     float distanceSqr = max(dot(posToLightVec, posToLightVec), FLT_MIN);
 
     directionAndAttenuation.xyz = half3(posToLightVec * rsqrt(distanceSqr));
     light.attenuation = 1.0;
     light.subtractiveModeAttenuation = _MainLightPosition.w;
     light.color = _MainLightColor.rgb;
-    light.castShadows = _MainLightPosition.w;
 
     return light;
 }
     light.attenuation = directionAndRealtimeAttenuation.w;
     light.subtractiveModeAttenuation = lightInput.distanceAttenuation.w;
     light.color = lightInput.color;
-    light.castShadows = lightInput.position.w;
 
     return light;
 }
     {
         half index = half(i);
         Light light = GetLight(index, inputData.positionWS);
-        light.attenuation *= LocalLightRealtimeShadowAttenuation(index, light.castShadows, inputData.positionWS);
+        light.attenuation *= LocalLightRealtimeShadowAttenuation(index, inputData.positionWS);
         color += LightingPhysicallyBased(brdfData, light, inputData.normalWS, inputData.viewDirectionWS);
     }
 #endif
     {
         half index = half(i);
         Light light = GetLight(index, inputData.positionWS);
-        light.attenuation *= LocalLightRealtimeShadowAttenuation(index, light.castShadows, inputData.positionWS);
+        light.attenuation *= LocalLightRealtimeShadowAttenuation(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

     attenuation = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz);
 #endif
 
-#if SHADER_HINT_NICE_QUALITY
-#endif
 
     // Shadow coords that fall out of the light frustum volume must always return attenuation 1.0
     return BEYOND_SHADOW_FAR(shadowCoord) ? 1.0 : attenuation;
 
 }
 
-half LocalLightRealtimeShadowAttenuation(int lightIndex, half castShadows, float3 positionWS)
+half LocalLightRealtimeShadowAttenuation(int lightIndex, float3 positionWS)
 {
 #if defined(NO_SHADOWS) || !defined(_LOCAL_SHADOWS_ENABLED)
     return 1.0h;
-    half attenuation = SampleShadowmap(shadowCoord, TEXTURE2D_PARAM(_LocalShadowMapAtlas, sampler_LocalShadowMapAtlas), shadowSamplingData, 0.0);
-    return (castShadows < 1.0h) ? 1.0h : attenuation;
+    return SampleShadowmap(shadowCoord, TEXTURE2D_PARAM(_LocalShadowMapAtlas, sampler_LocalShadowMapAtlas), shadowSamplingData, 0.0);
 #endif
 }