Merge branch 'master' of https://github.com/Unity-Technologies/ScriptableRenderLoop into Branch_DebugMenu

# Conflicts:
#	Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs
#	Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.asset

Assets/LowEndMobilePipeline/TestScenes/Materials/LegacyMobileMaterials/LegacyMobileColors.mat.meta

   userData: 
   assetBundleName: 
   assetBundleVariant: 
-

Assets/LowEndMobilePipeline/TestScenes/Materials/LegacyMobileMaterials/LegacyMobileGlass.mat.meta

   userData: 
   assetBundleName: 
   assetBundleVariant: 
-

Assets/LowEndMobilePipeline/TestScenes/Materials/LegacyMobileMaterials/LegacyMobilePlane.mat.meta

   userData: 
   assetBundleName: 
   assetBundleVariant: 
-

Assets/ScriptableRenderPipeline/AdditionalLightData.cs

         public bool affectSpecular = true;
 
         public LightArchetype archetype = LightArchetype.Punctual;
-        public bool isDoubleSided = false; // Rectangular area lights only
 
         [Range(0.0f, 20.0f)]
         public float lightLength = 0.0f; // Area & projector lights

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/Resources/DebugViewMaterialGBuffer.shader

             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
             #include "../../ShaderConfig.cs.hlsl"
             #include "../../ShaderVariables.hlsl"
-            #include "../../Debug/DebugViewMaterial.cs.hlsl"
+            #define DEBUG_DISPLAY
+            #include "../../Debug/DebugDisplay.hlsl"
-
-            int         _DebugViewMaterial;
 
             struct Attributes
             {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/Resources/DebugViewMaterialGBuffer.shader.meta

 fileFormatVersion: 2
 guid: 439949ea1bfa91b4ba0d04269fcde33d
-timeCreated: 1476053153
+timeCreated: 1492803708
 licenseType: Pro
 ShaderImporter:
   defaultTextures: []

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/Resources/DebugViewTiles.shader

                 UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
 
                 int2 pixelCoord = posInput.unPositionSS.xy;
-                int2 tileCoord = (float2)pixelCoord / TILE_SIZE;
-                int2 mouseTileCoord = _MousePixelCoord / TILE_SIZE;
-                int2 offsetInTile = pixelCoord - tileCoord * TILE_SIZE;
+                int2 tileCoord = (float2)pixelCoord / GetTileSize();
+                int2 mouseTileCoord = _MousePixelCoord / GetTileSize();
+                int2 offsetInTile = pixelCoord - tileCoord * GetTileSize();
 
                 int n = 0;
 #ifdef SHOW_LIGHT_CATEGORIES
                 // Tile overlap counter
                 if (n >= 0)
                 {
-                    result = OverlayHeatMap(int2(posInput.unPositionSS.xy) & (TILE_SIZE - 1), n);
+                    result = OverlayHeatMap(int2(posInput.unPositionSS.xy) & (GetTileSize() - 1), n);
                 }
 
 #ifdef SHOW_LIGHT_CATEGORIES
-                    bool border = any(offsetInTile == 0 || offsetInTile == TILE_SIZE - 1);
+                    bool border = any(offsetInTile == 0 || offsetInTile == GetTileSize() - 1);
                     float4 result2 = float4(1.0, 1.0, 1.0, border ? 1.0 : 0.5);
                     result = AlphaBlend(result, result2);
                 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

             // Sky Settings
             public readonly GUIContent skyParams = new GUIContent("Sky Settings");
 
-            // Global debug Settings
+            // Debug Display Settings
+            public readonly GUIContent debugDisplayMode = new GUIContent("Debug Display Mode");
             public readonly GUIContent debugging = new GUIContent("Debugging");
             public readonly GUIContent debugOverlayRatio = new GUIContent("Overlay Ratio");
 
             public readonly GUIContent lightingDebugSettings = new GUIContent("Lighting Debug");
             public readonly GUIContent shadowDebugEnable = new GUIContent("Enable Shadows");
             public readonly GUIContent shadowDebugVisualizationMode = new GUIContent("Shadow Maps Debug Mode");
-            public readonly GUIContent shadowDebugVisualizeShadowIndex = new GUIContent("Visualize Shadow Index");
-            public readonly GUIContent lightingDebugMode = new GUIContent("Lighting Debug Mode");
+            public readonly GUIContent shadowDebugVisualizeShadowIndex = new GUIContent("Visualize Shadow Index");            
             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");
             }
         }
 
-        // Global debug
+        // Display Debug
+        SerializedProperty m_DebugDisplayMode = null;
         SerializedProperty m_ShowMaterialDebug = null;
         SerializedProperty m_ShowLightingDebug = null;
         SerializedProperty m_ShowRenderingDebug = null;
         SerializedProperty m_DebugShadowEnabled = 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;
 
         private void InitializeProperties()
         {
-            // Global debug
-            m_DebugOverlayRatio = FindProperty(x => x.globalDebugSettings.debugOverlayRatio);
-            m_ShowLightingDebug = FindProperty(x => x.globalDebugSettings.displayLightingDebug);
-            m_ShowRenderingDebug = FindProperty(x => x.globalDebugSettings.displayRenderingDebug);
-            m_ShowMaterialDebug = FindProperty(x => x.globalDebugSettings.displayMaterialDebug);
+            // DebugDisplay debug
+            m_DebugDisplayMode = FindProperty(x => x.debugDisplaySettings.debugDisplayMode);
+            m_DebugOverlayRatio = FindProperty(x => x.debugDisplaySettings.debugOverlayRatio);
+            m_ShowLightingDebug = FindProperty(x => x.debugDisplaySettings.displayLightingDebug);
+            m_ShowRenderingDebug = FindProperty(x => x.debugDisplaySettings.displayRenderingDebug);
+            m_ShowMaterialDebug = FindProperty(x => x.debugDisplaySettings.displayMaterialDebug);
-            m_MaterialDebugMode = FindProperty(x => x.globalDebugSettings.materialDebugSettings.debugViewMaterial);
+            m_MaterialDebugMode = FindProperty(x => x.debugDisplaySettings.materialDebugSettings.debugViewMaterial);
-            m_DisplayOpaqueObjects = FindProperty(x => x.globalDebugSettings.renderingDebugSettings.displayOpaqueObjects);
-            m_DisplayTransparentObjects = FindProperty(x => x.globalDebugSettings.renderingDebugSettings.displayTransparentObjects);
-            m_EnableDistortion = FindProperty(x => x.globalDebugSettings.renderingDebugSettings.enableDistortion);
-            m_EnableSSS = FindProperty(x => x.globalDebugSettings.renderingDebugSettings.enableSSS);
+            m_DisplayOpaqueObjects = FindProperty(x => x.debugDisplaySettings.renderingDebugSettings.displayOpaqueObjects);
+            m_DisplayTransparentObjects = FindProperty(x => x.debugDisplaySettings.renderingDebugSettings.displayTransparentObjects);
+            m_EnableDistortion = FindProperty(x => x.debugDisplaySettings.renderingDebugSettings.enableDistortion);
+            m_EnableSSS = FindProperty(x => x.debugDisplaySettings.renderingDebugSettings.enableSSS);
-            m_DebugShadowEnabled = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.enableShadows);
-            m_ShadowDebugMode = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.shadowDebugMode);
-            m_ShadowDebugShadowMapIndex = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.shadowMapIndex);
-            m_LightingDebugMode = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.lightingDebugMode);
-            m_LightingDebugOverrideSmoothness = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.overrideSmoothness);
-            m_LightingDebugOverrideSmoothnessValue = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.overrideSmoothnessValue);
-            m_LightingDebugAlbedo = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.debugLightingAlbedo);
-            m_LightingDebugDisplaySkyReflection = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.displaySkyReflection);
-            m_LightingDebugDisplaySkyReflectionMipmap = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.skyReflectionMipmap);
+            m_DebugShadowEnabled = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.enableShadows);
+            m_ShadowDebugMode = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.shadowDebugMode);
+            m_ShadowDebugShadowMapIndex = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.shadowMapIndex);
+            m_LightingDebugOverrideSmoothness = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.overrideSmoothness);
+            m_LightingDebugOverrideSmoothnessValue = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.overrideSmoothnessValue);
+            m_LightingDebugAlbedo = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.debugLightingAlbedo);
+            m_LightingDebugDisplaySkyReflection = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.displaySkyReflection);
+            m_LightingDebugDisplaySkyReflectionMipmap = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.skyReflectionMipmap);
 
             // Rendering settings
             m_RenderingUseForwardOnly = FindProperty(x => x.renderingSettings.useForwardRenderingOnly);
             // Get attribute to get the start number of the value for the enum
             var attr = attributes[0] as GenerateHLSL;
 
-            if (!attr.needParamDefines)
+            if (!attr.needParamDebug)
             {
                 return;
             }
         {
             EditorGUILayout.LabelField(styles.debugging);
 
-            // Global debug settings
+            // Debug Display settings
+            EditorGUILayout.PropertyField(m_DebugDisplayMode, styles.debugDisplayMode);
-            MaterialDebugSettingsUI(renderContext);
-            LightingDebugSettingsUI(renderContext, renderpipelineInstance);
+            if ((DebugDisplayMode)m_DebugDisplayMode.intValue == DebugDisplayMode.ViewMaterial)
+            {
+                MaterialDebugSettingsUI(renderContext);
+            }
+            else
+            {
+                LightingDebugSettingsUI(renderContext, renderpipelineInstance);
+            }            
 
             EditorGUILayout.Space();
 
                 var varyingNames = Enum.GetNames(typeof(Attributes.DebugViewVarying));
                 var gbufferNames = Enum.GetNames(typeof(Attributes.DebugViewGbuffer));
 
-                // +1 for the zero case
-                var num = 1 + varyingNames.Length
+                var num = varyingNames.Length
                     + gbufferNames.Length
                     + typeof(Builtin.BuiltinData).GetFields().Length * 2       // BuildtinData are duplicated for each material
                     + typeof(Lit.SurfaceData).GetFields().Length
 
                 var index = 0;
 
-                // 0 is a reserved number
-                styles.debugViewMaterialStrings[0] = new GUIContent("None");
-                styles.debugViewMaterialValues[0] = 0;
-                index++;
-
+                // 0 is a reserved number and should not be used (allow to track error)
                 FillWithPropertiesEnum(typeof(Attributes.DebugViewVarying), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, GetSubNameSpaceName(typeof(Attributes.DebugViewVarying)), false, ref index);
                 FillWithProperties(typeof(Builtin.BuiltinData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Lit.SurfaceData)), ref index);
                 FillWithProperties(typeof(Lit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Lit.SurfaceData)), ref index);
                     EditorGUILayout.IntSlider(m_ShadowDebugShadowMapIndex, 0, renderpipelineInstance.GetCurrentShadowCount() - 1, styles.shadowDebugVisualizeShadowIndex);
                 }
             }
-            EditorGUILayout.PropertyField(m_LightingDebugMode, styles.lightingDebugMode);
-            if (!m_LightingDebugMode.hasMultipleDifferentValues)
+
+            if (!m_DebugDisplayMode.hasMultipleDifferentValues)
-                if ((LightingDebugMode)m_LightingDebugMode.intValue != LightingDebugMode.None)
+                if ((DebugDisplayMode)m_DebugDisplayMode.intValue == DebugDisplayMode.DiffuseLighting)
+                    EditorGUI.indentLevel--;
+                }
+
+                if ((DebugDisplayMode)m_DebugDisplayMode.intValue == DebugDisplayMode.SpecularLighting)
+                {
+                    EditorGUI.indentLevel++;
                     EditorGUILayout.PropertyField(m_LightingDebugOverrideSmoothness, styles.lightingDebugOverrideSmoothness);
                     if (!m_LightingDebugOverrideSmoothness.hasMultipleDifferentValues && m_LightingDebugOverrideSmoothness.boolValue == true)
                     {

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.asset

   m_EditorClassIdentifier: 
   m_LightLoopProducer: {fileID: 11400000, guid: bf8cd9ae03ff7d54c89603e67be0bfc5,
     type: 2}
-  globalDebugSettings:
+  debugDisplaySettings:
-    displayRenderingDebug: 1
-    displayLightingDebug: 1
+    displayRenderingDebug: 0
+    displayLightingDebug: 0
+    debugDisplayMode: 0
-      debugViewMaterial: 0
+      debugViewMaterial: 1
-      lightingDebugMode: 0
       overrideSmoothness: 0
       overrideSmoothnessValue: 0.5
       debugLightingAlbedo: {r: 0.5, g: 0.5, b: 0.5, a: 1}
     useForwardRenderingOnly: 0
     useDepthPrepass: 0
   sssSettings:
-    numProfiles: 0
-    profiles: []
+    numProfiles: 7
+    profiles:
+    - {fileID: 11400000, guid: d6ee4403015766f4093158d69216c0bf, type: 2}
+    - {fileID: 0}
+    - {fileID: 0}
+    - {fileID: 0}
+    - {fileID: 0}
+    - {fileID: 0}
+    - {fileID: 0}
-    maxShadowDistance: 800
+    maxShadowDistance: 1000
-    directionalLightNearPlaneOffset: 10
+    directionalLightNearPlaneOffset: 5
   m_TextureSettings:
     spotCookieSize: 128
     pointCookieSize: 512

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

         // Those that are not will be refatored later.
 
         // Debugging
-        public GlobalDebugSettings          globalDebugSettings = new GlobalDebugSettings();
+        public DebugDisplaySettings debugDisplaySettings = new DebugDisplaySettings();
 
         // Renderer Settings (per project)
         public RenderingSettings            renderingSettings = new RenderingSettings();
             }
         }
 
-        public void ApplyDebugSettings()
+        public void ApplyDebugDisplaySettings()
-            m_ShadowSettings.enabled = globalDebugSettings.lightingDebugSettings.enableShadows;
+            m_ShadowSettings.enabled = debugDisplaySettings.lightingDebugSettings.enableShadows;
-            LightingDebugSettings lightDebugSettings = globalDebugSettings.lightingDebugSettings;
-            Vector4 debugModeAndAlbedo = new Vector4((float)lightDebugSettings.lightingDebugMode, lightDebugSettings.debugLightingAlbedo.r, lightDebugSettings.debugLightingAlbedo.g, lightDebugSettings.debugLightingAlbedo.b);
-            Vector4 debugSmoothness = new Vector4(lightDebugSettings.overrideSmoothness ? 1.0f : 0.0f, lightDebugSettings.overrideSmoothnessValue, 0.0f, 0.0f);
-            Shader.SetGlobalVector("_DebugLightModeAndAlbedo", debugModeAndAlbedo);
+            LightingDebugSettings lightingDebugSettings = debugDisplaySettings.lightingDebugSettings;
+            Vector4 debugAlbedo = new Vector4(lightingDebugSettings.debugLightingAlbedo.r, lightingDebugSettings.debugLightingAlbedo.g, lightingDebugSettings.debugLightingAlbedo.b, 0.0f);
+            Vector4 debugSmoothness = new Vector4(lightingDebugSettings.overrideSmoothness ? 1.0f : 0.0f, lightingDebugSettings.overrideSmoothnessValue, 0.0f, 0.0f);
+
+            Shader.SetGlobalInt("_DebugDisplayMode", (int)debugDisplaySettings.debugDisplayMode);
+            Shader.SetGlobalInt("_DebugViewMaterial", (int)debugDisplaySettings.materialDebugSettings.debugViewMaterial);
+            Shader.SetGlobalVector("_DebugLightingAlbedo", debugAlbedo);
             Shader.SetGlobalVector("_DebugLightingSmoothness", debugSmoothness);
         }
 
 
         public void OnValidate()
         {
-            globalDebugSettings.OnValidate();
+            debugDisplaySettings.OnValidate();
             sssSettings.OnValidate();
         }
 
         readonly SkyManager m_SkyManager = new SkyManager();
         private readonly BaseLightLoop m_LightLoop;
 
-        private GlobalDebugSettings globalDebugSettings
+        private DebugDisplaySettings debugDisplaySettings
-            get { return m_Owner.globalDebugSettings; }
+            get { return m_Owner.debugDisplaySettings; }
         }
 
         public SubsurfaceScatteringSettings sssSettings
 
             m_LitRenderLoop.Cleanup();
 
+            Utilities.Destroy(m_DebugDisplayShadowMap);
-            Utilities.Destroy(m_DebugDisplayShadowMap);
+            Utilities.Destroy(m_DebugDisplayLatlong);
 
             m_SkyManager.Cleanup();
 
             }
 
             // Broadcast SSS parameters to all shaders.
-            Shader.SetGlobalInt("_EnableSSS", globalDebugSettings.renderingDebugSettings.enableSSS ? 1 : 0);
+            Shader.SetGlobalInt("_EnableSSS", debugDisplaySettings.renderingDebugSettings.enableSSS ? 1 : 0);
+            cmd.SetGlobalVectorArray("_TintColors",     sssParameters.tintColors);
             cmd.SetGlobalVectorArray("_HalfRcpVariancesAndLerpWeights", sssParameters.halfRcpVariancesAndLerpWeights);
 
             renderContext.ExecuteCommandBuffer(cmd);
 
         private void CopyDepthBufferIfNeeded(ScriptableRenderContext renderContext)
         {
-            var cmd = new CommandBuffer();
+            var cmd = new CommandBuffer() { name = NeedDepthBufferCopy() ? "Copy DepthBuffer" : "Set DepthBuffer"};
+            
             if (NeedDepthBufferCopy())
             {
                 using (new Utilities.ProfilingSample("Copy depth-stencil buffer", renderContext))
             if (m_LightLoop != null)
                 m_LightLoop.NewFrame();
 
-            m_Owner.ApplyDebugSettings();
+            m_Owner.ApplyDebugDisplaySettings();
             m_Owner.UpdateCommonSettings();
 
             // Set Frame constant buffer
                 CopyDepthBufferIfNeeded(renderContext);
             }
 
-            if (globalDebugSettings.materialDebugSettings.debugViewMaterial != 0)
+            if (debugDisplaySettings.debugDisplayMode == DebugDisplayMode.ViewMaterial)
-                using (new Utilities.ProfilingSample("Shadow Pass", renderContext))
+                using (new Utilities.ProfilingSample("Shadow", renderContext))
                 {
                     m_ShadowPass.Render(renderContext, cullResults, out m_ShadowsResult);
                 }
                 // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
                 UpdateSkyEnvironment(hdCamera, renderContext);
 
-                RenderDeferredLighting(hdCamera, renderContext, m_Owner.globalDebugSettings.renderingDebugSettings.enableSSS);
+                RenderDeferredLighting(hdCamera, renderContext);
 
                 // We compute subsurface scattering here. Therefore, no objects rendered afterwards will exhibit SSS.
                 // Currently, there is no efficient way to switch between SRT and MRT for the forward pass;
 
         void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, string passName, RendererConfiguration rendererConfiguration = 0)
         {
-            if (!globalDebugSettings.renderingDebugSettings.displayOpaqueObjects)
+            if (!debugDisplaySettings.renderingDebugSettings.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 (!globalDebugSettings.renderingDebugSettings.displayTransparentObjects)
+            if (!debugDisplaySettings.renderingDebugSettings.displayTransparentObjects)
                 return;
 
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
                 return;
             }
 
-            using (new Utilities.ProfilingSample("GBuffer Pass", renderContext))
+            string passName = debugDisplaySettings.IsDebugDisplayEnable() ? "GBufferDebugDisplay" : "GBuffer";
+
+            using (new Utilities.ProfilingSample(passName, renderContext))
-                bool debugLighting = globalDebugSettings.lightingDebugSettings.lightingDebugMode != LightingDebugMode.None;
-
-                RenderOpaqueRenderList(cull, camera, renderContext, debugLighting ? "GBufferDebugLighting" : "GBuffer", Utilities.kRendererConfigurationBakedLighting);
+                RenderOpaqueRenderList(cull, camera, renderContext, passName, Utilities.kRendererConfigurationBakedLighting);
             }
         }
 
 
         void RenderDebugViewMaterial(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext)
         {
-            using (new Utilities.ProfilingSample("DebugView Material Mode Pass", renderContext))
+            using (new Utilities.ProfilingSample("DisplayDebug ViewMaterial", renderContext))
-
-                Shader.SetGlobalInt("_DebugViewMaterial", (int)globalDebugSettings.materialDebugSettings.debugViewMaterial);
-
-                RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, "DebugViewMaterial", Utilities.kRendererConfigurationBakedLighting);
+                RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
             }
 
             // Render GBuffer opaque
-                m_DebugViewMaterialGBuffer.SetFloat("_DebugViewMaterial", (float)globalDebugSettings.materialDebugSettings.debugViewMaterial);
-                var cmd = new CommandBuffer { name = "GBuffer Debug Pass" };
+                var cmd = new CommandBuffer { name = "DebugViewMaterialGBuffer" };
                 cmd.Blit(null, m_CameraColorBufferRT, m_DebugViewMaterialGBuffer, 0);
                 renderContext.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             {
-                RenderTransparentRenderList(cull, hdCamera.camera, renderContext, "DebugViewMaterial", Utilities.kRendererConfigurationBakedLighting);
+                RenderTransparentRenderList(cull, hdCamera.camera, renderContext, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
             }
 
             // Last blit
             }
         }
 
-        void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext, bool enableSSS)
+        void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext)
         {
             if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly() || m_LightLoop == null)
             {
             RenderTargetIdentifier[] colorRTs = { m_CameraColorBufferRT, m_CameraSubsurfaceBufferRT };
 
-            if (enableSSS)
+            if (debugDisplaySettings.renderingDebugSettings.enableSSS)
-                m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugSettings.lightingDebugSettings, colorRTs, m_CameraDepthStencilBufferRT, new RenderTargetIdentifier(GetDepthTexture()), true, enableSSS);
+                m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, debugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, new RenderTargetIdentifier(GetDepthTexture()), true);
-            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugSettings.lightingDebugSettings, colorRTs, m_CameraDepthStencilBufferRT, new RenderTargetIdentifier(GetDepthTexture()), false, enableSSS);
+            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, debugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, new RenderTargetIdentifier(GetDepthTexture()), false);
         }
 
         // Combines specular lighting and diffuse lighting with subsurface scattering.
             if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly()) return;
 
