Shadow Performance Improvements

com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/RendererLighting.cs

@@ -174,11 +174,11 @@ public static void DrawPointLight(CommandBuffer cmd, Light2D light, Mesh lightMe
 
         private static void RenderLightSet(IRenderPass2D pass, RenderingData renderingData, int blendStyleIndex, CommandBuffer cmd, int layerToRender, RenderTargetIdentifier renderTexture, List<Light2D> lights)
         {
-            var maxShadowTextureCount = ShadowRendering.maxTextureCount;
+            var maxShadowLightCount = ShadowRendering.maxTextureCount * 4;
             var requiresRTInit = true;
 
             // This case should never happen, but if it does it may cause an infinite loop later.
-            if (maxShadowTextureCount < 1)
+            if (maxShadowLightCount < 1)
             {
                 Debug.LogError("maxShadowTextureCount cannot be less than 1");
                 return;
@@ -193,12 +193,11 @@ private static void RenderLightSet(IRenderPass2D pass, RenderingData renderingDa
 
                 // Add lights to our batch until the number of shadow textures reach the maxShadowTextureCount
                 var shadowLightCount = 0;
-                while (batchedLights < remainingLights && shadowLightCount < maxShadowTextureCount)
+                while (batchedLights < remainingLights && shadowLightCount < maxShadowLightCount)
                 {
                     var light = lights[lightIndex + batchedLights];
                     if (light.shadowsEnabled && light.shadowIntensity > 0)
                     {
-                        ShadowRendering.CreateShadowRenderTexture(pass, renderingData, cmd, shadowLightCount);
                         ShadowRendering.PrerenderShadows(pass, renderingData, cmd, layerToRender, light, shadowLightCount, light.shadowIntensity);
                         shadowLightCount++;
                     }
@@ -269,11 +268,11 @@ private static void RenderLightSet(IRenderPass2D pass, RenderingData renderingDa
 
         public static void RenderLightVolumes(this IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmd, int layerToRender, int endLayerValue, RenderTargetIdentifier renderTexture, RenderTargetIdentifier depthTexture, List<Light2D> lights)
         {
-            var maxShadowTextureCount = ShadowRendering.maxTextureCount;
+            var maxShadowLightCount = ShadowRendering.maxTextureCount * 4;  // Now encodes shadows into RGBA as well as seperate textures
             var requiresRTInit = true;
 
             // This case should never happen, but if it does it may cause an infinite loop later.
-            if (maxShadowTextureCount < 1)
+            if (maxShadowLightCount < 1)
             {
                 Debug.LogError("maxShadowTextureCount cannot be less than 1");
                 return;
@@ -288,12 +287,11 @@ public static void RenderLightVolumes(this IRenderPass2D pass, RenderingData ren
 
                 // Add lights to our batch until the number of shadow textures reach the maxShadowTextureCount
                 var shadowLightCount = 0;
-                while (batchedLights < remainingLights && shadowLightCount < maxShadowTextureCount)
+                while (batchedLights < remainingLights && shadowLightCount < maxShadowLightCount)
                 {
                     var light = lights[lightIndex + batchedLights];
                     if (light.volumetricShadowsEnabled && light.shadowVolumeIntensity > 0)
                     {
-                        ShadowRendering.CreateShadowRenderTexture(pass, renderingData, cmd, shadowLightCount);
                         ShadowRendering.PrerenderShadows(pass, renderingData, cmd, layerToRender, light, shadowLightCount, light.shadowVolumeIntensity);
                         shadowLightCount++;
                     }
@@ -325,7 +323,7 @@ public static void RenderLightVolumes(this IRenderPass2D pass, RenderingData ren
                         var lightVolumeMaterial = pass.rendererData.GetLightMaterial(light, true);
                         var lightMesh = light.lightMesh;
 
-                        // Set the shadow texture to read from
+                        // Set the shadow texture to read from.
                         if (light.volumetricShadowsEnabled && light.shadowVolumeIntensity > 0)
                             ShadowRendering.SetGlobalShadowTexture(cmd, light, shadowLightCount++);
                         else

com.unity.render-pipelines.universal/Runtime/2D/Renderer2DData.cs

@@ -75,11 +75,14 @@ public enum Renderer2DDefaultMaterialType
         [SerializeField, Reload("Shaders/Utils/Sampling.shader")]
         Shader m_SamplingShader = null;
 
-        [SerializeField, Reload("Shaders/2D/ShadowGroup2D.shader")]
-        Shader m_ShadowGroupShader = null;
+        [SerializeField, Reload("Shaders/2D/Shadow2D-Projected.shader")]
+        Shader m_ProjectedShadowShader = null;
 
-        [SerializeField, Reload("Shaders/2D/Shadow2DRemoveSelf.shader")]
-        Shader m_RemoveSelfShadowShader = null;
+        [SerializeField, Reload("Shaders/2D/Shadow2D-Shadow-Sprite.shader")]
+        Shader m_SpriteShadowShader = null;
+
+        [SerializeField, Reload("Shaders/2D/Shadow2D-Unshadow-Sprite.shader")]
+        Shader m_SpriteUnshadowShader = null;
 
         [SerializeField, Reload("Shaders/Utils/FallbackError.shader")]
         Shader m_FallbackErrorShader;
@@ -102,9 +105,10 @@ public enum Renderer2DDefaultMaterialType
         internal Shader pointLightVolumeShader => m_PointLightVolumeShader;
         internal Shader blitShader => m_BlitShader;
         internal Shader samplingShader => m_SamplingShader;
-        internal Shader shadowGroupShader => m_ShadowGroupShader;
-        internal Shader removeSelfShadowShader => m_RemoveSelfShadowShader;
         internal PostProcessData postProcessData { get => m_PostProcessData; set { m_PostProcessData = value; } }
+        internal Shader spriteShadowShader => m_SpriteShadowShader;
+        internal Shader spriteUnshadowShader => m_SpriteUnshadowShader;
+        internal Shader projectedShadowShader => m_ProjectedShadowShader;
         internal TransparencySortMode transparencySortMode => m_TransparencySortMode;
         internal Vector3 transparencySortAxis => m_TransparencySortAxis;
         internal uint lightRenderTextureMemoryBudget => m_MaxLightRenderTextureCount;
@@ -135,18 +139,14 @@ protected override void OnEnable()
 
             normalsRenderTarget.Init("_NormalMap");
             shadowsRenderTarget.Init("_ShadowTex");
-
-            const int totalMaterials = 256;
-            if (shadowMaterials == null || shadowMaterials.Length == 0)
-                shadowMaterials = new Material[totalMaterials];
-            if (removeSelfShadowMaterials == null || removeSelfShadowMaterials.Length == 0)
-                removeSelfShadowMaterials = new Material[totalMaterials];
         }
 
         // transient data
         internal Dictionary<uint, Material> lightMaterials { get; } = new Dictionary<uint, Material>();
-        internal Material[] shadowMaterials { get; private set; }
-        internal Material[] removeSelfShadowMaterials { get; private set; }
+        internal Material spriteSelfShadowMaterial { get; set; }
+        internal Material spriteUnshadowMaterial { get; set; }
+        internal Material projectedShadowMaterial { get; set; }
+        internal Material stencilOnlyShadowMaterial { get; set; }
 
         internal bool isNormalsRenderTargetValid { get; set; }
         internal float normalsRenderTargetScale { get; set; }

com.unity.render-pipelines.universal/Runtime/2D/Shadows/ShadowCaster2D.cs

@@ -11,8 +11,16 @@ namespace UnityEngine.Experimental.Rendering.Universal
     [ExecuteInEditMode]
     [DisallowMultipleComponent]
     [AddComponentMenu("Rendering/2D/Shadow Caster 2D (Experimental)")]
-    public class ShadowCaster2D : ShadowCasterGroup2D
+    public class ShadowCaster2D : ShadowCasterGroup2D, ISerializationCallbackReceiver
     {
+        public enum ComponentVersions
+        {
+            Version_Unserialized = 0,
+            Version_1 = 1
+        }
+        const ComponentVersions k_CurrentComponentVersion = ComponentVersions.Version_1;
+        [SerializeField] ComponentVersions m_ComponentVersion = ComponentVersions.Version_Unserialized;
+
         [SerializeField] bool m_HasRenderer = false;
         [SerializeField] bool m_UseRendererSilhouette = true;
         [SerializeField] bool m_CastsShadows = true;
@@ -26,15 +34,17 @@ public class ShadowCaster2D : ShadowCasterGroup2D
         internal ShadowCasterGroup2D m_ShadowCasterGroup = null;
         internal ShadowCasterGroup2D m_PreviousShadowCasterGroup = null;
 
-        internal Mesh mesh => m_Mesh;
-        internal Vector3[] shapePath => m_ShapePath;
+        [SerializeField]
+        internal BoundingSphere m_ProjectedBoundingSphere;
+
+        public Mesh mesh => m_Mesh;
+        public Vector3[] shapePath => m_ShapePath;
         internal int shapePathHash { get { return m_ShapePathHash; } set { m_ShapePathHash = value; } }
 
         int m_PreviousShadowGroup = 0;
         bool m_PreviousCastsShadows = true;
         int m_PreviousPathHash = 0;
 
-
         /// <summary>
         /// If selfShadows is true, useRendererSilhoutte specifies that the renderer's sihouette should be considered part of the shadow. If selfShadows is false, useRendererSilhoutte specifies that the renderer's sihouette should be excluded from the shadow
         /// </summary>
@@ -75,6 +85,17 @@ static int[] SetDefaultSortingLayers()
             return allLayers;
         }
 
+        internal bool IsLit(Light2D light)
+        {
+            Vector3 deltaPos = light.transform.position - (m_ProjectedBoundingSphere.position + transform.position);
+            float distanceSq = Vector3.SqrMagnitude(deltaPos);
+
+            float lightRadiusSq = light.boundingSphere.radius * light.boundingSphere.radius;
+            float projectedRadiusSq = m_ProjectedBoundingSphere.radius * m_ProjectedBoundingSphere.radius;
+
+            return distanceSq <= (lightRadiusSq + projectedRadiusSq);
+        }
+
         internal bool IsShadowedLayer(int layer)
         {
             return m_ApplyToSortingLayers != null ? Array.IndexOf(m_ApplyToSortingLayers, layer) >= 0 : false;
@@ -126,7 +147,7 @@ protected void OnEnable()
             if (m_Mesh == null || m_InstanceId != GetInstanceID())
             {
                 m_Mesh = new Mesh();
-                ShadowUtility.GenerateShadowMesh(m_Mesh, m_ShapePath);
+                m_ProjectedBoundingSphere = ShadowUtility.GenerateShadowMesh(m_Mesh, m_ShapePath);
                 m_InstanceId = GetInstanceID();
             }
 
@@ -145,7 +166,9 @@ public void Update()
 
             bool rebuildMesh = LightUtility.CheckForChange(m_ShapePathHash, ref m_PreviousPathHash);
             if (rebuildMesh)
-                ShadowUtility.GenerateShadowMesh(m_Mesh, m_ShapePath);
+            {
+                m_ProjectedBoundingSphere = ShadowUtility.GenerateShadowMesh(m_Mesh, m_ShapePath);
+            }
 
             m_PreviousShadowCasterGroup = m_ShadowCasterGroup;
             bool addedToNewGroup = ShadowCasterGroup2DManager.AddToShadowCasterGroup(this, ref m_ShadowCasterGroup);
@@ -174,6 +197,23 @@ public void Update()
             }
         }
 
+        public void OnBeforeSerialize()
+        {
+            m_ComponentVersion = k_CurrentComponentVersion;
+        }
+
+        public void OnAfterDeserialize()
+        {
+            // Upgrade from no serialized version
+            if (m_ComponentVersion == ComponentVersions.Version_Unserialized)
+            {
+                // Regenerate the shadow mesh
+                m_Mesh = new Mesh();
+                m_ProjectedBoundingSphere = ShadowUtility.GenerateShadowMesh(m_Mesh, m_ShapePath);
+                m_ComponentVersion = ComponentVersions.Version_1;
+            }
+        }
+
 #if UNITY_EDITOR
         void Reset()
         {