Refactored shadow map debug views. Now ShadowMap implementation is responsible for display.

Assets/ScriptableRenderPipeline/Core/Camera/CameraSwitcher.cs

             m_CameraNames[GetCameraCount() - 1] = new GUIContent("Original Camera");
             m_CameraIndices[GetCameraCount() - 1] = GetCameraCount() - 1;
 
-            DebugMenuManager.instance.AddDebugItem<int>("Camera", "Camera Switcher", () => m_CurrentCameraIndex, (value) => SetCameraIndex((int)value), false, new DebugItemHandlerIntEnum(m_CameraNames, m_CameraIndices));
+            DebugMenuManager.instance.AddDebugItem<int>("Camera", "Camera Switcher", () => m_CurrentCameraIndex, (value) => SetCameraIndex((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(m_CameraNames, m_CameraIndices));
         }
 
         int GetCameraCount()

Assets/ScriptableRenderPipeline/Core/Debugging/DebugActionManager.cs

             public enum Axis { X, Y, Third, Fourth, Fifth, Sixth, Seventh, Eigth }
             public enum Joy { All, First, Second }
 
-            public string	name;
-            public string	desc;
-            public string	btnNegative;
-            public string	btnPositive;
-            public string	altBtnNegative;
-            public string	altBtnPositive;
-            public float	gravity;
-            public float	deadZone;
-            public float	sensitivity;
-            public bool		snap;
-            public bool		invert;
-            public Kind		kind;
-            public Axis		axis;
-            public Joy		joystick;
+            public string	name = "";
+            public string	desc = "";
+            public string	btnNegative = "";
+            public string	btnPositive = "";
+            public string	altBtnNegative = "";
+            public string	altBtnPositive = "";
+            public float	gravity = 0.0f;
+            public float	deadZone = 0.0f;
+            public float	sensitivity = 0.0f;
+            public bool		snap = false;
+            public bool		invert = false;
+            public Kind		kind = Kind.Axis;
+            public Axis		axis = Axis.X;
+            public Joy		joystick = Joy.All;
 
             bool InputAlreadyRegistered(string name, Kind kind, UnityEditor.SerializedProperty spAxes)
             {

Assets/ScriptableRenderPipeline/Core/Debugging/DebugItemHandler.cs

     public class DebugItemHandlerFloatMinMax
         : DefaultDebugItemHandler
     {
-        float m_Min = 0.0f;
-        float m_Max = 1.0f;
+        protected float m_Min = 0.0f;
+        protected float m_Max = 1.0f;
+
         public DebugItemHandlerFloatMinMax(float min, float max)
         {
             m_Min = min;
             if (EditorGUI.EndChangeCheck())
             {
                 m_DebugItem.SetValue(value);
+                return true;
+            }
+
+            return false;
+        }
+#endif
+    }
+
+    public class DebugItemHandlerUIntMinMax
+    : DefaultDebugItemHandler
+    {
+        protected uint m_Min = 0;
+        protected uint m_Max = 1;
+
+        public DebugItemHandlerUIntMinMax(uint min, uint max)
+        {
+            m_Min = min;
+            m_Max = max;
+        }
+
+        public override void ClampValues(Func<object> getter, Action<object> setter)
+        {
+            setter(Math.Min(m_Max, Math.Max(m_Min, (uint)getter())));
+        }
+
+#if UNITY_EDITOR
+        public override bool OnEditorGUIImpl()
+        {
+            Initialize();
+
+            EditorGUI.BeginChangeCheck();
+            int value = EditorGUILayout.IntSlider(m_DebugItem.name, (int)(uint)m_DebugItem.GetValue(), (int)m_Min, (int)m_Max);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_DebugItem.SetValue((uint)value);
                 return true;
             }
 

Assets/ScriptableRenderPipeline/Core/Debugging/DebugItemUI.cs

         protected GameObject    m_Root = null;
         protected DebugItem     m_DebugItem = null;
 
-        public bool dynamicDisplay { get { return m_DebugItem.dynamicDisplay; } }
+        public bool dynamicDisplay { get { return (m_DebugItem.flags & DebugItemFlag.DynamicDisplay) != 0; } }
 
         protected DebugItemUI(DebugItem debugItem)
         {

Assets/ScriptableRenderPipeline/Core/Debugging/DebugMenuManager.cs

             m_DebugMenuUI.AddDebugPanel(panel);
         }
 
-        public void AddDebugItem<DebugPanelType, DebugItemType>(string name, Func<object> getter, Action<object> setter = null, bool dynamicDisplay = false, DebugItemHandler handler = null) where DebugPanelType : DebugPanel
+        public void AddDebugItem<DebugPanelType, DebugItemType>(string name, Func<object> getter, Action<object> setter = null, DebugItemFlag flags = DebugItemFlag.None, DebugItemHandler handler = null) where DebugPanelType : DebugPanel
-                debugPanel.AddDebugItem<DebugItemType>(name, getter, setter, dynamicDisplay, handler);
+                debugPanel.AddDebugItem<DebugItemType>(name, getter, setter, flags, handler);
-        public void AddDebugItem<DebugItemType>(string debugPanelName, string name, Func<object> getter, Action<object> setter = null, bool dynamicDisplay = false, DebugItemHandler handler = null)
+        public void AddDebugItem<DebugItemType>(string debugPanelName, string name, Func<object> getter, Action<object> setter = null, DebugItemFlag flags = DebugItemFlag.None, DebugItemHandler handler = null)
         {
             DebugPanel debugPanel = GetDebugPanel(debugPanelName);
             // If the menu does not exist, create a generic one. This way, users don't have to explicitely create a new DebugMenu class if they don't need any particular overriding of default behavior.
 
             if (debugPanel != null)
             {
-                debugPanel.AddDebugItem<DebugItemType>(name, getter, setter, dynamicDisplay, handler);
+                debugPanel.AddDebugItem<DebugItemType>(name, getter, setter, flags, handler);
             }
 
             m_DebugMenuStateDirty = true;

Assets/ScriptableRenderPipeline/Core/Debugging/DebugMenuUI.cs

 
             m_PersistentPanelRoot.SetActive(false);
 
-            DebugMenuUI.CreateTextElement("DebugMenuTitle", "Debug Menu", 14, TextAnchor.MiddleCenter, m_MainPanelLayout);
+            DebugMenuUI.CreateTextElement("DebugMenuTitle", "Debug Window", 14, TextAnchor.MiddleCenter, m_MainPanelLayout);
 
             m_DebugMenuManager.GetPersistentDebugPanel().panelUI.BuildGUI(m_PersistentPanelLayout);
             m_PersistentDebugPanelUI = m_DebugMenuManager.GetPersistentDebugPanel().panelUI;

Assets/ScriptableRenderPipeline/Core/Debugging/DebugPanel.cs

 
 namespace UnityEngine.Experimental.Rendering
 {
+    [Flags]
+    public enum DebugItemFlag
+    {
+        None,
+        DynamicDisplay
+    }
+
     public class DebugItem
     {
         static public event Action<DebugItem> OnItemDirty;
         public string           panelName       { get { return m_PanelName; } }
-        public DebugItemHandler handler          { get { return m_Handler; } }
-        public bool             dynamicDisplay  { get { return m_DynamicDisplay; } }
+        public DebugItemHandler handler         { get { return m_Handler; } }
+        public DebugItemFlag    flags           { get { return m_Flags; } }
-        public DebugItem(string name, string panelName, Type type, Func<object> getter, Action<object> setter, bool dynamicDisplay = false, DebugItemHandler handler = null)
+        public DebugItem(string name, string panelName, Type type, Func<object> getter, Action<object> setter, DebugItemFlag flags = DebugItemFlag.None, DebugItemHandler handler = null)
         {
             m_Type = type;
             m_Setter = setter;
             m_Handler = handler;
-            m_DynamicDisplay = dynamicDisplay;
+            m_Flags = flags;
         }
 
         public Type GetItemType()
         string              m_Name;
         string              m_PanelName;
         DebugItemHandler    m_Handler = null;
-        bool                m_DynamicDisplay = false;
+        DebugItemFlag       m_Flags = DebugItemFlag.None;
     }
 
     public class DebugPanel
             m_DebugPanelUI.RebuildGUI();
         }
 
-        public void AddDebugItem<ItemType>(string itemName, Func<object> getter, Action<object> setter, bool dynamicDisplay = false, DebugItemHandler handler = null)
+        public void AddDebugItem<ItemType>(string itemName, Func<object> getter, Action<object> setter, DebugItemFlag flags = DebugItemFlag.None, DebugItemHandler handler = null)
         {
             if (handler == null)
                 handler = new DefaultDebugItemHandler();
                 RemoveDebugItem(oldItem);
 
-            DebugItem newItem = new DebugItem(itemName, m_Name, typeof(ItemType), getter, setter, dynamicDisplay, handler);
+            DebugItem newItem = new DebugItem(itemName, m_Name, typeof(ItemType), getter, setter, flags, handler);
             handler.SetDebugItem(newItem);
             m_Items.Add(newItem);
         }

Assets/ScriptableRenderPipeline/Core/Debugging/Editor/DebugMenuEditor.cs

         [SerializeField]
         private DebugMenuState m_DebugMenuState;
 
-        [MenuItem("HDRenderPipeline/Debug Menu")]
+        [MenuItem("HDRenderPipeline/Debug Window")]
-            var window = EditorWindow.GetWindow<DebugMenuEditor>("Debug Menu");
+            var window = EditorWindow.GetWindow<DebugMenuEditor>("Debug Window");
             window.Show();
         }
 

Assets/ScriptableRenderPipeline/Core/Shadow/Shadow.cs

         {
             // Nothing to do for this implementation here, as the atlas is reconstructed each frame, instead of keeping state across frames
         }
+
+        override public void DisplayShadowMap(ScriptableRenderContext renderContext, Material displayMaterial, Vector4 scaleBias, float screenX, float screenY, float screenSizeX, float screenSizeY)
+        {
+            CommandBuffer debugCB = new CommandBuffer();
+            debugCB.name = "";
+
+            MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
+            propertyBlock.SetTexture("_AtlasTexture", m_Shadowmap);
+            propertyBlock.SetVector("_TextureScaleBias", scaleBias);
+            debugCB.SetViewport(new Rect(screenX, screenY, screenSizeX, screenSizeY));
+            debugCB.DrawProcedural(Matrix4x4.identity, displayMaterial, displayMaterial.FindPass("RegularShadow"), MeshTopology.Triangles, 3, 1, propertyBlock);
+
+            renderContext.ExecuteCommandBuffer(debugCB);
+        }
     }
 
 // -------------------------------------------------------------------------------------------------------------------------------------------------
         // The following vector holds data that are returned to the caller so it can be sent to GPU memory in some form. Contents are stable in between calls to ProcessShadowRequests.
         private ShadowIndicesVector m_ShadowIndices = new ShadowIndicesVector( 0, false );
 
+
+        public override uint GetShadowMapCount()
+        {
+            return (uint)m_Shadowmaps.Length;
+        }
+
+        public override uint GetShadowRequestCount()
+        {
+            return m_TmpRequests.Count();
+        }
+
+        public override uint GetShadowRequestFaceCount(uint requestIndex)
+        {
+            if (requestIndex >= (int)m_TmpRequests.Count())
+                return 0;
+            else
+                return m_TmpRequests[requestIndex].facecount;
+        }
+
         public ShadowManager( ShadowSettings shadowSettings, ref ShadowContext.CtxtInit ctxtInitializer, ShadowmapBase[] shadowmaps )
         {
             m_ShadowSettings = shadowSettings;
             }
         }
 
-        public override void DisplayShadows(ScriptableRenderContext renderContext, Material displayMaterial, int shadowMapIndex, float screenX, float screenY, float screenSizeX, float screenSizeY)
+        public override void DisplayShadows(ScriptableRenderContext renderContext, Material displayMaterial, int shadowMapRequestIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY)
-            using (new HDPipeline.Utilities.ProfilingSample("Display Shadows", renderContext))
-            {
-                // This code is specific to shadow atlas implementation
-                MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
+            if (m_ShadowIndices.Count() == 0)
+                return;
-                CommandBuffer debugCB = new CommandBuffer();
-                debugCB.name = "Display shadow Overlay";
+            uint index = Math.Max(0, Math.Min((uint)(m_ShadowIndices.Count() - 1), (uint)shadowMapRequestIndex));
+            int offset = (m_TmpRequests[index].facecount > 1 ) ? 1 : 0;
+            VectorArray<ShadowData> shadowDatas = m_ShadowCtxt.shadowDatas;
+            ShadowData faceData = shadowDatas[(uint)(m_ShadowIndices[index] + offset + faceIndex)];
+            uint texID, samplerID, slice;
+            faceData.UnpackShadowmapId(out texID, out samplerID, out slice);
+            m_Shadowmaps[texID].DisplayShadowMap(renderContext, displayMaterial, faceData.scaleOffset, screenX, screenY, screenSizeX, screenSizeY);
+        }
-                if (shadowMapIndex == -1) // Display the Atlas
-                {
-                    propertyBlock.SetVector("_TextureScaleBias", new Vector4(1.0f, 1.0f, 0.0f, 0.0f));
-                }
-                else // Display particular index
-                {
-                    VectorArray<ShadowData> shadowDatas = m_ShadowCtxt.shadowDatas;
-                    uint shadowIdx = Math.Min((uint)shadowMapIndex, shadowDatas.Count());
-                    propertyBlock.SetVector("_TextureScaleBias", shadowDatas[shadowIdx].scaleOffset);
-                }
+        public override void DisplayShadowAtlas(ScriptableRenderContext renderContext, Material displayMaterial, uint atlasIndex, float screenX, float screenY, float screenSizeX, float screenSizeY)
+        {
+            if(m_Shadowmaps.Length == 0)
+                return;
-                debugCB.SetViewport(new Rect(screenX, screenY, screenSizeX, screenSizeY));
-                debugCB.DrawProcedural(Matrix4x4.identity, displayMaterial, 0, MeshTopology.Triangles, 3, 1, propertyBlock);
-
-                renderContext.ExecuteCommandBuffer(debugCB);
-            }
+            uint index = Math.Max(0, Math.Min((uint)(m_Shadowmaps.Length - 1), atlasIndex));
+            m_Shadowmaps[index].DisplayShadowMap(renderContext, displayMaterial, new Vector4(1.0f, 1.0f, 0.0f, 0.0f), screenX, screenY, screenSizeX, screenSizeY);
         }
 
         public override void SyncData()

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs

             id = texIdx << 24 | sampIdx << 16 | slice;
         }
 