-            if (!globalDebugSettings.renderingDebugSettings.enableSSS) return;
+            if (!debugDisplaySettings.renderingDebugSettings.enableSSS) return;
-            var cmd = new CommandBuffer() { name = "Subsurface Scattering Pass" };
+            var cmd = new CommandBuffer() { name = "Subsurface Scattering" };
 
             // Perform the vertical SSS filtering pass.
             m_FilterSubsurfaceScattering.SetVectorArray("_FilterKernels", sssParameters.filterKernels);
             if (!m_Owner.renderingSettings.ShouldUseForwardRenderingOnly() && renderOpaque)
                 return;
 
-            using (new Utilities.ProfilingSample("Forward Pass", renderContext))
+            string passName = debugDisplaySettings.IsDebugDisplayEnable() ? "ForwardDisplayDebug" : "Forward";
+
+            using (new Utilities.ProfilingSample(passName, renderContext))
             {
                 Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
 
-                bool debugLighting = globalDebugSettings.lightingDebugSettings.lightingDebugMode != LightingDebugMode.None;
-
-                string forwardPassName = debugLighting ? "ForwardDebugLighting" : "Forward";
-                    RenderOpaqueRenderList(cullResults, camera, renderContext, forwardPassName, Utilities.kRendererConfigurationBakedLighting);
+                    RenderOpaqueRenderList(cullResults, camera, renderContext, passName, Utilities.kRendererConfigurationBakedLighting);
-                    RenderTransparentRenderList(cullResults, camera, renderContext, forwardPassName, Utilities.kRendererConfigurationBakedLighting);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, passName, Utilities.kRendererConfigurationBakedLighting);
                 }
             }
         }
         {
-            using (new Utilities.ProfilingSample("Forward Only Pass", renderContext))
+            string passName = debugDisplaySettings.IsDebugDisplayEnable() ? "ForwardOnlyOpaqueDisplayDebug" : "ForwardOnlyOpaque";
+
+            using (new Utilities.ProfilingSample(passName, renderContext))
             {
                 Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
 
-                bool debugLighting = globalDebugSettings.lightingDebugSettings.lightingDebugMode != LightingDebugMode.None;
-                RenderOpaqueRenderList(cullResults, camera, renderContext, debugLighting ? "ForwardOnlyOpaqueDebugLighting" : "ForwardOnlyOpaque", Utilities.kRendererConfigurationBakedLighting);
+                RenderOpaqueRenderList(cullResults, camera, renderContext, passName, Utilities.kRendererConfigurationBakedLighting);
-            using (new Utilities.ProfilingSample("Velocity Pass", renderContext))
+            using (new Utilities.ProfilingSample("Velocity", renderContext))
             {
                 // If opaque velocity have been render during GBuffer no need to render it here
                 if ((ShaderConfig.s_VelocityInGbuffer == 1) || m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
 
         void RenderDistortion(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext)
         {
-            if (!globalDebugSettings.renderingDebugSettings.enableDistortion)
+            if (!debugDisplaySettings.renderingDebugSettings.enableDistortion)
-            using (new Utilities.ProfilingSample("Distortion Pass", renderContext))
+            using (new Utilities.ProfilingSample("Distortion", renderContext))
             {
                 int w = camera.pixelWidth;
                 int h = camera.pixelHeight;
 
         void FinalPass(Camera camera, ScriptableRenderContext renderContext)
         {
-            using (new Utilities.ProfilingSample("Final Pass", renderContext))
+            using (new Utilities.ProfilingSample("Final", renderContext))
             {
                 // All of this is temporary, sub-optimal and quickly hacked together but is necessary
                 // for artists to do lighting work until the fully-featured framework is ready
             debugCB.name = "Debug Overlay";
 
             float x = 0;
-            float overlayRatio = globalDebugSettings.debugOverlayRatio;
+            float overlayRatio = debugDisplaySettings.debugOverlayRatio;
-            LightingDebugSettings lightingDebug = globalDebugSettings.lightingDebugSettings;
+            LightingDebugSettings lightingDebug = debugDisplaySettings.lightingDebugSettings;
 
             if (lightingDebug.shadowDebugMode != ShadowMapDebugMode.None)
             {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs

         public int IESIndex;
         public int cookieIndex;
 
+        public Vector2 size;  // Used by area, projector and spot lights; x = cot(outerHalfAngle) for spot lights
-        
-        public Vector2 size;  // Used by area, projector and spot lights; x = cot(outerHalfAngle) for spot lights
-        public bool twoSided; // Used by rectangular area lights only
+        public float unused;
     };
 
     [GenerateHLSL]

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs.hlsl

     int shadowIndex;
     int IESIndex;
     int cookieIndex;
-    int lightType;
-    bool twoSided;
+    int lightType;
+    float unused;
 };
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.DirectionalLightData
 //
 float3 GetPositionWS(LightData value)
 {
-    return value.positionWS;
+	return value.positionWS;
-    return value.invSqrAttenuationRadius;
+	return value.invSqrAttenuationRadius;
-    return value.color;
+	return value.color;
-    return value.angleScale;
+	return value.angleScale;
-    return value.forward;
+	return value.forward;
-    return value.angleOffset;
+	return value.angleOffset;
-    return value.up;
+	return value.up;
-    return value.diffuseScale;
+	return value.diffuseScale;
-    return value.right;
+	return value.right;
-    return value.specularScale;
+	return value.specularScale;
-    return value.shadowDimmer;
+	return value.shadowDimmer;
-    return value.shadowIndex;
+	return value.shadowIndex;
-    return value.IESIndex;
+	return value.IESIndex;
-    return value.cookieIndex;
+	return value.cookieIndex;
-int GetLightType(LightData value)
+float2 GetSize(LightData value)
-    return value.lightType;
+	return value.size;
-float2 GetSize(LightData value)
+int GetLightType(LightData value)
-    return value.size;
+	return value.lightType;
-bool GetTwoSided(LightData value)
+float GetUnused(LightData value)
-    return value.twoSided;
+	return value.unused;
 }
 
 //
 {
-    return value.forward;
+	return value.forward;
-    return value.diffuseScale;
+	return value.diffuseScale;
-    return value.up;
+	return value.up;
-    return value.invScaleY;
+	return value.invScaleY;
-    return value.right;
+	return value.right;
-    return value.invScaleX;
+	return value.invScaleX;
-    return value.positionWS;
+	return value.positionWS;
-    return value.tileCookie;
+	return value.tileCookie;
-    return value.color;
+	return value.color;
-    return value.specularScale;
+	return value.specularScale;
-    return value.cosAngle;
+	return value.cosAngle;
-    return value.sinAngle;
+	return value.sinAngle;
-    return value.shadowIndex;
+	return value.shadowIndex;
-    return value.cookieIndex;
+	return value.cookieIndex;
 }
 
 //
 {
-    return value.worldToShadow;
+	return value.worldToShadow;
-    return value.bias;
+	return value.bias;
-    return value.quality;
+	return value.quality;
-    return value.unused;
+	return value.unused;
-    return value.unused2;
+	return value.unused2;
-    return value.invResolution;
+	return value.invResolution;
 }
 
 //
 {
-    return value.positionWS;
+	return value.positionWS;
-    return value.envShapeType;
+	return value.envShapeType;
-    return value.forward;
+	return value.forward;
-    return value.envIndex;
+	return value.envIndex;
-    return value.up;
+	return value.up;
-    return value.blendDistance;
+	return value.blendDistance;
-    return value.right;
+	return value.right;
-    return value.unused0;
+	return value.unused0;
-    return value.innerDistance;
+	return value.innerDistance;
-    return value.unused1;
+	return value.unused1;
-    return value.offsetLS;
+	return value.offsetLS;
-    return value.unused2;
+	return value.unused2;
 }
 
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop.cs

         // TODO: this should not be part of the interface but for now make something working
         public virtual void BuildGPULightLists(Camera camera, ScriptableRenderContext loop, RenderTargetIdentifier cameraDepthBufferRT) {}
 
-        public virtual void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
-            LightingDebugSettings lightDebugParameters,
-            RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthStencilTexture,
-            bool outputSplitLightingForSSS, bool enableSSS) {}
+        public virtual void RenderDeferredLighting( HDCamera hdCamera, ScriptableRenderContext renderContext,
+                                                    DebugDisplaySettings debugDisplaySettings,
+                                                    RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthStencilTexture,
+                                                    bool outputSplitLightingForSSS) { }
 
         public virtual void RenderForward(Camera camera, ScriptableRenderContext renderContext, bool renderOpaque) {}
 

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

             // Split lighting is utilized during the SSS pass.
             #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
 
-         // #ifdef OUTPUT_SPLIT_LIGHTING
-            #pragma shader_feature _ SSS_PRE_SCATTER_TEXTURING SSS_POST_SCATTER_TEXTURING
-         // #endif
-
-            #pragma multi_compile _ LIGHTING_DEBUG
+            #pragma multi_compile _ DEBUG_DISPLAY
 
             //-------------------------------------------------------------------------------------
             // Include
-            #include "../../Debug/HDRenderPipelineDebug.cs.hlsl"
-            #include "../../Debug/DebugLighting.hlsl"
+            #include "../../Debug/DebugDisplay.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),
             #else
                 outputs.combinedLighting = float4(diffuseLighting + specularLighting, 1.0);
             #endif
+
                 return outputs;
             }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Resources/lightlistbuild-clustered.compute

 	GroupMemoryBarrierWithGroupSync();
 #endif
 	dpt_ma = asfloat(ldsZMax);
+	if(dpt_ma<=0.0) dpt_ma = VIEWPORT_SCALE_Z;		// assume sky pixel
 #endif
 
 	float2 vTileLL = float2(viTilLL.x/(float) iWidth, viTilLL.y/(float) iHeight);

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

-#pragma kernel ShadeOpaque_Direct_Fptl                          SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl                              USE_FPTL_LIGHTLIST
-#pragma kernel ShadeOpaque_Direct_Fptl_DebugLighting            SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl_DebugLighting                USE_FPTL_LIGHTLIST        LIGHTING_DEBUG
-#pragma kernel ShadeOpaque_Direct_Clustered                     SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered                         USE_CLUSTERED_LIGHTLIST
-#pragma kernel ShadeOpaque_Direct_Clustered_DebugLighting       SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered_DebugLighting           USE_CLUSTERED_LIGHTLIST   LIGHTING_DEBUG
-
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant0               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant0                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=0
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant1               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant1                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=1
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant2               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant2                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=2
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant3               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant3                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=3
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant4               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant4                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=4
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant5               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant5                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=5
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant6               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant6                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=6
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant7               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant7                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=7
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant8               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant8                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=8
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant9               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant9                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=9
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant10              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant10                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=10
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant11              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant11                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=11
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant12              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant12                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=12
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant13              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant13                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=13
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant14              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant14                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=14
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant15              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant15                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=15
-
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant1          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant1              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=1
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant2          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant2              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=2
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant3          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant3              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=3
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant4          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant4              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=4
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant5          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant5              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=5
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant6          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant6              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=6
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant7          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant7              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=7
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant8          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant8              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=8
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant9          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant9              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=9
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant10         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant10             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=10
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant11         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant11             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=11
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant12         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant12             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=12
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant13         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant13             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=13
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant14         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant14             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=14
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant15         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant15             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=15
-
-#pragma #pragma enable_d3d11_debug_symbols
-
-// Split lighting is required for the SSS pass.
-// Not currently possible since we need to access the stencil buffer from the compute shader.
-// #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
-
-#define LIGHTLOOP_TILE_PASS 1
-#define LIGHTLOOP_TILE_DIRECT 1
-#define LIGHTLOOP_TILE_INDIRECT 1
-#define LIGHTLOOP_TILE_ALL 1
-
-//-------------------------------------------------------------------------------------
-// Include
-//-------------------------------------------------------------------------------------
-
-#include "../../../../ShaderLibrary/Common.hlsl"
-#include "../../../Debug/HDRenderPipelineDebug.cs.hlsl"
-#include "../../../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), 
-// the deferred shader will require to use multicompile.
-#define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-#include "../../../ShaderConfig.cs.hlsl"
-#include "../../../ShaderVariables.hlsl"
-#include "../../../Lighting/Lighting.hlsl" // This include Material.hlsl
-#include "../../../Lighting/TilePass/FeatureFlags.hlsl"
-//-------------------------------------------------------------------------------------
-// variable declaration
-//-------------------------------------------------------------------------------------
-
-DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
-
-#ifdef OUTPUT_SPLIT_LIGHTING
-    RWTexture2D<float4> specularLightingUAV;
-    RWTexture2D<float3> diffuseLightingUAV;
-#else
-    RWTexture2D<float4> combinedLightingUAV;
-#endif
-
-#if USE_INDIRECT
-	uint g_TileListOffset;
-    StructuredBuffer<uint> g_TileList;
-// Indirect
-[numthreads(16, 16, 1)]
-void SHADE_OPAQUE_ENTRY(uint2 groupThreadId : SV_GroupThreadID, uint groupId : SV_GroupID)
-{
-    uint tileIndex = g_TileList[g_TileListOffset + groupId];
-    uint2 tileCoord = uint2(tileIndex & 0xFFFF, tileIndex >> 16);
-    uint2 pixelCoord = tileCoord * GetTileSize() + groupThreadId;
-
-    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, tileCoord);
-    uint featureFlags = TileVariantToFeatureFlags(VARIANT);
-#else
-// Direct
-[numthreads(16, 16, 1)]
-void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
-{
-    uint2 pixelCoord = dispatchThreadId;
-    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, groupId);
-	uint featureFlags = 0xFFFFFFFF;
-#endif
-    
-    float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
-    float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
-
-    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-    BSDFData bsdfData;
-    float3 bakeDiffuseLighting;
-    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeDiffuseLighting);
-
-    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
-
-    float3 diffuseLighting;
-    float3 specularLighting;
-    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, featureFlags, diffuseLighting, specularLighting);
-
-#ifdef OUTPUT_SPLIT_LIGHTING
-    specularLightingUAV[pixelCoord] = float4(specularLighting, 1.0);
-    diffuseLightingUAV[pixelCoord]  = diffuseLighting;
-#else
-    combinedLightingUAV[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
-#endif
-}
-
+#pragma kernel ShadeOpaque_Direct_Fptl                          SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl                              USE_FPTL_LIGHTLIST
+#pragma kernel ShadeOpaque_Direct_Fptl_DebugDisplay             SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl_DebugDisplay                 USE_FPTL_LIGHTLIST        DEBUG_DISPLAY
+#pragma kernel ShadeOpaque_Direct_Clustered                     SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered                         USE_CLUSTERED_LIGHTLIST
+#pragma kernel ShadeOpaque_Direct_Clustered_DebugDisplay        SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered_DebugDisplay            USE_CLUSTERED_LIGHTLIST   DEBUG_DISPLAY
+
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant0               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant0                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=0
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant1               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant1                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=1
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant2               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant2                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=2
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant3               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant3                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=3
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant4               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant4                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=4
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant5               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant5                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=5
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant6               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant6                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=6
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant7               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant7                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=7
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant8               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant8                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=8
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant9               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant9                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=9
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant10              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant10                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=10
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant11              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant11                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=11
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant12              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant12                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=12
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant13              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant13                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=13
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant14              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant14                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=14
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant15              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant15                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=15
+
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant1          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant1              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=1
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant2          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant2              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=2
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant3          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant3              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=3
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant4          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant4              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=4
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant5          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant5              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=5
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant6          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant6              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=6
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant7          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant7              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=7
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant8          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant8              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=8
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant9          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant9              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=9
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant10         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant10             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=10
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant11         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant11             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=11
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant12         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant12             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=12
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant13         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant13             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=13
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant14         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant14             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=14
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant15         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant15             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=15
+
+#pragma #pragma enable_d3d11_debug_symbols
+
+// Split lighting is required for the SSS pass.
+// Not currently possible since we need to access the stencil buffer from the compute shader.
+// #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
+
+#define LIGHTLOOP_TILE_PASS 1
+#define LIGHTLOOP_TILE_DIRECT 1
+#define LIGHTLOOP_TILE_INDIRECT 1
+#define LIGHTLOOP_TILE_ALL 1
+
+//-------------------------------------------------------------------------------------
+// Include
+//-------------------------------------------------------------------------------------
+
+#include "../../../../ShaderLibrary/Common.hlsl"
+#include "../../../Debug/DebugDisplay.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), 
+// the deferred shader will require to use multicompile.
+#define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
+#include "../../../ShaderConfig.cs.hlsl"
+#include "../../../ShaderVariables.hlsl"
+#include "../../../Lighting/Lighting.hlsl" // This include Material.hlsl
+#include "../../../Lighting/TilePass/FeatureFlags.hlsl"
+//-------------------------------------------------------------------------------------
+// variable declaration
+//-------------------------------------------------------------------------------------
+
+DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
+
+#ifdef OUTPUT_SPLIT_LIGHTING
+    RWTexture2D<float4> specularLightingUAV;
+    RWTexture2D<float3> diffuseLightingUAV;
+#else
+    RWTexture2D<float4> combinedLightingUAV;
+#endif
+
+#if USE_INDIRECT
+	uint g_TileListOffset;
+    StructuredBuffer<uint> g_TileList;
+// Indirect
+[numthreads(16, 16, 1)]
+void SHADE_OPAQUE_ENTRY(uint2 groupThreadId : SV_GroupThreadID, uint groupId : SV_GroupID)
+{
+    uint tileIndex = g_TileList[g_TileListOffset + groupId];
+    uint2 tileCoord = uint2(tileIndex & 0xFFFF, tileIndex >> 16);
+    uint2 pixelCoord = tileCoord * GetTileSize() + groupThreadId;
+
+    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, tileCoord);
+    uint featureFlags = TileVariantToFeatureFlags(VARIANT);
+#else
+// Direct
+[numthreads(16, 16, 1)]
+void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
+{
+    uint2 pixelCoord = dispatchThreadId;
+    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, groupId);
+	uint featureFlags = 0xFFFFFFFF;
+#endif
+    
+    float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
+    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+    float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
+
+    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
+    BSDFData bsdfData;
+    float3 bakeDiffuseLighting;
+    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeDiffuseLighting);
+
+    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
+
+    float3 diffuseLighting;
+    float3 specularLighting;
+    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, featureFlags, diffuseLighting, specularLighting);
+
+#ifdef OUTPUT_SPLIT_LIGHTING
+    specularLightingUAV[pixelCoord] = float4(specularLighting, 1.0);
+    diffuseLightingUAV[pixelCoord]  = diffuseLighting;
+#else
+    combinedLightingUAV[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
+#endif
+}
+

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

             static int s_ClearDispatchIndirectKernel;
             static int s_shadeOpaqueDirectClusteredKernel;
             static int s_shadeOpaqueDirectFptlKernel;
-            static int s_shadeOpaqueDirectClusteredDebugLightingKernel;
-            static int s_shadeOpaqueDirectFptlDebugLightingKernel;
+            static int s_shadeOpaqueDirectClusteredDebugDisplayKernel;
+            static int s_shadeOpaqueDirectFptlDebugDisplayKernel;
             static int[] s_shadeOpaqueIndirectClusteredKernels = new int[LightDefinitions.NUM_FEATURE_VARIANTS];
             static int[] s_shadeOpaqueIndirectFptlKernels = new int[LightDefinitions.NUM_FEATURE_VARIANTS];
 
                 m_CubeCookieTexArray = new TextureCacheCubemap();
                 m_CubeCookieTexArray.AllocTextureArray(4, textureSettings.pointCookieSize, TextureFormat.RGBA32, true);
                 m_CubeReflTexArray = new TextureCacheCubemap();
-                m_CubeReflTexArray.AllocTextureArray(32, textureSettings.reflectionCubemapSize, TextureCache.GetPreferredCompressedTextureFormat, true);
+                m_CubeReflTexArray.AllocTextureArray(32, textureSettings.reflectionCubemapSize, TextureCache.GetPreferredHdrCompressedTextureFormat, true);
 
                 s_GenAABBKernel = buildScreenAABBShader.FindKernel("ScreenBoundsAABB");
 
 
                 s_shadeOpaqueDirectClusteredKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Clustered");
                 s_shadeOpaqueDirectFptlKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Fptl");
-                s_shadeOpaqueDirectClusteredDebugLightingKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Clustered_DebugLighting");
-                s_shadeOpaqueDirectFptlDebugLightingKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Fptl_DebugLighting");
+                s_shadeOpaqueDirectClusteredDebugDisplayKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Clustered_DebugDisplay");
+                s_shadeOpaqueDirectFptlDebugDisplayKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Fptl_DebugDisplay");
 
                 for (int variant = 0; variant < LightDefinitions.NUM_FEATURE_VARIANTS; variant++)
                 {
 
                 if (additionalData.archetype != LightArchetype.Punctual)
                 {
-                    lightData.twoSided = additionalData.isDoubleSided;
                     lightData.size = new Vector2(additionalData.lightLength, additionalData.lightWidth);
                 }
 
 
                     Vector3 dimensions = new Vector3(lightData.size.x * 0.5f + radius, lightData.size.y * 0.5f + radius, radius);
 
-                    if (!lightData.twoSided)
-                    {
-                        centerVS += zAxisVS * radius * 0.5f;
-                        dimensions.z *= 0.5f;
-                    }
+                    dimensions.z *= 0.5f;
+                    centerVS += zAxisVS * radius * 0.5f;
 
                     bound.center = centerVS;
                     bound.boxAxisX = dimensions.x * xAxisVS;
 #endif
             }
 
-            private void SetupRenderingForDebug(LightingDebugSettings lightDebugSettings)
+            private void SetupDebugDisplayMode(bool debugDisplayEnable)
-                Utilities.SetKeyword(m_DeferredDirectMaterialSRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredDirectMaterialMRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredIndirectMaterialSRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredIndirectMaterialMRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredAllMaterialSRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredAllMaterialMRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_SingleDeferredMaterialSRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_SingleDeferredMaterialMRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredDirectMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
+                Utilities.SetKeyword(m_DeferredDirectMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
+                Utilities.SetKeyword(m_DeferredIndirectMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
+                Utilities.SetKeyword(m_DeferredIndirectMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
+                Utilities.SetKeyword(m_DeferredAllMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
+                Utilities.SetKeyword(m_DeferredAllMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
+                Utilities.SetKeyword(m_SingleDeferredMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
+                Utilities.SetKeyword(m_SingleDeferredMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
-                LightingDebugSettings lightDebugSettings,
-                RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthStencilTexture,
-                bool outputSplitLightingForSSS, bool enableSSS)
+                                                        DebugDisplaySettings debugDisplaySettings,
+                                                        RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthStencilTexture,
+                                                        bool outputSplitLightingForSSS)
             {
                 var bUseClusteredForDeferred = !usingFptl;
 
                 }
 #endif
 
-                using (new Utilities.ProfilingSample(m_PassSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass", renderContext))
+                using (new Utilities.ProfilingSample((m_PassSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLightingForSSS ? " MRT" : ""), renderContext))
                 {
                     var cmd = new CommandBuffer();
                     cmd.name = bUseClusteredForDeferred ? "Clustered pass" : "Tiled pass";
-                    // Must be done after setting up the compute shader above.
-                    SetupRenderingForDebug(lightDebugSettings);
+                    SetupDebugDisplayMode(debugDisplaySettings.IsDebugDisplayEnable());
 
                     if (!m_PassSettings.enableTileAndCluster)
                     {
                         }
                         else
                         {
-                            m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)(enableSSS ? StencilBits.Standard : StencilBits.SSS));
+                            // Note: in the enum StencilBits, Standard is before SSS and the stencil is setup to greater equal. So the code below is draw all stencil bit except SSS
+                            m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)(debugDisplaySettings.renderingDebugSettings.enableSSS ? StencilBits.Standard : StencilBits.SSS));
                             Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
                         }
                     }
 
                         if (m_PassSettings.enableComputeLightEvaluation)
                         {
-                            bool enableFeatureVariants = GetFeatureVariantsEnabled() && lightDebugSettings.lightingDebugMode == LightingDebugMode.None;
+                            bool enableFeatureVariants = GetFeatureVariantsEnabled() && !debugDisplaySettings.IsDebugDisplayEnable();
 
                             int numVariants = 1;
                             if (enableFeatureVariants)
                                 }
                                 else
                                 {
-                                    if (lightDebugSettings.lightingDebugMode == LightingDebugMode.None)
-                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlKernel : s_shadeOpaqueDirectClusteredKernel;
+                                    if (debugDisplaySettings.IsDebugDisplayEnable())
+                                    {
+                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlDebugDisplayKernel : s_shadeOpaqueDirectClusteredDebugDisplayKernel;
+                                    }
-                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlDebugLightingKernel : s_shadeOpaqueDirectClusteredDebugLightingKernel;
+                                    {
+                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlKernel : s_shadeOpaqueDirectClusteredKernel;
+                                    }
+
+                                // TODO: Update value like in ApplyDebugDisplaySettings() call. Sadly it is high likely that this will not be keep in sync. we really need to get rid of this by making global parameters visible to compute shaders
+                                cmd.SetComputeIntParam(shadeOpaqueShader, "_DebugDisplayMode", Shader.GetGlobalInt("_DebugDisplayMode"));
+                                cmd.SetComputeIntParam(shadeOpaqueShader, "_DebugViewMaterial", Shader.GetGlobalInt("_DebugViewMaterial"));
+                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_DebugLightingAlbedo", Shader.GetGlobalVector("_DebugLightingAlbedo"));
+                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_DebugLightingSmoothness", Shader.GetGlobalVector("_DebugLightingSmoothness"));
 
                                 cmd.SetComputeBufferParam(shadeOpaqueShader, kernel, "g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
 
                                 }
                                 else
                                 {
-                                    m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)(enableSSS ? StencilBits.Standard : StencilBits.SSS));
+                                    // Note: in the enum StencilBits, Standard is before SSS and the stencil is setup to greater equal. So the code below is draw all stencil bit except SSS
+                                    m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)(debugDisplaySettings.renderingDebugSettings.enableSSS ? StencilBits.Standard : StencilBits.SSS));
-                                    m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)(enableSSS ? StencilBits.Standard : StencilBits.SSS));
+                                    m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)(debugDisplaySettings.renderingDebugSettings.enableSSS ? StencilBits.Standard : StencilBits.SSS));
                                     Utilities.SelectKeyword(m_DeferredIndirectMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
                                     Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
                                 }
                                 }
                                 else
                                 {
-                                    m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)(enableSSS ? StencilBits.Standard : StencilBits.SSS));
+                                    // Note: in the enum StencilBits, Standard is before SSS and the stencil is setup to greater equal. So the code below is draw all stencil bit except SSS
+                                    m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)(debugDisplaySettings.renderingDebugSettings.enableSSS ? StencilBits.Standard : StencilBits.SSS));
                                     Utilities.SelectKeyword(m_DeferredAllMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
                                     Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
                                 }

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

 //
 float3 GetBoxAxisX(SFiniteLightBound value)
 {
-    return value.boxAxisX;
+	return value.boxAxisX;
-    return value.boxAxisY;
+	return value.boxAxisY;
-    return value.boxAxisZ;
+	return value.boxAxisZ;
-    return value.center;
+	return value.center;
-    return value.scaleXY;
+	return value.scaleXY;
-    return value.radius;
+	return value.radius;
 }
 
 //
 {
-    return value.lightPos;
+	return value.lightPos;
-    return value.lightVolume;
+	return value.lightVolume;
-    return value.lightAxisX;
+	return value.lightAxisX;
-    return value.lightCategory;
+	return value.lightCategory;
-    return value.lightAxisY;
+	return value.lightAxisY;
-    return value.radiusSq;
+	return value.radiusSq;
-    return value.lightAxisZ;
+	return value.lightAxisZ;
-    return value.cotan;
+	return value.cotan;
-    return value.boxInnerDist;
+	return value.boxInnerDist;
-    return value.featureFlags;
+	return value.featureFlags;
-    return value.boxInvRange;
+	return value.boxInvRange;
-    return value.unused2;
+	return value.unused2;
 }
 
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

 
 StructuredBuffer<uint> g_vLightListGlobal;      // don't support Buffer yet in unity
 
