[Port] [6000.0] [UUM-109322][6000.3][URP 2D] Expose methods to add/remove sorting layers

Author: svc-reach-platform-support

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

@@ -3,6 +3,7 @@
 using UnityEngine.Scripting.APIUpdating;
 using UnityEngine.U2D;
 using UnityEngine.Rendering.RenderGraphModule;
+using System.Collections.Generic;
 #if UNITY_EDITOR
 using System.Linq;
 #endif
@@ -180,7 +181,6 @@ private enum ComponentVersions
         // We use Blue Channel of LightMesh's vertex color to indicate Slot Index.
         int m_BatchSlotIndex = 0;
         internal int batchSlotIndex { get { return m_BatchSlotIndex; } set {  m_BatchSlotIndex = value; } }
-        internal int[] affectedSortingLayers => m_ApplyToSortingLayers;
 
         private int lightCookieSpriteInstanceID => lightCookieSprite?.GetInstanceID() ?? 0;
 
@@ -338,6 +338,96 @@ public LightType lightType
         /// </summary>
         public bool renderVolumetricShadows => volumetricShadowsEnabled && shadowVolumeIntensity > 0;
 
+        /// <summary>
+        /// Gets or sets the target sorting layers for the light. Contains an array of sorting layer IDs.
+        /// </summary>
+        public int[] targetSortingLayers
+        {
+            get => m_ApplyToSortingLayers;
+            set
+            {
+                var layers = new List<int>();
+                foreach (var layerID in value)
+                {
+                    if (SortingLayer.IsValid(layerID))
+                        layers.Add(layerID);
+                }
+                m_ApplyToSortingLayers = layers.ToArray();
+            }
+        }
+
+        bool IsValidLayer(string name)
+        {
+            // Have this check as SortingLayer.NameToID returns 0 (default layer) if layer is not found
+            foreach (var layer in Light2DManager.GetCachedSortingLayer())
+            {
+                if (layer.name == name)
+                    return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Adds a target sorting layer to the light.
+        /// </summary>
+        /// <param name="layerName">The sorting layer name to be added.</param>
+        /// <returns>Returns true if the sorting layer is added. Returns false if the layer name is invalid or has already been added.</returns>
+        public bool AddTargetSortingLayer(string layerName)
+        {
+            var layers = new List<int>(m_ApplyToSortingLayers);
+            var id = SortingLayer.NameToID(layerName);
+
+            // Invalid or duplicate layerID
+            if (!IsValidLayer(layerName) || layers.Contains(id))
+                return false;
+
+            layers.Add(id);
+            m_ApplyToSortingLayers = layers.ToArray();
+
+            return true;
+        }
+
+        /// <summary>
+        /// Adds a target sorting layer to the light.
+        /// </summary>
+        /// <param name="layerID">The sorting layer ID to be added.</param>
+        /// <returns>Returns true if the sorting layer is added. Returns false if the layer ID is invalid or has already been added.</returns>
+        public bool AddTargetSortingLayer(int layerID)
+        {
+            return AddTargetSortingLayer(SortingLayer.IDToName(layerID));
+        }
+
+        /// <summary>
+        /// Removes a target sorting layer from the light.
+        /// </summary>
+        /// <param name="layerName">The sorting layer name to be removed.</param>
+        /// <returns>Returns true if the sorting layer is removed. Returns false if the layer name is invalid or doesn't exist.</returns>
+        public bool RemoveTargetSortingLayer(string layerName)
+        {
+            var layers = new List<int>(m_ApplyToSortingLayers);
+            var id = SortingLayer.NameToID(layerName);
+
+            // Invalid or layerID does not exist
+            if (!IsValidLayer(layerName) || !layers.Contains(id))
+                return false;
+
+            layers.Remove(id);
+            m_ApplyToSortingLayers = layers.ToArray();
+
+            return true;
+        }
+
+        /// <summary>
+        /// Removes a target sorting layer from the light.
+        /// </summary>
+        /// <param name="layerID">The sorting layer ID to be removed.</param>
+        /// <returns>Returns true if the sorting layer is removed. Returns false if the layer ID is invalid or doesn't exist.</returns>
+        public bool RemoveTargetSortingLayer(int layerID)
+        {
+            return RemoveTargetSortingLayer(SortingLayer.IDToName(layerID));
+        }
+
         internal void MarkForUpdate()
         {
             forceUpdate = true;

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

@@ -42,7 +42,7 @@ public static void ErrorIfDuplicateGlobalLight(Light2D light)
             if (light.lightType != Light2D.LightType.Global)
                 return;
 
-            foreach (var sortingLayer in light.affectedSortingLayers)
+            foreach (var sortingLayer in light.targetSortingLayers)
             {
                 // should this really trigger at runtime?
                 if (ContainsDuplicateGlobalLight(sortingLayer, light.blendStyleIndex))

Tests/SRPTests/Projects/UniversalGraphicsTest_2D/Assets/Test/Runtime/Light2DTests.cs

@@ -0,0 +1,94 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.Rendering.Universal;
+
+[TestFixture]
+class Light2DTests 
+{
+    GameObject m_BaseObj;
+    Light2D m_Light;
+
+    [SetUp]
+    public void Setup()
+    {
+        m_BaseObj = new GameObject();
+        m_Light = m_BaseObj.AddComponent<Light2D>();
+    }
+
+    [TearDown]
+    public void Cleanup()
+    {
+        Object.DestroyImmediate(m_BaseObj);
+    }
+
+    [Test]
+    public void TargetSortingLayer_Getter()
+    {
+        Assert.IsNotNull(m_Light.targetSortingLayers);
+        Assert.IsNotEmpty(m_Light.targetSortingLayers);
+    }
+
+    [Test]
+    public void TargetSortingLayer_Setter()
+    {
+        // Empty
+        m_Light.targetSortingLayers = new int[] { };
+        Assert.IsEmpty(m_Light.targetSortingLayers);
+
+        // Add default layer
+        m_Light.targetSortingLayers = new int[] { SortingLayer.NameToID("Default") };
+        Assert.IsTrue(m_Light.targetSortingLayers.Length == 1);
+    }
+
+    [Test]
+    public void TargetSortingLayer_IsValid()
+    {
+        foreach (var layer in m_Light.targetSortingLayers)
+            Assert.IsTrue(SortingLayer.IsValid(layer));
+    }
+
+    [Test]
+    public void TargetSortingLayer_AddValidLayer()
+    {
+        var layers = m_Light.targetSortingLayers;
+
+        m_Light.targetSortingLayers = new int[] { };
+
+        // Add back layers
+        foreach (var layer in layers)
+            Assert.IsTrue(m_Light.AddTargetSortingLayer(layer));
+
+        Assert.IsTrue(m_Light.targetSortingLayers.Length == layers.Length);
+    }
+
+    [Test]
+    public void TargetSortingLayer_AddInvalidLayer()
+    {
+        // Add an invalid layer returns false
+        Assert.IsFalse(m_Light.AddTargetSortingLayer("Invalid"));
+        // Add random layerID
+        Assert.IsFalse(m_Light.AddTargetSortingLayer(234393945));
+
+    }
+
+    [Test]
+    public void TargetSortingLayer_RemoveValidLayer()
+    {
+        var layers = m_Light.targetSortingLayers;
+
+        // Remove layers
+        foreach (var layer in layers)
+            Assert.IsTrue(m_Light.RemoveTargetSortingLayer(layer));
+
+        Assert.IsEmpty(m_Light.targetSortingLayers);
+    }
+
+    [Test]
+    public void TargetSortingLayer_RemoveInvalidLayer()
+    {
+        // Remove an invalid layer returns false
+        Assert.IsFalse(m_Light.RemoveTargetSortingLayer("Invalid"));
+        // Remove random layerID
+        Assert.IsFalse(m_Light.AddTargetSortingLayer(234393945));
+    }
+}