diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer.meta b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer.meta
new file mode 100644
index 00000000000..5e714c24ce5
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5329900f84e7b4d949d9e72ec7a12c90
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatch.uxml b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatch.uxml
new file mode 100644
index 00000000000..8ab763a5643
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatch.uxml
@@ -0,0 +1,12 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../UIElementsSchema/UIElements.xsd" editor-extension-mode="False">
+    <Style src="project://database/Assets/LayerExplorer/LayerExplorer.uss?fileID=7433441132597879392&amp;guid=fd5cb3dd3de574f1585db92b6689f86a&amp;type=3#LayerExplorer" />
+
+    <ui:VisualElement class="BatchList BatchContainer">
+
+        <ui:Label name="BatchIndex"         class="BatchList IndexColumn Batch" />
+        <ui:VisualElement name="BatchColor" class="BatchList ColorColumn" />
+        <ui:VisualElement name="LayerNames" class="BatchList NameColumn Batch" />
+
+    </ui:VisualElement>
+
+</ui:UXML>
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatch.uxml.meta b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatch.uxml.meta
new file mode 100644
index 00000000000..46f02345329
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatch.uxml.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 754a67c6d4788447895a4349508b2f37
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatchInfoView.uxml b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatchInfoView.uxml
new file mode 100644
index 00000000000..a6f22a67914
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatchInfoView.uxml
@@ -0,0 +1,13 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../UIElementsSchema/UIElements.xsd" editor-extension-mode="False">
+    <Style src="project://database/Assets/LayerExplorer/LayerExplorer.uss?fileID=7433441132597879392&amp;guid=fd5cb3dd3de574f1585db92b6689f86a&amp;type=3#LayerExplorer" />
+
+    <ui:ScrollView name="InfoScroller" class="InfoScroller">
+        <ui:Label name="InfoLabel1" class="InfoView Content"/>
+        <ui:VisualElement name="InfoBubble1" class="InfoView Content PillContainer"/>
+        <ui:Label name="InfoLabel2" class="InfoView Content"/>
+        <ui:VisualElement name="InfoBubble2" class="InfoView Content PillContainer"/>
+        <ui:Label name="InfoLabel3" class="InfoView Content"/>
+        <ui:VisualElement name="InfoBubble3" class="InfoView Content PillContainer"/>
+    </ui:ScrollView>
+
+</ui:UXML>
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatchInfoView.uxml.meta b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatchInfoView.uxml.meta
new file mode 100644
index 00000000000..60a0224e0cd
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerBatchInfoView.uxml.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 00dfae39f4ff4d0daa568f0746dc709d
+timeCreated: 1626254709
\ No newline at end of file
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.cs b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.cs
new file mode 100644
index 00000000000..bbe69de7965
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.cs
@@ -0,0 +1,350 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Rendering.Universal;
+using UnityEngine.SceneManagement;
+using UnityEngine.UIElements;
+
+/**
+ * Todos:
+ * - Hook up to the actual render pass (duh)
+ * - Move assets into package
+ */
+namespace UnityEditor.Rendering.Universal
+{
+    internal class LayerExplorer : EditorWindow
+    {
+        private const string ResourcePath = "Packages/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/";
+
+        private class LayerBatch
+        {
+            public List<string> LayerNames = new List<string>();
+            public List<Light2D> Lights = new List<Light2D>();
+            public List<ShadowCaster2D> Shadows = new List<ShadowCaster2D>();
+            public int batchId;
+            public int color;
+        }
+
+        [MenuItem("Window/2D/Sorting Layer Explorer")]
+        public static void ShowExample()
+        {
+            LayerExplorer wnd = GetWindow<LayerExplorer>();
+            wnd.titleContent = new GUIContent("Sorting Layer Explorer");
+        }
+
+        private static Color[] BatchColors = new[] {
+            Color.green,
+            Color.magenta,
+            Color.yellow,
+            Color.red,
+            Color.cyan,
+            Color.white,
+            Color.gray,
+            Color.blue,
+            Color.black,
+        };
+
+        private List<LayerBatch> batchList;
+        private ListView batchListView;
+        private int cachedSceneHandle;
+
+        private bool PopulateData()
+        {
+            batchList = new List<LayerBatch>();
+            var renderer = Light2DEditorUtility.GetRenderer2DData();
+            if (renderer == null || renderer.lightCullResult == null)
+                return false;
+
+            cachedSceneHandle = SceneManager.GetActiveScene().handle;
+            var layers = Light2DManager.GetCachedSortingLayer();
+            var batches = LayerUtility.CalculateBatches(renderer.lightCullResult, out var batchCount);
+
+            for (var i = 0; i < batchCount; i++)
+            {
+                var batchInfo = new LayerBatch
+                {
+                    batchId = i
+                };
+
+                var batch = batches[i];
+
+                // get the lights
+                foreach (var light in renderer.lightCullResult.visibleLights)
+                {
+                    // If the lit layers are different, or if they are lit but this is a shadow casting light then don't batch.
+                    if (light.IsLitLayer(batch.startLayerID))
+                    {
+                        batchInfo.Lights.Add(light);
+                    }
+                }
+
+                if (ShadowCasterGroup2DManager.shadowCasterGroups != null)
+                {
+                    var allShadows = ShadowCasterGroup2DManager.shadowCasterGroups.SelectMany(x => x.GetShadowCasters());
+                    foreach (var shadowCaster in allShadows)
+                    {
+                        if (shadowCaster.IsShadowedLayer(batch.startLayerID))
+                            batchInfo.Shadows.Add(shadowCaster);
+                    }
+                }
+
+                for (var batchIndex = batch.startIndex; batchIndex <= batch.endIndex; batchIndex++)
+                {
+                    batchInfo.LayerNames.Add(layers[batchIndex].name);
+                }
+
+                batchList.Add(batchInfo);
+            }
+
+            return true;
+        }
+
+        private VisualElement MakeLightPill(UnityEngine.Object light)
+        {
+            var bubble = new Button();
+            bubble.AddToClassList("Pill");
+            bubble.text = light.name;
+
+            bubble.clicked += () =>
+            {
+                Selection.activeObject = light;
+            };
+
+            return bubble;
+        }
+
+        private VisualElement GetOrCreateInfoView()
+        {
+            var root = rootVisualElement;
+            var infoView = root.Query<VisualElement>("InfoScroller").First();
+            if (infoView != null)
+                return infoView;
+
+            var infoContainer = root.Query<VisualElement>("InfoContainer").First();
+            infoContainer.Clear();
+
+            // load it
+            var visualTree = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(ResourcePath + "LayerBatchInfoView.uxml");
+            infoView = visualTree.Instantiate();
+            infoContainer.Add(infoView);
+
+            return infoView;
+        }
+
+        private void ViewBatch(int index)
+        {
+            if (index >= batchList.Count())
+                return;
+
+            var root = rootVisualElement;
+            var infoView = GetOrCreateInfoView();
+
+            var batch1 = batchList[index];
+
+            var title = root.Query<Label>("InfoTitle").First();
+            title.text = $"<b>Batch {batch1.batchId}</b>" + " selected.";
+
+            var title2 = root.Query<Label>("InfoTitle2").First();
+            title2.text = "Select any two adjacent batches to compare.";
+
+            var label1 = infoView.Query<Label>("InfoLabel1").First();
+            label1.text = $"Lights in <b>Batch {batch1.batchId}</b>";
+
+            var bubble1 = infoView.Query<VisualElement>("InfoBubble1").First();
+            bubble1.Clear();
+            foreach (var light in batch1.Lights)
+            {
+                bubble1.Add(MakeLightPill(light));
+            }
+
+            var label2 = infoView.Query<Label>("InfoLabel2").First();
+            label2.text = "";
+
+            var bubble2 = infoView.Query<VisualElement>("InfoBubble2").First();
+            bubble2.Clear();
+
+            var label3 = infoView.Query<Label>("InfoLabel3").First();
+            label3.text = $"Shadows in <b>Batch {batch1.batchId}</b>";
+
+            var bubble3 = infoView.Query<VisualElement>("InfoBubble3").First();
+            bubble3.Clear();
+            foreach (var shadow in batch1.Shadows)
+            {
+                bubble3.Add(MakeLightPill(shadow));
+            }
+        }
+
+        private void CompareBatch(int index1, int index2)
+        {
+            // Each editor window contains a root VisualElement object
+            var root = rootVisualElement;
+            var infoView = GetOrCreateInfoView();
+
+            LayerBatch batch1;
+            LayerBatch batch2;
+
+            if (batchList[index1].batchId < batchList[index2].batchId)
+            {
+                batch1 = batchList[index1];
+                batch2 = batchList[index2];
+            }
+            else
+            {
+                batch1 = batchList[index2];
+                batch2 = batchList[index1];
+            }
+
+            var lightSet1 = new HashSet<Light2D>();
+            foreach (var light in batch1.Lights)
+                lightSet1.Add(light);
+
+            var lightSet2 = new HashSet<Light2D>();
+            foreach (var light in batch2.Lights)
+                lightSet2.Add(light);
+
+            // populate
+            var title = root.Query<Label>("InfoTitle").First();
+            title.text = $"Comparing <b>Batch {batch1.batchId}</b> and <b>Batch {batch2.batchId}</b>";
+
+            var title2 = root.Query<Label>("InfoTitle2").First();
+            title2.text = $"To batch <b>Batch {batch1.batchId}</b> and <b>Batch {batch2.batchId}</b>, ensure that the Sorting Layers in both batches share the same set of Lights.";
+
+            var label1 = infoView.Query<Label>("InfoLabel1").First();
+            label1.text = $"Lights only in <b>Batch {batch1.batchId}</b>";
+
+            var bubble1 = infoView.Query<VisualElement>("InfoBubble1").First();
+            bubble1.Clear();
+            foreach (var light in lightSet1.Except(lightSet2))
+                bubble1.Add(MakeLightPill(light));
+
+            var label2 = infoView.Query<Label>("InfoLabel2").First();
+            label2.text = $"Lights only in <b>Batch {batch2.batchId}</b>";
+
+            var bubble2 = infoView.Query<VisualElement>("InfoBubble2").First();
+            bubble2.Clear();
+            foreach (var light in lightSet2.Except(lightSet1))
+                bubble2.Add(MakeLightPill(light));
+        }
+
+        void OnEnable()
+        {
+            CreateGUI();
+        }
+
+        // Create once, initialize
+        private void CreateGUI()
+        {
+            if (!PopulateData())
+                return;
+
+            var root = rootVisualElement;
+            root.Clear();
+
+            var visualTree = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(ResourcePath + "LayerExplorer.uxml");
+            var templateRoot = visualTree.Instantiate();
+            templateRoot.style.flexGrow = 1;
+            templateRoot.Q("ParentElement").StretchToParentSize();
+            root.Add(templateRoot);
+
+            var batchElement = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(ResourcePath + "LayerBatch.uxml");
+            Func<VisualElement> makeItem = () => batchElement.Instantiate();
+
+            Action<VisualElement, int> bindItem = (e, i) =>
+            {
+                if (i >= batchList.Count())
+                    return;
+
+                // this line is required to make the child of the Listview vary in heights
+                e.style.height = new StyleLength(StyleKeyword.Auto);
+
+                var batch = batchList[i];
+                var batchIndex = e.Query<Label>("BatchIndex").First();
+                batchIndex.text = batch.batchId.ToString();
+
+                var layers = e.Query<VisualElement>("LayerNames").First();
+                layers.Clear();
+                foreach (var layerName in batchList[i].LayerNames)
+                {
+                    var label = new Label { text = layerName };
+                    label.AddToClassList("LayerNameLabel");
+                    layers.Add(label);
+                }
+
+                var color = e.Query<VisualElement>("BatchColor").First();
+                color.style.backgroundColor = new StyleColor(BatchColors[i % BatchColors.Length]);
+            };
+
+            batchListView = root.Query<ListView>("BatchList").First();
+            batchListView.itemsSource = batchList;
+            batchListView.makeItem = makeItem;
+            batchListView.bindItem = bindItem;
+            batchListView.virtualizationMethod = CollectionVirtualizationMethod.DynamicHeight;
+            batchListView.showAlternatingRowBackgrounds = AlternatingRowBackground.ContentOnly;
+            batchListView.selectionType = SelectionType.Multiple;
+
+            batchListView.onSelectionChange += objects =>
+            {
+                OnSelectionChange();
+            };
+
+            // Select first index by default
+            batchListView.selectedIndex = 0;
+        }
+
+        private void OnSelectionChange()
+        {
+            if (batchListView == null)
+                return;
+
+            switch (batchListView.selectedIndices.Count())
+            {
+                case 1:
+                    int primaryIndex = batchListView.selectedIndices.First();
+                    ViewBatch(primaryIndex);
+                    break;
+                case 2:
+                    // order of new indices isn't deterministic
+                    primaryIndex = batchListView.selectedIndices.First();
+                    var secondIndex = batchListView.selectedIndices.Last();
+                    if (secondIndex == primaryIndex + 1 || secondIndex == primaryIndex - 1)
+                        CompareBatch(primaryIndex, secondIndex);
+                    else
+                    {
+                        secondIndex = Mathf.Clamp(secondIndex, primaryIndex - 1, primaryIndex + 1);
+                        batchListView.selectedIndex = primaryIndex;
+                        batchListView.AddToSelection(secondIndex);
+                    }
+                    break;
+                default:
+                    if (batchListView.selectedIndices.Count() > 2)
+                        batchListView.RemoveFromSelection(batchListView.selectedIndices.Last());
+                    break;
+            }
+        }
+
+        public void RefreshBatchView()
+        {
+            PopulateData();
+            batchListView.itemsSource = batchList;
+            batchListView.Rebuild();
+
+            OnSelectionChange();
+        }
+
+        private void OnGUI()
+        {
+            if(batchList.Any())
+            {
+                // Refresh if layers are added or removed
+                bool needsRefresh = false;
+
+                needsRefresh |= Light2DManager.GetCachedSortingLayer().Count() != batchList.Sum(x => x.LayerNames.Count());
+                needsRefresh |= cachedSceneHandle != SceneManager.GetActiveScene().handle;
+
+                if (needsRefresh)
+                    RefreshBatchView();
+            }
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.cs.meta b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.cs.meta
new file mode 100644
index 00000000000..fcbda658083
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3f0281a9a104946b4b845f0338560878
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uss b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uss
new file mode 100644
index 00000000000..1fd3631be00
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uss
@@ -0,0 +1,123 @@
+.BatchList {
+
+}
+
+.BatchList.HeaderContainer {
+    flex-direction: row;
+    height: auto;
+}
+
+.BatchList.IndexColumn {
+    margin-left: 5px;
+    width: 65px;
+}
+
+.BatchList.ColorColumn {
+    width: 3px;
+}
+
+.BatchList.NameColumn {
+    flex-grow: 2;
+    margin-left: 5px;
+}
+
+.BatchList.BatchContainer {
+    flex-direction: row;
+}
+
+.BatchList.ColorColumn.Container {
+    align-items: center;
+}
+
+.BatchList.ColorColumn.Splitter {
+    margin-top: 5px;
+    margin-bottom: 5px;
+    margin-right: 5px;
+}
+
+.BatchList.IndexColumn.Header {
+    margin-top: 5px;
+    margin-bottom: 5px;
+}
+
+.BatchList.NameColumn.Header {
+    margin-top: 5px;
+    margin-bottom: 5px;
+}
+
+.BatchList.IndexColumn.Batch {
+    margin-top: 5px;
+}
+
+.BatchList.NameColumn.Batch {
+    margin-top: 5px;
+    flex-direction: column;
+}
+
+.BatchList .List {
+    flex-grow: 1;
+}
+
+.LayerNameLabel {
+    margin-bottom: 5px;
+}
+
+.InfoView {
+}
+
+.InfoView.Content {
+    border-bottom-width: 10px;
+    white-space: normal;
+}
+
+.InfoView.Content.PillContainer {
+    flex-direction: row;
+    flex-wrap: wrap;
+}
+
+.InfoView.Content.Spacer {
+    flex-grow: 1;
+}
+
+.InfoView.Footer {
+    padding: 10px;
+    white-space: normal;
+}
+
+.InfoView.Header {
+    padding: 5px;
+    flex-basis: 60px;
+    align-items: flex-start;
+    justify-content: space-around;
+}
+
+.InfoScroller {
+    flex-grow: 1;
+    padding: 10px;
+    align-self: flex-start;
+}
+
+.InfoContainer{
+    flex-grow: 1;
+    background-color: #2A2A2A;
+    justify-content: center;
+}
+
+.InitialPrompt {
+    align-self: center;
+}
+
+.Pill {
+    border-left-color: rgb(161, 154, 154);
+    border-right-color: rgba(161, 154, 154, 255);
+    border-top-color: rgba(161, 154, 154, 255);
+    border-bottom-color: rgba(161, 154, 154, 255);
+    border-left-width: 1px;
+    border-right-width: 1px;
+    border-top-width: 1px;
+    border-bottom-width: 1px;
+    border-top-left-radius: 10px;
+    border-bottom-left-radius: 10px;
+    border-top-right-radius: 10px;
+    border-bottom-right-radius: 10px;
+}
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uss.meta b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uss.meta
new file mode 100644
index 00000000000..5840bd0404d
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uss.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fd5cb3dd3de574f1585db92b6689f86a
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uxml b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uxml
new file mode 100644
index 00000000000..da5f972ae15
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uxml
@@ -0,0 +1,31 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../UIElementsSchema/UIElements.xsd" editor-extension-mode="False">
+
+        <ui:VisualElement name="ParentElement" style="flex-direction:column">
+            <Style src="LayerExplorer.uss" />
+
+            <ui:VisualElement class="InfoView Header">
+                <ui:Label name="InfoTitle"/>
+                <ui:Label name="InfoTitle2"/>
+            </ui:VisualElement>
+
+            <ui:TwoPaneSplitView fixed-pane-initial-dimension="200">                          
+                <ui:VisualElement>
+                    <ui:Box class="BatchList HeaderContainer">
+                        <ui:Label class="BatchList IndexColumn Header" text="Batch ID"/>
+                        <ui:VisualElement class="BatchList ColorColumn Container">
+                            <ui:Label text="|" class="BatchList ColorColumn Splitter"/>
+                        </ui:VisualElement>
+                        <ui:Label class="BatchList NameColumn Header" text="Layer Names"/>
+                    </ui:Box>
+                    <ui:ListView name="BatchList" class="BatchList List"/>
+                </ui:VisualElement>
+
+                <ui:VisualElement>
+                    <ui:VisualElement name="InfoContainer" class="InfoContainer">
+                        <ui:Label name="InitialPrompt" text="Select a batch to begin..." class="InitialPrompt"/>
+                    </ui:VisualElement>
+                </ui:VisualElement>
+            </ui:TwoPaneSplitView>
+
+        </ui:VisualElement>
+</ui:UXML>
diff --git a/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uxml.meta b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uxml.meta
new file mode 100644
index 00000000000..2dfcd418096
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Editor/2D/LayerExplorer/LayerExplorer.uxml.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7f54b2764826949c192810bd3944abcc
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/com.unity.render-pipelines.universal/Editor/2D/Light2DEditorUtility.cs b/com.unity.render-pipelines.universal/Editor/2D/Light2DEditorUtility.cs
index 4a03f072fd9..d46486e2b96 100644
--- a/com.unity.render-pipelines.universal/Editor/2D/Light2DEditorUtility.cs
+++ b/com.unity.render-pipelines.universal/Editor/2D/Light2DEditorUtility.cs
@@ -1,7 +1,10 @@
+using System.Runtime.CompilerServices;
 using UnityEngine;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.Universal;
 
+[assembly: InternalsVisibleTo("Unity.RenderPipelines.Universal.Editor")]
+
 namespace UnityEditor.Rendering.Universal
 {
     internal static class Light2DEditorUtility
diff --git a/com.unity.render-pipelines.universal/Editor/2D/SortingLayerDropDown.cs b/com.unity.render-pipelines.universal/Editor/2D/SortingLayerDropDown.cs
index faa0c62edb6..a23d1f641fa 100644
--- a/com.unity.render-pipelines.universal/Editor/2D/SortingLayerDropDown.cs
+++ b/com.unity.render-pipelines.universal/Editor/2D/SortingLayerDropDown.cs
@@ -95,6 +95,13 @@ void OnSortingLayerSelected(object layerSelectionDataObject)
                 m_ApplyToSortingLayersList.Add(layerID);
 
             UpdateApplyToSortingLayersArray(layerSelectionDataObject);
+
+            if(EditorWindow.HasOpenInstances<LayerExplorer>())
+            {
+                var layerExplorer = EditorWindow.GetWindow<LayerExplorer>();
+                if (layerExplorer != null)
+                    layerExplorer.RefreshBatchView();
+            }
         }
 
         public void OnTargetSortingLayers(SerializedObject serializedObject, Object[] targets, GUIContent labelContent, System.Action<SerializedObject> selectionChangedCallback)
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Light2DCullResult.cs b/com.unity.render-pipelines.universal/Runtime/2D/Light2DCullResult.cs
index 41b00587703..6abd604e58d 100644
--- a/com.unity.render-pipelines.universal/Runtime/2D/Light2DCullResult.cs
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Light2DCullResult.cs
@@ -7,6 +7,7 @@ namespace UnityEngine.Rendering.Universal
     internal struct LightStats
     {
         public int totalLights;
+        public int totalShadowCasters;
         public int totalNormalMapUsage;
         public int totalVolumetricUsage;
         public uint blendStylesUsed;
@@ -27,7 +28,7 @@ internal class Light2DCullResult : ILight2DCullResult
 
         public bool IsSceneLit()
         {
-            if (visibleLights.Count > 0)
+            /*if (visibleLights.Count > 0)
                 return true;
 
             foreach (var light in Light2DManager.lights)
@@ -36,7 +37,8 @@ public bool IsSceneLit()
                     return true;
             }
 
-            return false;
+            return false;*/
+            return Light2DManager.lights.Count > 0;
         }
 
         public LightStats GetLightStatsByLayer(int layer)
@@ -58,6 +60,23 @@ public LightStats GetLightStatsByLayer(int layer)
                     returnStats.blendStylesWithLights |= (uint)(1 << light.blendStyleIndex);
             }
 
+            if(ShadowCasterGroup2DManager.shadowCasterGroups != null)
+            {
+                foreach (var shadowGroup in ShadowCasterGroup2DManager.shadowCasterGroups)
+                {
+                    if (shadowGroup != null)
+                    {
+                        foreach (var shadowCaster in shadowGroup.GetShadowCasters())
+                        {
+                            if (shadowCaster != null && !shadowCaster.IsShadowedLayer(layer))
+                                continue;
+
+                            returnStats.totalShadowCasters++;
+                        }
+                    }
+                }
+            }
+
             return returnStats;
         }
 
@@ -65,6 +84,7 @@ public void SetupCulling(ref ScriptableCullingParameters cullingParameters, Came
         {
             Profiler.BeginSample("Cull 2D Lights");
             m_VisibleLights.Clear();
+
             foreach (var light in Light2DManager.lights)
             {
                 if ((camera.cullingMask & (1 << light.gameObject.layer)) == 0)
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Passes/LightingPass.cs b/com.unity.render-pipelines.universal/Runtime/2D/Passes/LightingPass.cs
new file mode 100644
index 00000000000..2cf62241ce1
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Passes/LightingPass.cs
@@ -0,0 +1,75 @@
+namespace UnityEngine.Rendering.Universal
+{
+    internal class LightingPass : ScriptableRenderPass, IRenderPass2D
+    {
+        private static readonly int k_HDREmulationScaleID = Shader.PropertyToID("_HDREmulationScale");
+        private static readonly int k_InverseHDREmulationScaleID = Shader.PropertyToID("_InverseHDREmulationScale");
+        private static readonly int k_UseSceneLightingID = Shader.PropertyToID("_UseSceneLighting");
+        private static readonly int k_RendererColorID = Shader.PropertyToID("_RendererColor");
+        private readonly Renderer2DData m_Renderer2DData;
+
+        Renderer2DData IRenderPass2D.rendererData
+        {
+            get { return m_Renderer2DData; }
+        }
+
+        public LightingPass(Renderer2DData rendererData)
+        {
+            profilingSampler = new ProfilingSampler(nameof(LightingPass));
+            m_Renderer2DData = rendererData;
+        }
+
+        public void Setup()
+        {
+        }
+
+        public override void OnCameraCleanup(CommandBuffer cmd)
+        {
+            this.ReleaseRenderTextures(cmd);
+        }
+
+        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+        {
+            var rtCount = 0U;
+            var cmd = renderingData.commandBuffer;
+            using (new ProfilingScope(cmd, profilingSampler))
+            {
+                ref var layerBatch = ref m_Renderer2DData.layerBatches[m_Renderer2DData.currLayerBatch];
+
+                var blendStyleMask = layerBatch.lightStats.blendStylesUsed;
+                var blendStyleCount = 0U;
+                while (blendStyleMask > 0)
+                {
+                    blendStyleCount += blendStyleMask & 1;
+                    blendStyleMask >>= 1;
+                }
+
+                rtCount += blendStyleCount;
+
+                if (rtCount > LayerUtility.maxTextureCount)
+                    return;
+
+                var isLitView = true;
+
+#if UNITY_EDITOR
+                if (renderingData.cameraData.isSceneViewCamera)
+                    isLitView = UnityEditor.SceneView.currentDrawingSceneView.sceneLighting;
+
+                if (renderingData.cameraData.camera.cameraType == CameraType.Preview)
+                    isLitView = false;
+#endif
+
+                cmd.SetGlobalFloat(k_HDREmulationScaleID, m_Renderer2DData.hdrEmulationScale);
+                cmd.SetGlobalFloat(k_InverseHDREmulationScaleID, 1.0f / m_Renderer2DData.hdrEmulationScale);
+                cmd.SetGlobalFloat(k_UseSceneLightingID, isLitView ? 1.0f : 0.0f);
+                cmd.SetGlobalColor(k_RendererColorID, Color.white);
+                this.SetShapeLightShaderGlobals(cmd);
+
+                var desc = this.GetBlendStyleRenderTextureDesc(renderingData);
+                this.RenderLights(renderingData, cmd, ref layerBatch, ref desc);
+
+                ++m_Renderer2DData.currLayerBatch;
+            }
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Passes/LightingPass.cs.meta b/com.unity.render-pipelines.universal/Runtime/2D/Passes/LightingPass.cs.meta
new file mode 100644
index 00000000000..48296bc6d84
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Passes/LightingPass.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 69ca647472556a34a865b592b6e7dad6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Passes/NormalPass.cs b/com.unity.render-pipelines.universal/Runtime/2D/Passes/NormalPass.cs
new file mode 100644
index 00000000000..1ebeaba1541
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Passes/NormalPass.cs
@@ -0,0 +1,56 @@
+namespace UnityEngine.Rendering.Universal
+{
+    internal class NormalPass : ScriptableRenderPass, IRenderPass2D
+    {
+        private static readonly ShaderTagId k_NormalsRenderingPassName = new ShaderTagId("NormalsRendering");
+
+        private readonly Renderer2DData m_Renderer2DData;
+        private bool m_NeedsDepth;
+
+        Renderer2DData IRenderPass2D.rendererData
+        {
+            get { return m_Renderer2DData; }
+        }
+
+        public NormalPass(Renderer2DData rendererData)
+        {
+            profilingSampler = new ProfilingSampler(nameof(NormalPass));
+            m_Renderer2DData = rendererData;
+        }
+
+        public void Setup(bool needsDepth)
+        {
+            m_NeedsDepth = needsDepth;
+        }
+
+        public override void OnCameraCleanup(CommandBuffer cmd)
+        {
+            //this.ReleaseNormalMap(cmd);
+        }
+
+        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+        {
+            var cmd = renderingData.commandBuffer;
+            using (new ProfilingScope(cmd, profilingSampler))
+            {
+                ref LayerBatch layerBatch = ref m_Renderer2DData.layerBatches[m_Renderer2DData.currLayerBatch];
+            
+                if (layerBatch.lightStats.totalNormalMapUsage > 0)
+                {
+                    var filterSettings = new FilteringSettings();
+                    filterSettings.renderQueueRange = RenderQueueRange.all;
+                    filterSettings.layerMask = -1;
+                    filterSettings.renderingLayerMask = 0xFFFFFFFF;
+                    filterSettings.sortingLayerRange = layerBatch.layerRange;
+
+                    var camera = renderingData.cameraData.camera;
+                    var normalsDrawSettings = CreateDrawingSettings(k_NormalsRenderingPassName, ref renderingData, SortingCriteria.CommonTransparent);
+                    LayerUtility.SetTransparencySortingMode(camera, m_Renderer2DData, ref normalsDrawSettings);
+
+                    var depthTarget = m_NeedsDepth ? depthAttachmentHandle.nameID : BuiltinRenderTextureType.None;
+                    this.RenderNormals(context, renderingData, normalsDrawSettings, filterSettings, depthTarget, layerBatch.lightStats);
+                }
+            }
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Passes/NormalPass.cs.meta b/com.unity.render-pipelines.universal/Runtime/2D/Passes/NormalPass.cs.meta
new file mode 100644
index 00000000000..3abb06ebfd1
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Passes/NormalPass.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3b169a4b8285b4d459a7c75737490261
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Passes/Render2DLightingPass.cs b/com.unity.render-pipelines.universal/Runtime/2D/Passes/Render2DLightingPass.cs
index df0c4e714ba..a11fee633e5 100644
--- a/com.unity.render-pipelines.universal/Runtime/2D/Passes/Render2DLightingPass.cs
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Passes/Render2DLightingPass.cs
@@ -50,30 +50,6 @@ internal void Setup(bool useDepth)
             m_NeedsDepth = useDepth;
         }
 
-        private void GetTransparencySortingMode(Camera camera, ref SortingSettings sortingSettings)
-        {
-            var mode = m_Renderer2DData.transparencySortMode;
-
-            if (mode == TransparencySortMode.Default)
-            {
-                mode = camera.orthographic ? TransparencySortMode.Orthographic : TransparencySortMode.Perspective;
-            }
-
-            switch (mode)
-            {
-                case TransparencySortMode.Perspective:
-                    sortingSettings.distanceMetric = DistanceMetric.Perspective;
-                    break;
-                case TransparencySortMode.Orthographic:
-                    sortingSettings.distanceMetric = DistanceMetric.Orthographic;
-                    break;
-                default:
-                    sortingSettings.distanceMetric = DistanceMetric.CustomAxis;
-                    sortingSettings.customAxis = m_Renderer2DData.transparencySortAxis;
-                    break;
-            }
-        }
-
         private void CopyCameraSortingLayerRenderTexture(ScriptableRenderContext context, RenderingData renderingData, RenderBufferStoreAction mainTargetStoreAction)
         {
             var cmd = renderingData.commandBuffer;
@@ -152,24 +128,6 @@ private void DetermineWhenToResolve(int startIndex, int batchesDrawn, int batchC
             }
         }
 
-        private void Render(ScriptableRenderContext context, CommandBuffer cmd, ref RenderingData renderingData, ref FilteringSettings filterSettings, DrawingSettings drawSettings)
-        {
-            var activeDebugHandler = GetActiveDebugHandler(renderingData);
-            if (activeDebugHandler != null)
-            {
-                RenderStateBlock renderStateBlock = new RenderStateBlock();
-                activeDebugHandler.DrawWithDebugRenderState(context, cmd, ref renderingData, ref drawSettings, ref filterSettings, ref renderStateBlock,
-                    (ScriptableRenderContext ctx, ref RenderingData data, ref DrawingSettings ds, ref FilteringSettings fs, ref RenderStateBlock rsb) =>
-                    {
-                        ctx.DrawRenderers(data.cullResults, ref ds, ref fs, ref rsb);
-                    });
-            }
-            else
-            {
-                context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filterSettings);
-            }
-        }
-
         private int DrawLayerBatches(
             LayerBatch[] layerBatches,
             int batchCount,
@@ -218,7 +176,7 @@ private int DrawLayerBatches(
 
                     using (new ProfilingScope(cmd, m_ProfilingDrawLightTextures))
                     {
-                        this.RenderLights(renderingData, cmd, layerBatch.startLayerID, ref layerBatch, ref desc);
+                        this.RenderLights(renderingData, cmd, ref layerBatch, ref desc);
                     }
                 }
             }
@@ -292,16 +250,16 @@ private int DrawLayerBatches(
                         if (cameraSortingLayerBoundsIndex >= layerBatch.layerRange.lowerBound && cameraSortingLayerBoundsIndex < layerBatch.layerRange.upperBound && m_Renderer2DData.useCameraSortingLayerTexture)
                         {
                             filterSettings.sortingLayerRange = new SortingLayerRange(layerBatch.layerRange.lowerBound, cameraSortingLayerBoundsIndex);
-                            Render(context, cmd, ref renderingData, ref filterSettings, drawSettings);
+                            this.Render(context, cmd, ref renderingData, ref filterSettings, drawSettings);
                             CopyCameraSortingLayerRenderTexture(context, renderingData, copyStoreAction);
 
                             filterSettings.sortingLayerRange = new SortingLayerRange((short)(cameraSortingLayerBoundsIndex + 1), layerBatch.layerRange.upperBound);
-                            Render(context, cmd, ref renderingData, ref filterSettings, drawSettings);
+                            this.Render(context, cmd, ref renderingData, ref filterSettings, drawSettings);
                         }
                         else
                         {
                             filterSettings.sortingLayerRange = new SortingLayerRange(layerBatch.layerRange.lowerBound, layerBatch.layerRange.upperBound);
-                            Render(context, cmd, ref renderingData, ref filterSettings, drawSettings);
+                            this.Render(context, cmd, ref renderingData, ref filterSettings, drawSettings);
 
                             if (cameraSortingLayerBoundsIndex == layerBatch.layerRange.upperBound && m_Renderer2DData.useCameraSortingLayerTexture)
                                 CopyCameraSortingLayerRenderTexture(context, renderingData, copyStoreAction);
@@ -318,7 +276,7 @@ private int DrawLayerBatches(
                                 storeAction = resolveDuringBatch == i && !resolveIsAfterCopy ? RenderBufferStoreAction.Resolve : RenderBufferStoreAction.StoreAndResolve;
                             else
                                 storeAction = RenderBufferStoreAction.Store;
-                            this.RenderLightVolumes(renderingData, cmd, layerBatch.startLayerID, layerBatch.endLayerValue, colorAttachmentHandle.nameID, depthAttachmentHandle.nameID,
+                            this.RenderLightVolumes(renderingData, cmd, ref layerBatch, colorAttachmentHandle.nameID, depthAttachmentHandle.nameID,
                                 RenderBufferStoreAction.Store, storeAction, false, m_Renderer2DData.lightCullResult.visibleLights);
 
                             cmd.EndSample(sampleName);
@@ -363,10 +321,8 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
                 var combinedDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData, SortingCriteria.CommonTransparent);
                 var normalsDrawSettings = CreateDrawingSettings(k_NormalsRenderingPassName, ref renderingData, SortingCriteria.CommonTransparent);
 
-                var sortSettings = combinedDrawSettings.sortingSettings;
-                GetTransparencySortingMode(camera, ref sortSettings);
-                combinedDrawSettings.sortingSettings = sortSettings;
-                normalsDrawSettings.sortingSettings = sortSettings;
+                LayerUtility.SetTransparencySortingMode(camera, m_Renderer2DData, ref combinedDrawSettings);
+                normalsDrawSettings.sortingSettings = combinedDrawSettings.sortingSettings;
 
                 var cmd = renderingData.commandBuffer;
                 cmd.SetGlobalFloat(k_HDREmulationScaleID, m_Renderer2DData.hdrEmulationScale);
@@ -394,9 +350,7 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
                 var msaaEnabled = renderingData.cameraData.cameraTargetDescriptor.msaaSamples > 1;
                 var storeAction = msaaEnabled ? RenderBufferStoreAction.Resolve : RenderBufferStoreAction.Store;
 
-                var sortSettings = unlitDrawSettings.sortingSettings;
-                GetTransparencySortingMode(camera, ref sortSettings);
-                unlitDrawSettings.sortingSettings = sortSettings;
+                LayerUtility.SetTransparencySortingMode(camera, m_Renderer2DData, ref unlitDrawSettings);
 
                 var cmd = renderingData.commandBuffer;
                 using (new ProfilingScope(cmd, m_ProfilingSamplerUnlit))
@@ -426,16 +380,16 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
                 if (m_Renderer2DData.useCameraSortingLayerTexture)
                 {
                     filterSettings.sortingLayerRange = new SortingLayerRange(short.MinValue, m_CameraSortingLayerBoundsIndex);
-                    Render(context, cmd, ref renderingData, ref filterSettings, unlitDrawSettings);
+                    this.Render(context, cmd, ref renderingData, ref filterSettings, unlitDrawSettings);
 
                     CopyCameraSortingLayerRenderTexture(context, renderingData, storeAction);
 
                     filterSettings.sortingLayerRange = new SortingLayerRange(m_CameraSortingLayerBoundsIndex, short.MaxValue);
-                    Render(context, cmd, ref renderingData, ref filterSettings, unlitDrawSettings);
+                    this.Render(context, cmd, ref renderingData, ref filterSettings, unlitDrawSettings);
                 }
                 else
                 {
-                    Render(context, cmd, ref renderingData, ref filterSettings, unlitDrawSettings);
+                    this.Render(context, cmd, ref renderingData, ref filterSettings, unlitDrawSettings);
                 }
                 Profiler.EndSample();
             }
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Passes/TransparencyPass.cs b/com.unity.render-pipelines.universal/Runtime/2D/Passes/TransparencyPass.cs
new file mode 100644
index 00000000000..751fd977b77
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Passes/TransparencyPass.cs
@@ -0,0 +1,116 @@
+using System.Collections.Generic;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class TransparencyPass : ScriptableRenderPass, IRenderPass2D
+    {
+        private static readonly ShaderTagId k_CombinedRenderingPassName = new ShaderTagId("Universal2D");
+        private static readonly ShaderTagId k_LegacyPassName = new ShaderTagId("SRPDefaultUnlit");
+        private static readonly List<ShaderTagId> k_ShaderTags = new List<ShaderTagId>() { k_LegacyPassName, k_CombinedRenderingPassName };
+
+        private static readonly int[] k_ShapeLightTextureIDs =
+        {
+            Shader.PropertyToID("_ShapeLightTexture0"),
+            Shader.PropertyToID("_ShapeLightTexture1"),
+            Shader.PropertyToID("_ShapeLightTexture2"),
+            Shader.PropertyToID("_ShapeLightTexture3")
+        };
+
+        private readonly Renderer2DData m_Renderer2DData;
+        Renderer2DData IRenderPass2D.rendererData
+        {
+            get { return m_Renderer2DData;}
+        }
+
+        int m_BatchCount;
+
+        public TransparencyPass(Renderer2DData rendererData)
+        {
+            profilingSampler = new ProfilingSampler(nameof(TransparencyPass));
+            m_Renderer2DData = rendererData;
+        }
+
+        public void Setup(int batchCount)
+        {
+            m_BatchCount = batchCount;
+        }
+
+        public override void OnCameraCleanup(CommandBuffer cmd)
+        {
+            for (int i = 0; i < m_BatchCount; ++i)
+            {
+                ref var layerBatch = ref m_Renderer2DData.layerBatches[i];
+                layerBatch.ReleaseRT(cmd);
+            }
+
+            this.DisableAllKeywords(cmd);
+        }
+
+        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+        {
+            var cmd = renderingData.commandBuffer;
+            using (new ProfilingScope(cmd, profilingSampler))
+            {
+                var isSceneLit = m_Renderer2DData.lightCullResult.IsSceneLit();
+
+                for (int i = 0; i < m_BatchCount; ++i)
+                {
+                    ref var layerBatch = ref m_Renderer2DData.layerBatches[i];
+
+                    var blendStylesCount = m_Renderer2DData.lightBlendStyles.Length;
+                    var desc = this.GetBlendStyleRenderTextureDesc(renderingData);
+
+                    if (layerBatch.lightStats.totalLights > 0)
+                    {
+                        for (var blendStyleIndex = 0; blendStyleIndex < blendStylesCount; blendStyleIndex++)
+                        {
+                            var blendStyleMask = (uint)(1 << blendStyleIndex);
+                            var blendStyleUsed = (layerBatch.lightStats.blendStylesUsed & blendStyleMask) > 0;
+
+                            if (blendStyleUsed)
+                            {
+                                var identifier = layerBatch.GetRTId(cmd, desc, blendStyleIndex);
+                                cmd.SetGlobalTexture(k_ShapeLightTextureIDs[blendStyleIndex], identifier);
+                            }
+
+                            RendererLighting.EnableBlendStyle(cmd, blendStyleIndex, blendStyleUsed);
+                        }
+                    }
+                    else
+                    {
+                        for (var blendStyleIndex = 0; blendStyleIndex < k_ShapeLightTextureIDs.Length; blendStyleIndex++)
+                        {
+                            cmd.SetGlobalTexture(k_ShapeLightTextureIDs[blendStyleIndex], Texture2D.blackTexture);
+                            RendererLighting.EnableBlendStyle(cmd, blendStyleIndex, blendStyleIndex == 0);
+                        }
+                    }
+
+                    if (!isSceneLit)
+                        this.DisableAllKeywords(cmd);
+
+                    context.ExecuteCommandBuffer(cmd);
+                    cmd.Clear();
+
+                    var filterSettings = new FilteringSettings();
+                    filterSettings.renderQueueRange = RenderQueueRange.all;
+                    filterSettings.layerMask = -1;
+                    filterSettings.renderingLayerMask = 0xFFFFFFFF;
+                    filterSettings.sortingLayerRange = isSceneLit ? new SortingLayerRange(layerBatch.layerRange.lowerBound, layerBatch.layerRange.upperBound) : SortingLayerRange.all;
+
+                    var camera = renderingData.cameraData.camera;
+                    var drawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData, SortingCriteria.CommonTransparent);
+                    LayerUtility.SetTransparencySortingMode(camera, m_Renderer2DData, ref drawSettings);
+
+                    this.Render(context, cmd, ref renderingData, ref filterSettings, drawSettings);
+
+                    RenderBufferStoreAction storeAction = RenderBufferStoreAction.Store;
+                    this.RenderLightVolumes(renderingData, cmd, ref layerBatch, colorAttachmentHandle.nameID, depthAttachmentHandle.nameID,
+                              RenderBufferStoreAction.Store, storeAction, false, m_Renderer2DData.lightCullResult.visibleLights);
+
+                    if (!isSceneLit)
+                        break;
+                }
+            }
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Passes/TransparencyPass.cs.meta b/com.unity.render-pipelines.universal/Runtime/2D/Passes/TransparencyPass.cs.meta
new file mode 100644
index 00000000000..5707bc5441e
--- /dev/null
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Passes/TransparencyPass.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5ad49863672fcfe4a881b38c8d5f73e1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/LayerUtility.cs b/com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/LayerUtility.cs
index a9280ee9df6..c889b79de80 100644
--- a/com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/LayerUtility.cs
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/LayerUtility.cs
@@ -1,9 +1,13 @@
+using System.Collections.Generic;
 using Unity.Mathematics;
 
 namespace UnityEngine.Rendering.Universal
 {
     internal struct LayerBatch
     {
+        public int startIndex;
+        public int endIndex;
+
         public int startLayerID;
         public int endLayerValue;
         public SortingLayerRange layerRange;
@@ -66,13 +70,30 @@ private static bool CanBatchLightsInLayer(int layerIndex1, int layerIndex2, Sort
         {
             var layerId1 = sortingLayers[layerIndex1].id;
             var layerId2 = sortingLayers[layerIndex2].id;
+
             foreach (var light in lightCullResult.visibleLights)
             {
                 // If the lit layers are different, or if they are lit but this is a shadow casting light then don't batch.
-                bool lightCastsShadows = (light.lightType != Light2D.LightType.Global && light.shadowsEnabled);
-                if ((light.IsLitLayer(layerId1) != light.IsLitLayer(layerId2)) || (light.IsLitLayer(layerId1) && lightCastsShadows))
+                //bool lightCastsShadows = (light.lightType != Light2D.LightType.Global && light.shadowsEnabled);
+                if (light.IsLitLayer(layerId1) != light.IsLitLayer(layerId2))
                     return false;
             }
+
+            if (ShadowCasterGroup2DManager.shadowCasterGroups != null)
+            {
+                foreach (var group in ShadowCasterGroup2DManager.shadowCasterGroups)
+                {
+                    if (group != null)
+                    {
+                        foreach (var shadowCaster in group.GetShadowCasters())
+                        {
+                            if (shadowCaster.IsShadowedLayer(layerId1) != shadowCaster.IsShadowedLayer(layerId2))
+                                return false;
+                        }
+                    }
+                }
+            }
+
             return true;
         }
 
@@ -140,6 +161,8 @@ public static LayerBatch[] CalculateBatches(ILight2DCullResult lightCullResult,
                 // Renderer within this range share the same set of lights so they should be rendered together.
                 var sortingLayerRange = new SortingLayerRange(lowerBound, upperBound);
 
+                layerBatch.startIndex = i;
+                layerBatch.endIndex = upperLayerInBatch;
                 layerBatch.startLayerID = layerToRender;
                 layerBatch.endLayerValue = endLayerValue;
                 layerBatch.layerRange = sortingLayerRange;
@@ -150,5 +173,32 @@ public static LayerBatch[] CalculateBatches(ILight2DCullResult lightCullResult,
 
             return s_LayerBatches;
         }
+
+        public static void SetTransparencySortingMode(Camera camera, Renderer2DData data, ref DrawingSettings drawingSettings)
+        {
+            var sortingSettings = drawingSettings.sortingSettings;
+            var mode = data.transparencySortMode;
+
+            if (mode == TransparencySortMode.Default)
+            {
+                mode = camera.orthographic ? TransparencySortMode.Orthographic : TransparencySortMode.Perspective;
+            }
+
+            switch (mode)
+            {
+                case TransparencySortMode.Perspective:
+                    sortingSettings.distanceMetric = DistanceMetric.Perspective;
+                    break;
+                case TransparencySortMode.Orthographic:
+                    sortingSettings.distanceMetric = DistanceMetric.Orthographic;
+                    break;
+                default:
+                    sortingSettings.distanceMetric = DistanceMetric.CustomAxis;
+                    sortingSettings.customAxis = data.transparencySortAxis;
+                    break;
+            }
+
+            drawingSettings.sortingSettings = sortingSettings;
+        }
     }
 }
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/RendererLighting.cs b/com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/RendererLighting.cs
index 204f14751c6..e783142e359 100644
--- a/com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/RendererLighting.cs
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/RendererLighting.cs
@@ -191,7 +191,7 @@ private static bool CanCastVolumetricShadows(Light2D light, int endLayerValue)
         }
 
 
-        private static void RenderLightSet(IRenderPass2D pass, RenderingData renderingData, int blendStyleIndex, CommandBuffer cmd, int layerToRender, RenderTargetIdentifier renderTexture, List<Light2D> lights)
+        private static void RenderLightSet(IRenderPass2D pass, RenderingData renderingData, int blendStyleIndex, CommandBuffer cmd, ref LayerBatch layerBatch, RenderTargetIdentifier renderTexture)
         {
             var maxShadowLightCount = ShadowRendering.maxTextureCount * 4;
             var requiresRTInit = true;
@@ -203,7 +203,8 @@ private static void RenderLightSet(IRenderPass2D pass, RenderingData renderingDa
                 return;
             }
 
-
+            int layerToRender = layerBatch.startLayerID;
+            var lights = pass.rendererData.lightCullResult.visibleLights;
             NativeArray<bool> doesLightAtIndexHaveShadows = new NativeArray<bool>(lights.Count, Allocator.Temp);
 
             // Break up light rendering into batches for the purpose of shadow casting
@@ -222,7 +223,7 @@ private static void RenderLightSet(IRenderPass2D pass, RenderingData renderingDa
                     if (CanCastShadows(light, layerToRender))
                     {
                         doesLightAtIndexHaveShadows[curLightIndex] = false;
-                        if (ShadowRendering.PrerenderShadows(pass, renderingData, cmd, layerToRender, light, shadowLightCount, light.shadowIntensity))
+                        if (ShadowRendering.PrerenderShadows(pass, renderingData, cmd, ref layerBatch, light, shadowLightCount, light.shadowIntensity))
                         {
                             doesLightAtIndexHaveShadows[curLightIndex] = true;
                             shadowLightCount++;
@@ -296,7 +297,7 @@ private static void RenderLightSet(IRenderPass2D pass, RenderingData renderingDa
             doesLightAtIndexHaveShadows.Dispose();
         }
 
-        public static void RenderLightVolumes(this IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmd, int layerToRender, int endLayerValue,
+        public static void RenderLightVolumes(this IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmd, ref LayerBatch layerBatch,
             RenderTargetIdentifier renderTexture, RenderTargetIdentifier depthTexture, RenderBufferStoreAction intermediateStoreAction,
             RenderBufferStoreAction finalStoreAction, bool requiresRTInit, List<Light2D> lights)
         {
@@ -339,10 +340,10 @@ public static void RenderLightVolumes(this IRenderPass2D pass, RenderingData ren
                     int curLightIndex = lightIndex + batchedLights;
                     var light = lights[curLightIndex];
 
-                    if (CanCastVolumetricShadows(light, endLayerValue))
+                    if (CanCastVolumetricShadows(light, layerBatch.endLayerValue))
                     {
                         doesLightAtIndexHaveShadows[curLightIndex] = false;
-                        if (ShadowRendering.PrerenderShadows(pass, renderingData, cmd, layerToRender, light, shadowLightCount, light.shadowVolumeIntensity))
+                        if (ShadowRendering.PrerenderShadows(pass, renderingData, cmd, ref layerBatch, light, shadowLightCount, light.shadowVolumeIntensity))
                         {
                             doesLightAtIndexHaveShadows[curLightIndex] = true;
                             shadowLightCount++;
@@ -372,7 +373,7 @@ public static void RenderLightVolumes(this IRenderPass2D pass, RenderingData ren
                         continue;
 
                     var topMostLayerValue = light.GetTopMostLitLayer();
-                    if (endLayerValue == topMostLayerValue) // this implies the layer is correct
+                    if (layerBatch.endLayerValue == topMostLayerValue) // this implies the layer is correct
                     {
                         var lightVolumeMaterial = pass.rendererData.GetLightMaterial(light, true);
                         var lightMesh = light.lightMesh;
@@ -508,6 +509,24 @@ public static void ClearDirtyLighting(this IRenderPass2D pass, CommandBuffer cmd
             }
         }
 
+        public static void Render(this ScriptableRenderPass pass, ScriptableRenderContext context, CommandBuffer cmd, ref RenderingData renderingData, ref FilteringSettings filterSettings, DrawingSettings drawSettings)
+        {
+            var activeDebugHandler = pass.GetActiveDebugHandler(renderingData);
+            if (activeDebugHandler != null)
+            {
+                RenderStateBlock renderStateBlock = new RenderStateBlock();
+                activeDebugHandler.DrawWithDebugRenderState(context, cmd, ref renderingData, ref drawSettings, ref filterSettings, ref renderStateBlock,
+                    (ScriptableRenderContext ctx, ref RenderingData data, ref DrawingSettings ds, ref FilteringSettings fs, ref RenderStateBlock rsb) =>
+                    {
+                        ctx.DrawRenderers(data.cullResults, ref ds, ref fs, ref rsb);
+                    });
+            }
+            else
+            {
+                context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filterSettings);
+            }
+        }
+
         public static void RenderNormals(this IRenderPass2D pass, ScriptableRenderContext context, RenderingData renderingData, DrawingSettings drawSettings, FilteringSettings filterSettings, RenderTargetIdentifier depthTarget, LightStats lightStats)
         {
             var cmd = renderingData.commandBuffer;
@@ -523,7 +542,6 @@ public static void RenderNormals(this IRenderPass2D pass, ScriptableRenderContex
 
                 pass.CreateNormalMapRenderTexture(renderingData, cmd, normalRTScale);
 
-
                 var msaaEnabled = renderingData.cameraData.cameraTargetDescriptor.msaaSamples > 1;
                 var storeAction = msaaEnabled ? RenderBufferStoreAction.Resolve : RenderBufferStoreAction.Store;
                 var clearFlag = pass.rendererData.useDepthStencilBuffer ? ClearFlag.All : ClearFlag.Color;
@@ -540,12 +558,11 @@ public static void RenderNormals(this IRenderPass2D pass, ScriptableRenderContex
                 context.ExecuteCommandBuffer(cmd);
                 cmd.Clear();
 
-                drawSettings.SetShaderPassName(0, k_NormalsRenderingPassName);
                 context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filterSettings);
             }
         }
 
-        public static void RenderLights(this IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmd, int layerToRender, ref LayerBatch layerBatch, ref RenderTextureDescriptor rtDesc)
+        public static void RenderLights(this IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmd, ref LayerBatch layerBatch, ref RenderTextureDescriptor rtDesc)
         {
             // Before rendering the lights cache some values that are expensive to get/calculate
             var culledLights = pass.rendererData.lightCullResult.visibleLights;
@@ -556,7 +573,6 @@ public static void RenderLights(this IRenderPass2D pass, RenderingData rendering
 
             ShadowCasterGroup2DManager.CacheValues();
 
-
             var blendStyles = pass.rendererData.lightBlendStyles;
 
             for (var i = 0; i < blendStyles.Length; ++i)
@@ -567,7 +583,7 @@ public static void RenderLights(this IRenderPass2D pass, RenderingData rendering
                 var sampleName = blendStyles[i].name;
                 cmd.BeginSample(sampleName);
 
-                if (!Light2DManager.GetGlobalColor(layerToRender, i, out var clearColor))
+                if (!Light2DManager.GetGlobalColor(layerBatch.startLayerID, i, out var clearColor))
                     clearColor = Color.black;
 
                 var anyLights = (layerBatch.lightStats.blendStylesWithLights & (uint)(1 << i)) != 0;
@@ -590,9 +606,8 @@ public static void RenderLights(this IRenderPass2D pass, RenderingData rendering
                         pass, renderingData,
                         i,
                         cmd,
-                        layerToRender,
-                        identifier,
-                        pass.rendererData.lightCullResult.visibleLights
+                        ref layerBatch,
+                        identifier
                     );
                 }
 
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Renderer2D.cs b/com.unity.render-pipelines.universal/Runtime/2D/Renderer2D.cs
index 351aed06384..4e5a7b7121d 100644
--- a/com.unity.render-pipelines.universal/Runtime/2D/Renderer2D.cs
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Renderer2D.cs
@@ -6,6 +6,10 @@ namespace UnityEngine.Rendering.Universal
 {
     internal class Renderer2D : ScriptableRenderer
     {
+        NormalPass m_NormalPass;
+        LightingPass m_LightingPass;
+        TransparencyPass m_TransparencyPass;
+
         Render2DLightingPass m_Render2DLightingPass;
         PixelPerfectBackgroundPass m_PixelPerfectBackgroundPass;
         UpscalePass m_UpscalePass;
@@ -49,6 +53,10 @@ public Renderer2D(Renderer2DData data) : base(data)
             m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.blitShader);
             m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.samplingShader);
 
+            m_NormalPass = new NormalPass(data);
+            m_LightingPass = new LightingPass(data);
+            m_TransparencyPass = new TransparencyPass(data);
+
             m_Render2DLightingPass = new Render2DLightingPass(data, m_BlitMaterial, m_SamplingMaterial);
             // we should determine why clearing the camera target is set so late in the events... sounds like it could be earlier
             m_PixelPerfectBackgroundPass = new PixelPerfectBackgroundPass(RenderPassEvent.AfterRenderingTransparents);
@@ -227,9 +235,36 @@ public override void Setup(ScriptableRenderContext context, ref RenderingData re
             }
 
             var needsDepth = m_CreateDepthTexture || m_UseDepthStencilBuffer;
-            m_Render2DLightingPass.Setup(needsDepth);
-            m_Render2DLightingPass.ConfigureTarget(colorTargetHandle, depthTargetHandle);
-            EnqueuePass(m_Render2DLightingPass);
+
+            // New Passes - For each layer in layer batches do NORMAL, LIGHTING, TRANSPARENCY
+            bool newPass = true;
+            //bool newPass = false;
+
+            if (newPass)
+            {
+                LayerUtility.InitializeBudget(m_Renderer2DData.lightRenderTextureMemoryBudget);
+                ShadowRendering.InitializeBudget(m_Renderer2DData.shadowRenderTextureMemoryBudget);
+
+                m_Renderer2DData.currLayerBatch = 0;
+                m_Renderer2DData.layerBatches = LayerUtility.CalculateBatches(m_Renderer2DData.lightCullResult, out var batchCount);
+                for (int i = 0; i < batchCount; ++i)
+                {
+                    m_NormalPass.Setup(needsDepth);
+                    m_NormalPass.ConfigureTarget(colorTargetHandle, depthTargetHandle);
+                    EnqueuePass(m_NormalPass);
+                    EnqueuePass(m_LightingPass);
+                }
+
+                m_TransparencyPass.Setup(batchCount);
+                m_TransparencyPass.ConfigureTarget(colorTargetHandle, depthTargetHandle);
+                EnqueuePass(m_TransparencyPass);
+            }
+            else
+            {
+                m_Render2DLightingPass.Setup(needsDepth);
+                m_Render2DLightingPass.ConfigureTarget(colorTargetHandle, depthTargetHandle);
+                EnqueuePass(m_Render2DLightingPass);
+            }
 
             // When using Upscale Render Texture on a Pixel Perfect Camera, we want all post-processing effects done with a low-res RT,
             // and only upscale the low-res RT to fullscreen when blitting it to camera target. Also, final post processing pass is not run in this case,
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Renderer2DData.cs b/com.unity.render-pipelines.universal/Runtime/2D/Renderer2DData.cs
index 148aca84c43..519534764e6 100644
--- a/com.unity.render-pipelines.universal/Runtime/2D/Renderer2DData.cs
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Renderer2DData.cs
@@ -191,5 +191,8 @@ protected override void OnEnable()
 
         // this shouldn've been in RenderingData along with other cull results
         internal ILight2DCullResult lightCullResult { get; set; }
+        internal LayerBatch[] layerBatches { get; set; }
+        internal int currLayerBatch { get; set; }
+
     }
 }
diff --git a/com.unity.render-pipelines.universal/Runtime/2D/Shadows/ShadowRendering.cs b/com.unity.render-pipelines.universal/Runtime/2D/Shadows/ShadowRendering.cs
index 72646b24940..38b5cfac27d 100644
--- a/com.unity.render-pipelines.universal/Runtime/2D/Shadows/ShadowRendering.cs
+++ b/com.unity.render-pipelines.universal/Runtime/2D/Shadows/ShadowRendering.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using UnityEngine.Experimental.Rendering;
 
@@ -130,7 +129,7 @@ public static void CreateShadowRenderTexture(IRenderPass2D pass, RenderingData r
             CreateShadowRenderTexture(pass, m_RenderTargetIds[shadowIndex], renderingData, cmdBuffer);
         }
 
-        public static bool PrerenderShadows(IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmdBuffer, int layerToRender, Light2D light, int shadowIndex, float shadowIntensity)
+        public static bool PrerenderShadows(IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmdBuffer, ref LayerBatch layerBatch, Light2D light, int shadowIndex, float shadowIntensity)
         {
             var colorChannel = shadowIndex % 4;
             var textureIndex = shadowIndex / 4;
@@ -138,7 +137,7 @@ public static bool PrerenderShadows(IRenderPass2D pass, RenderingData renderingD
             if (colorChannel == 0)
                 ShadowRendering.CreateShadowRenderTexture(pass, renderingData, cmdBuffer, textureIndex);
 
-            bool hadShadowsToRender = RenderShadows(pass, renderingData, cmdBuffer, layerToRender, light, shadowIntensity, m_RenderTargets[textureIndex].nameID, colorChannel);
+            bool hadShadowsToRender = RenderShadows(pass, renderingData, cmdBuffer, ref layerBatch, light, shadowIntensity, m_RenderTargets[textureIndex].nameID, colorChannel);
 
             m_LightInputTextures[textureIndex] = m_RenderTargets[textureIndex].nameID;
 
@@ -195,138 +194,89 @@ public static void SetShadowProjectionGlobals(CommandBuffer cmdBuffer, ShadowCas
             cmdBuffer.SetGlobalMatrix(k_ShadowModelInvMatrixID, shadowCaster.m_CachedInverseShadowMatrix);
         }
 
-        public static bool RenderShadows(IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmdBuffer, int layerToRender, Light2D light, float shadowIntensity, RenderTargetIdentifier renderTexture, int colorBit)
+        public static bool RenderShadows(IRenderPass2D pass, RenderingData renderingData, CommandBuffer cmdBuffer, ref LayerBatch layerBatch, Light2D light, float shadowIntensity, RenderTargetIdentifier renderTexture, int colorBit)
         {
             using (new ProfilingScope(cmdBuffer, m_ProfilingSamplerShadows))
             {
-                bool hasShadow = false;
-                var shadowCasterGroups = ShadowCasterGroup2DManager.shadowCasterGroups;
-                if (shadowCasterGroups != null && shadowCasterGroups.Count > 0)
+                int layerToRender = layerBatch.startLayerID;
+                var shadowGroups = ShadowCasterGroup2DManager.shadowCasterGroups;
+                bool hasShadow = layerBatch.lightStats.totalShadowCasters > 0;
+
+                if (hasShadow && shadowGroups != null)
                 {
-                    // Before doing anything check to see if any of the shadow casters are visible to this light
-                    for (var group = 0; group < shadowCasterGroups.Count; group++)
-                    {
-                        var shadowCasterGroup = shadowCasterGroups[group];
-                        var shadowCasters = shadowCasterGroup.GetShadowCasters();
+                    cmdBuffer.SetRenderTarget(renderTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.DontCare);
 
-                        if (shadowCasters != null)
+                    using (new ProfilingScope(cmdBuffer, m_ProfilingSamplerShadowColorsLookup[colorBit]))
+                    {
+                        if (colorBit == 0)
+                            cmdBuffer.ClearRenderTarget(true, true, Color.clear);
+                        else
+                            cmdBuffer.ClearRenderTarget(true, false, Color.clear);
+
+                        var shadowRadius = light.boundingSphere.radius;
+
+                        cmdBuffer.SetGlobalVector(k_LightPosID, light.transform.position);
+                        cmdBuffer.SetGlobalFloat(k_ShadowRadiusID, shadowRadius);
+                        cmdBuffer.SetGlobalColor(k_ShadowColorMaskID, k_ColorLookup[colorBit]);
+                        var unshadowGeometryMaterial = pass.rendererData.GetGeometryUnshadowMaterial(colorBit);
+                        var projectedShadowsMaterial = pass.rendererData.GetProjectedShadowMaterial(colorBit);
+                        var selfShadowMaterial = pass.rendererData.GetSpriteSelfShadowMaterial(colorBit);
+                        var unshadowMaterial = pass.rendererData.GetSpriteUnshadowMaterial(colorBit);
+                        var setGlobalStencilMaterial = pass.rendererData.GetStencilOnlyShadowMaterial(colorBit);
+
+                        foreach (var shadowGroup in shadowGroups)
                         {
-                            // Draw the projected shadows for the shadow caster group. Writing into the group stencil buffer bit
-                            for (var i = 0; i < shadowCasters.Count; i++)
+                            var shadowCasters = shadowGroup.GetShadowCasters();
+
+                            foreach (var shadowCaster in shadowCasters)
                             {
-                                var shadowCaster = shadowCasters[i];
-                                if (shadowCaster != null && shadowCaster.IsLit(light) && shadowCaster.IsShadowedLayer(layerToRender))
+                                if (projectedShadowsMaterial != null && shadowCaster.IsLit(light) && shadowCaster.IsShadowedLayer(layerToRender))
                                 {
-                                    hasShadow = true;
-                                    break;
+                                    SetShadowProjectionGlobals(cmdBuffer, shadowCaster);
+
+                                    cmdBuffer.DrawMesh(shadowCaster.mesh, shadowCaster.m_CachedLocalToWorldMatrix, unshadowGeometryMaterial, 0, 0);
+                                    cmdBuffer.DrawMesh(shadowCaster.mesh, shadowCaster.m_CachedLocalToWorldMatrix, projectedShadowsMaterial, 0, 0);
+                                    cmdBuffer.DrawMesh(shadowCaster.mesh, shadowCaster.m_CachedLocalToWorldMatrix, unshadowGeometryMaterial, 0, 1);
                                 }
                             }
-                        }
-                    }
-
-                    if (hasShadow)
-                    {
-                        cmdBuffer.SetRenderTarget(renderTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.DontCare);
-
-                        using (new ProfilingScope(cmdBuffer, m_ProfilingSamplerShadowColorsLookup[colorBit]))
-                        {
-                            if (colorBit == 0)
-                                cmdBuffer.ClearRenderTarget(true, true, Color.clear);
-                            else
-                                cmdBuffer.ClearRenderTarget(true, false, Color.clear);
-
-                            var shadowRadius = light.boundingSphere.radius;
-
-                            cmdBuffer.SetGlobalVector(k_LightPosID, light.transform.position);
-                            cmdBuffer.SetGlobalFloat(k_ShadowRadiusID, shadowRadius);
-
 
-                            cmdBuffer.SetGlobalColor(k_ShadowColorMaskID, k_ColorLookup[colorBit]);
-                            var unshadowGeometryMaterial = pass.rendererData.GetGeometryUnshadowMaterial(colorBit);
-                            var projectedShadowsMaterial = pass.rendererData.GetProjectedShadowMaterial(colorBit);
-                            var selfShadowMaterial = pass.rendererData.GetSpriteSelfShadowMaterial(colorBit);
-                            var unshadowMaterial = pass.rendererData.GetSpriteUnshadowMaterial(colorBit);
-                            var setGlobalStencilMaterial = pass.rendererData.GetStencilOnlyShadowMaterial(colorBit);
-
-                            for (var group = 0; group < shadowCasterGroups.Count; group++)
+                            // Draw the sprites, either as self shadowing or unshadowing
+                            foreach (var shadowCaster in shadowCasters)
                             {
-                                var shadowCasterGroup = shadowCasterGroups[group];
-                                var shadowCasters = shadowCasterGroup.GetShadowCasters();
-
-                                if (shadowCasters != null)
+                                if (shadowCaster.IsLit(light) && shadowCaster.IsShadowedLayer(layerToRender))
                                 {
-                                    for (var i = 0; i < shadowCasters.Count; i++)
+                                    if (shadowCaster.useRendererSilhouette)
                                     {
-                                        var shadowCaster = shadowCasters[i];
+                                        // Draw using the sprite renderer
+                                        var renderer = (Renderer)null;
+                                        shadowCaster.TryGetComponent<Renderer>(out renderer);
 
-                                        if (shadowCaster.IsLit(light))
+                                        if (renderer != null)
                                         {
-                                            if (shadowCaster != null && projectedShadowsMaterial != null && shadowCaster.IsShadowedLayer(layerToRender))
-                                            {
-                                                if (shadowCaster.castsShadows)
-                                                {
-                                                    SetShadowProjectionGlobals(cmdBuffer, shadowCaster);
-
-                                                    cmdBuffer.DrawMesh(shadowCaster.mesh, shadowCaster.m_CachedLocalToWorldMatrix, unshadowGeometryMaterial, 0, 0);
-                                                    cmdBuffer.DrawMesh(shadowCaster.mesh, shadowCaster.m_CachedLocalToWorldMatrix, projectedShadowsMaterial, 0, 0);
-                                                    cmdBuffer.DrawMesh(shadowCaster.mesh, shadowCaster.m_CachedLocalToWorldMatrix, unshadowGeometryMaterial, 0, 1);
-                                                }
-                                            }
+                                            var material = shadowCaster.selfShadows ? selfShadowMaterial : unshadowMaterial;
+                                            if (material != null)
+                                                cmdBuffer.DrawRenderer(renderer, material);
                                         }
                                     }
-
-                                    // Draw the sprites, either as self shadowing or unshadowing
-                                    for (var i = 0; i < shadowCasters.Count; i++)
+                                    else
                                     {
-                                        var shadowCaster = shadowCasters[i];
+                                        var meshMat = shadowCaster.m_CachedLocalToWorldMatrix;
+                                        var material = shadowCaster.selfShadows ? selfShadowMaterial : unshadowMaterial;
 
-                                        if (shadowCaster.IsLit(light))
-                                        {
-                                            if (shadowCaster != null && shadowCaster.IsShadowedLayer(layerToRender))
-                                            {
-                                                if (shadowCaster.useRendererSilhouette)
-                                                {
-                                                    // Draw using the sprite renderer
-                                                    var renderer = (Renderer)null;
-                                                    shadowCaster.TryGetComponent<Renderer>(out renderer);
-
-                                                    if (renderer != null)
-                                                    {
-                                                        var material = shadowCaster.selfShadows ? selfShadowMaterial : unshadowMaterial;
-                                                        if (material != null)
-                                                            cmdBuffer.DrawRenderer(renderer, material);
-                                                    }
-                                                }
-                                                else
-                                                {
-                                                    var meshMat = shadowCaster.m_CachedLocalToWorldMatrix;
-                                                    var material = shadowCaster.selfShadows ? selfShadowMaterial : unshadowMaterial;
-
-                                                    // Draw using the shadow mesh
-                                                    if (material != null)
-                                                        cmdBuffer.DrawMesh(shadowCaster.mesh, meshMat, material);
-                                                }
-                                            }
-                                        }
+                                        // Draw using the shadow mesh
+                                        if (material != null)
+                                            cmdBuffer.DrawMesh(shadowCaster.mesh, meshMat, material);
                                     }
+                                }
+                            }
 
-                                    // Draw the projected shadows for the shadow caster group. Writing clearing the group stencil bit, and setting the global bit
-                                    for (var i = 0; i < shadowCasters.Count; i++)
-                                    {
-                                        var shadowCaster = shadowCasters[i];
-
-                                        if (shadowCaster.IsLit(light))
-                                        {
-                                            if (shadowCaster != null && projectedShadowsMaterial != null && shadowCaster.IsShadowedLayer(layerToRender))
-                                            {
-                                                if (shadowCaster.castsShadows)
-                                                {
-                                                    SetShadowProjectionGlobals(cmdBuffer, shadowCaster);
-                                                    cmdBuffer.DrawMesh(shadowCaster.mesh, shadowCaster.m_CachedLocalToWorldMatrix, projectedShadowsMaterial, 0, 1);
-                                                }
-                                            }
-                                        }
-                                    }
+                            // Draw the projected shadows for the shadow caster group. Writing clearing the group stencil bit, and setting the global bit
+                            foreach (var shadowCaster in shadowCasters)
+                            {
+                                if (projectedShadowsMaterial != null && shadowCaster.IsLit(light) && shadowCaster.IsShadowedLayer(layerToRender))
+                                {
+                                    SetShadowProjectionGlobals(cmdBuffer, shadowCaster);
+                                    cmdBuffer.DrawMesh(shadowCaster.mesh, shadowCaster.m_CachedLocalToWorldMatrix, projectedShadowsMaterial, 0, 1);
                                 }
                             }
                         }