-#ifdef USE_FPTL_LIGHTLIST
-#define TILE_SIZE TILE_SIZE_FPTL
-#endif
-// Don't do a "#else" so we can catch error if including call don't setup thing correctly
-#ifdef USE_CLUSTERED_LIGHTLIST
-#define TILE_SIZE TILE_SIZE_CLUSTERED
-#endif
-
 #define DWORD_PER_TILE 16 // See dwordsPerTile in TilePass.cs, we have roomm for 31 lights and a number of light value all store on 16 bit (ushort)
 
 // these uniforms are only needed for when OPAQUES_ONLY is NOT defined

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

 
 void ApplyDebug(LightLoopContext lightLoopContext, float3 positionWS, inout float3 diffuseLighting, inout float3 specularLighting)
 {
-#ifdef LIGHTING_DEBUG
-    int lightDebugMode = (int)_DebugLightModeAndAlbedo.x;
-
-    if (lightDebugMode == LIGHTINGDEBUGMODE_DIFFUSE_LIGHTING)
+#ifdef DEBUG_DISPLAY
+    if (_DebugDisplayMode == DEBUGDISPLAYMODE_DIFFUSE_LIGHTING)
-        specularLighting = float3(0.0, 0.0, 0.0);
+        specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-    else if (lightDebugMode == LIGHTINGDEBUGMODE_SPECULAR_LIGHTING)
+    else if (_DebugDisplayMode == DEBUGDISPLAYMODE_SPECULAR_LIGHTING)
-        diffuseLighting = float3(0.0, 0.0, 0.0);
+        diffuseLighting = float3(0.0, 0.0, 0.0); // Disable diffuse lighting
-    else if (lightDebugMode == LIGHTINGDEBUGMODE_VISUALIZE_CASCADE)
+    else if (_DebugDisplayMode == DEBUGDISPLAYMODE_VISUALIZE_CASCADE)
     {
         specularLighting = float3(0.0, 0.0, 0.0);
 
 
 uint GetTileSize()
 {
-    return TILE_SIZE_CLUSTERED;
+    if (_UseTileLightList)
+        return TILE_SIZE_FPTL;
+    else
+        return TILE_SIZE_CLUSTERED;
 }
 
 void GetCountAndStartCluster(PositionInputs posInput, uint lightCategory, out uint start, out uint lightCount)

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

         public ComputeShader buildPerVoxelLightListShader = null;    // clustered
         public ComputeShader clearDispatchIndirectShader = null;
         public ComputeShader shadeOpaqueShader = null;
-
-        // Various set of material use in render loop
-        public Shader m_DebugViewMaterialGBuffer;
-
-        // For image based lighting
-        public Shader m_InitPreFGD;
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Builtin/BuiltinData.cs

             // We would prefer to split lighting and material information but for performance reasons,
             // those lighting information are fill
             // at the same time than material information.
-            [SurfaceDataAttributes("Bake Diffuse Lighting")]
+            [SurfaceDataAttributes("Bake Diffuse Lighting", false, true)]
-            [SurfaceDataAttributes("Emissive Color")]
+            [SurfaceDataAttributes("Emissive Color", false, true)]
             public Vector3 emissiveColor;
             [SurfaceDataAttributes("Emissive Intensity")]
             public float emissiveIntensity;
         };
 
         //-----------------------------------------------------------------------------
-        // LighTransportData
+        // LightTransportData
-        public struct LighTransportData
+        public struct LightTransportData
+            [SurfaceDataAttributes("", false, true)]
-            public Vector3 emissiveColor;
+            public Vector3 emissiveColor; // HDR value
         };
 
         public class RenderLoop : Object

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Builtin/BuiltinData.cs.hlsl

 #define DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET (107)
 
 //
-// UnityEngine.Experimental.Rendering.HDPipeline.Builtin.LighTransportData:  static fields
+// UnityEngine.Experimental.Rendering.HDPipeline.Builtin.LightTransportData:  static fields
-#define DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_DIFFUSE_COLOR (120)
-#define DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_EMISSIVE_COLOR (121)
+#define DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_DIFFUSE_COLOR (120)
+#define DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_EMISSIVE_COLOR (121)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.Builtin.BuiltinData
 // PackingRules = Exact
     float depthOffset;
 };
 
-// Generated from UnityEngine.Experimental.Rendering.HDPipeline.Builtin.LighTransportData
+// Generated from UnityEngine.Experimental.Rendering.HDPipeline.Builtin.LightTransportData
-struct LighTransportData
+struct LightTransportData
+
+//
+// Debug functions
+//
+void GetGeneratedBuiltinDataDebug(uint paramId, BuiltinData builtindata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_OPACITY:
+            result = builtindata.opacity.xxx;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
+            result = builtindata.bakeDiffuseLighting;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR:
+            result = builtindata.emissiveColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_INTENSITY:
+            result = builtindata.emissiveIntensity.xxx;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY:
+            result = float3(builtindata.velocity, 0.0);
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION:
+            result = float3(builtindata.distortion, 0.0);
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR:
+            result = builtindata.distortionBlur.xxx;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET:
+            result = builtindata.depthOffset.xxx;
+            break;
+    }
+}
+
+//
+// Debug functions
+//
+void GetGeneratedLightTransportDataDebug(uint paramId, LightTransportData lighttransportdata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_DIFFUSE_COLOR:
+            result = lighttransportdata.diffuseColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_EMISSIVE_COLOR:
+            result = lighttransportdata.emissiveColor;
+            break;
+    }
+}
 
 
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Builtin/BuiltinData.hlsl

 // Note: These parameters can be store in GBuffer if the writer wants
 //-----------------------------------------------------------------------------
 
-//TODO: return this original relative path include after fixing a bug in Unity side
-//#include "BuiltinData.cs.hlsl"
-#include "../../Material/Builtin/BuiltinData.cs.hlsl"
+#include "BuiltinData.cs.hlsl"
 
 //-----------------------------------------------------------------------------
 // common Encode/Decode functions
 
 void GetBuiltinDataDebug(uint paramId, BuiltinData builtinData, inout float3 result, inout bool needLinearToSRGB)
 {
+    GetGeneratedBuiltinDataDebug(paramId, builtinData, result, needLinearToSRGB);
+
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_OPACITY:
-        result = builtinData.opacity.xxx;
-        break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
         // TODO: require a remap
         // TODO: we should not gamma correct, but easier to debug for now without correct high range value
         // emissiveColor is premultiply by emissive intensity
         result = (builtinData.emissiveColor / builtinData.emissiveIntensity); needLinearToSRGB = true;
         break;
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_INTENSITY:
-        result = builtinData.emissiveIntensity.xxx;
-        break;
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY:
-        result = float3(builtinData.velocity, 0.0);
-        break;
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION:
-        result = float3(builtinData.distortion, 0.0);
-        break;
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR:
-        result = builtinData.distortionBlur.xxx;
-        break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET:
         result = builtinData.depthOffset.xxx * 10.0; // * 10 assuming 1 unity unity is 1m
         break;
-void GetLighTransportDataDebug(uint paramId, LighTransportData lightTransportData, inout float3 result, inout bool needLinearToSRGB)
+void GetLightTransportDataDebug(uint paramId, LightTransportData lightTransportData, inout float3 result, inout bool needLinearToSRGB)
+    GetGeneratedLightTransportDataDebug(paramId, lightTransportData, result, needLinearToSRGB);
+
-    case DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_DIFFUSE_COLOR:
-        result = lightTransportData.diffuseColor; needLinearToSRGB = true;
-        break;
-    case DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_EMISSIVE_COLOR:
+    case DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_EMISSIVE_COLOR:
         // TODO: Need a tonemap ?
         result = lightTransportData.emissiveColor;
         break;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

 
         Pass
         {
-            Name "GBufferDebugLighting"  // Name is not used
-            Tags{ "LightMode" = "GBufferDebugLighting" } // This will be only for opaque object based on the RenderQueue index
+            Name "GBufferDebugDisplay"  // Name is not used
+            Tags{ "LightMode" = "GBufferDebugDisplay" } // This will be only for opaque object based on the RenderQueue index
 
             Cull [_CullMode]
 
 
             HLSLPROGRAM
 
-            #define LIGHTING_DEBUG
+            #define DEBUG_DISPLAY
-            #include "../../Debug/HDRenderPipelineDebug.cs.hlsl"
-            #include "../../Debug/DebugLighting.hlsl"
+            #include "../../Debug/DebugDisplay.hlsl"
-
-            ENDHLSL
-        }
-
-        Pass
-        {
-            Name "Debug"
-            Tags{ "LightMode" = "DebugViewMaterial" }
-
-            Cull[_CullMode]
-
-            HLSLPROGRAM
-
-            #define SHADERPASS SHADERPASS_DEBUG_VIEW_MATERIAL
-
-            #include "../../Material/Material.hlsl"
-            #include "../Lit/ShaderPass/LitSharePass.hlsl"
-            #include "../Lit/LitData.hlsl"
-            #include "../../ShaderPass/ShaderPassDebugViewMaterial.hlsl"
 
             ENDHLSL
         }
 
         Pass
         {
-            Name "ForwardDebugLighting" // Name is not used
-            Tags{ "LightMode" = "ForwardDebugLighting" } // This will be only for transparent object based on the RenderQueue index
+            Name "ForwardDisplayDebug" // Name is not used
+            Tags{ "LightMode" = "ForwardDisplayDebug" } // This will be only for transparent object based on the RenderQueue index
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]
 
-            #define LIGHTING_DEBUG
+            #define DEBUG_DISPLAY
-            #include "../../Lighting/Forward.hlsl"
-            #include "../../Debug/HDRenderPipelineDebug.cs.hlsl"
-            #include "../../Debug/DebugLighting.hlsl"
+            #include "../../Debug/DebugDisplay.hlsl"
+            #include "../../Lighting/Forward.hlsl"            
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

 
         Pass
         {
-            Name "GBufferDebugLighting"  // Name is not used
-            Tags{ "LightMode" = "GBufferDebugLighting" } // This will be only for opaque object based on the RenderQueue index
+            Name "GBufferDebugDisplay"  // Name is not used
+            Tags{ "LightMode" = "GBufferDebugDisplay" } // This will be only for opaque object based on the RenderQueue index
 
             Cull [_CullMode]
 
             #pragma hull Hull
             #pragma domain Domain
 
-            #define LIGHTING_DEBUG
+            #define DEBUG_DISPLAY
-            #include "../../Debug/HDRenderPipelineDebug.cs.hlsl"
-            #include "../../Debug/DebugLighting.hlsl"
+            #include "../../Debug/DebugDisplay.hlsl"
-
-            ENDHLSL
-        }
-
-        Pass
-        {
-            Name "Debug"
-            Tags{ "LightMode" = "DebugViewMaterial" }
-
-            Cull[_CullMode]
-
-            HLSLPROGRAM
-
-            #pragma hull Hull
-            #pragma domain Domain
-
-            #define SHADERPASS SHADERPASS_DEBUG_VIEW_MATERIAL
-
-            #include "../../Material/Material.hlsl"
-            #include "../Lit/ShaderPass/LitSharePass.hlsl"
-            #include "../Lit/LitData.hlsl"
-            #include "../../ShaderPass/ShaderPassDebugViewMaterial.hlsl"
 
             ENDHLSL
         }
 
         Pass
         {
-            Name "ForwardDebugLighting" // Name is not used
-            Tags{ "LightMode" = "ForwardDebugLighting" } // This will be only for transparent object based on the RenderQueue index
+            Name "ForwardDisplayDebug" // Name is not used
+            Tags{ "LightMode" = "ForwardDisplayDebug" } // This will be only for transparent object based on the RenderQueue index
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]
             #pragma hull Hull
             #pragma domain Domain
 
-            #define LIGHTING_DEBUG
+            #define DEBUG_DISPLAY
+            #include "../../Debug/DebugDisplay.hlsl"
-            #include "../../Debug/HDRenderPipelineDebug.cs.hlsl"
-            #include "../../Debug/DebugLighting.hlsl"
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/BaseLitUI.cs

 
             if (distortionEnable && distortionOnly)
             {
-                // Disable all passes except debug material
+                // Disable all passes except distortion (setup in BaseUnlitUI.cs) and debug passes (to visualize distortion)
-                material.SetShaderPassEnabled("DebugViewMaterial", true);
+                material.SetShaderPassEnabled("GBufferDisplayDebug", true);
+                material.SetShaderPassEnabled("ForwardDisplayDebug", true);
+                // Enable all passes except distortion (setup in BaseUnlitUI.cs)
-                material.SetShaderPassEnabled("DebugViewMaterial", true);
+                material.SetShaderPassEnabled("GBufferDisplayDebug", true);
+                material.SetShaderPassEnabled("ForwardDisplayDebug", true);
             }
         }
     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/LitUI.cs

             public static GUIContent maskMapSText = new GUIContent("Mask Map - M(R), AO(G), S(A)", "Mask map");
 
             public static GUIContent normalMapSpaceText = new GUIContent("Normal/Tangent Map space", "");
-            public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (DXT5) - Need to implement BC5");
+            public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (BC7/BC5/DXT5(nm))");
             public static GUIContent specularOcclusionMapText = new GUIContent("Specular Occlusion Map (RGBA)", "Specular Occlusion Map");
             public static GUIContent horizonFadeText = new GUIContent("Horizon Fade (Spec occlusion)", "horizon fade is use to control specular occlusion");
 
 
             // Details
             public static string detailText = "Inputs Detail";
-            public static GUIContent detailMapModeText = new GUIContent("Detail Map with Normal", "Detail Map with AO / Height");
             public static GUIContent UVDetailMappingText = new GUIContent("Detail UV mapping", "");
             public static GUIContent detailMapNormalText = new GUIContent("Detail Map A(R) Ny(G) S(B) Nx(A)", "Detail Map");
             public static GUIContent detailMaskText = new GUIContent("Detail Mask (G)", "Mask for detailMap");

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

         [GenerateHLSL(PackingRules.Exact, false, true, 1000)]
         public struct SurfaceData
         {
-            [SurfaceDataAttributes("Base Color")]
+            [SurfaceDataAttributes("Base Color", false, true)]
-            [SurfaceDataAttributes("Normal")]
+            [SurfaceDataAttributes("Normal", true)]
             public Vector3 normalWS;
             [SurfaceDataAttributes("Smoothness")]
             public float perceptualSmoothness;
             // MaterialId dependent attribute
 
             // standard
-            [SurfaceDataAttributes("Tangent")]
+            [SurfaceDataAttributes("Tangent", true)]
             public Vector3 tangentWS;
             [SurfaceDataAttributes("Anisotropy")]
             public float anisotropy; // anisotropic ratio(0->no isotropic; 1->full anisotropy in tangent direction)
             public int subsurfaceProfile;
 
             // Clearcoat
-            [SurfaceDataAttributes("Coat Normal")]
+            [SurfaceDataAttributes("Coat Normal", true)]
-            [SurfaceDataAttributes("Specular Color")]
+            [SurfaceDataAttributes("Specular Color", false, true)]
             public Vector3 specularColor;
         };
 
         [GenerateHLSL(PackingRules.Exact, false, true, 1030)]
         public struct BSDFData
         {
+            [SurfaceDataAttributes("", false, true)]
             public Vector3 diffuseColor;
 
             public Vector3 fresnel0;
+            [SurfaceDataAttributes("", true)]
-            public float materialId;
+            public int materialId;
+            [SurfaceDataAttributes("", true)]
+            [SurfaceDataAttributes("", true)]
             public Vector3 bitangentWS;
             public float roughnessT;
             public float roughnessB;
             public Vector3 transmittance;
 
             // Clearcoat
+            [SurfaceDataAttributes("", true)]
             public Vector3 coatNormalWS;
             public float coatRoughness;
 

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

     float3 normalWS;
     float perceptualRoughness;
     float roughness;
-    float materialId;
+    int materialId;
     float3 tangentWS;
     float3 bitangentWS;
     float roughnessT;
     float3 coatNormalWS;
     float coatRoughness;
 };
