Merge remote-tracking branch 'refs/remotes/origin/master' into Update-POM-+-Heightmap-behavior

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs

     public class GlobalDebugParameters
     {
         public float debugOverlayRatio = 0.33f;
-        public bool displayDebug = false;
-        public bool displayShadowDebug = false;
+        public bool displayMaterialDebug = false;
+        public bool displayRenderingDebug = false;
+        public bool displayLightingDebug = false;
+
+        public MaterialDebugParameters materialDebugParameters = new MaterialDebugParameters();
+        public LightingDebugParameters lightingDebugParameters = new LightingDebugParameters();
+        public RenderingDebugParameters renderingDebugParametrs = new RenderingDebugParameters();
-        public ShadowDebugParameters shadowDebugParameters = new ShadowDebugParameters();
+        public void OnValidate()
+        {
+            lightingDebugParameters.OnValidate();
+        }
-    public class DebugParameters
+
+    [Serializable]
+    public class MaterialDebugParameters
-        // Material Debugging
+    }
-        // Rendering debugging
+    [Serializable]
+    public class RenderingDebugParameters
+    {
-
-        public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
-        public bool useDepthPrepass = false;
-        public bool useDistortion = true;
-
-        // we have to fallback to forward-only rendering when scene view is using wireframe rendering mode --
-        // as rendering everything in wireframe + deferred do not play well together
-        public bool ShouldUseForwardRenderingOnly() { return useForwardRenderingOnly || GL.wireframe; }
+        public bool enableDistortion = true;
     }
 
     public enum ShadowDebugMode
         VisualizeShadowMap
     }
 
+    [GenerateHLSL]
+    public enum LightingDebugMode
+    {
+        None,
+        DiffuseLighting,
+        SpecularLighting
+    }
+
-    public class ShadowDebugParameters
+    public class LightingDebugParameters
-        public bool             enableShadows = true;
-        public ShadowDebugMode  visualizationMode = ShadowDebugMode.None;
-        public uint             visualizeShadowMapIndex = 0;
+        public bool                 enableShadows = true;
+        public ShadowDebugMode      shadowDebugMode = ShadowDebugMode.None;
+        public uint                 shadowMapIndex = 0;
+
+        public LightingDebugMode    lightingDebugMode = LightingDebugMode.None;
+        public bool                 overrideSmoothness = false;
+        public float                overrideSmoothnessValue = 0.5f;
+        public Color                debugLightingAlbedo = new Color(0.5f, 0.5f, 0.5f);
+
+        public void OnValidate()
+        {
+            overrideSmoothnessValue = Mathf.Clamp(overrideSmoothnessValue, 0.0f, 1.0f);
+        }
     }
 }

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/Resources/DebugDisplayShadowMap.shader

 
             #include "Common.hlsl"
 
-            TEXTURE2D(g_tShadowBuffer);
+            TEXTURE2D_FLOAT(g_tShadowBuffer);
 
             TEXTURE2D(_DummyTexture);
             SAMPLER2D(sampler_DummyTexture);

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

     {
         private class Styles
         {
-            // Global debug parameters
-            public readonly GUIContent debugging = new GUIContent("Debugging");
-            public readonly GUIContent debugOverlayRatio = new GUIContent("Overlay Ratio");
+            public readonly GUIContent settingsLabel = new GUIContent("Settings");
-            public readonly GUIContent debugParameters = new GUIContent("Debug Parameters");
-            public readonly GUIContent debugViewMaterial = new GUIContent("DebugView Material", "Display various properties of Materials.");
-
-            public readonly GUIContent displayOpaqueObjects = new GUIContent("Display Opaque Objects", "Toggle opaque objects rendering on and off.");
-            public readonly GUIContent displayTransparentObjects = new GUIContent("Display Transparent Objects", "Toggle transparent objects rendering on and off.");
-
+            // Rendering Settings
+            public readonly GUIContent renderingSettingsLabel = new GUIContent("Rendering Settings");
-            public readonly GUIContent useDistortion = new GUIContent("Use Distortion");        
-            public bool isDebugViewMaterialInit = false;
-            public GUIContent[] debugViewMaterialStrings = null;
-            public int[] debugViewMaterialValues = null;
+            // Texture Settings
+            public readonly GUIContent textureSettings = new GUIContent("Texture Settings");
+            public readonly GUIContent spotCookieSize = new GUIContent("Spot cookie size");
+            public readonly GUIContent pointCookieSize = new GUIContent("Point cookie size");
+            public readonly GUIContent reflectionCubemapSize = new GUIContent("Reflection cubemap size");
-            public readonly GUIContent skyParams = new GUIContent("Sky Settings");
-            // Shadow Debug
-            public readonly GUIContent shadowDebugParameters = new GUIContent("Shadow Debug");
-            public readonly GUIContent shadowDebugEnable = new GUIContent("Enable Shadows");
-            public readonly GUIContent shadowDebugVisualizationMode = new GUIContent("Visualize");
-            public readonly GUIContent shadowDebugVisualizeShadowIndex = new GUIContent("Visualize Shadow Index");
-
+            // Shadow Settings
+            // Tile pass Settings
             public readonly GUIContent tileLightLoopSettings = new GUIContent("Tile Light Loop Settings");
             public readonly string[] tileLightLoopDebugTileFlagStrings = new string[] { "Punctual Light", "Area Light", "Env Light"};
             public readonly GUIContent splitLightEvaluation = new GUIContent("Split light and reflection evaluation", "Toggle");
             public readonly GUIContent disableDeferredShadingInCompute = new GUIContent("Disable deferred shading in compute", "Toggle");
 
-            public readonly GUIContent textureSettings = new GUIContent("Texture Settings");
+            // Sky Settings
+            public readonly GUIContent skyParams = new GUIContent("Sky Settings");
+
+            // Global debug parameters
+            public readonly GUIContent debugging = new GUIContent("Debugging");
+            public readonly GUIContent debugOverlayRatio = new GUIContent("Overlay Ratio");
-            public readonly GUIContent spotCookieSize = new GUIContent("Spot cookie size");
-            public readonly GUIContent pointCookieSize = new GUIContent("Point cookie size");
-            public readonly GUIContent reflectionCubemapSize = new GUIContent("Reflection cubemap size");              
+            // Material debug
+            public readonly GUIContent materialDebugLabel = new GUIContent("Material Debug");
+            public readonly GUIContent debugViewMaterial = new GUIContent("DebugView Material", "Display various properties of Materials.");
+            public bool isDebugViewMaterialInit = false;
+            public GUIContent[] debugViewMaterialStrings = null;
+            public int[] debugViewMaterialValues = null;
+
+            // Rendering Debug
+            public readonly GUIContent renderingDebugParameters = new GUIContent("Rendering Debug");
+            public readonly GUIContent displayOpaqueObjects = new GUIContent("Display Opaque Objects", "Toggle opaque objects rendering on and off.");
+            public readonly GUIContent displayTransparentObjects = new GUIContent("Display Transparent Objects", "Toggle transparent objects rendering on and off.");
+            public readonly GUIContent enableDistortion = new GUIContent("Enable Distortion");
+
+            // Lighting Debug
+            public readonly GUIContent lightingDebugParameters = new GUIContent("Lighting Debug");
+            public readonly GUIContent shadowDebugEnable = new GUIContent("Enable Shadows");
+            public readonly GUIContent shadowDebugVisualizationMode = new GUIContent("Shadow Debug Mode");
+            public readonly GUIContent shadowDebugVisualizeShadowIndex = new GUIContent("Visualize Shadow Index");
+            public readonly GUIContent lightingDebugMode = new GUIContent("Lighting Debug Mode");
+            public readonly GUIContent lightingDebugOverrideSmoothness = new GUIContent("Override Smoothness");
+            public readonly GUIContent lightingDebugOverrideSmoothnessValue = new GUIContent("Smoothness Value");
+            public readonly GUIContent lightingDebugAlbedo = new GUIContent("Lighting Debug Albedo");
         }
 
         private static Styles s_Styles = null;
             }
         }
 