+        public void UnpackShadowmapId(out uint texIdx, out uint sampIdx, out uint slice)
+        {
+            texIdx = (id >> 24) & 0xff;
+            sampIdx = (id >> 16) & 0xff;
+            slice = (id & 0xffff);
+        }
+
         public void PackShadowType( GPUShadowType type, GPUShadowAlgorithm algorithm )
         {
             shadowType = (uint)type << ShadowConstants.Bits.k_GPUShadowAlgorithm | (uint) algorithm;
         abstract public void ReserveSlots( ShadowContextStorage sc );
         abstract public void Fill( ShadowContextStorage cs );
         abstract protected void Register( GPUShadowType type, ShadowRegistry registry );
+        abstract public void DisplayShadowMap(ScriptableRenderContext renderContext, Material displayMaterial, Vector4 scaleBias, float screenX, float screenY, float screenSizeX, float screenSizeY);
     }
 
     interface IShadowManager
         // Renders all shadows for lights the were deemed shadow casters after the last call to ProcessShadowRequests
         void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, VisibleLight[] lights );
         // Debug function to display a shadow at the screen coordinate with the provided material.
-        void DisplayShadows(ScriptableRenderContext renderContext, Material displayMaterial, int shadowMapIndex, float screenX, float screenY, float screenSizeX, float screenSizeY);
+        void DisplayShadows(ScriptableRenderContext renderContext, Material displayMaterial, int shadowMapIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY);
+        void DisplayShadowAtlas(ScriptableRenderContext renderContext, Material displayMaterial, uint atlasIndex, float screenX, float screenY, float screenSizeX, float screenSizeY);
         // Synchronize data with GPU buffers
         void SyncData();
         // Binds resources to shader stages just before rendering the lighting pass
