Added support to spot light cookies.

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

 
         private void SetupShadowShaderConstants(CommandBuffer cmd, ref VisibleLight shadowLight, int cascadeCount)
         {
-            Vector3 shadowLightDir = Vector3.Normalize(shadowLight.localToWorld.GetColumn(2));
-
             Light light = shadowLight.light;
             float bias = light.shadowBias * 0.1f;
             float normalBias = light.shadowNormalBias;
 
             cmd.SetGlobalMatrixArray("_WorldToShadow", shadowMatrices);
             cmd.SetGlobalVectorArray("_DirShadowSplitSpheres", m_DirectionalShadowSplitDistances);
-            cmd.SetGlobalVector("_ShadowLightDirection", new Vector4(-shadowLightDir.x, -shadowLightDir.y, -shadowLightDir.z, 0.0f));
             cmd.SetGlobalVector("_ShadowData", new Vector4(0.0f, bias, normalBias, 0.0f));
             cmd.SetGlobalFloatArray("_PCFKernel", pcfKernel);
         }

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineUtils.cs

         public static void GetLightCookieMatrix(VisibleLight light, out Matrix4x4 cookieMatrix)
         {
             cookieMatrix = Matrix4x4.Inverse(light.localToWorld);
-            float scale = 1.0f / light.light.cookieSize;
-            // apply cookie scale and offset by 0.5 to convert from [-0.5, 0.5] to texture space [0, 1]
-            Vector4 row0 = cookieMatrix.GetRow(0);
-            Vector4 row1 = cookieMatrix.GetRow(1);
-            cookieMatrix.SetRow(0, new Vector4(row0.x * scale, row0.y * scale, row0.z * scale, row0.w * scale + 0.5f));
-            cookieMatrix.SetRow(1, new Vector4(row1.x * scale, row1.y * scale, row1.z * scale, row1.w * scale + 0.5f));
+            if (light.lightType == LightType.Directional)
+            {
+                float scale = 1.0f/light.light.cookieSize;
+
+                // apply cookie scale and offset by 0.5 to convert from [-0.5, 0.5] to texture space [0, 1]
+                Vector4 row0 = cookieMatrix.GetRow(0);
+                Vector4 row1 = cookieMatrix.GetRow(1);
+                cookieMatrix.SetRow(0, new Vector4(row0.x*scale, row0.y*scale, row0.z*scale, row0.w*scale + 0.5f));
+                cookieMatrix.SetRow(1, new Vector4(row1.x*scale, row1.y*scale, row1.z*scale, row1.w*scale + 0.5f));
+            }
+            else if (light.lightType == LightType.Spot)
+            {
+                // we want out.w = 2.0 * in.z / m_CotanHalfSpotAngle
+                // c = cotHalfSpotAngle
+                // 1 0 0 0
+                // 0 1 0 0
+                // 0 0 1 0
+                // 0 0 2/c 0
+                // the "2" will be used to scale .xy for the cookie as in .xy/2 + 0.5
+                float scale = 1.0f / light.range;
+                float halfSpotAngleRad = Mathf.Deg2Rad * light.spotAngle * 0.5f;
+                float cs = Mathf.Cos(halfSpotAngleRad);
+                float ss = Mathf.Sin(halfSpotAngleRad);
+                float cotHalfSpotAngle = cs / ss;
+
+                Matrix4x4 scaleMatrix = Matrix4x4.identity;
+                scaleMatrix.m00 = scaleMatrix.m11 = scaleMatrix.m22 = scale;
+                scaleMatrix.m33 = 0.0f;
+                scaleMatrix.m32 = scale * (2.0f / cotHalfSpotAngle);
+
+                cookieMatrix = scaleMatrix * cookieMatrix;
+            }
+
+            // Remaining light types don't support cookies
         }
 
         public static void SetKeyword(CommandBuffer cmd, string keyword, bool enable)

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightLighting.cginc

     return lightColor * specularReflection;
 }
 