-        SerializedProperty m_ShowDebug = null;
-        SerializedProperty m_ShowDebugShadow = null;
+        // Global debug
+        SerializedProperty m_ShowMaterialDebug = null;
+        SerializedProperty m_ShowLightingDebug = null;
+        SerializedProperty m_ShowRenderingDebug = null;
+        // Rendering Debug
+        SerializedProperty m_MaterialDebugMode = null;
+
+        // Rendering Debug
+        SerializedProperty m_DisplayOpaqueObjects = null;
+        SerializedProperty m_DisplayTransparentObjects = null;
+        SerializedProperty m_EnableDistortion = null;
+
+        // Lighting debug
-        SerializedProperty m_DebugShadowVisualizationMode = null;
-        SerializedProperty m_DebugShadowVisualizeShadowIndex = null;
+        SerializedProperty m_ShadowDebugMode = null;
+        SerializedProperty m_ShadowDebugShadowMapIndex = null;
+        SerializedProperty m_LightingDebugMode = null;
+        SerializedProperty m_LightingDebugOverrideSmoothness = null;
+        SerializedProperty m_LightingDebugOverrideSmoothnessValue = null;
+        SerializedProperty m_LightingDebugAlbedo = null;
+
+        // Rendering Parameters
+        SerializedProperty m_RenderingUseForwardOnly = null;
+        SerializedProperty m_RenderingUseDepthPrepass = null;
+            // Global debug
-            m_ShowDebugShadow = FindProperty(x => x.globalDebugParameters.displayShadowDebug);
-            m_ShowDebug = FindProperty(x => x.globalDebugParameters.displayDebug);
+            m_ShowLightingDebug = FindProperty(x => x.globalDebugParameters.displayLightingDebug);
+            m_ShowRenderingDebug = FindProperty(x => x.globalDebugParameters.displayRenderingDebug);
+            m_ShowMaterialDebug = FindProperty(x => x.globalDebugParameters.displayMaterialDebug);
-            m_DebugShadowEnabled = FindProperty(x => x.globalDebugParameters.shadowDebugParameters.enableShadows);
-            m_DebugShadowVisualizationMode = FindProperty(x => x.globalDebugParameters.shadowDebugParameters.visualizationMode);
-            m_DebugShadowVisualizeShadowIndex = FindProperty(x => x.globalDebugParameters.shadowDebugParameters.visualizeShadowMapIndex);
+            // Material debug
+            m_MaterialDebugMode = FindProperty(x => x.globalDebugParameters.materialDebugParameters.debugViewMaterial);
+
+            // Rendering debug
+            m_DisplayOpaqueObjects = FindProperty(x => x.globalDebugParameters.renderingDebugParametrs.displayOpaqueObjects);
+            m_DisplayTransparentObjects = FindProperty(x => x.globalDebugParameters.renderingDebugParametrs.displayTransparentObjects);
+            m_EnableDistortion = FindProperty(x => x.globalDebugParameters.renderingDebugParametrs.enableDistortion);
+
+            // Lighting debug
+            m_DebugShadowEnabled = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.enableShadows);
+            m_ShadowDebugMode = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.shadowDebugMode);
+            m_ShadowDebugShadowMapIndex = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.shadowMapIndex);
+            m_LightingDebugMode = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.lightingDebugMode);
+            m_LightingDebugOverrideSmoothness = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.overrideSmoothness);
+            m_LightingDebugOverrideSmoothnessValue = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.overrideSmoothnessValue);
+            m_LightingDebugAlbedo = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.debugLightingAlbedo);
+
+            // Rendering settings
+            m_RenderingUseForwardOnly = FindProperty(x => x.renderingParameters.useForwardRenderingOnly);
+            m_RenderingUseDepthPrepass = FindProperty(x => x.renderingParameters.useDepthPrepass);
+
         }
 
         SerializedProperty FindProperty<TValue>(Expression<Func<HDRenderPipeline, TValue>> expr)
             m_DebugOverlayRatio.floatValue = EditorGUILayout.Slider(styles.debugOverlayRatio, m_DebugOverlayRatio.floatValue, 0.1f, 1.0f);
             EditorGUILayout.Space();
 
