Created shadow utils.

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipelineCore.cs

         public LightShadows renderedLocalShadowQuality;
     }
 
-    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 CameraComparer : IComparer<Camera>
     {
         public int Compare(Camera lhs, Camera rhs)

ScriptableRenderPipeline/LightweightPipeline/LWRP/Passes/DirectionalShadowsPass.cs

-using System;
-using System.Collections.Generic;
 using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.LightweightPipeline
         Matrix4x4[] m_DirectionalShadowMatrices;
         ShadowSliceData[] m_CascadeSlices;
         Vector4[] m_CascadeSplitDistances;
-        Vector4 m_CascadeSplitRadii;
 
         public DirectionalShadowsPass(LightweightForwardRenderer renderer, int atlasResolution) : base(renderer)
         {
 
         public override void Setup(CommandBuffer cmd, RenderTextureDescriptor baseDescriptor, int samples)
         {
-            //m_DirectionalShadowmapTexture = RenderTexture.GetTemporary(m_DirectionalShadowmapDescriptor);
-            //m_DirectionalShadowmapTexture.filterMode = FilterMode.Bilinear;
-            //m_DirectionalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
         }
 
         public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref CameraData cameraData, ref LightData lightData)
             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();
         }
             CommandBuffer cmd = CommandBufferPool.Get("Prepare Directional Shadowmap");
             m_ShadowCasterCascadesCount = shadowData.directionalLightCascadeCount;
 
-            int shadowResolution = GetMaxTileResolutionInAtlas(shadowData.directionalShadowAtlasWidth, shadowData.directionalShadowAtlasHeight, m_ShadowCasterCascadesCount);
+            int shadowResolution = LightweightShadowUtils.GetMaxTileResolutionInAtlas(shadowData.directionalShadowAtlasWidth, shadowData.directionalShadowAtlasHeight, m_ShadowCasterCascadesCount);
             float shadowNearPlane = light.shadowNearPlane;
 
             Matrix4x4 view, proj;
             bool success = false;
             for (int cascadeIndex = 0; cascadeIndex < m_ShadowCasterCascadesCount; ++cascadeIndex)
             {
-                success = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(shadowLightIndex,
-                        cascadeIndex, m_ShadowCasterCascadesCount, shadowData.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], shadowData.directionalShadowAtlasWidth, shadowData.directionalShadowAtlasHeight);
-
-                SetupShadowCasterConstants(cmd, ref shadowLight, proj, shadowResolution);
-                RenderShadowSlice(cmd, ref context, ref m_CascadeSlices[cascadeIndex], proj, view, settings);
+                success = LightweightShadowUtils.ExtractDirectionalLightMatrix(ref cullResults, ref shadowData, shadowLightIndex, cascadeIndex, shadowResolution, shadowNearPlane, out m_CascadeSplitDistances[cascadeIndex], out m_CascadeSlices[cascadeIndex], out view, out proj);
+                if (success)
+                {
+                    LightweightShadowUtils.SetupShadowCasterConstants(cmd, ref shadowLight, proj, shadowResolution);
+                    LightweightShadowUtils.RenderShadowSlice(cmd, ref context, ref m_CascadeSlices[cascadeIndex], proj,
+                        view, settings);
+                }
             }
 
             if (success)
             return shadowQuality;
         }
 
-        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;
-        }
-
-        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;
-        }
-
-        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();
-        }
-
-        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;
-        }
-
-        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));
-        }
-
         void SetupDirectionalShadowReceiverConstants(ref ScriptableRenderContext context, CommandBuffer cmd, ref ShadowData shadowData, VisibleLight shadowLight)
         {
             Light light = shadowLight.light;
             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._DirShadowSplitSphereRadii, new Vector4(m_CascadeSplitDistances[0].w, m_CascadeSplitDistances[1].w, m_CascadeSplitDistances[2].w, m_CascadeSplitDistances[3].w));
             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));

ScriptableRenderPipeline/LightweightPipeline/LWRP/Passes/LocalShadowsPass.cs

 
         public override void Setup(CommandBuffer cmd, RenderTextureDescriptor baseDescriptor, int samples)
         {
-            //m_LocalShadowmapTexture = RenderTexture.GetTemporary(m_LocalShadowmapDescriptor);
-            //m_LocalShadowmapTexture.filterMode = FilterMode.Bilinear;
-            //m_LocalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
-
-            m_Disposed = false;
         }
 
         public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref CameraData cameraData, ref LightData lightData)
             // for spot lights and with max spot shadows per pass.
             int atlasWidth = shadowData.localShadowAtlasWidth;
             int atlasHeight = shadowData.localShadowAtlasHeight;