+
+//
+// Debug functions
+//
+void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_LIT_SURFACEDATA_BASE_COLOR:
+            result = surfacedata.baseColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_OCCLUSION:
+            result = surfacedata.specularOcclusion.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_NORMAL_WS:
+            result = surfacedata.normalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_PERCEPTUAL_SMOOTHNESS:
+            result = surfacedata.perceptualSmoothness.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_MATERIAL_ID:
+            result = GetIndexColor(surfacedata.materialId);
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_AMBIENT_OCCLUSION:
+            result = surfacedata.ambientOcclusion.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_TANGENT_WS:
+            result = surfacedata.tangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_ANISOTROPY:
+            result = surfacedata.anisotropy.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_METALLIC:
+            result = surfacedata.metallic.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR:
+            result = surfacedata.specular.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS:
+            result = surfacedata.subsurfaceRadius.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_THICKNESS:
+            result = surfacedata.thickness.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE:
+            result = GetIndexColor(surfacedata.subsurfaceProfile);
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS:
+            result = surfacedata.coatNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_COAT_PERCEPTUAL_SMOOTHNESS:
+            result = surfacedata.coatPerceptualSmoothness.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR:
+            result = surfacedata.specularColor;
+            needLinearToSRGB = true;
+            break;
+    }
+}
+
+//
+// Debug functions
+//
+void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_LIT_BSDFDATA_DIFFUSE_COLOR:
+            result = bsdfdata.diffuseColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_FRESNEL0:
+            result = bsdfdata.fresnel0;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_SPECULAR_OCCLUSION:
+            result = bsdfdata.specularOcclusion.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_NORMAL_WS:
+            result = bsdfdata.normalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_PERCEPTUAL_ROUGHNESS:
+            result = bsdfdata.perceptualRoughness.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS:
+            result = bsdfdata.roughness.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_MATERIAL_ID:
+            result = GetIndexColor(bsdfdata.materialId);
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_TANGENT_WS:
+            result = bsdfdata.tangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_BITANGENT_WS:
+            result = bsdfdata.bitangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_T:
+            result = bsdfdata.roughnessT.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_B:
+            result = bsdfdata.roughnessB.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY:
+            result = bsdfdata.anisotropy.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS:
+            result = bsdfdata.subsurfaceRadius.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_THICKNESS:
+            result = bsdfdata.thickness.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE:
+            result = GetIndexColor(bsdfdata.subsurfaceProfile);
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ENABLE_TRANSMISSION:
+            result = (bsdfdata.enableTransmission) ? float3(1.0, 1.0, 1.0) : float3(0.0, 0.0, 0.0);
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE:
+            result = bsdfdata.transmittance;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS:
+            result = bsdfdata.coatNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS:
+            result = bsdfdata.coatRoughness.xxx;
+            break;
+    }
+}
 
 
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 #define LTC_GGX_MATRIX_INDEX 0 // RGBA
 #define LTC_DISNEY_DIFFUSE_MATRIX_INDEX 1 // RGBA
 #define LTC_MULTI_GGX_FRESNEL_DISNEY_DIFFUSE_INDEX 2 // RGB, A unused
+#define LTC_LUT_SIZE   64
+#define LTC_LUT_SCALE  ((LTC_LUT_SIZE - 1) * rcp(LTC_LUT_SIZE))
+#define LTC_LUT_OFFSET (0.5 * rcp(LTC_LUT_SIZE))
-#define SSS_N_PROFILES 8
-#define SSS_UNIT_CONVERSION (1.0 / 300.0)                  // From meters to 1/3 centimeters
+#define SSS_N_PROFILES      8
+#define SSS_UNIT_CONVERSION (1.0 / 300.0)                  // From 1/3 centimeters to meters
+#define SSS_LOW_THICKNESS   0.002                          // 2 mm
+
+float4 _TintColors[SSS_N_PROFILES];                        // For transmission; alpha is unused
 float  _ThicknessRemaps[SSS_N_PROFILES][2];                // Remap: 0 = start, 1 = end - start
 float4 _HalfRcpVariancesAndLerpWeights[SSS_N_PROFILES][2]; // 2x Gaussians per color channel, A is the the associated interpolation weight
 
 
 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)
+#ifdef DEBUG_DISPLAY
+    if (_DebugDisplayMode == DEBUGDISPLAYMODE_SPECULAR_LIGHTING)
-        bsdfData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(overrideSmoothnessValue);
-        bsdfData.roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
+        bool overrideSmoothness = _DebugLightingSmoothness.x != 0.0;
+        float overrideSmoothnessValue = _DebugLightingSmoothness.y;
+
+        if (overrideSmoothness)
+        {
+            bsdfData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(overrideSmoothnessValue);
+            bsdfData.roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
+        }
-    if (lightDebugMode == LIGHTINGDEBUGMODE_DIFFUSE_LIGHTING)
+    if (_DebugDisplayMode == DEBUGDISPLAYMODE_DIFFUSE_LIGHTING)
-        bsdfData.diffuseColor = lightDebugAlbedo;
+        bsdfData.diffuseColor = _DebugLightingAlbedo.xyz;
-
 #endif
 }
 
 // Ref: Real-Time Realistic Skin Translucency (2010), equation 9 (modified).
 float3 ComputeTransmittance(float3 halfRcpVariance1, float lerpWeight1,
                             float3 halfRcpVariance2, float lerpWeight2,
-                            float thickness, float radiusScale)
+                            float3 tintColor, float thickness, float radiusScale)
 {
 
     // Thickness and SSS radius are decoupled for artists.
     float t2 = thickness * thickness;
 
     // TODO: 6 exponentials is kind of expensive... Should we use a LUT instead?
-    // lerp(exp(-t2 * halfRcpVariance1), exp(-t2 * halfRcpVariance2), lerpWeight2)
-    return exp(-t2 * halfRcpVariance1) * lerpWeight1 + exp(-t2 * halfRcpVariance2) * lerpWeight2;
+    // T = lerp(exp(-t2 * halfRcpVariance1), exp(-t2 * halfRcpVariance2), lerpWeight2)
+    float3 transmittance = exp(-t2 * halfRcpVariance1) * lerpWeight1
+                         + exp(-t2 * halfRcpVariance2) * lerpWeight2;
+    return transmittance * tintColor;
 }
 
 //-----------------------------------------------------------------------------
         bsdfData.fresnel0 = 0.04; /* 0.028 ? */
         bsdfData.subsurfaceProfile = surfaceData.subsurfaceProfile;
         // Make the Std. Dev. of 1 correspond to the effective radius of 1 cm (three-sigma rule).
-        bsdfData.subsurfaceRadius  = SSS_UNIT_CONVERSION * surfaceData.subsurfaceRadius;
+        bsdfData.subsurfaceRadius  = SSS_UNIT_CONVERSION * surfaceData.subsurfaceRadius + 0.0001;
         bsdfData.thickness         = SSS_UNIT_CONVERSION * (_ThicknessRemaps[bsdfData.subsurfaceProfile][0] +
                                                             _ThicknessRemaps[bsdfData.subsurfaceProfile][1] * surfaceData.thickness);
         bsdfData.enableTransmission = IsBitSet(_TransmissionFlags, bsdfData.subsurfaceProfile);
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].w,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].xyz,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].w,
-                                                          bsdfData.thickness, bsdfData.subsurfaceRadius);
+                                                          _TintColors[bsdfData.subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
         }
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
         bsdfData.diffuseColor = baseColor;
         // TODO take from subsurfaceProfile
         bsdfData.fresnel0 = 0.04; /* 0.028 ? */