-            DebugParametersUI(renderContext);
+            MaterialDebugParametersUI(renderContext);
+            RenderingDebugParametersUI(renderContext);
+            LightingDebugParametersUI(renderContext, renderpipelineInstance);
+
-            ShadowDebugParametersUI(renderContext, renderpipelineInstance);
-        private void DebugParametersUI(HDRenderPipeline renderContext)
+        private void MaterialDebugParametersUI(HDRenderPipeline renderContext)
-            m_ShowDebug.boolValue = EditorGUILayout.Foldout(m_ShowDebug.boolValue, styles.debugParameters);
-            if (!m_ShowDebug.boolValue)
+            m_ShowMaterialDebug.boolValue = EditorGUILayout.Foldout(m_ShowMaterialDebug.boolValue, styles.materialDebugLabel);
+            if (!m_ShowMaterialDebug.boolValue)
-
-            var debugParameters = renderContext.debugParameters;
 
             EditorGUI.indentLevel++;
             EditorGUI.BeginChangeCheck();
                 styles.isDebugViewMaterialInit = true;
             }
 
-            debugParameters.debugViewMaterial = EditorGUILayout.IntPopup(styles.debugViewMaterial, (int)debugParameters.debugViewMaterial, styles.debugViewMaterialStrings, styles.debugViewMaterialValues);
-
-            EditorGUILayout.Space();
-            debugParameters.displayOpaqueObjects = EditorGUILayout.Toggle(styles.displayOpaqueObjects, debugParameters.displayOpaqueObjects);
-            debugParameters.displayTransparentObjects = EditorGUILayout.Toggle(styles.displayTransparentObjects, debugParameters.displayTransparentObjects);
-            debugParameters.useForwardRenderingOnly = EditorGUILayout.Toggle(styles.useForwardRenderingOnly, debugParameters.useForwardRenderingOnly);
-            debugParameters.useDepthPrepass = EditorGUILayout.Toggle(styles.useDepthPrepass, debugParameters.useDepthPrepass);
-            debugParameters.useDistortion = EditorGUILayout.Toggle(styles.useDistortion, debugParameters.useDistortion);
+            EditorGUI.showMixedValue = m_MaterialDebugMode.hasMultipleDifferentValues;
+            m_MaterialDebugMode.intValue = EditorGUILayout.IntPopup(styles.debugViewMaterial, m_MaterialDebugMode.intValue, styles.debugViewMaterialStrings, styles.debugViewMaterialValues);
+            EditorGUI.showMixedValue = false;
 
             if (EditorGUI.EndChangeCheck())
             {
         }
 
-        private void SkySettingsUI(HDRenderPipeline pipe)
+        private void RenderingDebugParametersUI(HDRenderPipeline renderContext)
-            EditorGUILayout.Space();
+            m_ShowRenderingDebug.boolValue = EditorGUILayout.Foldout(m_ShowRenderingDebug.boolValue, styles.renderingDebugParameters);
+            if (!m_ShowRenderingDebug.boolValue)
+                return;
-            EditorGUILayout.LabelField(styles.skyParams);
-            EditorGUI.BeginChangeCheck();
-            pipe.skyParameters = (SkyParameters) EditorGUILayout.ObjectField(new GUIContent("Sky Settings"), pipe.skyParameters, typeof(SkyParameters), false);
-            pipe.lightLoopProducer = (LightLoopProducer) EditorGUILayout.ObjectField(new GUIContent("Light Loop"), pipe.lightLoopProducer, typeof(LightLoopProducer), false);
+            EditorGUILayout.PropertyField(m_DisplayOpaqueObjects, styles.displayOpaqueObjects);
+            EditorGUILayout.PropertyField(m_DisplayTransparentObjects, styles.displayTransparentObjects);
+            EditorGUILayout.PropertyField(m_EnableDistortion, styles.enableDistortion);
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                HackSetDirty(pipe); // Repaint
-            }
         }
 
         private void SssSettingsUI(HDRenderPipeline pipe)
             }
         }
 