+half CookieAttenuation(float3 worldPos)
+{
+#ifdef _MAIN_LIGHT_COOKIE
+    #ifdef _MAIN_DIRECTIONAL_LIGHT
+        float2 cookieUV = mul(_WorldToLight, float4(worldPos, 1.0)).xy;
+        return tex2D(_MainLightCookie, cookieUV).a;
+    #elif defined(_MAIN_SPOT_LIGHT)
+        float3 projPos = mul(_WorldToLight, float4(worldPos, 1.0)).xyz;
+        float2 cookieUV = projPos.xy / projPos.w + 0.5;
+        return tex2D(_MainLightCookie, cookieUV).a;
+    #endif // POINT LIGHT cookie not supported
+#endif
+
+    return 1;
+}
+
 half SpotAttenuation(half3 spotDirection, half3 lightDirection, float4 attenuationParams)
 {
     // Spot Attenuation with a linear falloff can be defined as
     return lightAtten;
 }
 
-inline half ComputeMainLightAttenuation(LightInput lightInput, half3 normal, float3 worldPos, out half3 lightDirection)
+inline half ComputeMainLightAttenuation(LightInput lightInput, half3 normalWS, float3 positionWS, out half3 lightDirection)
-
-#ifdef _MAIN_LIGHT_COOKIE
-    float2 cookieUV = mul(_WorldToLight, float4(worldPos, 1.0)).xy;
-    return tex2D(_MainLightCookie, cookieUV).a;
-#endif
-    return 1.0;
+    half attenuation = 1.0;
-    return ComputePixelLightAttenuation(lightInput, normal, worldPos, lightDirection);
+    half attenuation = ComputePixelLightAttenuation(lightInput, normalWS, positionWS, lightDirection);
+
+    // Cookies and shadows are only computed for main light
+    attenuation *= CookieAttenuation(positionWS);
+    attenuation *= LIGHTWEIGHT_SHADOW_ATTENUATION(positionWS, normalWS, lightDirection);
+    return attenuation;
 }
 
 half3 VertexLighting(float positionWS, half3 normalWS)
     LightInput light;
     INITIALIZE_MAIN_LIGHT(light);
     half lightAtten = ComputeMainLightAttenuation(light, normalWS, positionWS, lightDirectionWS);
-    lightAtten *= LIGHTWEIGHT_SHADOW_ATTENUATION(positionWS, normalize(vertexNormal), _ShadowLightDirection.xyz);
-
     half NdotL = saturate(dot(normalWS, lightDirectionWS));
     half3 radiance = light.color * (lightAtten * NdotL);
     color += LightweightBDRF(brdfData, roughness2, normalWS, lightDirectionWS, viewDirectionWS) * radiance;
     LightInput mainLight;
     INITIALIZE_MAIN_LIGHT(mainLight);
     half lightAtten = ComputeMainLightAttenuation(mainLight, normalWS, positionWS, lightDirection);
-    lightAtten *= LIGHTWEIGHT_SHADOW_ATTENUATION(positionWS, normalWS, _ShadowLightDirection.xyz);
-
     half3 lightColor = mainLight.color * lightAtten;
     diffuseColor += LightingLambert(lightColor, lightDirection, normalWS);
 
     LightInput mainLight;
     INITIALIZE_MAIN_LIGHT(mainLight);
     half lightAtten = ComputeMainLightAttenuation(mainLight, normalWS, positionWS, lightDirection);
-    lightAtten *= LIGHTWEIGHT_SHADOW_ATTENUATION(positionWS, normalWS, _ShadowLightDirection.xyz);
 
     half3 lightColor = mainLight.color * lightAtten;
     diffuseColor += LightingLambert(lightColor, lightDirection, normalWS);

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightShadows.cginc

 float4x4 _WorldToShadow[MAX_SHADOW_CASCADES];
 float4 _DirShadowSplitSpheres[MAX_SHADOW_CASCADES];
 half4 _ShadowData;
-half4 _ShadowLightDirection;
 
 inline half ShadowAttenuation(float3 shadowCoord)
 {