-        bsdfData.subsurfaceProfile = (SSS_N_PROFILES - 1) * inGBuffer2.a;
+        bsdfData.subsurfaceProfile = (SSS_N_PROFILES - 0.9) * inGBuffer2.a; // Need to bias for integers to round trip through the G-buffer
-        bsdfData.subsurfaceRadius  = SSS_UNIT_CONVERSION * inGBuffer2.r;
+        bsdfData.subsurfaceRadius  = SSS_UNIT_CONVERSION * inGBuffer2.r + 0.0001;
         bsdfData.thickness         = SSS_UNIT_CONVERSION * (_ThicknessRemaps[bsdfData.subsurfaceProfile][0] +
                                                             _ThicknessRemaps[bsdfData.subsurfaceProfile][1] * inGBuffer2.g);
         bsdfData.enableTransmission = IsBitSet(_TransmissionFlags, bsdfData.subsurfaceProfile);
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].w,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].xyz,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].w,
-                                                          bsdfData.thickness, bsdfData.subsurfaceRadius);
+                                                          _TintColors[bsdfData.subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
         }
     }
     else if (supportsClearCoat && bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
 
 void GetSurfaceDataDebug(uint paramId, SurfaceData surfaceData, inout float3 result, inout bool needLinearToSRGB)
 {
+    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB);
+
-        case DEBUGVIEW_LIT_SURFACEDATA_BASE_COLOR:
-            result = surfaceData.baseColor; needLinearToSRGB = true;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_OCCLUSION:
-            result = surfaceData.specularOcclusion.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_NORMAL_WS:
-            result = surfaceData.normalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_PERCEPTUAL_SMOOTHNESS:
-            result = surfaceData.perceptualSmoothness.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_MATERIAL_ID:
-            result = GetIndexColor(surfaceData.materialId);
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_AMBIENT_OCCLUSION:
-            result = surfaceData.ambientOcclusion.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_TANGENT_WS:
-            result = surfaceData.tangentWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_ANISOTROPY:
-            result = surfaceData.anisotropy.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_METALLIC:
-            result = surfaceData.metallic.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS:
-            result = surfaceData.subsurfaceRadius.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_THICKNESS:
-            result = surfaceData.thickness.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE:
-            result = GetIndexColor(surfaceData.subsurfaceProfile);
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS:
-            result = surfaceData.coatNormalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_COAT_PERCEPTUAL_SMOOTHNESS:
-            result = surfaceData.coatPerceptualSmoothness.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR:
-            result = surfaceData.specularColor; needLinearToSRGB = true;
-            break;
-    switch (paramId)
-    {
-        case DEBUGVIEW_LIT_BSDFDATA_DIFFUSE_COLOR:
-            result = bsdfData.diffuseColor; needLinearToSRGB = true;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_FRESNEL0:
-            result = bsdfData.fresnel0;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_SPECULAR_OCCLUSION:
-            result = bsdfData.specularOcclusion.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_NORMAL_WS:
-            result = bsdfData.normalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_PERCEPTUAL_ROUGHNESS:
-            result = bsdfData.perceptualRoughness.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS:
-            result = bsdfData.roughness.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_MATERIAL_ID:
-            result = GetIndexColor(bsdfData.materialId);
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_TANGENT_WS:
-            result = bsdfData.tangentWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_BITANGENT_WS:
-            result = bsdfData.bitangentWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_T:
-            result = bsdfData.roughnessT.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_B:
-            result = bsdfData.roughnessB.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY:
-            result = bsdfData.anisotropy.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS:
-            result = bsdfData.subsurfaceRadius.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_THICKNESS:
-            result = bsdfData.thickness.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE:
-            result = GetIndexColor(bsdfData.subsurfaceProfile);
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS:
-            result = bsdfData.coatNormalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS:
-            result = bsdfData.coatRoughness.xxx;
-            break;
-    }
+    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB);
 }
 
 //-----------------------------------------------------------------------------
 // Precomputed lighting data to send to the various lighting functions
 struct PreLightData
 {
+    // General
+
+    // GGX iso
-    // Aniso
+    // GGX Aniso
-
+    // IBL
     float3 iblDirWS;    // Dominant specular direction, used for IBL in EvaluateBSDF_Env()
     float  iblMipLevel;
 
 {
     PreLightData preLightData;
 
-    // We have handle the case of NdotV being negative in GetData() function with GetShiftedNdotV.
-    // So we don't need to saturate or take the abs here.
-    // In case a material use negative normal for double sided lighting like speedtree this will be handle in the GetData() code too.
-    preLightData.NdotV = dot(bsdfData.normalWS, V);
+    // General
+    float3 iblNormalWS = bsdfData.normalWS;
+    // GetShiftedNdotV return a positive NdotV
+    // In case a material use negative normal for double sided lighting like Speedtree  they need to do a new calculation
+    preLightData.NdotV = GetShiftedNdotV(iblNormalWS, V); // Handle artificat for specular lighting
+    // GGX iso
-    float  iblNdotV    = preLightData.NdotV;
-    float3 iblNormalWS = bsdfData.normalWS;
-
-    // Check if we precompute anisotropy too
+    // GGX aniso
     if (bsdfData.materialId == MATERIALID_LIT_ANISO)
     {
         preLightData.TdotV = dot(bsdfData.tangentWS, V);
-        iblNormalWS = GetAnisotropicModifiedNormal(bsdfData.bitangentWS, bsdfData.normalWS, V, bsdfData.anisotropy);
+        iblNormalWS = GetAnisotropicModifiedNormal(bsdfData.bitangentWS, iblNormalWS, V, bsdfData.anisotropy);
-        // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NDotV) and use iblNormalWS
+        // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NdotV) and use iblNormalWS
-    GetPreIntegratedFGD(iblNdotV, bsdfData.perceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD);
+    // IBL
+    GetPreIntegratedFGD(preLightData.NdotV, bsdfData.perceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD);
-
-    // Area light specific
+    // Area light
-    // Scale and bias for the current precomputed table - the constant use here are the one that have been use when the table in LtcData.DisneyDiffuse.cs and LtcData.GGX.cs was use
-    float2 uv = 0.0078125 + 0.984375 * float2(bsdfData.perceptualRoughness, theta * INV_HALF_PI);
+    float2 uv = LTC_LUT_OFFSET + LTC_LUT_SCALE * float2(bsdfData.perceptualRoughness, theta * INV_HALF_PI);
 
     // Get the inverse LTC matrix for GGX
     // Note we load the matrix transpose (avoid to have to transpose it in shader)
 // light transport functions
 //-----------------------------------------------------------------------------
 
-LighTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
+LightTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
-    LighTransportData lightTransportData;
+    LightTransportData lightTransportData;
 
     // diffuseColor for lightmapping should basically be diffuse color.
     // But rough metals (black diffuse) still scatter quite a lot of light around, so
     float NdotL    = saturate(dot(bsdfData.normalWS, L));
     float NdotV    = preLightData.NdotV;
     float LdotV    = dot(L, V);
-    float invLenLV = rsqrt(abs(2 + 2 * LdotV));    // invLenLV = rcp(length(L + V))
+    // GCN Optimization: reference PBR Diffuse Lighting for GGX + Smith Microsurfaces
+    float invLenLV = rsqrt(abs(2.0 * LdotV + 2.0));    // invLenLV = rcp(length(L + V))
-    float LdotH    = saturate(invLenLV + invLenLV * LdotV);
+    float LdotH    = saturate(invLenLV * LdotV + invLenLV);
 
     float3 F = F_Schlick(bsdfData.fresnel0, LdotH);
 
     diffuseLighting  = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
     float4 cookie    = float4(1.0, 1.0, 1.0, 1.0);
+    float  shadow    = 1;
-    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
+    [branch] if (lightData.shadowIndex >= 0)
-        float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
+        shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-        float shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
+        shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-
-    [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
+    [branch] if (lightData.cookieIndex >= 0)
     {
         float3 lightToSurface = positionWS - lightData.positionWS;
 
 
     [branch] if (bsdfData.enableTransmission)
     {
-        // Reverse the normal.
-        illuminance = saturate(dot(-bsdfData.normalWS, L));
+        // Reverse the normal + do some wrap lighting to have a nicer transition between regular lighting and transmittance
+        // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
+        const float w = 0.15;
+        float illuminance = saturate((dot(-bsdfData.normalWS, L) + w) / ((1.0 + w) * (1.0 + w)));
-        [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
-        {
-            // TODO: factor out the biased position?
-            float3 biasedPositionWS = positionWS + bsdfData.normalWS * bsdfData.thickness;
-#ifdef SHADOWS_USE_SHADOWCTXT
-            float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, biasedPositionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#else
-            float shadow = GetDirectionalShadowAttenuation(lightLoopContext, biasedPositionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#endif
+        // For low thickness, we can reuse the shadowing status for the back of the object.
+        shadow       = (bsdfData.thickness <= SSS_LOW_THICKNESS) ? shadow : 1;
+        illuminance *= shadow * cookie.a;
-            illuminance *= shadow;
-        }
-
-        illuminance *= cookie.a;
-
-        // The difference between the Disney Diffuse and the Lambertian BRDF for transmittance is negligible.
+        // The difference between the Disney Diffuse and the Lambertian BRDF for transmission is negligible.
         float3 backLight = (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale * Lambert());
         // TODO: multiplication by 'diffuseColor' and 'transmittance' is the same for each light.
         float3 transmittedLight = backLight * bsdfData.diffuseColor * bsdfData.transmittance;
     diffuseLighting  = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
     float4 cookie    = float4(1.0, 1.0, 1.0, 1.0);
+    float  shadow    = 1;
 
     // TODO: measure impact of having all these dynamic branch here and the gain (or not) of testing illuminace > 0
 
     //    illuminance *= SampleIES(lightLoopContext, lightData.IESIndex, sphericalCoord, 0).r;
     //}
 
-    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
+    [branch] if (lightData.shadowIndex >= 0)
-        float shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
+        shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
-        float shadow = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
+        shadow = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
 #endif
         shadow = lerp(1.0, shadow, lightData.shadowDimmer);
 
-    [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
+    [branch] if (lightData.cookieIndex >= 0)
     {
         float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
 
 
     [branch] if (bsdfData.enableTransmission)
     {
-        // Reverse the normal.
-        illuminance = saturate(dot(-bsdfData.normalWS, L)) * attenuation;
-
-        [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
-        {
-            // TODO: factor out the common biased position?
-            float3 biasedPositionWS = positionWS + bsdfData.normalWS * bsdfData.thickness;
-            float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
-#ifdef SHADOWS_USE_SHADOWCTXT
-            float shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, biasedPositionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
-#else
-            float shadow = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, biasedPositionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
-#endif
-            shadow = lerp(1.0, shadow, lightData.shadowDimmer);
-
-            illuminance *= shadow;
-        }
+        // Reverse the normal + do some wrap lighting to have a nicer transition between regular lighting and transmittance
+        // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
+        const float w = 0.15;
+        float illuminance = saturate((dot(-bsdfData.normalWS, L) + w) / ((1.0 + w) * (1.0 + w)));
+        illuminance *= attenuation;
-        illuminance *= cookie.a;
+        // For low thickness, we can reuse the shadowing status for the back of the object.
+        shadow       = (bsdfData.thickness <= SSS_LOW_THICKNESS) ? shadow : 1;
+        illuminance *= shadow * cookie.a;
-        // The difference between the Disney Diffuse and the Lambertian BRDF for transmittance is negligible.
+        // The difference between the Disney Diffuse and the Lambertian BRDF for transmission is negligible.
         float3 backLight = (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale * Lambert());
         // TODO: multiplication by 'diffuseColor' and 'transmittance' is the same for each light.
         float3 transmittedLight = backLight * bsdfData.diffuseColor * bsdfData.transmittance;
     diffuseLighting  = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
     float4 cookie    = float4(1.0, 1.0, 1.0, 1.0);
+    float shadow = 1;
-    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
+    [branch] if (lightData.shadowIndex >= 0)
-        float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
+        shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-        float shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
+        shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-
-    [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
+    [branch] if (lightData.cookieIndex >= 0)
     {
         // Compute the texture coordinates in [0, 1]^2.
         float2 coord = positionNDC * 0.5 + 0.5;
 
     [branch] if (bsdfData.enableTransmission)
     {
-        // Reverse the normal.
-        illuminance = saturate(dot(-bsdfData.normalWS, L));
+        // Reverse the normal + do some wrap lighting to have a nicer transition between regular lighting and transmittance
+        // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
+        const float w = 0.15;
+        float illuminance = saturate((dot(-bsdfData.normalWS, L) + w) / ((1.0 + w) * (1.0 + w)));
+        illuminance *= clipFactor;
-        [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
-        {
-            // TODO: factor out the biased position?
-            float3 biasedPositionWS = positionWS + bsdfData.normalWS * bsdfData.thickness;
-#ifdef SHADOWS_USE_SHADOWCTXT
-            float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, biasedPositionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#else
-            float shadow = GetDirectionalShadowAttenuation(lightLoopContext, biasedPositionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#endif
+        // For low thickness, we can reuse the shadowing status for the back of the object.
+        shadow       = (bsdfData.thickness <= SSS_LOW_THICKNESS) ? shadow : 1;
+        illuminance *= shadow * cookie.a;
-            illuminance *= shadow;
-        }
-
-        illuminance *= cookie.a;
-
-        // The difference between the Disney Diffuse and the Lambertian BRDF for transmittance is negligible.
+        // The difference between the Disney Diffuse and the Lambertian BRDF for transmission is negligible.
         float3 backLight = (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale * Lambert());
         // TODO: multiplication by 'diffuseColor' and 'transmittance' is the same for each light.
         float3 transmittedLight = backLight * bsdfData.diffuseColor * bsdfData.transmittance;
         float3 L = normalize(unL);
 
         // Cosine of the angle between the light direction and the normal of the light's surface.
-        float cosLNs = dot(-L, Ns);
-        cosLNs = lightData.twoSided ? abs(cosLNs) : saturate(cosLNs);
+        float cosLNs = saturate(dot(-L, Ns));
 
         // We calculate area reference light with the area integral rather than the solid angle one.
         float illuminance = cosLNs * saturate(dot(bsdfData.normalWS, L)) / (sqrDist * lightPdf);
     diffuseLighting  = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
 
-    // TODO: This could be precomputed.
-    float halfWidth  = lightData.size.x * 0.5;
-    float halfHeight = lightData.size.y * 0.5;
+    float3 unL = lightData.positionWS - positionWS;
-    float3 unL = lightData.positionWS - positionWS;
+    [branch]
+    if (dot(lightData.forward, unL) >= 0)
+    {
+        // The light is back-facing.
+        return;
+    }
+    // TODO: This could be precomputed.
+    float halfWidth  = lightData.size.x * 0.5;
+    float halfHeight = lightData.size.y * 0.5;
+
     // Define the dimensions of the attenuation volume.
     // TODO: This could be precomputed.
     float  radius     = rsqrt(lightData.invSqrAttenuationRadius);
     // Evaluate the diffuse part.
     {
     #ifdef LIT_DIFFUSE_LAMBERT_BRDF
-        ltcValue = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
-                               k_identity3x3);
+        ltcValue = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, k_identity3x3);
-        ltcValue = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
-                               preLightData.ltcXformDisneyDiffuse);
+        ltcValue = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, preLightData.ltcXformDisneyDiffuse);
     #endif
 
         if (ltcValue == 0.0)
         float3 fresnelTerm = bsdfData.fresnel0 * preLightData.ltcGGXFresnelMagnitudeDiff
                            + (float3)preLightData.ltcGGXFresnelMagnitude;
 
-        ltcValue  = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
-                                preLightData.ltcXformGGX);
+        ltcValue  = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, preLightData.ltcXformGGX);
         ltcValue *= lightData.specularScale;
         specularLighting = fresnelTerm * lightData.color * ltcValue;
     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 
         _SubsurfaceProfile("Subsurface Profile", Int) = 0
-        _SubsurfaceRadius("Subsurface Radius", Range(0.004, 1.0)) = 1.0
+        _SubsurfaceRadius("Subsurface Radius", Range(0.0, 1.0)) = 1.0
-        _Thickness("Thickness", Range(0.004, 1.0)) = 1.0
+        _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
         // Wind
 
         Pass
         {
-            Name "GBufferDebugLighting"  // Name is not used
-            Tags{ "LightMode" = "GBufferDebugLighting" } // This will be only for opaque object based on the RenderQueue index
+            Name "GBufferDebugDisplay"  // Name is not used
+            Tags{ "LightMode" = "GBufferDebugDisplay" } // This will be only for opaque object based on the RenderQueue index
 
             Cull [_CullMode]
 
 
             HLSLPROGRAM
 
-            #define LIGHTING_DEBUG
+            #define DEBUG_DISPLAY
-            #include "../../Debug/HDRenderPipelineDebug.cs.hlsl"
-            #include "../../Debug/DebugLighting.hlsl"
+            #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
         }
 
-        Pass
-        {
-            Name "Debug"
-            Tags { "LightMode" = "DebugViewMaterial" }
-
-            Cull[_CullMode]
-
-            HLSLPROGRAM
-
-            #define SHADERPASS SHADERPASS_DEBUG_VIEW_MATERIAL
-            #include "../../Material/Material.hlsl"
-            #include "ShaderPass/LitSharePass.hlsl"
-            #include "LitData.hlsl"
-            #include "../../ShaderPass/ShaderPassDebugViewMaterial.hlsl"
-
-            ENDHLSL
-        }
-
         // Extracts information for lightmapping, GI (emission, albedo, ...)
         // This pass it not used during regular rendering.
         Pass
 
         Pass
         {
-            Name "ForwardDebugLighting" // Name is not used
-            Tags{ "LightMode" = "ForwardDebugLighting" } // This will be only for transparent object based on the RenderQueue index
+            Name "ForwardDisplayDebug" // Name is not used
+            Tags{ "LightMode" = "ForwardDisplayDebug" } // This will be only for transparent object based on the RenderQueue index
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]
 
-            #define LIGHTING_DEBUG
+            #define DEBUG_DISPLAY
+            #include "../../Debug/DebugDisplay.hlsl"
-            #include "../../Debug/HDRenderPipelineDebug.cs.hlsl"
-            #include "../../Debug/DebugLighting.hlsl"
-
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl

 #endif
     surfaceData.normalWS = float3(0.0, 0.0, 0.0); // Need to init this to keep quiet the compiler, but this is overriden later (0, 0, 0) so if we forget to override the compiler may comply.
 
-    // TODO: think about using BC5
     normalTS = ADD_IDX(GetNormalTS)(input, layerTexCoord, detailNormalTS, detailMask, false, 0.0);
 
 #if defined(_MASKMAP_IDX)
 
     surfaceData.materialId = (_EnableSSS || _MaterialID != MATERIALID_LIT_SSS) ? _MaterialID : MATERIALID_LIT_STANDARD;
 
-    // TODO: think about using BC5
 #ifdef _TANGENTMAP
     #ifdef _NORMALMAP_TANGENT_SPACE_IDX // Normal and tangent use same space
     float3 tangentTS = SAMPLE_UVMAPPING_NORMALMAP(_TangentMap, sampler_TangentMap, layerTexCoord.base, 1.0);
     surfaceData.specular = 0.04;
 
     surfaceData.subsurfaceProfile = _SubsurfaceProfile;
+    surfaceData.subsurfaceRadius  = _SubsurfaceRadius;
+    surfaceData.thickness         = _Thickness;
+
-    surfaceData.subsurfaceRadius = SAMPLE_UVMAPPING_TEXTURE2D(_SubsurfaceRadiusMap, sampler_SubsurfaceRadiusMap, layerTexCoord.base).r * _SubsurfaceRadius;
-#else
-    surfaceData.subsurfaceRadius = _SubsurfaceRadius;
+    surfaceData.subsurfaceRadius *= SAMPLE_UVMAPPING_TEXTURE2D(_SubsurfaceRadiusMap, sampler_SubsurfaceRadiusMap, layerTexCoord.base).r;
-    surfaceData.thickness = SAMPLE_UVMAPPING_TEXTURE2D(_ThicknessMap, sampler_ThicknessMap, layerTexCoord.base).r;
-#else
-    surfaceData.thickness = _Thickness;
+    surfaceData.thickness *= SAMPLE_UVMAPPING_TEXTURE2D(_ThicknessMap, sampler_ThicknessMap, layerTexCoord.base).r;
 #endif
 
     surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitProperties.hlsl

+CBUFFER_START(_PerMaterial)
+
 // shared constant between lit and layered lit
 float _AlphaCutoff;
 float4 _DoubleSidedConstants;
 float3 _EmissionColor;
 
 // Wind
-float _InitialBend; 
+float _InitialBend;
 float _Stiffness;
 float _Drag;
 float _ShiverDrag;
 float _TessellationObjectScale;
 float _TessellationTilingScale;
 #endif
+
+CBUFFER_END

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 
         _SubsurfaceProfile("Subsurface Profile", Int) = 0
-        _SubsurfaceRadius("Subsurface Radius", Range(0.004, 1.0)) = 1.0
+        _SubsurfaceRadius("Subsurface Radius", Range(0.0, 1.0)) = 1.0
-        _Thickness("Thickness", Range(0.004, 1.0)) = 1.0
+        _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
         // Wind
 
         Pass
         {
-            Name "GBufferDebugLighting"  // Name is not used
-            Tags{ "LightMode" = "GBufferDebugLighting" } // This will be only for opaque object based on the RenderQueue index
+            Name "GBufferDebugDisplay"  // Name is not used
+            Tags{ "LightMode" = "GBufferDebugDisplay" } // This will be only for opaque object based on the RenderQueue index
 
             Cull [_CullMode]
 
             #pragma hull Hull
             #pragma domain Domain
 
-            #define LIGHTING_DEBUG
+            #define DEBUG_DISPLAY
-            #include "../../Debug/HDRenderPipelineDebug.cs.hlsl"
-            #include "../../Debug/DebugLighting.hlsl"
+            #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
         }
 
-        Pass
-        {
-            Name "Debug"
-            Tags { "LightMode" = "DebugViewMaterial" }
-
-            Cull[_CullMode]
-
-            HLSLPROGRAM
-
-            #pragma hull Hull
-            #pragma domain Domain
-
-            #define SHADERPASS SHADERPASS_DEBUG_VIEW_MATERIAL
-            #include "../../Material/Material.hlsl"
-            #include "ShaderPass/LitSharePass.hlsl"
-            #include "LitData.hlsl"
-            #include "../../ShaderPass/ShaderPassDebugViewMaterial.hlsl"
-
-            ENDHLSL
-        }
-
         // Extracts information for lightmapping, GI (emission, albedo, ...)
         // This pass it not used during regular rendering.
         Pass
 
         Pass
         {
-            Name "ForwardDebugLighting" // Name is not used
-            Tags{ "LightMode" = "ForwardDebugLighting" } // This will be only for transparent object based on the RenderQueue index
+            Name "ForwardDisplayDebug" // Name is not used
+            Tags{ "LightMode" = "ForwardDisplayDebug" } // This will be only for transparent object based on the RenderQueue index
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]
             #pragma hull Hull
             #pragma domain Domain
 
-            #define LIGHTING_DEBUG
+            #define DEBUG_DISPLAY
+            #include "../../Debug/DebugDisplay.hlsl"
-            #include "../../Debug/HDRenderPipelineDebug.cs.hlsl"
-            #include "../../Debug/DebugLighting.hlsl"
-
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/CombineSubsurfaceScattering.shader

                     float zDistance   = invDistScale * sampleDepth - (invDistScale * centerPosVS.z);
                     sampleWeight     *= exp(-zDistance * zDistance * halfRcpVariance);
 
+                    if (any(sampleIrradiance) == false)
+                    {
+                        // The irradiance is 0. This could happen for 2 reasons.
+                        // Most likely, the surface fragment does not have an SSS material.
+                        // Alternatively, the surface fragment could be completely shadowed.
+                        // Our blur is energy-preserving, so 'sampleWeight' should be set to 0.
+                        // We do not terminate the loop since we want to gather the contribution
+                        // of the remaining samples (e.g. in case of hair covering skin).
+                        continue;
+                    }
+
                     totalIrradiance += sampleWeight * sampleIrradiance;
                     totalWeight     += sampleWeight;
                 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitSharePass.hlsl

 #define ATTRIBUTES_NEED_TEXCOORD1
 #define ATTRIBUTES_NEED_COLOR
 
-#if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3) || defined(DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+#if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3) || defined(DYNAMICLIGHTMAP_ON) || defined(DEBUG_DISPLAY)
-#if defined(_REQUIRE_UV3) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+#if defined(_REQUIRE_UV3) || defined(DEBUG_DISPLAY)
 #define ATTRIBUTES_NEED_TEXCOORD3
 #endif
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringProfile.cs

         public float         lerpWeight;
         public TexturingMode texturingMode;
         public bool          enableTransmission;
+        public Color         tintColor;
         public Vector2       thicknessRemap;
         [HideInInspector]
         public int           settingsIndex;
             lerpWeight         = 0.5f;
             texturingMode      = TexturingMode.PreAndPostScatter;
             enableTransmission = false;
+            tintColor          = Color.white;
             thicknessRemap     = new Vector2(0, 1);
             settingsIndex      = SubsurfaceScatteringSettings.neutralProfileID; // Updated by SubsurfaceScatteringSettings.OnValidate() once assigned
 
 
             Vector3 weightSum = new Vector3(0, 0, 0);
 
+            float rcpNumSamples = 1.0f / numSamples;
+
-                float u   = (i + 0.5f) / numSamples;
+                float u = (i <= numSamples / 2) ? 0.5f - i * rcpNumSamples    // The center and to the left
+                                                : (i + 0.5f) * rcpNumSamples; // From the center to the right
+
                 float pos = GaussianCombinationCdfInverse(u, maxStdDev1, maxStdDev2, lerpWeight);
                 float pdf = GaussianCombination(pos, maxStdDev1, maxStdDev2, lerpWeight);
 
     public class SubsurfaceScatteringSettings : ISerializationCallbackReceiver
     {
         public const int maxNumProfiles   = 8;
-        public const int neutralProfileID = 7;
+        public const int neutralProfileID = maxNumProfiles - 1;
 
         public int                           numProfiles;
         public SubsurfaceScatteringProfile[] profiles;
+        [NonSerialized] public Vector4[]     tintColors;         // For transmission; alpha is unused
         [NonSerialized] public float[]       thicknessRemaps;
         [NonSerialized] public Vector4[]     halfRcpVariancesAndLerpWeights;
         [NonSerialized] public Vector4[]     halfRcpWeightedVariances;
             profiles[0]                    = null;
             texturingModeFlags             = 0;
             transmissionFlags              = 0;
+            tintColors                     = null;
             thicknessRemaps                = null;
             halfRcpVariancesAndLerpWeights = null;
             halfRcpWeightedVariances       = null;
 
                 profiles[i].lerpWeight = Mathf.Clamp01(profiles[i].lerpWeight);
 
+                profiles[i].tintColor.r = Mathf.Clamp01(profiles[i].tintColor.r);
+                profiles[i].tintColor.g = Mathf.Clamp01(profiles[i].tintColor.g);
+                profiles[i].tintColor.b = Mathf.Clamp01(profiles[i].tintColor.b);
+                profiles[i].tintColor.a = 1.0f;
+
                 profiles[i].thicknessRemap.x = Mathf.Clamp(profiles[i].thicknessRemap.x, 0, profiles[i].thicknessRemap.y);
                 profiles[i].thicknessRemap.y = Mathf.Max(profiles[i].thicknessRemap.x, profiles[i].thicknessRemap.y);
 
         {
             texturingModeFlags = 0;
             transmissionFlags  = 0;
+
+            if (tintColors == null || tintColors.Length != maxNumProfiles)
+            {
+                tintColors = new Vector4[maxNumProfiles];
+            }
 
             if (thicknessRemaps == null || thicknessRemaps.Length != (maxNumProfiles * 2))
             {
                 texturingModeFlags |= ((int)profiles[i].texturingMode) << i;
                 transmissionFlags  |= (profiles[i].enableTransmission ? 1 : 0) << i;
 
+                tintColors[i]                               = profiles[i].tintColor;
                 thicknessRemaps[2 * i]                      = profiles[i].thicknessRemap.x;
                 thicknessRemaps[2 * i + 1]                  = profiles[i].thicknessRemap.y - profiles[i].thicknessRemap.x;
                 halfRcpVariancesAndLerpWeights[2 * i]       = profiles[i].halfRcpVariances[0];
     {
         private class Styles
         {
-            public readonly GUIContent   sssProfilePreview0       = new GUIContent("Profile preview");
-            public readonly GUIContent   sssProfilePreview1       = new GUIContent("Shows the fraction of light scattered from the source as radius increases to 1.");
-            public readonly GUIContent   sssProfilePreview2       = new GUIContent("Note that the intensity of the region in the center may be clamped.");
-            public readonly GUIContent   sssTransmittancePreview0 = new GUIContent("Transmittance preview");
-            public readonly GUIContent   sssTransmittancePreview1 = new GUIContent("Shows the fraction of light passing through the object as thickness increases to 1.");
-            public readonly GUIContent   sssProfileStdDev1        = new GUIContent("Standard deviation #1", "Determines the shape of the 1st Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
-            public readonly GUIContent   sssProfileStdDev2        = new GUIContent("Standard deviation #2", "Determines the shape of the 2nd Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
-            public readonly GUIContent   sssProfileLerpWeight     = new GUIContent("Filter interpolation", "Controls linear interpolation between the two Gaussian filters.");
-            public readonly GUIContent   sssTexturingMode         = new GUIContent("Texturing mode", "Specifies when the diffuse texture should be applied.");
-            public readonly GUIContent[] sssTexturingModeOptions  = new GUIContent[2]
+            public readonly GUIContent   sssProfilePreview0        = new GUIContent("Profile Preview");
+            public readonly GUIContent   sssProfilePreview1        = new GUIContent("Shows the fraction of light scattered from the source as radius increases to 1.");
+            public readonly GUIContent   sssProfilePreview2        = new GUIContent("Note that the intensity of the region in the center may be clamped.");
+            public readonly GUIContent   sssTransmittancePreview0  = new GUIContent("Transmittance Preview");
+            public readonly GUIContent   sssTransmittancePreview1  = new GUIContent("Shows the fraction of light passing through the object as thickness increases to 1.");
+            public readonly GUIContent   sssProfileStdDev1         = new GUIContent("Standard Deviation #1", "Determines the shape of the 1st Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
+            public readonly GUIContent   sssProfileStdDev2         = new GUIContent("Standard Deviation #2", "Determines the shape of the 2nd Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
+            public readonly GUIContent   sssProfileLerpWeight      = new GUIContent("Filter Interpolation", "Controls linear interpolation between the two Gaussian filters.");
+            public readonly GUIContent   sssTexturingMode          = new GUIContent("Texturing Mode", "Specifies when the diffuse texture should be applied.");
+            public readonly GUIContent[] sssTexturingModeOptions   = new GUIContent[2]
-            public readonly GUIContent   sssProfileTransmission   = new GUIContent("Enable transmission", "Toggles simulation of light passing through thin objects. Depends on the thickness of the material.");
-            public readonly GUIContent   sssProfileThicknessRemap = new GUIContent("Thickness remap", "Remaps the thickness parameter from [0, 1] to the desired range.");
+            public readonly GUIContent   sssProfileTransmission    = new GUIContent("Enable Transmission", "Toggles simulation of light passing through thin objects. Depends on the thickness of the material.");
+            public readonly GUIContent   sssProfileTintColor       = new GUIContent("Transmission Tint Color", "Tints transmitted light.");
+            public readonly GUIContent   sssProfileMinMaxThickness = new GUIContent("Min-Max Thickness", "Shows the values of the thickness remap below.");
+            public readonly GUIContent   sssProfileThicknessRemap  = new GUIContent("Thickness Remap", "Remaps the thickness parameter from [0, 1] to the desired range.");
-            public readonly GUIStyle     centeredMiniBoldLabel    = new GUIStyle(GUI.skin.label);
+            public readonly GUIStyle     centeredMiniBoldLabel     = new GUIStyle(GUI.skin.label);
 
             public Styles()
             {
 
         private RenderTexture      m_ProfileImage, m_TransmittanceImage;
         private Material           m_ProfileMaterial, m_TransmittanceMaterial;
-        private SerializedProperty m_StdDev1, m_StdDev2, m_LerpWeight,
+        private SerializedProperty m_StdDev1, m_StdDev2, m_LerpWeight, m_TintColor,
                                    m_TexturingMode, m_Transmission, m_ThicknessRemap;
 
         void OnEnable()
             m_LerpWeight     = serializedObject.FindProperty("lerpWeight");
             m_TexturingMode  = serializedObject.FindProperty("texturingMode");
             m_Transmission   = serializedObject.FindProperty("enableTransmission");
+            m_TintColor      = serializedObject.FindProperty("tintColor");
             m_ThicknessRemap = serializedObject.FindProperty("thicknessRemap");
 
             m_ProfileMaterial       = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawGaussianProfile");
                 EditorGUILayout.PropertyField(m_LerpWeight,   styles.sssProfileLerpWeight);
                 m_TexturingMode.intValue = EditorGUILayout.Popup(styles.sssTexturingMode, m_TexturingMode.intValue, styles.sssTexturingModeOptions);
                 EditorGUILayout.PropertyField(m_Transmission, styles.sssProfileTransmission);
+                EditorGUILayout.PropertyField(m_TintColor,    styles.sssProfileTintColor);
+                EditorGUILayout.PropertyField(m_ThicknessRemap, styles.sssProfileMinMaxThickness);
-                EditorGUILayout.LabelField("Min thickness: ", thicknessRemap.x.ToString());
-                EditorGUILayout.LabelField("Max thickness: ", thicknessRemap.y.ToString());
                 EditorGUILayout.MinMaxSlider(styles.sssProfileThicknessRemap, ref thicknessRemap.x, ref thicknessRemap.y, 0, 10);
                 m_ThicknessRemap.vector2Value = thicknessRemap;
 
             m_TransmittanceMaterial.SetColor("_StdDev2",         m_StdDev2.colorValue);
             m_TransmittanceMaterial.SetFloat("_LerpWeight",      m_LerpWeight.floatValue);
             m_TransmittanceMaterial.SetVector("_ThicknessRemap", m_ThicknessRemap.vector2Value);
+            m_TransmittanceMaterial.SetVector("_TintColor",      m_TintColor.colorValue);
             EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(16, 16), m_TransmittanceImage, m_TransmittanceMaterial, ScaleMode.ScaleToFit, 16.0f);
 
             serializedObject.ApplyModifiedProperties();

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/MaterialUtilities.hlsl

 }
 
 // This function convert the tangent space normal/tangent to world space and orthonormalize it + apply a correction of the normal if it is not pointing towards the near plane
-void GetNormalAndTangentWS(FragInputs input, float3 V, float3 normalTS, inout float3 normalWS, inout float3 tangentWS, bool wantNegativeNormal = false)
+void GetNormalAndTangentWS(FragInputs input, float3 V, float3 normalTS, inout float3 normalWS, inout float3 tangentWS)
 {
     #ifdef SURFACE_GRADIENT
     normalWS = SurfaceGradientResolveNormal(input.worldToTangent[2], normalTS);
-
-    GetShiftedNdotV(normalWS, V, wantNegativeNormal);
 
     // Orthonormalize the basis vectors using the Gram-Schmidt process.
     // We assume that the length of the surface normal is sufficiently close to 1.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs

             alphaCutoff = FindProperty(kAlphaCutoff, props);
             doubleSidedEnable = FindProperty(kDoubleSidedEnable, props);
             blendMode = FindProperty(kBlendMode, props);
-            distortionEnable = FindProperty(kDistortionEnable, props);
-            distortionOnly = FindProperty(kDistortionOnly, props);
-            distortionDepthTest = FindProperty(kDistortionDepthTest, props);
+            distortionEnable = FindProperty(kDistortionEnable, props, false);
+            distortionOnly = FindProperty(kDistortionOnly, props, false);
+            distortionDepthTest = FindProperty(kDistortionDepthTest, props, false);
         }
 
         void SurfaceTypePopup()
             if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
             {
                 BlendModePopup();
-                m_MaterialEditor.ShaderProperty(distortionEnable, StylesBaseUnlit.distortionEnableText);
-                if (distortionEnable.floatValue == 1.0f)
+                if (distortionEnable != null)
-                    m_MaterialEditor.ShaderProperty(distortionOnly, StylesBaseUnlit.distortionOnlyText);
-                    m_MaterialEditor.ShaderProperty(distortionDepthTest, StylesBaseUnlit.distortionDepthTestText);
+                    m_MaterialEditor.ShaderProperty(distortionEnable, StylesBaseUnlit.distortionEnableText);
+
+                    if (distortionEnable.floatValue == 1.0f)
+                    {
+                        m_MaterialEditor.ShaderProperty(distortionOnly, StylesBaseUnlit.distortionOnlyText);
+                        m_MaterialEditor.ShaderProperty(distortionDepthTest, StylesBaseUnlit.distortionDepthTestText);
+                    }
                 }
             }
             m_MaterialEditor.ShaderProperty(alphaCutoffEnable, StylesBaseUnlit.alphaCutoffEnableText);
             SetKeyword(material, "_DOUBLESIDED_ON", doubleSidedEnable);
             SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
 
-            bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
-            if (distortionEnable)
+            if (material.HasProperty(kDistortionEnable))
-                material.SetShaderPassEnabled("DistortionVectors", true);
-            }
-            else
-            {
-                material.SetShaderPassEnabled("DistortionVectors", false);
-            }
+                bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
+                if (distortionEnable)
+                {
+                    material.SetShaderPassEnabled("DistortionVectors", true);
+                }
+                else
+                {
+                    material.SetShaderPassEnabled("DistortionVectors", false);
+                }
-            bool distortionDepthTest = material.GetFloat(kDistortionDepthTest) > 0.0f;
-            if (distortionDepthTest)
-            {
-                material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.LessEqual);
-            }
-            else
-            {
-                material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.Always);
-            }
+                bool distortionDepthTest = material.GetFloat(kDistortionDepthTest) > 0.0f;
+                if (distortionDepthTest)
+                {
+                    material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.LessEqual);
+                }
+                else
+                {
+                    material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.Always);
+                }
-            SetKeyword(material, "_DISTORTION_ON", distortionEnable);
+                SetKeyword(material, "_DISTORTION_ON", distortionEnable);
+            }
 
             // A material's GI flag internally keeps track of whether emission is enabled at all, it's enabled but has no effect
             // or is enabled and may be modified at runtime. This state depends on the values of the current flag and emissive color.
 
         static public void SetupBaseUnlitMaterialPass(Material material)
         {
-            bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
-            bool distortionOnly = material.GetFloat(kDistortionOnly) > 0.0f;
+            if (material.HasProperty(kDistortionEnable))
+            {
+                bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
+                bool distortionOnly = material.GetFloat(kDistortionOnly) > 0.0f;
-            if (distortionEnable && distortionOnly)
-            {
-                // Disable all passes except debug material
-                material.SetShaderPassEnabled("GBuffer", false);
-                material.SetShaderPassEnabled("DebugViewMaterial", true);
-                material.SetShaderPassEnabled("Meta", false);
-                material.SetShaderPassEnabled("ShadowCaster", false);
-                material.SetShaderPassEnabled("DepthOnly", false);
-                material.SetShaderPassEnabled("MotionVectors", false);
-                material.SetShaderPassEnabled("Forward", false);
-            }
-            else
-            {
-                material.SetShaderPassEnabled("GBuffer", true);
-                material.SetShaderPassEnabled("DebugViewMaterial", true);
-                material.SetShaderPassEnabled("Meta", true);
-                material.SetShaderPassEnabled("ShadowCaster", true);
-                material.SetShaderPassEnabled("DepthOnly", true);
-                material.SetShaderPassEnabled("MotionVectors", true);
-                material.SetShaderPassEnabled("Forward", true);
+                if (distortionEnable && distortionOnly)
+                {
+                    // Disable all passes except debug material
+                    material.SetShaderPassEnabled("GBuffer", false);
+                    material.SetShaderPassEnabled("DebugViewMaterial", true);
+                    material.SetShaderPassEnabled("Meta", false);
+                    material.SetShaderPassEnabled("ShadowCaster", false);
+                    material.SetShaderPassEnabled("DepthOnly", false);
+                    material.SetShaderPassEnabled("MotionVectors", false);
+                    material.SetShaderPassEnabled("Forward", false);
+                }
+                else
+                {
+                    material.SetShaderPassEnabled("GBuffer", true);
+                    material.SetShaderPassEnabled("DebugViewMaterial", true);
+                    material.SetShaderPassEnabled("Meta", true);
+                    material.SetShaderPassEnabled("ShadowCaster", true);
+                    material.SetShaderPassEnabled("DepthOnly", true);
+                    material.SetShaderPassEnabled("MotionVectors", true);
+                    material.SetShaderPassEnabled("Forward", true);
+                }
             }
         }
 
                 EditorGUILayout.Space();
 
                 VertexAnimationPropertiesGUI();
-                
+
                 EditorGUILayout.Space();
                 MaterialPropertiesGUI(material);
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.cs

         [GenerateHLSL(PackingRules.Exact, false, true, 1100)]
         public struct SurfaceData
         {
-            [SurfaceDataAttributes("Color")]
+            [SurfaceDataAttributes("Color", false, true)]
             public Vector3 color;
         };
 
         [GenerateHLSL(PackingRules.Exact, false, true, 1130)]
         public struct BSDFData
         {
+            [SurfaceDataAttributes("", false, true)]
             public Vector3 color;
         };
     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.cs.hlsl

     float3 color;
 };
 
+//
+// Debug functions
+//
+void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_UNLIT_SURFACEDATA_COLOR:
+            result = surfacedata.color;
+            needLinearToSRGB = true;
+            break;
+    }
+}
+
+//
+// Debug functions
+//
+void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_UNLIT_BSDFDATA_COLOR:
+            result = bsdfdata.color;
+            needLinearToSRGB = true;
+            break;
+    }
+}
+
 
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.hlsl

 }
 
 //-----------------------------------------------------------------------------
-// No light evaluation, this is unlit
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-    switch (paramId)
-    {
-    case DEBUGVIEW_UNLIT_SURFACEDATA_COLOR:
-        result = surfaceData.color; needLinearToSRGB = true;
-        break;
-    }
+    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB);
-    switch (paramId)
-    {
-    case DEBUGVIEW_UNLIT_SURFACEDATA_COLOR:
-        result = bsdfData.color; needLinearToSRGB = true;
-        break;
-    }
+    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB);
-LighTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
+//-----------------------------------------------------------------------------
+// No light evaluation, this is unlit
+//-----------------------------------------------------------------------------
+
+LightTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
-    LighTransportData lightTransportData;
+    LightTransportData lightTransportData;
 
     lightTransportData.diffuseColor = float3(0.0, 0.0, 0.0);
     lightTransportData.emissiveColor = builtinData.emissiveColor;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader

         Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
         LOD 300
 
-        Pass
-        {
-            Name "Debug"
-            Tags { "LightMode" = "DebugViewMaterial" }
-
-            Cull[_CullMode]
-
-            HLSLPROGRAM
-
-            #define SHADERPASS SHADERPASS_DEBUG_VIEW_MATERIAL
-            #include "../../Material/Material.hlsl"
-            #include "ShaderPass/UnlitSharePass.hlsl"
-            #include "UnlitData.hlsl"
-            #include "../../ShaderPass/ShaderPassDebugViewMaterial.hlsl"
-
-            ENDHLSL
-        }
-
         // Extracts information for lightmapping, GI (emission, albedo, ...)
         // This pass it not used during regular rendering.
         Pass
             ENDHLSL
         }
 
+        Pass
+        {
+            Name "ForwardUnlit"
+            Tags { "LightMode" = "ForwardDisplayDebug" }
+
+            Blend [_SrcBlend] [_DstBlend]
+            ZWrite [_ZWrite]
+            Cull [_CullMode]
+
+            HLSLPROGRAM
+
+            #define DEBUG_DISPLAY
+            #define SHADERPASS SHADERPASS_FORWARD_UNLIT
+            #include "../../Debug/DebugDisplay.hlsl"
+            #include "../../Material/Material.hlsl"
+            #include "ShaderPass/UnlitSharePass.hlsl"
+            #include "UnlitData.hlsl"
+            #include "../../ShaderPass/ShaderPassForwardUnlit.hlsl"
+
+            ENDHLSL
+        }
+
         // Unlit opaque material need to be render with ForwardOnlyOpaque. Unlike Lit that can be both deferred and forward,
         // unlit require to be forward only, that's why we need this pass. Unlit transparent will use regular Forward pass
         // (Code is exactly the same as "Forward", it simply allow our system to filter objects correctly)
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_FORWARD_UNLIT
+            #include "../../Material/Material.hlsl"
+            #include "ShaderPass/UnlitSharePass.hlsl"
+            #include "UnlitData.hlsl"
+            #include "../../ShaderPass/ShaderPassForwardUnlit.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "ForwardUnlit"
+            Tags { "LightMode" = "ForwardOnlyOpaqueDisplayDebug" }
+
+            Blend [_SrcBlend] [_DstBlend]
+            ZWrite [_ZWrite]
+            Cull [_CullMode]
+
+            HLSLPROGRAM
+
+            #define SHADERPASS SHADERPASS_FORWARD_UNLIT
+            #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/UnlitSharePass.hlsl"
             #include "UnlitData.hlsl"

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawTransmittanceGraph.shader

         [HideInInspector] _StdDev2("", Color) = (0, 0, 0)
         [HideInInspector] _LerpWeight("", Float) = 0
         [HideInInspector] _ThicknessScale("", Float) = 0
+        [HideInInspector] _TintColor("", Color) = (0, 0, 0)
     }
 
     SubShader
             // Inputs & outputs
             //-------------------------------------------------------------------------------------
 
-            float4 _StdDev1, _StdDev2, _ThicknessRemap;
+            float4 _StdDev1, _StdDev2, _ThicknessRemap, _TintColor;
             float _LerpWeight; // See 'SubsurfaceScatteringParameters'
 
             //-------------------------------------------------------------------------------------
                 float3 transmittance = lerp(exp(-t2 * 0.5 * rcp(var1)),
                                             exp(-t2 * 0.5 * rcp(var2)), _LerpWeight);
 
-                return float4(transmittance, 1);
+                return float4(transmittance * _TintColor.rgb, 1);
             }
             ENDHLSL
         }

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/SceneSettings.cs

             get { return m_SkySettings; }
         }
 
-        [SerializeField] private CommonSettings m_CommonSettings;
-        [SerializeField] private SkySettings    m_SkySettings;
+        [SerializeField] private CommonSettings m_CommonSettings = null;
+        [SerializeField] private SkySettings    m_SkySettings = null;
 
         // Use this for initialization
         void OnEnable()

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/FragInputs.hlsl

 // This structure gather all possible varying/interpolator for this shader.
 //-------------------------------------------------------------------------------------
 
-#include "../Debug/DebugViewMaterial.cs.hlsl"
+#include "../Debug/DebugDisplay.cs.hlsl"
 
 struct FragInputs
 {

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPass.cs

         DepthOnly,
         Velocity,
         Distortion,
-        LightTransport,
-        DebugViewMaterial
+        LightTransport
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPass.cs.hlsl

 #define SHADERPASS_VELOCITY (4)
 #define SHADERPASS_DISTORTION (5)
 #define SHADERPASS_LIGHT_TRANSPORT (6)
-#define SHADERPASS_DEBUG_VIEW_MATERIAL (7)
 
 
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassForward.hlsl

 #ifdef _DEPTHOFFSET_ON
     outputDepth = posInput.depthRaw;
 #endif
+
+#ifdef DEBUG_DISPLAY
+    if (_DebugDisplayMode == DEBUGDISPLAYMODE_VIEW_MATERIAL)
+    {
+        float3 result = float3(1.0, 0.0, 1.0);
+        bool needLinearToSRGB = false;
+
+        GetVaryingsDataDebug(_DebugViewMaterial, input, result, needLinearToSRGB);
+        GetBuiltinDataDebug(_DebugViewMaterial, builtinData, result, needLinearToSRGB);
+        GetSurfaceDataDebug(_DebugViewMaterial, surfaceData, result, needLinearToSRGB);
+        GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB); // TODO: This required to initialize all field from BSDFData...
+
+        // TEMP!
+        // For now, the final blit in the backbuffer performs an sRGB write
+        // So in the meantime we apply the inverse transform to linear data to compensate.
+        if (!needLinearToSRGB)
+            result = SRGBToLinear(max(0, result));
+
+        outColor = float4(result, 1.0);
+    }
+#endif
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl

     GetSurfaceAndBuiltinData(input, V, posInput, surfaceData, builtinData);
 
     BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
-    LighTransportData lightTransportData = GetLightTransportData(surfaceData, builtinData, bsdfData);
+    LightTransportData lightTransportData = GetLightTransportData(surfaceData, builtinData, bsdfData);
 
     // This shader is call two time. Once for getting emissiveColor, the other time to get diffuseColor
     // We use unity_MetaFragmentControl to make the distinction.

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 
 // ----------------------------------------------------------------------------
 
-CBUFFER_START(UnityPerDraw)
+CBUFFER_START(UnityPerDraw : register(b0))
-float4x4 glstate_matrix_mvp;
-float4x4 glstate_matrix_modelview0;
-float4x4 glstate_matrix_invtrans_modelview0;
+    float4x4 glstate_matrix_mvp;
+    float4x4 glstate_matrix_modelview0;
+    float4x4 glstate_matrix_invtrans_modelview0;
-float4x4 unity_ObjectToWorld;
-float4x4 unity_WorldToObject;
-float4 unity_LODFade; // x is the fade value ranging within [0,1]. y is x quantized into 16 levels
-float4 unity_WorldTransformParams; // w is usually 1.0, or -1.0 for odd-negative scale transforms
+    float4x4 unity_ObjectToWorld;
+    float4x4 unity_WorldToObject;
+    float4 unity_LODFade; // x is the fade value ranging within [0,1]. y is x quantized into 16 levels
+    float4 unity_WorldTransformParams; // w is usually 1.0, or -1.0 for odd-negative scale transforms
+
+    float4 unity_LightmapST;
+    float4 unity_DynamicLightmapST;
+
+    // SH lighting environment
+    float4 unity_SHAr;
+    float4 unity_SHAg;
+    float4 unity_SHAb;
+    float4 unity_SHBr;
+    float4 unity_SHBg;
+    float4 unity_SHBb;
+    float4 unity_SHC;
+
+    // x = Disabled(0)/Enabled(1)
+    // y = Computation are done in global space(0) or local space(1)
+    // z = Texel size on U texture coordinate
+    float4 unity_ProbeVolumeParams;
+    float4x4 unity_ProbeVolumeWorldToObject;
+    float3 unity_ProbeVolumeSizeInv;
+    float3 unity_ProbeVolumeMin;
+
 CBUFFER_END
 
 #if defined(USING_STEREO_MATRICES)
 
 CBUFFER_END
 
-
-CBUFFER_START(UnityLighting)
-    // SH lighting environment
-    float4 unity_SHAr;
-    float4 unity_SHAg;
-    float4 unity_SHAb;
-    float4 unity_SHBr;
-    float4 unity_SHBg;
-    float4 unity_SHBb;
-    float4 unity_SHC;
-CBUFFER_END
-
 TEXTURE2D_FLOAT(_MainDepthTexture);
 SAMPLER2D(sampler_MainDepthTexture);
 
 
 TEXTURE2D(unity_DynamicDirectionality);
 
-CBUFFER_START(UnityLightmaps)
-float4 unity_LightmapST;
-float4 unity_DynamicLightmapST;
-CBUFFER_END
-
-
-CBUFFER_START(UnityProbeVolume)
-    // x = Disabled(0)/Enabled(1)
-    // y = Computation are done in global space(0) or local space(1)
-    // z = Texel size on U texture coordinate
-    float4 unity_ProbeVolumeParams;
-
-    float4x4 unity_ProbeVolumeWorldToObject;
-    float3 unity_ProbeVolumeSizeInv;
-    float3 unity_ProbeVolumeMin;
-CBUFFER_END
 
 CBUFFER_START(UnityVelocityPass)
     float4x4 _NonJitteredVP;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow/ShadowBase.cs.hlsl

 //
 float4x4 GetWorldToShadow(ShadowData value)
 {
-    return value.worldToShadow;
+	return value.worldToShadow;
-    return value.scaleOffset;
+	return value.scaleOffset;
-    return value.texelSizeRcp;
+	return value.texelSizeRcp;
-    return value.id;
+	return value.id;
-    return value.shadowType;
+	return value.shadowType;
-    return value.payloadOffset;
+	return value.payloadOffset;
-    return value.lightType;
+	return value.lightType;
-    return value.bias;
+	return value.bias;
-    return value.quality;
+	return value.quality;
 }
 
 

Assets/ScriptableRenderPipeline/ShaderLibrary/AreaLighting.hlsl

 #ifndef UNITY_AREA_LIGHTING_INCLUDED
 #define UNITY_AREA_LIGHTING_INCLUDED
 
-float IntegrateEdge(float3 v1, float3 v2)
+#define SPHERE_LIGHT_APPROXIMATION
+
+// Not normalized by the factor of 1/TWO_PI.
+float3 ComputeEdgeFactor(float3 V1, float3 V2)
-    float cosTheta = dot(v1, v2);
-    // Clamp to avoid artifacts. This particular constant gives the best results.
-    cosTheta    = Clamp(cosTheta, -0.9999, 0.9999);
-    float theta = FastACos(cosTheta);
-    float res = cross(v1, v2).z * theta * rsqrt(1.0 - cosTheta * cosTheta); // optimization from * 1 / sin(theta)
+    float  V1oV2 = dot(V1, V2);
+    float3 V1xV2 = cross(V1, V2);
+#if 0
+    return V1xV2 * (rsqrt(1.0 - V1oV2 * V1oV2) * acos(V1oV2));
+#else
+    // Approximate: { y = rsqrt(1.0 - V1oV2 * V1oV2) * acos(V1oV2) } on [0, 1].
+    // Fit: HornerForm[MiniMaxApproximation[ArcCos[x]/Sqrt[1 - x^2], {x, {0, 1 - $MachineEpsilon}, 6, 0}][[2, 1]]].
+    // Maximum relative error: 2.6855360216340534 * 10^-6. Intensities up to 1000 are artifact-free.
+    float x = abs(V1oV2);
+    float y = 1.5707921083647782 + x * (-0.9995697178013095 + x * (0.778026455830408 + x * (-0.6173111361273548 + x * (0.4202724111150622 + x * (-0.19452783598217288 + x * 0.04232040013661036)))));
+
+    if (V1oV2 < 0)
+    {
+        // Undo range reduction.
+        y = PI * rsqrt(saturate(1 - V1oV2 * V1oV2)) - y;
+    }
-    return res;
+    return V1xV2 * y;
+#endif
+}
+
+// Not normalized by the factor of 1/TWO_PI.
+// Ref: Improving radiosity solutions through the use of analytically determined form-factors.
+float IntegrateEdge(float3 V1, float3 V2)
+{
+    // 'V1' and 'V2' are represented in a coordinate system with N = (0, 0, 1).
+    return ComputeEdgeFactor(V1, V2).z;
-// Baum's equation
-// Expects non-normalized vertex positions
-float PolygonRadiance(float4x3 L, bool twoSided)
+// 'sinSqSigma' is the sine^2 of the half of the opening angle of the sphere as seen from the shaded point.
+// 'cosOmega' is the cosine of the angle between the normal and the direction to the center of the light.
+// N.b.: this function accounts for horizon clipping.
+float DiffuseSphereLightIrradiance(float sinSqSigma, float cosOmega)
+    float irradiance;
+
+#if 0 // Ref: Area Light Sources for Real-Time Graphics, page 4 (1996).
+    float sinSqOmega = saturate(1 - cosOmega * cosOmega);
+    float cosSqSigma = saturate(1 - sinSqSigma);
+    float sinSqGamma = saturate(cosSqSigma / sinSqOmega);
+    float cosSqGamma = saturate(1 - sinSqGamma);
+
+    float sinSigma = sqrt(sinSqSigma);
+    float sinGamma = sqrt(sinSqGamma);
+    float cosGamma = sqrt(cosSqGamma);
+
+    float sigma = asin(sinSigma);
+    float omega = acos(cosOmega);
+    float gamma = asin(sinGamma);
+
+    if (omega < 0 || omega >= HALF_PI + sigma)
+    {
+        // Full horizon occlusion (case #4).
+        return 0;
+    }
+
+    float e = sinSqSigma * cosOmega;
+
+    [branch]
+    if (omega < HALF_PI - sigma)
+    {
+        // No horizon occlusion (case #1).
+        irradiance = e;
+    }
+    else
+    {
+        float g = (-2 * sqrt(sinSqOmega * cosSqSigma) + sinGamma) * cosGamma + (HALF_PI - gamma);
+        float h = cosOmega * (cosGamma * sqrt(saturate(sinSqSigma - cosSqGamma)) + sinSqSigma * asin(saturate(cosGamma / sinSigma)));
+
+        if (omega < HALF_PI)
+        {
+            // Partial horizon occlusion (case #2).
+            irradiance = e + INV_PI * (g - h);
+        }
+        else
+        {
+            // Partial horizon occlusion (case #3).
+            irradiance = INV_PI * (g + h);
+        }
+    }
+#else // Ref: Moving Frostbite to Physically Based Rendering, page 47 (2015).
+    float cosSqOmega = cosOmega * cosOmega;
+
+    [branch]
+    if (cosSqOmega > sinSqSigma)
+    {
+        irradiance = sinSqSigma * saturate(cosOmega);
+    }
+    else
+    {
+        float cotanOmega = cosOmega * rsqrt(1 - cosSqOmega);
+
+        float x = rcp(sinSqSigma) - 1;
+        float y = -cotanOmega * sqrt(x);
+        float z = sqrt(1 - cosSqOmega * rcp(sinSqSigma));
+
+        irradiance = INV_PI * ((cosOmega * acos(y) - z * sqrt(x)) * sinSqSigma + atan(z * rsqrt(x)));
+    }
+#endif
+    return max(irradiance, 0);
+}
+
+// Expects non-normalized vertex positions.
+float PolygonIrradiance(float4x3 L)
+{
+#ifdef SPHERE_LIGHT_APPROXIMATION
+    for (int i = 0; i < 4; i++)
+    {
+        L[i] = normalize(L[i]);
+    }
+
+    float3 F = float3(0, 0, 0);
+
+    for (uint edge = 0; edge < 4; edge++)
+    {
+        float3 V1 = L[edge];
+        float3 V2 = L[(edge + 1) % 4];
+
+        F += INV_TWO_PI * ComputeEdgeFactor(V1, V2);
+    }
+
+    float f2         = saturate(dot(F, F));
+    float sinSqSigma = sqrt(f2);
+    float cosOmega   = clamp(F.z * rsqrt(f2), -1, 1);
+
+    return DiffuseSphereLightIrradiance(sinSqSigma, cosOmega);
+#else
     // 1. ClipQuadToHorizon
 
     // detect clipping config
 
     sum *= INV_TWO_PI; // Normalization
 
-    sum = twoSided ? abs(sum) : max(sum, 0.0);
+    sum = max(sum, 0.0);
+#endif
-float LTCEvaluate(float4x3 L, float3 V, float3 N, float NdotV, bool twoSided, float3x3 invM)
+float LTCEvaluate(float4x3 L, float3 V, float3 N, float NdotV, float3x3 invM)
 {
     // Construct a view-dependent orthonormal basis around N.
     // TODO: it could be stored in PreLightData, since all LTC lights compute it more than once.
     invM = mul(transpose(basis), invM);
     L = mul(L, invM);
 
-    // Polygon radiance in transformed configuration - specular
-    return PolygonRadiance(L, twoSided);
+    // Polygon irradiance in the transformed configuration
+    return PolygonIrradiance(L);
 }
 
 float LineFpo(float tLDDL, float lrcpD, float rcpD)

Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl

 // Example: unL for unormalized light vector
 
 // use capital letter for regular vector, vector are always pointing outward the current pixel position (ready for lighting equation)
-// capital letter mean the vector is normalize, unless we put un in front of it.
+// capital letter mean the vector is normalize, unless we put 'un' in front of it.
 // V: View vector  (no eye vector)
 // L: Light vector
 // N: Normal vector
 #define FLT_MIN     1.175494351e-38 // Minimum representable positive floating-point number
 #define FLT_MAX     3.402823466e+38 // Maximum representable floating-point number
 
-#define MERGE_NAME(X, Y) X##Y
-
 float DegToRad(float deg)
 {
     return deg * PI / 180.0;
     return (x < 0.0) ? -t0 : t0;
 }
 
-// Same smoothstep except it assume 0, 1 interval for x
+// Same as smoothstep except it assume 0, 1 interval for x
 float smoothstep01(float x)
 {
     return x * x * (3.0 - (2.0 * x));
 // Texture format sampling
 // ----------------------------------------------------------------------------
 
-float2 DirectionToLatLongCoordinate(float3 dir_in)
+float2 DirectionToLatLongCoordinate(float3 unDir)
-    float3 dir = normalize(dir_in);
+    float3 dir = normalize(unDir);
     // coordinate frame is (-Z, X) meaning negative Z is primary axis and X is secondary axis.
     return float2(1.0 - 0.5 * INV_PI * atan2(dir.x, -dir.z), asin(dir.y) * INV_PI + 0.5);
 }
     posInput.depthVS  = positionCS.w;
     posInput.depthRaw = positionCS.z / positionCS.w;
 }