-        private void ShadowDebugParametersUI(HDRenderPipeline renderContext, HDRenderPipelineInstance renderpipelineInstance)
+        private void LightingDebugParametersUI(HDRenderPipeline renderContext, HDRenderPipelineInstance renderpipelineInstance)
-            m_ShowDebugShadow.boolValue = EditorGUILayout.Foldout(m_ShowDebugShadow.boolValue, styles.shadowDebugParameters);
-            if (!m_ShowDebugShadow.boolValue)
+            m_ShowLightingDebug.boolValue = EditorGUILayout.Foldout(m_ShowLightingDebug.boolValue, styles.lightingDebugParameters);
+            if (!m_ShowLightingDebug.boolValue)
+
+            EditorGUI.BeginChangeCheck();
-            EditorGUILayout.PropertyField(m_DebugShadowVisualizationMode, styles.shadowDebugVisualizationMode);
-            if (!m_DebugShadowVisualizationMode.hasMultipleDifferentValues)
+            EditorGUILayout.PropertyField(m_ShadowDebugMode, styles.shadowDebugVisualizationMode);
+            if (!m_ShadowDebugMode.hasMultipleDifferentValues)
-                if ((ShadowDebugMode)m_DebugShadowVisualizationMode.intValue == ShadowDebugMode.VisualizeShadowMap)
+                if ((ShadowDebugMode)m_ShadowDebugMode.intValue == ShadowDebugMode.VisualizeShadowMap)
-                    EditorGUILayout.IntSlider(m_DebugShadowVisualizeShadowIndex, 0, renderpipelineInstance.GetCurrentShadowCount() - 1, styles.shadowDebugVisualizeShadowIndex);
+                    EditorGUILayout.IntSlider(m_ShadowDebugShadowMapIndex, 0, renderpipelineInstance.GetCurrentShadowCount() - 1, styles.shadowDebugVisualizeShadowIndex);
+                }
+            }
+            EditorGUILayout.PropertyField(m_LightingDebugMode, styles.lightingDebugMode);
+            if (!m_LightingDebugMode.hasMultipleDifferentValues)
+            {
+                if ((LightingDebugMode)m_LightingDebugMode.intValue != LightingDebugMode.None)
+            {
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.PropertyField(m_LightingDebugAlbedo, styles.lightingDebugAlbedo);
+                    EditorGUILayout.PropertyField(m_LightingDebugOverrideSmoothness, styles.lightingDebugOverrideSmoothness);
+                    if (!m_LightingDebugOverrideSmoothness.hasMultipleDifferentValues && m_LightingDebugOverrideSmoothness.boolValue == true)
+                {
+                        EditorGUI.indentLevel++;
+                        EditorGUILayout.PropertyField(m_LightingDebugOverrideSmoothnessValue, styles.lightingDebugOverrideSmoothnessValue);
+                        EditorGUI.indentLevel--;
+                    }
+                    EditorGUI.indentLevel--;
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                HackSetDirty(renderContext);
+            }
+        }
+
+        private void SettingsUI(HDRenderPipeline renderContext)
+        {
+            EditorGUILayout.LabelField(styles.settingsLabel);
+            EditorGUI.indentLevel++;
+
+            EditorGUI.BeginChangeCheck();
+
+            renderContext.lightLoopProducer = (LightLoopProducer)EditorGUILayout.ObjectField(new GUIContent("Light Loop"), renderContext.lightLoopProducer, typeof(LightLoopProducer), false);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                HackSetDirty(renderContext); // Repaint
+            }
+
+
+            SkySettingsUI(renderContext);
+            SssSettingsUI(renderContext);
+            ShadowParametersUI(renderContext);
+            TextureParametersUI(renderContext);
+            RendereringParametersUI(renderContext);
+            //TilePassUI(renderContext);
+
+            EditorGUI.indentLevel--;
+        }
+
+        private void SkySettingsUI(HDRenderPipeline pipe)
+        {
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField(styles.skyParams);
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.indentLevel++;
+            pipe.skyParameters = (SkyParameters)EditorGUILayout.ObjectField(new GUIContent("Sky Settings"), pipe.skyParameters, typeof(SkyParameters), false);
+            EditorGUI.indentLevel--;
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                HackSetDirty(pipe); // Repaint
+            }
         }
 
         private void ShadowParametersUI(HDRenderPipeline renderContext)
             {
                 HackSetDirty(renderContext); // Repaint
             }
+            EditorGUI.indentLevel--;
+        }
+
+        private void RendereringParametersUI(HDRenderPipeline renderContext)
+        {
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(styles.renderingSettingsLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_RenderingUseDepthPrepass, styles.useDepthPrepass);
+            EditorGUILayout.PropertyField(m_RenderingUseForwardOnly, styles.useForwardRenderingOnly);
             EditorGUI.indentLevel--;
         }
 
             serializedObject.Update();
 
             DebuggingUI(renderContext, renderpipelineInstance);
-            SkySettingsUI(renderContext);
-            SssSettingsUI(renderContext);
-            ShadowParametersUI(renderContext);
-            TextureParametersUI(renderContext);
-            //TilePassUI(renderContext);
+            SettingsUI(renderContext);
 
             serializedObject.ApplyModifiedProperties();
         }

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.cs

         private HDRenderPipeline()
         {}
 
+        [SerializeField]
+        private LightLoopProducer m_LightLoopProducer;
+        public LightLoopProducer lightLoopProducer
+        {
+            get { return m_LightLoopProducer; }
+            set { m_LightLoopProducer = value; }
+        }
-        [SerializeField]
-        private CommonSettings.Settings m_CommonSettings = CommonSettings.Settings.s_Defaultsettings;
+        protected override IRenderPipeline InternalCreatePipeline()
+        {
+            return new HDRenderPipelineInstance(this);
+        }
+
+        // NOTE:
+        // All those properties are public because of how HDRenderPipelineInspector retrieve those properties via serialization/reflection
+
+        // Debugging
+        public GlobalDebugParameters globalDebugParameters = new GlobalDebugParameters();
+
+        // Renderer Settings (per project)
+        public RenderingParameters                      renderingParameters = new RenderingParameters();
+        [SerializeField] ShadowSettings                 m_ShadowSettings = ShadowSettings.Default;
+        public SubsurfaceScatteringParameters           localSssParameters;
+        [SerializeField] TextureSettings                m_TextureSettings = TextureSettings.Default;
+
+        public ShadowSettings shadowSettings                { get { return m_ShadowSettings; } }
+        public TextureSettings textureSettings              { get { return m_TextureSettings; } set { m_TextureSettings = value; } }
+
+        // Renderer Settings (per "scene")
+        [SerializeField] private CommonSettings.Settings    m_CommonSettings = CommonSettings.Settings.s_Defaultsettings;
+        [SerializeField] private SkyParameters              m_SkyParameters;
 
         public CommonSettings.Settings commonSettingsToUse
         {
                 return m_CommonSettings;
             }
         }
-
-        [SerializeField]
-        private SkyParameters m_SkyParameters;
 
         public SkyParameters skyParameters
         {
             }
         }
         
-        [SerializeField]
-        public SubsurfaceScatteringParameters localSssParameters;
-
         public SubsurfaceScatteringParameters sssParameters
         {
             get
                 return localSssParameters;
             }
         }