+
+        uint GetShadowMapCount();
+
+        uint GetShadowRequestCount();
+
+        uint GetShadowRequestFaceCount(uint requestIndex);
     }
 
     abstract public class ShadowManagerBase : ShadowRegistry, IShadowManager
-        public  abstract void DisplayShadows(ScriptableRenderContext renderContext, Material displayMaterial, int shadowMapIndex, float screenX, float screenY, float screenSizeX, float screenSizeY);
+        public  abstract void DisplayShadows(ScriptableRenderContext renderContext, Material displayMaterial, int shadowMapIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY);
+        public  abstract void DisplayShadowAtlas(ScriptableRenderContext renderContext, Material displayMaterial, uint atlasIndex, float screenX, float screenY, float screenSizeX, float screenSizeY);
         public  abstract void SyncData();
         public  abstract void BindResources( ScriptableRenderContext renderContext );
         public  abstract void UpdateCullingParameters( ref CullingParameters cullingParams );
         protected abstract void PruneShadowCasters( Camera camera, VisibleLight[] lights, ref VectorArray<int> shadowRequests, ref VectorArray<ShadowmapBase.ShadowRequest> requestsGranted, out uint totalRequestCount );
         // allocate the shadow requests in the shadow map, only is called if shadowsCount > 0 - may modify shadowRequests and shadowsCount
         protected abstract void AllocateShadows( FrameId frameId, VisibleLight[] lights, uint totalGranted, ref VectorArray<ShadowmapBase.ShadowRequest> grantedRequests, ref VectorArray<int> shadowIndices, ref VectorArray<ShadowData> shadowmapDatas, ref VectorArray<ShadowPayload> shadowmapPayload );