+
+// ----------------------------------------------------------------------------
+// Misc utilities
+// ----------------------------------------------------------------------------
 
 // Generates a triangle in homogeneous clip space, s.t.
 // v0 = (-1, -1, 1), v1 = (3, -1, 1), v2 = (-1, 3, 1).

Assets/ScriptableRenderPipeline/ShaderLibrary/CommonLighting.hlsl

 // Helper functions
 //-----------------------------------------------------------------------------
 
-// NdotV should not be negative for visible pixels, but it can happen due to the
-// perspective projection and the normal mapping + decals. In that case, the normal
-// should be modified to become valid (i.e facing the camera) to avoid weird artifacts.
-// Note: certain applications (e.g. SpeedTree) require to still have negative normal to perform their own two sided lighting, they can use wantNegativeNormal
-// This will potentially reduce the length of the normal at edges of geometry.
-float GetShiftedNdotV(inout float3 N, float3 V, bool wantNegativeNormal)
+// NdotV can be negative for visible pixels due to the perspective projection, the normal mapping and decals.
+// This can produce visible artifacts with direct specular lighting (white point, black point) and indirect specular (artifact with cubemap fetch)
+// A way to reduce artifact is to limit NdotV value to not be negative and calculate reflection vector for cubemap with a shifted normal (i.e what depends on the view)
+// This is what provide this function
+// Note: NdotV return by this function is always positive, no need for saturate
+float GetShiftedNdotV(inout float3 N, float3 V)
-    float limit = rcp(256.0); // Determined mostly by the quality of the G-buffer normal encoding
+    const float limit = 0.0001; // Epsilon value that avoid divide by 0 (several BSDF divide by NdotV)
-    if (!wantNegativeNormal && NdotV < limit)
+    if (NdotV < limit)
-        // We do not renormalize the normal because { abs(length(N) - 1.0) < limit }.
+        // We do not renormalize the normal because { abs(length(N) - 1.0) < limit } + It is use for cubemap
         N    += (-NdotV + limit) * V;
         NdotV = limit;
     }