-
-        [SerializeField]
-        private LightLoopProducer m_LightLoopProducer;
-        public LightLoopProducer lightLoopProducer
+        public void ApplyDebugParameters()
-            get { return m_LightLoopProducer; }
-            set { m_LightLoopProducer = value; }
+            m_ShadowSettings.enabled = globalDebugParameters.lightingDebugParameters.enableShadows;
-        protected override IRenderPipeline InternalCreatePipeline()
+        public void UpdateCommonSettings()
-            return new HDRenderPipelineInstance(this);
-        }
+            var commonSettings = commonSettingsToUse;
-        // Debugging
-        public GlobalDebugParameters globalDebugParameters = new GlobalDebugParameters();
-        readonly DebugParameters m_DebugParameters = new DebugParameters();
-
-        public DebugParameters debugParameters
-        {
-            get { return m_DebugParameters; }
+            m_ShadowSettings.directionalLightCascadeCount = commonSettings.shadowCascadeCount;
+            m_ShadowSettings.directionalLightCascades = new Vector3(commonSettings.shadowCascadeSplit0, commonSettings.shadowCascadeSplit1, commonSettings.shadowCascadeSplit2);
+            m_ShadowSettings.maxShadowDistance = commonSettings.shadowMaxDistance;
-        [SerializeField]
-        ShadowSettings m_ShadowSettings = ShadowSettings.Default;
-
-        public ShadowSettings shadowSettings
+        public void OnValidate()
-            get { return m_ShadowSettings; }
+            globalDebugParameters.OnValidate();
+    }
-        [SerializeField]
-        TextureSettings m_TextureSettings = TextureSettings.Default;
+    [Serializable]
+    public class RenderingParameters
+    {
+        public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
+        public bool useDepthPrepass = false;
-        public TextureSettings textureSettings
+        // we have to fallback to forward-only rendering when scene view is using wireframe rendering mode --
+        // as rendering everything in wireframe + deferred do not play well together
+        public bool ShouldUseForwardRenderingOnly()
-            get { return m_TextureSettings; }
-            set { m_TextureSettings = value; }
-        }
-
-        public void ApplyDebugParameters()
-        {
-            m_ShadowSettings.enabled = globalDebugParameters.shadowDebugParameters.enableShadows;
-        }
-
-        public void UpdateCommonSettings()
-        {
-            var commonSettings = commonSettingsToUse;
-
-            m_ShadowSettings.directionalLightCascadeCount = commonSettings.shadowCascadeCount;
-            m_ShadowSettings.directionalLightCascades = new Vector3(commonSettings.shadowCascadeSplit0, commonSettings.shadowCascadeSplit1, commonSettings.shadowCascadeSplit2);
-            m_ShadowSettings.maxShadowDistance = commonSettings.shadowMaxDistance;
+            return useForwardRenderingOnly || GL.wireframe;
         }
     }
 
         readonly SkyManager m_SkyManager = new SkyManager();
         private readonly BaseLightLoop m_LightLoop;
 
-        private DebugParameters debugParameters
-        {
-            get { return m_Owner.debugParameters; }
-        }
         private GlobalDebugParameters globalDebugParameters
         {
             get { return m_Owner.globalDebugParameters; }
             if (m_LightLoop != null)
                 m_LightLoop.NewFrame();
 
-            m_Owner. ApplyDebugParameters();
+            m_Owner.ApplyDebugParameters();
             m_Owner.UpdateCommonSettings();
 
             // Set Frame constant buffer
                 cmd.Dispose();
             }
 
-            if (debugParameters.debugViewMaterial != 0)
+            if (globalDebugParameters.materialDebugParameters.debugViewMaterial != 0)
             {
                 RenderDebugViewMaterial(cullResults, hdCamera, renderContext);
             }
 
         void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, string passName, RendererConfiguration rendererConfiguration = 0)
         {
-            if (!debugParameters.displayOpaqueObjects)
+            if (!globalDebugParameters.renderingDebugParametrs.displayOpaqueObjects)
                 return;
 
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
 
         void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, string passName, RendererConfiguration rendererConfiguration = 0)
         {
-            if (!debugParameters.displayTransparentObjects)
+            if (!globalDebugParameters.renderingDebugParametrs.displayTransparentObjects)
                 return;
 
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
         {
             // If we are forward only we will do a depth prepass
             // TODO: Depth prepass should be enabled based on light loop settings. LightLoop define if they need a depth prepass + forward only...
-            if (!debugParameters.useDepthPrepass)
+            if (!m_Owner.renderingParameters.useDepthPrepass)
                 return;
 
             using (new Utilities.ProfilingSample("Depth Prepass", renderContext))
 
         void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext renderContext)
         {
-            if (debugParameters.ShouldUseForwardRenderingOnly())
+            if (m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
             {
                 return ;
             }
         {
             // If we are forward only we don't need to render ForwardOnlyOpaqueDepthOnly object
             // But in case we request a prepass we render it
-            if (debugParameters.ShouldUseForwardRenderingOnly() && !debugParameters.useDepthPrepass)
+            if (m_Owner.renderingParameters.ShouldUseForwardRenderingOnly() && !m_Owner.renderingParameters.useDepthPrepass)
                 return;
 
             using (new Utilities.ProfilingSample("Forward opaque depth", renderContext))
             {
                 Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, Utilities.kClearAll, Color.black);
 
-                Shader.SetGlobalInt("_DebugViewMaterial", (int)debugParameters.debugViewMaterial);
+                Shader.SetGlobalInt("_DebugViewMaterial", (int)globalDebugParameters.materialDebugParameters.debugViewMaterial);
-            if (!debugParameters.ShouldUseForwardRenderingOnly())
+            if (!m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
-                m_DebugViewMaterialGBuffer.SetFloat("_DebugViewMaterial", (float)debugParameters.debugViewMaterial);
+                m_DebugViewMaterialGBuffer.SetFloat("_DebugViewMaterial", (float)globalDebugParameters.materialDebugParameters.debugViewMaterial);
 
                 // m_gbufferManager.BindBuffers(m_DebugViewMaterialGBuffer);
                 // TODO: Bind depth textures
 
         void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext)
         {
-            if (debugParameters.ShouldUseForwardRenderingOnly() || m_LightLoop == null)
+            if (m_Owner.renderingParameters.ShouldUseForwardRenderingOnly() || m_LightLoop == null)
             {
                 return ;
             }
             // Output split lighting for materials tagged with the SSS stencil bit.
-            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, colorRTs, m_CameraStencilBufferRT, true);
+            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugParameters.lightingDebugParameters, colorRTs, m_CameraStencilBufferRT, true);
-            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, colorRTs, m_CameraStencilBufferRT, false);
+            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugParameters.lightingDebugParameters, colorRTs, m_CameraStencilBufferRT, false);
         }
 
         // Combines specular lighting and diffuse lighting with subsurface scattering.