+
+        public abstract uint GetShadowMapCount();
+        public abstract uint GetShadowRequestCount();
+        public abstract uint GetShadowRequestFaceCount(uint requestIndex);
+
     }
 } // end of namespace UnityEngine.Experimental.ScriptableRenderLoop

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

         public static string kEnableShadowDebug = "Enable Shadows";
         public static string kShadowDebugMode = "Shadow Debug Mode";
         public static string kShadowMapIndexDebug = "Shadow Map Index";
+        public static string kShadowAtlasIndexDebug = "Shadow Atlas Index";
         public static string kLightingDebugMode = "Lighting Debug Mode";
         public static string kOverrideSmoothnessDebug = "Override Smoothness";
         public static string kOverrideSmoothnessValueDebug = "Override Smoothness Value";
 
         public void RegisterDebug()
         {
-            DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Rate", () => 1.0f / Time.smoothDeltaTime, null, true);
-            DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Time (ms)", () => Time.smoothDeltaTime * 1000.0f, null, true);
+            DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Rate", () => 1.0f / Time.smoothDeltaTime, null, DebugItemFlag.DynamicDisplay);
+            DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Time (ms)", () => Time.smoothDeltaTime * 1000.0f, null, DebugItemFlag.DynamicDisplay);
-            DebugMenuManager.instance.AddDebugItem<int>("Material", "Material",() => materialDebugSettings.debugViewMaterial, (value) => SetDebugViewMaterial((int)value), false, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialStrings, DebugDisplaySettings.debugViewMaterialValues));
-            DebugMenuManager.instance.AddDebugItem<int>("Material", "Engine",() => materialDebugSettings.debugViewEngine, (value) => SetDebugViewEngine((int)value), false, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewEngineStrings, DebugDisplaySettings.debugViewEngineValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "Material",() => materialDebugSettings.debugViewMaterial, (value) => SetDebugViewMaterial((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialStrings, DebugDisplaySettings.debugViewMaterialValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "Engine",() => materialDebugSettings.debugViewEngine, (value) => SetDebugViewEngine((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewEngineStrings, DebugDisplaySettings.debugViewEngineValues));
-            DebugMenuManager.instance.AddDebugItem<int>("Material", "GBuffer",() => materialDebugSettings.debugViewGBuffer, (value) => SetDebugViewGBuffer((int)value), false, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialGBufferStrings, DebugDisplaySettings.debugViewMaterialGBufferValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "GBuffer",() => materialDebugSettings.debugViewGBuffer, (value) => SetDebugViewGBuffer((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialGBufferStrings, DebugDisplaySettings.debugViewMaterialGBufferValues));
-            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, uint>(kShadowMapIndexDebug, () => lightingDebugSettings.shadowMapIndex, (value) => lightingDebugSettings.shadowMapIndex = (uint)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, uint>(kShadowMapIndexDebug, () => lightingDebugSettings.shadowMapIndex, (value) => lightingDebugSettings.shadowMapIndex = (uint)value, DebugItemFlag.None, new DebugItemHandlerShadowIndex(1));
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, uint>(kShadowAtlasIndexDebug, () => lightingDebugSettings.shadowAtlasIndex, (value) => lightingDebugSettings.shadowAtlasIndex = (uint)value, DebugItemFlag.None, new DebugItemHandlerShadowAtlasIndex(1));
-            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kOverrideSmoothnessValueDebug, () => lightingDebugSettings.overrideSmoothnessValue, (value) => lightingDebugSettings.overrideSmoothnessValue = (float)value, false, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kOverrideSmoothnessValueDebug, () => lightingDebugSettings.overrideSmoothnessValue, (value) => lightingDebugSettings.overrideSmoothnessValue = (float)value, DebugItemFlag.None, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
-            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kSkyReflectionMipmapDebug, () => lightingDebugSettings.skyReflectionMipmap, (value) => lightingDebugSettings.skyReflectionMipmap = (float)value, false, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kSkyReflectionMipmapDebug, () => lightingDebugSettings.skyReflectionMipmap, (value) => lightingDebugSettings.skyReflectionMipmap = (float)value, DebugItemFlag.None, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
 
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Opaque",() => renderingDebugSettings.displayOpaqueObjects, (value) => renderingDebugSettings.displayOpaqueObjects = (bool)value);
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Transparency",() => renderingDebugSettings.displayTransparentObjects, (value) => renderingDebugSettings.displayTransparentObjects = (bool)value);
         public bool                 enableShadows = true;
         public ShadowMapDebugMode   shadowDebugMode = ShadowMapDebugMode.None;
         public uint                 shadowMapIndex = 0;
+        public uint                 shadowAtlasIndex = 0;
         public FullScreenDebugMode  fullScreenDebugMode = FullScreenDebugMode.None;
 
         public bool                 overrideSmoothness = false;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplayShadowMap.shader

 Shader "Hidden/HDRenderPipeline/DebugDisplayShadowMap"
 {
+    HLSLINCLUDE
+        #pragma target 4.5
+        #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+
+        #include "../../ShaderLibrary/Common.hlsl"
+
+        #define SHADOW_TILEPASS // TODO: Not sure it must be define, ask uygar
+        #include "../../ShaderLibrary/Shadow/Shadow.hlsl"
+        #undef SHADOW_TILEPASS
+
+        float4 _TextureScaleBias;
+        SamplerState ltc_linear_clamp_sampler;
+        TEXTURE2D_ARRAY(_AtlasTexture);
+
+        struct Attributes
+        {
+            uint vertexID : SV_VertexID;
+        };
+
+        struct Varyings
+        {
+            float4 positionCS : SV_POSITION;
+            float2 texcoord : TEXCOORD0;
+        };
+
+        Varyings Vert(Attributes input)
+        {
+            Varyings output;
+            output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
+            output.texcoord   = GetFullScreenTriangleTexcoord(input.vertexID) * _TextureScaleBias.xy + _TextureScaleBias.zw;
+
+            return output;
+        }
+    ENDHLSL
+
-            ZWrite Off
+            Name "RegularShadow"
+            ZWrite On
-            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
-            #pragma fragment Frag
-
-            #include "../../ShaderLibrary/Common.hlsl"
-
-            #define SHADOW_TILEPASS // TODO: Not sure it must be define, ask uygar
-            #include "../../ShaderLibrary/Shadow/Shadow.hlsl"
-            #undef SHADOW_TILEPASS
-
-            SamplerState ltc_linear_clamp_sampler;
-
-            float4 _TextureScaleBias;
-
-            struct Attributes
+            #pragma fragment FragAtlas
+            
+            float4 FragAtlas(Varyings input) : SV_Target
-                uint vertexID : SV_VertexID;
-            };
-
-            struct Varyings
-            {
-                float4 positionCS : SV_POSITION;
-                float2 texcoord : TEXCOORD0;
-            };
-
-            Varyings Vert(Attributes input)
-            {
-                Varyings output;
-                output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
-                output.texcoord   = GetFullScreenTriangleTexcoord(input.vertexID) * _TextureScaleBias.xy + _TextureScaleBias.zw;
-
-                return output;
-            }
-
-            float4 Frag(Varyings input) : SV_Target
-            {
-                ShadowContext shadowContext = InitShadowContext();
-
-                // Caution: ShadowContext is define in Shadowcontext.hlsl for current render pipeline. This shader must be in sync with its content else it doesn't work.
-                return SAMPLE_TEXTURE2D_ARRAY(_ShadowmapExp_PCF, ltc_linear_clamp_sampler, input.texcoord, 0).xxxx;
+                return SAMPLE_TEXTURE2D_ARRAY(_AtlasTexture, ltc_linear_clamp_sampler, input.texcoord, 0).xxxx;
-
     }
     Fallback Off
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/LightingDebugPanel.cs

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
+using System;
 
 #if UNITY_EDITOR
 using UnityEditor;
 {
+    public class DebugItemHandlerShadowAtlasIndex
+        : DebugItemHandlerUIntMinMax
+    {
+        public DebugItemHandlerShadowAtlasIndex(uint max)
+            : base(0, max)
+        {
+
+        }
+
+        public override void ClampValues(Func<object> getter, Action<object> setter)
+        {
+            HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
+            m_Max = (uint)hdPipeline.GetShadowAtlasCount() - 1;
+            setter(Math.Min(m_Max, Math.Max(m_Min, (uint)getter())));
+        }
+    }
+
+    public class DebugItemHandlerShadowIndex
+    : DebugItemHandlerUIntMinMax
+    {
+        public DebugItemHandlerShadowIndex(uint max)
+            : base(0, max)
+        {
+
+        }
+
+        public override void ClampValues(Func<object> getter, Action<object> setter)
+        {
+            HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
+            m_Max = (uint)hdPipeline.GetCurrentShadowCount() - 1;
+            setter(Math.Min(m_Max, Math.Max(m_Min, (uint)getter())));
+        }
+    }
+
     public class LightingDebugPanelUI
         : DebugPanelUI
     {
                     m_DebugPanel.GetDebugItem(DebugDisplaySettings.kShadowMapIndexDebug).handler.OnEditorGUI();
                     EditorGUI.indentLevel--;
                 }
+                if ((ShadowMapDebugMode)shadowDebug.GetValue() == ShadowMapDebugMode.VisualizeAtlas)
+                {
+                    EditorGUI.indentLevel++;
+                    m_DebugPanel.GetDebugItem(DebugDisplaySettings.kShadowAtlasIndexDebug).handler.OnEditorGUI();
+                    EditorGUI.indentLevel--;
+                }
+
                 DebugItem lightingDebugModeItem = m_DebugPanel.GetDebugItem(DebugDisplaySettings.kLightingDebugMode);
                 lightingDebugModeItem.handler.OnEditorGUI();
                 if ((DebugLightingMode)lightingDebugModeItem.GetValue() == DebugLightingMode.SpecularLighting)

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

         int m_CurrentHeight;
 
         public int GetCurrentShadowCount() { return m_LightLoop.GetCurrentShadowCount(); }
+        public int GetShadowAtlasCount() { return m_LightLoop.GetShadowAtlasCount(); }
 
         readonly SkyManager m_SkyManager = new SkyManager();
         readonly LightLoop m_LightLoop = new LightLoop();
         public DebugDisplaySettings m_DebugDisplaySettings = new DebugDisplaySettings();
         private int m_DebugFullScreenTempRT;
+        private bool m_FullScreenDebugPushed = false;
 
         public SubsurfaceScatteringSettings sssSettings
         {
 
         private CommonSettings.Settings m_CommonSettings = CommonSettings.Settings.s_Defaultsettings;
-        private SkySettings m_SkySettings;
+        private SkySettings m_SkySettings = null;
         private ScreenSpaceAmbientOcclusionSettings.Settings m_SsaoSettings = ScreenSpaceAmbientOcclusionSettings.Settings.s_Defaultsettings;
 
         public CommonSettings.Settings commonSettingsToUse
         {
             if(debugMode == m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode)
             {
+                m_FullScreenDebugPushed = true; // We need this flag because otherwise if no fullscreen debug is pushed, when we render the result in RenderDebug the temporary RT will not exist.
                 cb.GetTemporaryRT(m_DebugFullScreenTempRT, camera.pixelWidth, camera.pixelHeight, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
                 cb.Blit(textureID, m_DebugFullScreenTempRT);
             }
             if (camera.camera.cameraType == CameraType.Reflection || camera.camera.cameraType == CameraType.Preview)
                 return;
 
+            // We make sure the depth buffer is bound because we need it to write depth at near plane for overlays otherwise the editor grid end up visible in them.
+            Utilities.SetRenderTarget(renderContext, BuiltinRenderTextureType.CameraTarget, m_CameraDepthStencilBufferRT);
+
-            if(m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode != FullScreenDebugMode.None)
+            if(m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode != FullScreenDebugMode.None && m_FullScreenDebugPushed)
+                m_FullScreenDebugPushed = false;
                 debugCB.SetGlobalTexture("_DebugFullScreenTexture", m_DebugFullScreenTempRT);
                 m_DebugFullScreen.SetFloat("_FullScreenDebugMode", (float)m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode);
                 Utilities.DrawFullScreen(debugCB, m_DebugFullScreen, camera, BuiltinRenderTextureType.CameraTarget);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

                 return m_ShadowRequests.Count;
             }
 
+            public int GetShadowAtlasCount()
+            {
+                return (int)m_ShadowMgr.GetShadowMapCount();
+            }
+
             public void UpdateCullingParameters(ref CullingParameters cullingParams)
             {
                 m_ShadowMgr.UpdateCullingParameters( ref cullingParams );
             public void RenderDebugOverlay(Camera camera, ScriptableRenderContext renderContext, DebugDisplaySettings debugDisplaySettings, ref float x, ref float y, float overlaySize, float width)
             {
                 LightingDebugSettings lightingDebug = debugDisplaySettings.lightingDebugSettings;
-
-                if (lightingDebug.shadowDebugMode != ShadowMapDebugMode.None)
+                using (new Utilities.ProfilingSample("Display Shadows", renderContext))
-                        m_ShadowMgr.DisplayShadows(renderContext, m_DebugDisplayShadowMap, (int)lightingDebug.shadowMapIndex, x, y, overlaySize, overlaySize);
-                        Utilities.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.pixelWidth);
-
-                        // TODO: @Julien exchange shadowmapIndex by lightIndex and draw all slide like below
-                        /*
-                        for (int slice = 0; slice < shadowLight.shadowSliceCount; ++slice)
+                        uint faceCount = m_ShadowMgr.GetShadowRequestFaceCount(lightingDebug.shadowMapIndex);
+                        for (uint i = 0; i < faceCount; ++i )
-                            ShadowSliceData sliceData = m_ShadowsResult.shadowSlices[shadowLight.shadowSliceIndex + slice];
-
-                            Vector4 texcoordScaleBias = new Vector4((float)sliceData.shadowResolution / m_Owner.shadowSettings.shadowAtlasWidth,
-                                    (float)sliceData.shadowResolution / m_Owner.shadowSettings.shadowAtlasHeight,
-                                    (float)sliceData.atlasX / m_Owner.shadowSettings.shadowAtlasWidth,
-                                    (float)sliceData.atlasY / m_Owner.shadowSettings.shadowAtlasHeight);
-
-                            propertyBlock.SetVector("_TextureScaleBias", texcoordScaleBias);
-
-                            debugCB.SetViewport(new Rect(x, y, overlaySize, overlaySize));
-                            debugCB.DrawProcedural(Matrix4x4.identity, m_DebugDisplayShadowMap, 0, MeshTopology.Triangles, 3, 1, propertyBlock);
-
-                            Utilities.NextOverlayCoord(ref x, ref y, overlaySize, camera.pixelWidth);
+                            m_ShadowMgr.DisplayShadows(renderContext, m_DebugDisplayShadowMap, (int)lightingDebug.shadowMapIndex, i, x, y, overlaySize, overlaySize);
+                            Utilities.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.pixelWidth);
-                        */
-                        m_ShadowMgr.DisplayShadows(renderContext, m_DebugDisplayShadowMap, -1, x, y, overlaySize, overlaySize);
+                        m_ShadowMgr.DisplayShadowAtlas(renderContext, m_DebugDisplayShadowMap, lightingDebug.shadowAtlasIndex, x, y, overlaySize, overlaySize);
                         Utilities.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.pixelWidth);
                     }
                 }