-            int sliceResolution = GetMaxTileResolutionInAtlas(atlasWidth, atlasHeight, shadowCastingLightsCount);
+            int sliceResolution = LightweightShadowUtils.GetMaxTileResolutionInAtlas(atlasWidth, atlasHeight, shadowCastingLightsCount);
             int shadowSampling = 0;
 
             m_LocalShadowmapTexture = RenderTexture.GetTemporary(m_LocalShadowmapDescriptor);
                 if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
                     continue;
 
-                var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
+                Matrix4x4 shadowTransform;
+                bool success = LightweightShadowUtils.ExtractSpotLightMatrix(ref cullResults, ref shadowData,
+                        shadowLightIndex, out shadowTransform, out view, out proj);
-                if (cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(shadowLightIndex, out view, out proj, out settings.splitData))
+                if (success)
                 {
                     // 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.
                     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);
+                    m_LocalLightSlices[i].shadowTransform = shadowTransform;
-                    SetupShadowCasterConstants(cmd, ref shadowLight, proj, sliceResolution);
-                    RenderShadowSlice(cmd, ref context, ref m_LocalLightSlices[i], proj, view, settings);
+
+                    if (shadowCastingLightsCount > 1)
+                        LightweightShadowUtils.ApplySliceTransform(ref m_LocalLightSlices[i], atlasWidth, atlasHeight);
+
+                    LightweightShadowUtils.SetupShadowCasterConstants(cmd, ref shadowLight, proj, sliceResolution);
+
+                    var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
+                    LightweightShadowUtils.RenderShadowSlice(cmd, ref context, ref m_LocalLightSlices[i], proj, view, settings);
                 }
             }
 
             CommandBufferPool.Release(cmd);
             return shadowQuality;
-        }
-
-        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;
-        }
-
-        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;
-        }
-
-        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();
-        }
-
-        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;
-        }
-
-        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));
         }
 
         void SetupLocalLightsShadowReceiverConstants(ref ScriptableRenderContext context, CommandBuffer cmd, ref ShadowData shadowData)

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightShadowUtils.cs

+using System;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.LightweightPipeline
+{
+    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 LightweightShadowUtils
+    {
+        public static bool ExtractDirectionalLightMatrix(ref CullResults cullResults, ref ShadowData shadowData, int shadowLightIndex, int cascadeIndex, int shadowResolution, float shadowNearPlane, out Vector4 cascadeSplitDistance, out ShadowSliceData shadowSliceData, out Matrix4x4 viewMatrix, out Matrix4x4 projMatrix)
+        {
+            ShadowSplitData splitData;
+            bool success = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(shadowLightIndex,
+                    cascadeIndex, shadowData.directionalLightCascadeCount, shadowData.directionalLightCascades, shadowResolution, shadowNearPlane, out viewMatrix, out projMatrix,
+                    out splitData);
+
+            float cullingSphereRadius = splitData.cullingSphere.w;
+            cascadeSplitDistance = splitData.cullingSphere;
+            cascadeSplitDistance.w = cullingSphereRadius * cullingSphereRadius;
+
+            shadowSliceData.offsetX = (cascadeIndex % 2) * shadowResolution;
+            shadowSliceData.offsetY = (cascadeIndex / 2) * shadowResolution;
+            shadowSliceData.resolution = shadowResolution;
+            shadowSliceData.shadowTransform = GetShadowTransform(projMatrix, viewMatrix);
+
+            // 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 (shadowData.directionalLightCascadeCount > 1)
+                ApplySliceTransform(ref shadowSliceData, shadowData.directionalShadowAtlasWidth, shadowData.directionalShadowAtlasHeight);
+
+            return success;
+        }
+
+        public static bool ExtractSpotLightMatrix(ref CullResults cullResults, ref ShadowData shadowData, int shadowLightIndex, out Matrix4x4 shadowMatrix, out Matrix4x4 viewMatrix, out Matrix4x4 projMatrix)
+        {
+            ShadowSplitData splitData;
+            bool success = cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(shadowLightIndex, out viewMatrix, out projMatrix, out splitData);
+            shadowMatrix = GetShadowTransform(projMatrix, viewMatrix);
+            return success;
+        }
+
+        public static 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();
+        }
+
+        public static 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;
+        }
+
+        public static 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;
+        }
+
+        public static 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));
+        }
+
+        static 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;
+        }
+    }
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightShadowUtils.cs.meta

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