-            if (debugParameters.ShouldUseForwardRenderingOnly()) return;
+            if (m_Owner.renderingParameters.ShouldUseForwardRenderingOnly()) return;
 
             // Load the kernel data.
             Vector4[] kernelData = new Vector4[SubsurfaceScatteringParameters.maxNumProfiles * SubsurfaceScatteringProfile.numVectors];
         {
             // TODO: Currently we can't render opaque object forward when deferred is enabled
             // miss option
-            if (!debugParameters.ShouldUseForwardRenderingOnly() && renderOpaque)
+            if (!m_Owner.renderingParameters.ShouldUseForwardRenderingOnly() && renderOpaque)
                 return;
 
             using (new Utilities.ProfilingSample("Forward Pass", renderContext))
             using (new Utilities.ProfilingSample("Velocity Pass", renderContext))
             {
                 // If opaque velocity have been render during GBuffer no need to render it here
-                if ((ShaderConfig.s_VelocityInGbuffer == 1) || debugParameters.ShouldUseForwardRenderingOnly())
+                if ((ShaderConfig.s_VelocityInGbuffer == 1) || m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
                     return ;
 
                 int w = camera.pixelWidth;
 
         void RenderDistortion(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext)
         {
-            if (!debugParameters.useDistortion)
+            if (!globalDebugParameters.renderingDebugParametrs.enableDistortion)
                 return ;
 
             using (new Utilities.ProfilingSample("Distortion Pass", renderContext))
 
             MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
 
-            ShadowDebugParameters shadowDebug = globalDebugParameters.shadowDebugParameters;
+            LightingDebugParameters shadowDebug = globalDebugParameters.lightingDebugParameters;
-            if (shadowDebug.visualizationMode != ShadowDebugMode.None)
+            if (shadowDebug.shadowDebugMode != ShadowDebugMode.None)
-                if (shadowDebug.visualizationMode == ShadowDebugMode.VisualizeShadowMap)
+                if (shadowDebug.shadowDebugMode == ShadowDebugMode.VisualizeShadowMap)
-                    uint visualizeShadowIndex = Math.Min(shadowDebug.visualizeShadowMapIndex, (uint)(GetCurrentShadowCount() - 1));
+                    uint visualizeShadowIndex = Math.Min(shadowDebug.shadowMapIndex, (uint)(GetCurrentShadowCount() - 1));
                     ShadowLight shadowLight = m_ShadowsResult.shadowLights[visualizeShadowIndex];
                     for (int slice = 0; slice < shadowLight.shadowSliceCount; ++slice)
                     {
                         NextOverlayCoord(ref x, ref y, overlaySize, camera.pixelWidth);
                     }
                 }
-                else if (shadowDebug.visualizationMode == ShadowDebugMode.VisualizeAtlas)
+                else if (shadowDebug.shadowDebugMode == ShadowDebugMode.VisualizeAtlas)
                 {
                     propertyBlock.SetVector("_TextureScaleBias", new Vector4(1.0f, 1.0f, 0.0f, 0.0f));
 
                     cmd.GetTemporaryRT(m_CameraDepthStencilBuffer, w, h, 24, FilterMode.Point, RenderTextureFormat.Depth);
                     cmd.GetTemporaryRT(m_CameraStencilBuffer,      w, h, 24, FilterMode.Point, RenderTextureFormat.Depth);
 
-                    if (!m_Owner.debugParameters.ShouldUseForwardRenderingOnly())
+                    if (!m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
                     {
                         m_gbufferManager.InitGBuffers(w, h, cmd);
                     }
                 }
 
                 // Clear GBuffers
-                if (!debugParameters.ShouldUseForwardRenderingOnly())
+                if (!m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
                 {
                     using (new Utilities.ProfilingSample("Clear GBuffer", renderContext))
                     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightLoop.cs

         public virtual void PushGlobalParams(Camera camera, ScriptableRenderContext loop) {}
 
         public virtual void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
+                                                   LightingDebugParameters lightDebugParameters,
                                                    RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier stencilBuffer,
                                                    bool outputSplitLighting) {}
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/Resources/Deferred.shader

             // Split lighting is utilized during the SSS pass.
             #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
 
+            #pragma multi_compile _ LIGHTING_DEBUG
+
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugLighting.hlsl"
 
             // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
             // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
 
             DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 
-			TEXTURE2D_FLOAT(_CameraDepthTexture);
-			SAMPLER2D(sampler_CameraDepthTexture);
+            TEXTURE2D_FLOAT(_CameraDepthTexture);
+            SAMPLER2D(sampler_CameraDepthTexture);
 
             struct Attributes
             {

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TileLightLoopProducer.cs

 
 #endif
         [Serializable]
-        public struct TileSettings
+        public class TileSettings
         {
             public bool enableDrawLightBoundsDebug;
             public bool disableTileAndCluster; // For debug / test

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/Resources/shadeopaque.compute

-#pragma kernel ShadeOpaque_Fptl				SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl				USE_FPTL_LIGHTLIST=1
-#pragma kernel ShadeOpaque_Clustered		SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered		USE_CLUSTERED_LIGHTLIST=1
+#pragma kernel ShadeOpaque_Fptl				            SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl				        USE_FPTL_LIGHTLIST
+#pragma kernel ShadeOpaque_Fptl_DebugLighting			SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl_DebugLighting		USE_FPTL_LIGHTLIST        LIGHTING_DEBUG
+#pragma kernel ShadeOpaque_Clustered		            SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered		        USE_CLUSTERED_LIGHTLIST
+#pragma kernel ShadeOpaque_Clustered_DebugLighting		SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered_DebugLighting	USE_CLUSTERED_LIGHTLIST   LIGHTING_DEBUG
 
 // Split lighting is required for the SSS pass.
 // Not currently possible since we need to access the stencil buffer from the compute shader.
 //-------------------------------------------------------------------------------------
 
 #include "Common.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugLighting.hlsl"
 
 // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
 // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             static int s_ClearVoxelAtomicKernel;
             static int s_shadeOpaqueClusteredKernel;
             static int s_shadeOpaqueFptlKernel;
+            static int s_shadeOpaqueClusteredDebugLightingKernel;
+            static int s_shadeOpaqueFptlDebugLightingKernel;
 
             static ComputeBuffer s_LightVolumeDataBuffer = null;
             static ComputeBuffer s_ConvexBoundsBuffer = null;
 
                 s_shadeOpaqueClusteredKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Clustered");
                 s_shadeOpaqueFptlKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Fptl");
+                s_shadeOpaqueClusteredDebugLightingKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Clustered_DebugLighting");
+                s_shadeOpaqueFptlDebugLightingKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Fptl_DebugLighting");
 
                 s_LightList = null;
 
                     Shader.SetGlobalFloat(name, value);
             }
 
+            private void SetGlobalVector(string name, Vector4 value)
+            {
+                if (activeComputeShader)
+                    activeCommandBuffer.SetComputeVectorParam(activeComputeShader, name, value);
+                else
+                    Shader.SetGlobalVector(name, value);
+            }
+
             private void SetGlobalVectorArray(string name, Vector4[] values)
             {
                 if (activeComputeShader)
             }
 #endif
 
+            private void SetupRenderingForDebug(LightingDebugParameters lightDebugParameters)
+            {
+                Utilities.SetKeyword(m_DeferredDirectMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredDirectMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredIndirectMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredIndirectMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredAllMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredAllMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_SingleDeferredMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_SingleDeferredMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+
+                Vector4 debugModeAndAlbedo = new Vector4((float)lightDebugParameters.lightingDebugMode, lightDebugParameters.debugLightingAlbedo.r, lightDebugParameters.debugLightingAlbedo.g, lightDebugParameters.debugLightingAlbedo.b);
+                Vector4 debugSmoothness = new Vector4(lightDebugParameters.overrideSmoothness ? 1.0f : 0.0f, lightDebugParameters.overrideSmoothnessValue, 0.0f, 0.0f);
+                SetGlobalVector("_DebugLightModeAndAlbedo", debugModeAndAlbedo);
+                SetGlobalVector("_DebugLightingSmoothness", debugSmoothness);
+            }
+
+                                                        LightingDebugParameters lightDebugParameters,
                                                         RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier stencilBuffer,
                                                         bool outputSplitLighting)
             {
                     mousePixelCoord.y = (hdCamera.screenSize.y - 1.0f) - mousePixelCoord.y;
                 }
 #endif
+
                 using (new Utilities.ProfilingSample(m_PassSettings.disableTileAndCluster ? "SinglePass - Deferred Lighting Pass" : "TilePass - Deferred Lighting Pass", renderContext))
                 {
                     var cmd = new CommandBuffer();
+                    SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
-                    SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
-                    SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlKernel : s_shadeOpaqueClusteredKernel, cmd);
+                    bool useCompute = !m_PassSettings.disableTileAndCluster && !m_PassSettings.disableDeferredShadingInCompute;
+                    // We don't want to setup the compute if it's not needed. Otherwwise, the SetGlobalXXX method will not set the parameters properly for regular shaders.
+                    if (useCompute)
+                    {
+                        if (lightDebugParameters.lightingDebugMode == LightingDebugMode.None)
+                            SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlKernel : s_shadeOpaqueClusteredKernel, cmd);
+                        else
+                            SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlDebugLightingKernel : s_shadeOpaqueClusteredDebugLightingKernel, cmd);
+                    }
 
                     // In case of bUseClusteredForDeferred disable toggle option since we're using m_perVoxelLightLists as opposed to lightList
                     if (bUseClusteredForDeferred)
+
+                    // Must be done after setting up the compute shader above.
+                    SetupRenderingForDebug(lightDebugParameters);
 
                     if (m_PassSettings.disableTileAndCluster)
                     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

 
 // Gets the cascade weights based on the world position of the fragment and the positions of the split spheres for each cascade.
 // Returns an invalid split index if past shadowDistance (ie 4 is invalid for cascade)
-uint GetSplitSphereIndexForDirshadows(float3 positionWS, float4 dirShadowSplitSpheres[4])
+int GetSplitSphereIndexForDirshadows(float3 positionWS, float4 dirShadowSplitSpheres[4])
 {
     float3 fromCenter0 = positionWS.xyz - dirShadowSplitSpheres[0].xyz;
     float3 fromCenter1 = positionWS.xyz - dirShadowSplitSpheres[1].xyz;
     dirShadowSplitSphereSqRadii.z = dirShadowSplitSpheres[2].w;
     dirShadowSplitSphereSqRadii.w = dirShadowSplitSpheres[3].w;
 
+    if (distances2.w > dirShadowSplitSphereSqRadii.w)
+        return -1;
+
-    return uint(4.0 - dot(weights, float4(4.0, 3.0, 2.0, 1.0)));
+    return int(4.0 - dot(weights, float4(4.0, 3.0, 2.0, 1.0)));
-    uint shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _DirShadowSplitSpheres);
+    int shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _DirShadowSplitSpheres);
+    if (shadowSplitIndex == -1)
+        return 1.0;
 
     ShadowData shadowData = _ShadowDatas[shadowSplitIndex];
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

 // LightLoop
 // ----------------------------------------------------------------------------
 
+void ApplyDebug(inout float3 diffuseLighting, inout float3 specularLighting)
+{
+#ifdef LIGHTING_DEBUG
+    int lightDebugMode = (int)_DebugLightModeAndAlbedo.x;
+
+    if (lightDebugMode == LIGHTINGDEBUGMODE_DIFFUSE_LIGHTING)
+    {
+        specularLighting = float3(0.0, 0.0, 0.0);
+    }
+    else if (lightDebugMode == LIGHTINGDEBUGMODE_SPECULAR_LIGHTING)
+    {
+        diffuseLighting = float3(0.0, 0.0, 0.0);
+    }
+#endif
+}
+
 #ifdef LIGHTLOOP_TILE_PASS
 
 // Calculate the offset in global light index light for current light category
     // Add indirect diffuse + emissive (if any)
     diffuseLighting += bakeDiffuseLighting;
 #endif
+
+    ApplyDebug(diffuseLighting, specularLighting);
 }
 
 #else // LIGHTLOOP_SINGLE_PASS
 
     // Add indirect diffuse + emissive (if any)
     diffuseLighting += bakeDiffuseLighting;
+
+    ApplyDebug(diffuseLighting, specularLighting);
 }
 
 #endif

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.cs.hlsl

 #define DEBUGVIEW_LIT_SURFACEDATA_ANISOTROPY (1007)
 #define DEBUGVIEW_LIT_SURFACEDATA_METALLIC (1008)
 #define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR (1009)
-#define DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_RADIUS (1010)
+#define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS (1010)
-#define DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_PROFILE (1012)
+#define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE (1012)
 #define DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS (1013)
 #define DEBUGVIEW_LIT_SURFACEDATA_COAT_PERCEPTUAL_SMOOTHNESS (1014)
 #define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR (1015)
 #define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_T (1039)
 #define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_B (1040)
 #define DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY (1041)
-#define DEBUGVIEW_LIT_BSDFDATA_SUB_SURFACE_RADIUS (1042)
+#define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS (1042)
-#define DEBUGVIEW_LIT_BSDFDATA_SUB_SURFACE_PROFILE (1044)
+#define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE (1044)
 #define DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS (1045)
 #define DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS (1046)
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.hlsl

 #endif
 }
 