Assets/ScriptableRenderPipeline/ShaderLibrary/NormalSurfaceGradient.hlsl

     return deriv * scale;
 }
 
+// Unpack normal as DXT5nm (1, y, 0, x) or BC5 (x, y, 0, 1)
+float2 UnpackDerivativeNormalRGorAG(float4 packedNormal, float scale = 1.0)
+{
+    // This do the trick
+    packedNormal.w *= packedNormal.x;
+    return UnpackDerivativeNormalAG(packedNormal, scale);
+}
+
 float2 UnpackDerivativeNormalRGB(float4 packedNormal, float scale = 1.0)
 {
     const float fS = 1.0 / (128.0 * 128.0);

Assets/ScriptableRenderPipeline/ShaderLibrary/Packing.hlsl

 float3 UnpackNormalmapRGorAG(float4 packedNormal, float scale = 1.0)
 {
     // This do the trick
-    packedNormal.x *= packedNormal.w;
-
-    float3 normal;
-    normal.xy = packedNormal.xy * 2.0 - 1.0;
-    normal.xy *= scale;
-    normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));
-    return normal;
+    packedNormal.w *= packedNormal.x;
+    return UnpackNormalAG(packedNormal, scale);
 }
 
 //-----------------------------------------------------------------------------

Assets/ScriptableRenderPipeline/ShaderLibrary/SampleUVMappingInternal.hlsl

 
 // Nested multiple includes of the file to handle all variations of normal map (AG, RG or RGB)
 
-// TODO: Handle BC5 format, currently this code is for DXT5nm - After the change, rename this function UnpackNormalmapRGorAG
-// This version is use for the base normal map
+// This version is use for the base normal map (BC5 or DXT5nm)
-#define UNPACK_NORMAL_FUNC UnpackNormalAG
-#define UNPACK_DERIVATIVE_FUNC UnpackDerivativeNormalAG
+#define UNPACK_NORMAL_FUNC UnpackNormalmapRGorAG
+#define UNPACK_DERIVATIVE_FUNC UnpackDerivativeNormalRGorAG
 #endif
 #include "SampleUVMappingNormalInternal.hlsl"
 #undef ADD_NORMAL_FUNC_SUFFIX
-// This version is for normalmap with AG encoding only. Mainly use with details map.
+// This version is for normalmap with AG encoding only. Use with details map encoded with others properties (like smoothness).
-#if defined(UNITY_NO_DXT5nm)
-#define UNPACK_NORMAL_FUNC UnpackNormalRGB
-#define UNPACK_DERIVATIVE_FUNC UnpackDerivativeNormalRGB
-#else
-#endif
 #include "SampleUVMappingNormalInternal.hlsl"
 #undef ADD_NORMAL_FUNC_SUFFIX
 #undef UNPACK_NORMAL_FUNC

Assets/ScriptableRenderPipeline/ShaderLibrary/Wind.hlsl

 float AttenuateTrunk(float x, float s)
 {
     float r = (x / s);
-    return pow(r,1/s);
+    return PositivePow(r,1/s);
 }
 
 
         gust = pow(gust, 2) * WIND_SETTINGS_GustScale;
     }
 
-    float3 trunkNoise = 
+    float3 trunkNoise =
-                (normalizedDir * WIND_SETTINGS_WorldDirectionAndSpeed.w) 
-                + (gust * normalizedDir * WIND_SETTINGS_GustSpeed) 
+                (normalizedDir * WIND_SETTINGS_WorldDirectionAndSpeed.w)
+                + (gust * normalizedDir * WIND_SETTINGS_GustSpeed)
                 + (trunk * WIND_SETTINGS_Turbulence)
         ) * drag;
 
 
 
 
-void ApplyWind( inout float3    worldPos, 
+void ApplyWind( inout float3    worldPos,
                 inout float3    worldNormal,
                 float3          rootWP,
                 float           stiffness,
         float3 rotAxis = cross(float3(0, 1, 0), wind.Direction);
 
         worldPos = Rotate(rootWP, worldPos, rotAxis, (wind.Strength) * 0.001 * att);
-        
+
         float3 shiverDirection = normalize(lerp(worldNormal, normalize(wind.Direction + wind.ShiverDirection), shiverDirectionality));
         worldPos += wind.ShiverStrength * shiverDirection * shiverMask;
     }

Assets/ScriptableRenderPipeline/common/TextureCache.cs

             }
         }
 
-        public static TextureFormat GetPreferredCompressedTextureFormat
+        public static TextureFormat GetPreferredHdrCompressedTextureFormat
         {
             get
             {
 
                 // On editor the texture is uncompressed when operating against mobile build targets
+#if UNITY_2017_2_OR_NEWER
+                if (SystemInfo.SupportsTextureFormat(probeFormat) && !UnityEngine.Rendering.GraphicsSettings.HasShaderDefine(UnityEngine.Rendering.BuiltinShaderDefine.UNITY_NO_DXT5nm))
+                    format = probeFormat;
+#else
+#endif
 
                 return format;
             }
         {
             get
             {
+#if UNITY_2017_2_OR_NEWER
+                return !UnityEngine.Rendering.GraphicsSettings.HasShaderDefine(UnityEngine.Rendering.BuiltinShaderDefine.UNITY_NO_CUBEMAP_ARRAY);
+#else
+#endif
             }
         }
 
         private static uint g_MaxFrameCount = unchecked((uint)(-1));
         private static uint g_InvalidTexID = (uint)0;
 
-        public int FetchSlice(Texture texture)
+        public int FetchSlice(Texture texture, bool forceReinject=false)
+            var sliceIndex = -1;
+
+            if (texture == null)
+                return sliceIndex;
+
-            var bSwapSlice = false;
+            var bSwapSlice = forceReinject;
-            var sliceIndex = -1;
-                if (m_TextureCacheVersion != s_GlobalTextureCacheVersion)
+                sliceIndex = m_LocatorInSliceArray[texId];
+                bFoundAvailOrExistingSlice = true;
+
+                if(m_TextureCacheVersion!=s_GlobalTextureCacheVersion)
-                    m_LocatorInSliceArray.Remove(texId);
-                }
-                else
-                {
-                    sliceIndex = m_LocatorInSliceArray[texId];
-                    bFoundAvailOrExistingSlice = true;
+                    bSwapSlice = true;  // force a reinject.
                 }
                 //assert(m_SliceArray[sliceIndex].TexID==TexID);
             }

Assets/ScriptableRenderPipeline/fptl/FptlLighting.cs

             m_CubeReflTexArray = new TextureCacheCubemap();
             m_CookieTexArray.AllocTextureArray(8, m_TextureSettings.spotCookieSize, m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
             m_CubeCookieTexArray.AllocTextureArray(4, m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
-            m_CubeReflTexArray.AllocTextureArray(64, m_TextureSettings.reflectionCubemapSize, TextureCache.GetPreferredCompressedTextureFormat, true);
+            m_CubeReflTexArray.AllocTextureArray(64, m_TextureSettings.reflectionCubemapSize, TextureCache.GetPreferredHdrCompressedTextureFormat, true);
 
             //m_DeferredMaterial.SetTexture("_spotCookieTextures", m_cookieTexArray.GetTexCache());
             //m_DeferredMaterial.SetTexture("_pointCookieTextures", m_cubeCookieTexArray.GetTexCache());
                     lightData[idxOut] = light;
                 }
             }
-            var numLightsOut = offsets[LightDefinitions.DIRECT_LIGHT, numVolTypes - 1] + numEntries[LightDefinitions.DIRECT_LIGHT, numVolTypes - 1];
+            int numLightsOut = 0;
+            for(int v=0; v<numVolTypes; v++) numLightsOut += numEntries[LightDefinitions.DIRECT_LIGHT, v];
 
             // probe.m_BlendDistance
             // Vector3f extents = 0.5*Abs(probe.m_BoxSize);
                 lightData[idxOut] = lgtData;
             }
 
-            var numProbesOut = offsets[LightDefinitions.REFLECTION_LIGHT, numVolTypes - 1] + numEntries[LightDefinitions.REFLECTION_LIGHT, numVolTypes - 1];
+            int numProbesOut = 0;
+            for(int v=0; v<numVolTypes; v++) numProbesOut += numEntries[LightDefinitions.REFLECTION_LIGHT, v];
+
             for (var m = 0; m < numModels; m++)
             {
                 for (var v = 0; v < numVolTypes; v++)

Assets/ScriptableRenderPipeline/fptl/LightDefinitions.cs.hlsl

 //
 float GetPenumbra(SFiniteLightData value)
 {
-    return value.penumbra;
+	return value.penumbra;
-    return value.flags;
+	return value.flags;
-    return value.lightType;
+	return value.lightType;
-    return value.lightModel;
+	return value.lightModel;
-    return value.lightPos;
+	return value.lightPos;
-    return value.lightIntensity;
+	return value.lightIntensity;
-    return value.lightAxisX;
+	return value.lightAxisX;
-    return value.recipRange;
+	return value.recipRange;
-    return value.lightAxisY;
+	return value.lightAxisY;
-    return value.radiusSq;
+	return value.radiusSq;
-    return value.lightAxisZ;
+	return value.lightAxisZ;
-    return value.cotan;
+	return value.cotan;
-    return value.color;
+	return value.color;
-    return value.sliceIndex;
+	return value.sliceIndex;
-    return value.boxInnerDist;
+	return value.boxInnerDist;
-    return value.decodeExp;
+	return value.decodeExp;
-    return value.boxInvRange;
+	return value.boxInvRange;
-    return value.shadowLightIndex;
+	return value.shadowLightIndex;
-    return value.localCubeCapturePoint;
+	return value.localCubeCapturePoint;
-    return value.probeBlendDistance;
+	return value.probeBlendDistance;
 }
 
 //
 {
-    return value.boxAxisX;
+	return value.boxAxisX;
-    return value.boxAxisY;
+	return value.boxAxisY;
-    return value.boxAxisZ;
+	return value.boxAxisZ;
-    return value.center;
+	return value.center;
-    return value.scaleXY;
+	return value.scaleXY;
-    return value.radius;
+	return value.radius;
 }
 
 //
 {
-    return value.color;
+	return value.color;
-    return value.intensity;
+	return value.intensity;
-    return value.lightAxisX;
+	return value.lightAxisX;
-    return value.shadowLightIndex;
+	return value.shadowLightIndex;
-    return value.lightAxisY;
+	return value.lightAxisY;
-    return value.pad0;
+	return value.pad0;
-    return value.lightAxisZ;
+	return value.lightAxisZ;
-    return value.pad1;
+	return value.pad1;
 }
 
 

Assets/ScriptableRenderPipeline/fptl/lightlistbuild-clustered.compute

 	GroupMemoryBarrierWithGroupSync();
 #endif
 	dpt_ma = asfloat(ldsZMax);
+	if(dpt_ma<=0.0) dpt_ma = VIEWPORT_SCALE_Z;		// assume sky pixel
 #endif
 
 	float2 vTileLL = float2(viTilLL.x/(float) iWidth, viTilLL.y/(float) iHeight);

Assets/ShaderGenerator/Editor/CSharpToHLSL.cs

                         }
                     }
 
+                    foreach (var gen in it.Value)
+                    {
+                        if (gen.hasStatics && gen.hasFields && gen.needParamDebug)
+                        {
+                            writer.Write(gen.EmitFunctions() + "\n");
+                        }
+                    }                    
+
+
                 }
             }
         }

Assets/ShaderGenerator/Editor/ShaderTypeGeneration.cs

             public Accessor accessor;
         };
 
+        class DebugFieldInfo
+        {
+            public DebugFieldInfo(string defineName, string fieldName, Type fieldType, bool isDirection, bool isSRGB)
+            {
+                this.defineName = defineName;
+                this.fieldName = fieldName;
+                this.fieldType = fieldType;
+                this.isDirection = isDirection;
+                this.isSRGB = isSRGB;
+            }
+
+            public string defineName;
+            public string fieldName;
+            public Type fieldType;
+            public bool isDirection;
+            public bool isSRGB;            
+        }
+
         void Error(string error)
         {
             if (errors == null)
             return shaderText;
         }
 
+        public string EmitFunctions()
+        {
+            string shaderText = string.Empty;
+
+            // In case users ask for debug functions
+            if (!attr.needParamDebug)
+                return shaderText;
+
+            // Specific to HDRenderPipeline            
+            string lowerStructName = type.Name.ToLower();
+
+            shaderText += "//\n";
+            shaderText += "// Debug functions\n";
+            shaderText += "//\n";
+
+            shaderText += "void GetGenerated" + type.Name + "Debug(uint paramId, " + type.Name + " " + lowerStructName + ", inout float3 result, inout bool needLinearToSRGB)\n";
+            shaderText += "{\n";
+            shaderText += "    switch (paramId)\n";
+            shaderText += "    {\n";
+
+            foreach (var debugField in m_DebugFields)
+            {
+                shaderText += "        case " + debugField.defineName + ":\n";
+                if (debugField.fieldType == typeof(float))
+                {
+                    if (debugField.isDirection)
+                    {
+                        shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + ".xxx * 0.5 + 0.5;\n";
+                    }
+                    else 
+                    {
+                        shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + ".xxx;\n";
+                    }
+                }
+                else if (debugField.fieldType == typeof(Vector2))
+                {
+                    shaderText += "            result = float3(" + lowerStructName + "." + debugField.fieldName + ", 0.0);\n";
+                }
+                else if (debugField.fieldType == typeof(Vector3))
+                {
+                    if (debugField.isDirection)
+                    {
+                        shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + " * 0.5 + 0.5;\n";
+                    }
+                    else 
+                    {
+                        shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + ";\n";
+                    }                    
+                }
+                else if (debugField.fieldType == typeof(Vector4))
+                {
+                    shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + ".xyz;\n";
+                }
+                else if (debugField.fieldType == typeof(bool))
+                {
+                    shaderText += "            result = (" + lowerStructName + "." + debugField.fieldName + ") ? float3(1.0, 1.0, 1.0) : float3(0.0, 0.0, 0.0);\n";
+                }
+                else if (debugField.fieldType == typeof(uint) || debugField.fieldType == typeof(int))
+                {
+                    shaderText += "            result = GetIndexColor(" + lowerStructName + "." + debugField.fieldName + ");\n";
+                }
+                else // This case left is suppose to be a complex structure. Either we don't support it or it is an enum. Consider it is an enum with GetIndexColor, user can override it if he want.
+                {
+                    shaderText += "            result = GetIndexColor(" + lowerStructName + "." + debugField.fieldName + ");\n";       
+                }
+                
+                if (debugField.isSRGB)
+                {
+                    shaderText += "            needLinearToSRGB = true;\n";
+                }
+
+                shaderText += "            break;\n";
+            }
+
+            shaderText += "    }\n";
+            shaderText += "}\n";            
+
+            return shaderText;
+        }
+
-        // This function is a helper to follow unity convertion
-        // when converting fooBar ro FOO_BAR
+        // This function is a helper to follow unity convention
+        // when converting fooBar to FOO_BAR
         string InsertUnderscore(string name)
         {
             for (int i = 1; i < name.Length; i++)
 
             FieldInfo[] fields = type.GetFields();
             m_ShaderFields = new List<ShaderFieldInfo>();
+            m_DebugFields = new List<DebugFieldInfo>();
 
             if (type.IsEnum)
             {
                     continue;
                 }
 
-                if (attr.needParamDefines)
+                if (attr.needParamDebug)
-                    m_Statics[("DEBUGVIEW_" + subNamespace + "_" + type.Name + "_" + name).ToUpper()] = Convert.ToString(attr.paramDefinesStart + debugCounter++);
+                    string defineName = ("DEBUGVIEW_" + subNamespace + "_" + type.Name + "_" + name).ToUpper();
+                    m_Statics[defineName] = Convert.ToString(attr.paramDefinesStart + debugCounter++);
+
+                    bool isDirection = false;
+                    bool sRGBDisplay = false;
+
+                    // Check if the display name have been override by the users
+                    if (Attribute.IsDefined(field, typeof(SurfaceDataAttributes)))
+                    {
+                        var propertyAttr = (SurfaceDataAttributes[])field.GetCustomAttributes(typeof(SurfaceDataAttributes), false);
+                        isDirection = propertyAttr[0].isDirection;
+                        sRGBDisplay = propertyAttr[0].sRGBDisplay;
+                    }
+
+                    m_DebugFields.Add(new DebugFieldInfo(defineName, field.Name, field.FieldType, isDirection, sRGBDisplay));
                 }
 
                 if (field.FieldType.IsPrimitive)
         {
             get { return attr.needAccessors; }
         }
+        public bool needParamDebug
+        {
+            get { return attr.needParamDebug; }
+        }
 
         public Type type;
         public GenerateHLSL attr;
         Dictionary<string, string> m_Statics;
         List<ShaderFieldInfo> m_ShaderFields;
         List<ShaderFieldInfo> m_PackedFields;
+        List<DebugFieldInfo> m_DebugFields;
     }
 }

Assets/ShaderGenerator/ShaderGeneratorAttributes.cs

     {
         public PackingRules packingRules;
         public bool needAccessors; // Whether or not to generate the accessors
-        public bool needParamDefines; // Wheter or not to generate define for each parameters of the struc
+        public bool needParamDebug; // // Whether or not to generate define for each field of the struct + debug function (use in HDRenderPipeline)
-        public GenerateHLSL(PackingRules rules = PackingRules.Exact, bool needAccessors = true, bool needParamDefines = false, int paramDefinesStart = 1)
+        public GenerateHLSL(PackingRules rules = PackingRules.Exact, bool needAccessors = true, bool needParamDebug = false, int paramDefinesStart = 1)
-            this.needParamDefines = needParamDefines;
+            this.needParamDebug = needParamDebug;
             this.paramDefinesStart = paramDefinesStart;
         }
     }
     {
         public string displayName;
+        public bool isDirection;
+        public bool sRGBDisplay;
-        public SurfaceDataAttributes(string displayName = "")
+        public SurfaceDataAttributes(string displayName = "", bool isDirection = false, bool sRGBDisplay = false)
+            this.isDirection = isDirection;
+            this.sRGBDisplay = sRGBDisplay;
         }
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [GenerateHLSL]
+    public enum DebugDisplayMode
+    {
+        None,
+        ViewMaterial,
+        DiffuseLighting,
+        SpecularLighting,
+        VisualizeCascade
+    }
+
+    [Serializable]
+    public class DebugDisplaySettings
+    {
+        public float debugOverlayRatio = 0.33f;
+        public bool displayMaterialDebug = false;
+        public bool displayRenderingDebug = false;
+        public bool displayLightingDebug = false;
+
+        public DebugDisplayMode debugDisplayMode = DebugDisplayMode.None;
+
+        public MaterialDebugSettings materialDebugSettings = new MaterialDebugSettings();
+        public LightingDebugSettings lightingDebugSettings = new LightingDebugSettings();
+        public RenderingDebugSettings renderingDebugSettings = new RenderingDebugSettings();
+
+        public bool IsDebugDisplayEnable()
+        {
+            return debugDisplayMode != DebugDisplayMode.None;
+        }
+        
+
+        public void RegisterDebug()
+        {
+            DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Rate", () => 1.0f / Time.deltaTime, null, true);
+            DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Time", () => Time.deltaTime * 1000.0f, null, true);
+
+            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, bool>("Enable Shadows", () => lightingDebugSettings.enableShadows, (value) => lightingDebugSettings.enableShadows = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, ShadowMapDebugMode>("Shadow Debug Mode", () => lightingDebugSettings.shadowDebugMode, (value) => lightingDebugSettings.shadowDebugMode = (ShadowMapDebugMode)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, uint>("Shadow Map Index", () => lightingDebugSettings.shadowMapIndex, (value) => lightingDebugSettings.shadowMapIndex = (uint)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, LightingDebugMode>("Lighting Debug Mode", () => lightingDebugSettings.lightingDebugMode, (value) => lightingDebugSettings.lightingDebugMode = (LightingDebugMode)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, bool>("Override Smoothness", () => lightingDebugSettings.overrideSmoothness, (value) => lightingDebugSettings.overrideSmoothness = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, float>("Override Smoothness Value", () => lightingDebugSettings.overrideSmoothnessValue, (value) => lightingDebugSettings.overrideSmoothnessValue = (float)value, false, new DebugItemDrawFloatMinMax(0.0f, 1.0f));
+            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, Color>("Debug Lighting Albedo", () => lightingDebugSettings.debugLightingAlbedo, (value) => lightingDebugSettings.debugLightingAlbedo = (Color)value);
+            DebugMenuManager.instance.AddDebugItem<bool>("Lighting", "Display Sky Reflection", () => lightingDebugSettings.displaySkyReflection, (value) => lightingDebugSettings.displaySkyReflection = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, float>("Sky Reflection Mipmap", () => lightingDebugSettings.skyReflectionMipmap, (value) => lightingDebugSettings.skyReflectionMipmap = (float)value, false, new DebugItemDrawFloatMinMax(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);
+            DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Enable Distortion",() => renderingDebugSettings.enableDistortion, (value) => renderingDebugSettings.enableDistortion = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Enable Subsurface Scattering",() => renderingDebugSettings.enableSSS, (value) => renderingDebugSettings.enableSSS = (bool)value);
+        }
+
+        public void OnValidate()
+        {
+            lightingDebugSettings.OnValidate();
+        }
+    }
+
+    namespace Attributes
+    {
+        // 0 is reserved!
+        [GenerateHLSL]
+        public enum DebugViewVarying
+        {
+            Texcoord0 = 1,
+            Texcoord1,
+            Texcoord2,
+            Texcoord3,
+            VertexTangentWS,
+            VertexBitangentWS,
+            VertexNormalWS,
+            VertexColor,
+            VertexColorAlpha,
+            // caution if you add something here, it must start below
+        };
+
+        // Number must be contiguous
+        [GenerateHLSL]
+        public enum DebugViewGbuffer
+        {
+            Depth = DebugViewVarying.VertexColorAlpha + 1,
+            BakeDiffuseLightingWithAlbedoPlusEmissive,
+        }
+    }
+
+    [Serializable]
+    public class MaterialDebugSettings
+    {
+        public int debugViewMaterial = 0;
+    }
+
+    [Serializable]
+    public class RenderingDebugSettings
+    {
+        public bool displayOpaqueObjects = true;
+        public bool displayTransparentObjects = true;
+        public bool enableDistortion = true;
+        public bool enableSSS = true;
+    }
+
+    public enum ShadowMapDebugMode
+    {
+        None,
+        VisualizeAtlas,
+        VisualizeShadowMap
+    }
+
+    [Serializable]
+    public class LightingDebugSettings
+    {
+        public bool                 enableShadows = true;
+        public ShadowMapDebugMode   shadowDebugMode = ShadowMapDebugMode.None;
+        public uint                 shadowMapIndex = 0;
+
+        public bool                 overrideSmoothness = false;
+        public float                overrideSmoothnessValue = 0.5f;
+        public Color                debugLightingAlbedo = new Color(0.5f, 0.5f, 0.5f);
+
+        public bool                 displaySkyReflection = false;
+        public float                skyReflectionMipmap = 0.0f;
+
+        public void OnValidate()
+        {
+            overrideSmoothnessValue = Mathf.Clamp(overrideSmoothnessValue, 0.0f, 1.0f);
+            skyReflectionMipmap = Mathf.Clamp(skyReflectionMipmap, 0.0f, 1.0f);
+        }
+    }
+}

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.hlsl

+//
+// This file was automatically generated from Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.  Please don't edit by hand.
+//
+
+#ifndef DEBUGDISPLAY_CS_HLSL
+#define DEBUGDISPLAY_CS_HLSL
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.DebugDisplayMode:  static fields
+//
+#define DEBUGDISPLAYMODE_NONE (0)
+#define DEBUGDISPLAYMODE_VIEW_MATERIAL (1)
+#define DEBUGDISPLAYMODE_DIFFUSE_LIGHTING (2)
+#define DEBUGDISPLAYMODE_SPECULAR_LIGHTING (3)
+#define DEBUGDISPLAYMODE_VISUALIZE_CASCADE (4)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewVarying:  static fields
+//
+#define DEBUGVIEWVARYING_TEXCOORD0 (1)
+#define DEBUGVIEWVARYING_TEXCOORD1 (2)
+#define DEBUGVIEWVARYING_TEXCOORD2 (3)
+#define DEBUGVIEWVARYING_TEXCOORD3 (4)
+#define DEBUGVIEWVARYING_VERTEX_TANGENT_WS (5)
+#define DEBUGVIEWVARYING_VERTEX_BITANGENT_WS (6)
+#define DEBUGVIEWVARYING_VERTEX_NORMAL_WS (7)
+#define DEBUGVIEWVARYING_VERTEX_COLOR (8)
+#define DEBUGVIEWVARYING_VERTEX_COLOR_ALPHA (9)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewGbuffer:  static fields
+//
+#define DEBUGVIEWGBUFFER_DEPTH (10)
+#define DEBUGVIEWGBUFFER_BAKE_DIFFUSE_LIGHTING_WITH_ALBEDO_PLUS_EMISSIVE (11)
+
+
+#endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.hlsl.meta

+fileFormatVersion: 2
+guid: 8f206be5d6c03164da4ba185ebead15a
+timeCreated: 1492764489
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.meta

+fileFormatVersion: 2
+guid: af3e841f9b2f10049b025e31928eef49
+timeCreated: 1492764488
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.hlsl

+#ifndef UNITY_DEBUG_DISPLAY_INCLUDED
+#define UNITY_DEBUG_DISPLAY_INCLUDED
+
+#include "DebugDisplay.cs.hlsl"
+
+// Set of parameters available when switching to debug shader mode
+int _DebugDisplayMode; // Match enum DebugDisplayMode
+int _DebugViewMaterial; // Contain the id (define in various materialXXX.cs.hlsl) of the property to display
+float4 _DebugLightingAlbedo; // xyz = albedo for diffuse, w unused
+float4 _DebugLightingSmoothness; // x == bool override, y == override value
+
+#endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.hlsl.meta

+fileFormatVersion: 2
+guid: d6dd73727229cdd41ab7f4b61be39b73
+timeCreated: 1492764490
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/SSSProfile.meta

+fileFormatVersion: 2
+guid: a0ba759eadcfdcc44bc08adad4960ed0
+folderAsset: yes
+timeCreated: 1493162006
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/Common.meta

+fileFormatVersion: 2
+guid: e42cfeaf226ad624786ad5b39095906c
+folderAsset: yes
+timeCreated: 1493044341
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Two Sided/Material/GroundLeaf_DoubleSidedFlipSSS.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: GroundLeaf_DoubleSidedFlipSSS
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHATEST_ON _DOUBLESIDED_ON _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: 2450
+  stringTagMap:
+    RenderType: TransparentCutout
+  disabledShaderPasses:
+  - DistortionVectors
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 2800000, guid: 00447c5eeb984f54d92c80818840a36b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 0c3144d154991884c8aa53e7dc7893ff, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DiffuseLightingMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 00447c5eeb984f54d92c80818840a36b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 2800000, guid: b24f69ff4ace9194fb0d9eee4f5cf1a4, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 2800000, guid: b24f69ff4ace9194fb0d9eee4f5cf1a4, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 2800000, guid: 0c3144d154991884c8aa53e7dc7893ff, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 1
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 0
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 1
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 2
+    - _Drag: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _EnableWind: 0
+    - _GlossMapScale: 0.892
+    - _Glossiness: 0.507
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.32
+    - _HeightBias: 0
+    - _HeightCenter: 0.68
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _InitialBend: 1
+    - _MaterialID: 1
+    - _Metalic: 0
+    - _Metallic: 0
+    - _Mode: 1
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 1
+    - _Stiffness: 1
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TessellationBackFaceCullEpsilon: -0.375
+    - _TessellationFactor: 4
+    - _TessellationFactorMaxDistance: 50
+    - _TessellationFactorMinDistance: 20
+    - _TessellationFactorTriangleSize: 100
+    - _TessellationMode: 1
+    - _TessellationObjectScale: 0
+    - _TessellationShapeFactor: 0.75
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.5882353, g: 0.5882353, b: 0.5882353, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Two Sided/Material/GroundLeaf_DoubleSidedFlipSSS.mat.meta

+fileFormatVersion: 2
+guid: 943c7c930eb495d4486788572dc49a12
+timeCreated: 1460562588
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Two Sided/Prefabs/Materials.meta

+fileFormatVersion: 2
+guid: ee9aedf6876b41c459d476afd81ab708
+folderAsset: yes
+timeCreated: 1492083994
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Mesh/Materials.meta

+fileFormatVersion: 2
+guid: babcbb0e8a80beb4ca87d6a963225ae6
+folderAsset: yes
+timeCreated: 1492083990
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/WindTest/Materials.meta

+fileFormatVersion: 2
+guid: fd0f1959e62dce14aa6e413beba5bdb4
+folderAsset: yes
+timeCreated: 1492083997
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Textures/cookieTest.png.meta

+fileFormatVersion: 2
+guid: 55fd692de65e703408cbda23b0eae8d0
+timeCreated: 1492083821
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/SSSProfile/FoliageSSSProfile.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: a6e7465350bf0d248b4799d98e18cd24, type: 3}
+  m_Name: FoliageSSSProfile
+  m_EditorClassIdentifier: 
+  stdDev1: {r: 0.27931032, g: 1, b: 0.050000012, a: 0}
+  stdDev2: {r: 0.3010142, g: 0.8235294, b: 0.05, a: 0}
+  lerpWeight: 0.5
+  texturingMode: 0
+  enableTransmission: 1
+  tintColor: {r: 1, g: 1, b: 1, a: 1}
+  thicknessRemap: {x: 0, y: 0.2873168}
+  settingsIndex: 0
+  m_FilterKernel:
+  - {x: 0.28517896, y: 0.09090909, z: 0.9996764, w: -0.00000009903661}
+  - {x: 0.22566724, y: 0.09090909, z: 0.00016186091, w: -0.209237}
+  - {x: 0.10604589, y: 0.09090909, z: 8.6876086e-17, w: -0.43068767}
+  - {x: 0.024215871, y: 0.09090909, z: 5.8571e-41, w: -0.6816498}
+  - {x: 0.0014802383, y: 0.09090909, z: 0, w: -1.0000685}
+  - {x: 0.0000013396462, y: 0.09090909, z: 0, w: -1.5417894}
+  - {x: 0.22566712, y: 0.09090909, z: 0.00016185877, w: 0.20923716}
+  - {x: 0.10604589, y: 0.09090909, z: 8.6876086e-17, w: 0.43068767}
+  - {x: 0.02421585, y: 0.09090909, z: 5.857e-41, w: 0.6816499}
+  - {x: 0.0014802383, y: 0.09090909, z: 0, w: 1.0000685}
+  - {x: 0.0000013396391, y: 0.09090909, z: 0, w: 1.5417898}
+  m_HalfRcpVariances:
+  - {x: 6.4090853, y: 0.5, z: 199.99991}
+  - {x: 5.518182, y: 0.7372449, z: 200}
+  m_HalfRcpWeightedVariances: {x: 5.9386554, y: 0.60145676, z: 199.99997, w: 0.60145676}

Assets/ScriptableRenderPipeline/HDRenderPipeline/SSSProfile/FoliageSSSProfile.asset.meta

+fileFormatVersion: 2
+guid: d6ee4403015766f4093158d69216c0bf
+timeCreated: 1493161911
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/Common/Scripts.meta

+fileFormatVersion: 2
+guid: 711a9f1e8aa51844980a04a15d8c8f58
+folderAsset: yes
+timeCreated: 1493044341
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/Common/Scripts/MiniProfiler.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using UnityEngine.Profiling;
+
+public class MiniProfiler : MonoBehaviour {
+
+    public bool m_Enable = false;
+
+    private int frameCount = 0;
+    private const int kAverageFrameCount = 64;
+    private float m_AccDeltaTime;
+    private float m_AvgDeltaTime;
+
+    internal class RecorderEntry
+    {
+        public string name;
+        public float time;
+        public int count;
+        public float avgTime;
+        public float avgCount;
+        public float accTime;
+        public int accCount;
+        public Recorder recorder;
+    };
+
+    RecorderEntry[] recordersList =
+    {
+        new RecorderEntry() { name="RenderLoop.Draw" },
+//        new RecorderEntry() { name="BatchRenderer.Flush" },
+        new RecorderEntry() { name="Shadows.Draw" },
+        new RecorderEntry() { name="BatchRenderer.ApplyShaderPass" },
+
+/*
+        new RecorderEntry() { name="gBatchGBufferObj" },
+        new RecorderEntry() { name="gBatchGBufferBatch" },
+        new RecorderEntry() { name="gBatchShadowObj" },
+        new RecorderEntry() { name="gBatchShadowBatch" },
+*/
+
+    /*
+            new RecorderEntry() { name="Map_PerDraw_Buffer" },
+            new RecorderEntry() { name="Unmap_PerDraw_Buffer" },
+            new RecorderEntry() { name="DrawBuffersBatchMode" },
+            new RecorderEntry() { name="DrawBatchIndexed" },
+            new RecorderEntry() { name="BatchRenderer.ApplyShaderPass" },
+            new RecorderEntry() { name="PerformFlushProperties" },
+    */
+
+
+    /*
+            new RecorderEntry() { name="Camera.Render" },
+            new RecorderEntry() { name="GUI.Repaint" },
+            new RecorderEntry() { name="PrepareValues" },
+            new RecorderEntry() { name="ApplyGpuProgram" },
+            new RecorderEntry() { name="WriteParameters" },
+            new RecorderEntry() { name="FlushBuffers" },
+            new RecorderEntry() { name="BindBuffers" },
+            new RecorderEntry() { name="Gfx.ProcessCommand" },
+    */
+};
+
+    void Awake()
+    {
+        for (int i=0;i<recordersList.Length;i++)
+        {
+            var sampler = Sampler.Get(recordersList[i].name);
+            if ( sampler != null )
+            {
+                recordersList[i].recorder = sampler.GetRecorder();
+            }
+        }
+    }
+
+
+    void Update()
+    {
+
+        if (m_Enable)
+        {
+
+            // get timing & update average accumulators
+            for (int i = 0; i < recordersList.Length; i++)
+            {
+                recordersList[i].time = recordersList[i].recorder.elapsedNanoseconds / 1000000.0f;
+                recordersList[i].count = recordersList[i].recorder.sampleBlockCount;
+                recordersList[i].accTime += recordersList[i].time;
+                recordersList[i].accCount += recordersList[i].count;
+            }
+
+            m_AccDeltaTime += Time.deltaTime;
+
+            frameCount++;
+            // time to time, update average values & reset accumulators
+            if (frameCount >= kAverageFrameCount)
+            {
+                for (int i = 0; i < recordersList.Length; i++)
+                {
+                    recordersList[i].avgTime = recordersList[i].accTime * (1.0f / kAverageFrameCount);
+                    recordersList[i].avgCount = recordersList[i].accCount * (1.0f / kAverageFrameCount);
+                    recordersList[i].accTime = 0.0f;
+                    recordersList[i].accCount = 0;
+
+                }
+
+                m_AvgDeltaTime = m_AccDeltaTime / kAverageFrameCount;
+                m_AccDeltaTime = 0.0f;
+                frameCount = 0;
+            }
+        }
+
+    }
+
+    void OnGUI()
+    {
+
+        if (m_Enable)
+        {
+            GUI.color = new Color(1, 1, 1, .75f);
+            float w = 500, h = 204;
+
+            GUILayout.BeginArea(new Rect(10, 150, w, h), "Mini Profiler", GUI.skin.window);
+            string sLabel = System.String.Format("<b>{0:F2} FPS ({1:F2}ms)</b>\n", 1.0f / m_AvgDeltaTime, Time.deltaTime * 1000.0f);
+            for (int i = 0; i < recordersList.Length; i++)
+            {
+                sLabel += string.Format("{0:F2}ms (*{1:F2})\t({2:F2}ms *{3:F2})\t<b>{4}</b>\n", recordersList[i].avgTime, recordersList[i].avgCount, recordersList[i].time, recordersList[i].count, recordersList[i].name);
+            }
+            GUILayout.Label(sLabel);
+            GUILayout.EndArea();
+        }
+    }
+
+}

Assets/TestScenes/Common/Scripts/MiniProfiler.cs.meta

+fileFormatVersion: 2
+guid: 6dc6eb1c59f1c9745b732f87dafd16f2
+timeCreated: 1493044341
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Two Sided/Prefabs/Materials/GroundLeaf_Albedo.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: GroundLeaf_Albedo
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.5882353, g: 0.5882353, b: 0.5882353, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/GraphicTest/Two Sided/Prefabs/Materials/GroundLeaf_Albedo.mat.meta

+fileFormatVersion: 2
+guid: 32cc1012aa8bda142b86f39a95e7973d
+timeCreated: 1492083994
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Mesh/Materials/No Name.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: No Name
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/LayeredLitTest/Mesh/Materials/No Name.mat.meta

+fileFormatVersion: 2
+guid: b2d32da2c9c5b24438e73edfe16d8a6c
+timeCreated: 1492083990
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/WindTest/Materials/Branches_03_BC.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Branches_03_BC
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.588, g: 0.588, b: 0.588, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/WindTest/Materials/Branches_03_BC.mat.meta

+fileFormatVersion: 2
+guid: e02899e01b0528c47b5574d9529b2499
+timeCreated: 1492083997
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/WindTest/Materials/Material #30.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: 'Material #30'
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.588, g: 0.588, b: 0.588, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}