+void ApplyDebugToBSDFData(inout BSDFData bsdfData)
+{
+#ifdef LIGHTING_DEBUG
+    int lightDebugMode = (int)_DebugLightModeAndAlbedo.x;
+    float3 lightDebugAlbedo = _DebugLightModeAndAlbedo.yzw;
+    bool overrideSmoothness = _DebugLightingSmoothness.x != 0.0f;
+    float overrideSmoothnessValue = _DebugLightingSmoothness.y;
+
+    if (overrideSmoothness)
+    {
+        bsdfData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(overrideSmoothnessValue);
+        bsdfData.roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
+    }
+
+    if (lightDebugMode == LIGHTINGDEBUGMODE_DIFFUSE_LIGHTING)
+    {
+        bsdfData.diffuseColor = lightDebugAlbedo;
+    }
+#endif
+}
 //-----------------------------------------------------------------------------
 // conversion function for forward
 //-----------------------------------------------------------------------------
         bsdfData.fresnel0 = surfaceData.specularColor;
     }
 
+    ApplyDebugToBSDFData(bsdfData);
+    
     return bsdfData;
 }
 
     }
 
     bakeDiffuseLighting = inGBuffer3.rgb;
+
+    ApplyDebugToBSDFData(bsdfData);
 }
 
 //-----------------------------------------------------------------------------
         case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR:
             result = surfaceData.specular.xxx;
             break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_RADIUS:
+        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS:
-        case DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_PROFILE:
+        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE:
             result = GetIndexColor(surfaceData.subsurfaceProfile);
             break;
         case DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS:
         case DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY:
             result = bsdfData.anisotropy.xxx;
             break;
-        case DEBUGVIEW_LIT_BSDFDATA_SUB_SURFACE_RADIUS:
+        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS:
-        case DEBUGVIEW_LIT_BSDFDATA_SUB_SURFACE_PROFILE:
+        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE:
             result = GetIndexColor(bsdfData.subsurfaceProfile);
             break;
         case DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS:

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugLighting.hlsl

+#ifndef UNITY_DEBUG_LIGHTING_INCLUDED
+#define UNITY_DEBUG_LIGHTING_INCLUDED
+
+float4 _DebugLightModeAndAlbedo; // x == debug mode, yzw = albedo for diffuse.
+float4 _DebugLightingSmoothness; // x == bool override, y == override value
+
+#endif

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugLighting.hlsl.meta

+fileFormatVersion: 2
+guid: 1af9f7b2ee767504fb89dc98550d62f6
+timeCreated: 1486032323
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.hlsl

+//
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.  Please don't edit by hand.
+//
+
+#ifndef HDRENDERPIPELINEDEBUG_CS_HLSL
+#define HDRENDERPIPELINEDEBUG_CS_HLSL
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.LightingDebugMode:  static fields
+//
+#define LIGHTINGDEBUGMODE_NONE (0)
+#define LIGHTINGDEBUGMODE_DIFFUSE_LIGHTING (1)
+#define LIGHTINGDEBUGMODE_SPECULAR_LIGHTING (2)
+
+
+#endif

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.hlsl.meta

+fileFormatVersion: 2
+guid: 04e346a720261d94b85f6d20b0cd8064
+timeCreated: 1486041561
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/CascadedShadowsTest/CommonSettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: bc357c46587fc9d4cb8f311794d7d2f3, type: 3}
+  m_Name: CommonSettings
+  m_EditorClassIdentifier: 
+  m_Settings:
+    m_ShadowMaxDistance: 400
+    m_ShadowCascadeCount: 4
+    m_ShadowCascadeSplit0: 0.015
+    m_ShadowCascadeSplit1: 0.05
+    m_ShadowCascadeSplit2: 0.2
+    m_SssProfileStdDev1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    m_SssProfileStdDev2: {r: 1, g: 1, b: 1, a: 0}
+    m_SssProfileLerpWeight: 0.5
+    m_SssBilateralScale: 0.1

Assets/TestScenes/HDTest/CascadedShadowsTest/CommonSettings.asset.meta

+fileFormatVersion: 2
+guid: 075f395cb6ba2534196f2ce83c32e633
+timeCreated: 1485858348
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: