Merge branch 'master' into Branch_Batching2

# Conflicts:
#	Assets/TestScenes/HDTest/NewBatcherTest.meta

.gitmodules

 [submodule "Assets/TestScenes/Big"]
 	path = Assets/TestScenes/Big
 	url = https://github.com/Unity-Technologies/ScriptableRenderLoopScenes
+	
+[submodule "Assets/ScriptableRenderPipeline/PostProcessing"]
+	path = Assets/ScriptableRenderPipeline/PostProcessing
+	url = https://github.com/Unity-Technologies/PostProcessing
+	branch = v2

Assets/ScriptableRenderPipeline/AdditionalLightData.cs

-namespace UnityEngine.Experimental.Rendering
+namespace UnityEngine.Experimental.Rendering
 {
     public enum LightArchetype { Punctual, Area, Projector };
 
 
         [Range(0.0f, 20.0f)]
         public float lightWidth  = 0.0f; // Area & projector lights
+
+        // shadow related parameters
+        [System.Serializable]
+        public struct ShadowData
+        {
+            public int   format;
+            public int[] data;
+        };
+
+        [HideInInspector, SerializeField] private int           shadowAlgorithm;
+        [HideInInspector, SerializeField] private int           shadowVariant;
+        [HideInInspector, SerializeField] private int           shadowPrecision;
+        [HideInInspector, SerializeField] private ShadowData    shadowData;
+        [HideInInspector, SerializeField] private ShadowData[]  shadowDatas = new ShadowData[0];
+
+        public void GetShadowAlgorithm( out int algorithm, out int variant, out int precision )    { algorithm = shadowAlgorithm; variant = shadowVariant; precision = shadowPrecision; }
+        public void SetShadowAlgorithm( int algorithm, int variant, int precision, int format, int[] data )
+        {
+            shadowAlgorithm   = algorithm;
+            shadowVariant     = variant;
+            shadowPrecision   = precision;
+            shadowData.format = format;
+            shadowData.data   = data;
+
+            int idx = FindShadowData( format );
+            if( idx < 0 )
+            {
+                idx = shadowDatas.Length;
+                ShadowData[] tmp = new ShadowData[idx+1];
+                for( int i = 0; i < idx; ++i )
+                    tmp[i] = shadowDatas[i];
+                shadowDatas = tmp;
+            }
+            shadowDatas[idx].format = format;
+            shadowDatas[idx].data   = data != null ? data : new int[0];
+        }
+        // Load a specific shadow data. Returns null if requested data is not present.
+        public int[] GetShadowData( int shadowDataFormat )
+        {
+            if( shadowData.format == shadowDataFormat )
+                return shadowData.data;
+
+            int idx = FindShadowData( shadowDataFormat );
+            return idx >= 0 ? shadowDatas[idx].data : null;
+        }
+        // Returns the currently set shadow data and format. Can return null.
+        public int[] GetShadowData( out int shadowDataFormat )
+        {
+            shadowDataFormat = shadowData.format;
+            return shadowData.data;
+        }
+#if UNITY_EDITOR
+        public void CompactShadowData()
+        {
+            shadowDatas = new ShadowData[0];
+            UnityEditor.EditorUtility.SetDirty(this);
+        }
+#endif
+        private int FindShadowData( int shadowDataFormat )
+        {
+            for( int i = 0; i < shadowDatas.Length; ++i )
+            {
+                if( shadowDatas[i].format == shadowDataFormat )
+                    return i;
+            }
+            return -1;
+        }
+
+#if UNITY_EDITOR
+    [UnityEditor.CustomEditor(typeof(AdditionalLightData))]
+    [UnityEditor.CanEditMultipleObjects]
+    public class AdditionalLightDataEditor : UnityEditor.Editor
+    {
+        static ShadowRegistry m_ShadowRegistry;
+
+#pragma warning disable 414 // CS0414 The private field '...' is assigned but its value is never used
+        UnityEditor.SerializedProperty m_ShadowAlgorithm;
+        UnityEditor.SerializedProperty m_ShadowVariant;
+        UnityEditor.SerializedProperty m_ShadowData;
+        UnityEditor.SerializedProperty m_ShadowDatas;
+#pragma warning restore 414
+
+        public static void SetRegistry( ShadowRegistry registry ) { m_ShadowRegistry = registry; }
+
+        void OnEnable()
+        {
+            m_ShadowAlgorithm = serializedObject.FindProperty( "shadowAlgorithm" );
+            m_ShadowVariant   = serializedObject.FindProperty( "shadowVariant" );
+            m_ShadowData      = serializedObject.FindProperty( "shadowData" );
+            m_ShadowDatas     = serializedObject.FindProperty( "shadowDatas" );
+        }
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            if( m_ShadowRegistry == null )
+                return;
+
+            AdditionalLightData ald = (AdditionalLightData) target;
+            if( ald == null )
+                return;
+
+            UnityEditor.EditorGUI.BeginChangeCheck();
+            m_ShadowRegistry.Draw( ald.gameObject.GetComponent<Light>() );
+            serializedObject.Update();
+            if( UnityEditor.EditorGUI.EndChangeCheck() )
+            {
+                UnityEditor.EditorUtility.SetDirty( ald );
+                UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
+                UnityEditor.SceneView.RepaintAll();
+            }
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+#endif
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [GenerateHLSL]
-    public enum DebugDisplayMode
+    public enum DebugLightingMode
-        ViewMaterial,
         DiffuseLighting,
         SpecularLighting,
         VisualizeCascade
         public bool displayRenderingDebug = false;
         public bool displayLightingDebug = false;
 
-        public DebugDisplayMode debugDisplayMode = DebugDisplayMode.None;
-
-        public bool IsDebugDisplayEnable()
+        private static bool isDebugViewMaterialInit = false;
+        public static GUIContent[] debugViewMaterialStrings = null;
+        public static int[] debugViewMaterialValues = null;
+        public static GUIContent[] debugViewEngineStrings = null;
+        public static int[] debugViewEngineValues = null;
+        public static GUIContent[] debugViewMaterialVaryingStrings = null;
+        public static int[] debugViewMaterialVaryingValues = null;
+        public static GUIContent[] debugViewMaterialGBufferStrings = null;
+        public static int[] debugViewMaterialGBufferValues = null;
+
+        public DebugDisplaySettings()
+        {
+            BuildDebugRepresentation();
+        }
+
+        public int GetDebugMaterialIndex()
+        {
+            return materialDebugSettings.GetDebugMaterialIndex();
+        }
+
+        public DebugLightingMode GetDebugLightingMode()
+        {
+            return lightingDebugSettings.debugLightingMode;
+        }
+
+        public bool IsDebugDisplayEnabled()
+        {
+            return materialDebugSettings.IsDebugDisplayEnabled() || lightingDebugSettings.IsDebugDisplayEnabled();
+        }
+
+        public bool IsDebugMaterialDisplayEnabled()
+        {
+            return materialDebugSettings.IsDebugDisplayEnabled();
+        }
+
+        public void SetDebugViewMaterial(int value)
+        {
+            if (value != 0)
+                lightingDebugSettings.debugLightingMode = DebugLightingMode.None;
+            materialDebugSettings.SetDebugViewMaterial(value);
+        }
+
+        public void SetDebugViewEngine(int value)
+        {
+            if (value != 0)
+                lightingDebugSettings.debugLightingMode = DebugLightingMode.None;
+            materialDebugSettings.SetDebugViewEngine(value);
+        }
+
+        public void SetDebugViewVarying(Attributes.DebugViewVarying value)
+        {
+            if (value != 0)
+                lightingDebugSettings.debugLightingMode = DebugLightingMode.None;
+            materialDebugSettings.SetDebugViewVarying(value);
+        }
+
+        public void SetDebugViewGBuffer(int value)
+        {
+            if (value != 0)
+                lightingDebugSettings.debugLightingMode = DebugLightingMode.None;
+            materialDebugSettings.SetDebugViewGBuffer(value);
+        }
+
+        public void SetDebugLightingMode(DebugLightingMode value)
-            return debugDisplayMode != DebugDisplayMode.None;
+            if(value != 0)
+                materialDebugSettings.DisableMaterialDebug();
+            lightingDebugSettings.debugLightingMode = value;
-        
 
         public void RegisterDebug()
         {
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "Material",() => materialDebugSettings.debugViewMaterial, (value) => SetDebugViewMaterial((int)value), false, new DebugItemDrawerIntEnum(DebugDisplaySettings.debugViewMaterialStrings, DebugDisplaySettings.debugViewMaterialValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "Engine",() => materialDebugSettings.debugViewEngine, (value) => SetDebugViewEngine((int)value), false, new DebugItemDrawerIntEnum(DebugDisplaySettings.debugViewEngineStrings, DebugDisplaySettings.debugViewEngineValues));
+            DebugMenuManager.instance.AddDebugItem<Attributes.DebugViewVarying>("Material", "Attributes",() => materialDebugSettings.debugViewVarying, (value) => SetDebugViewVarying((Attributes.DebugViewVarying)value));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "GBuffer",() => materialDebugSettings.debugViewGBuffer, (value) => SetDebugViewGBuffer((int)value), false, new DebugItemDrawerIntEnum(DebugDisplaySettings.debugViewMaterialGBufferStrings, DebugDisplaySettings.debugViewMaterialGBufferValues));
+
-            //DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, LightingDebugMode>("Lighting Debug Mode", () => lightingDebugSettings.lightingDebugMode, (value) => lightingDebugSettings.lightingDebugMode = (LightingDebugMode)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, DebugLightingMode>("Lighting Debug Mode", () => lightingDebugSettings.debugLightingMode, (value) => SetDebugLightingMode((DebugLightingMode)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);
         {
             lightingDebugSettings.OnValidate();
         }
+
+        void FillWithProperties(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, string strSubNameSpace, ref int index)
+        {
+            var attributes = type.GetCustomAttributes(true);
+            // Get attribute to get the start number of the value for the enum
+            var attr = attributes[0] as GenerateHLSL;
+
+            if (!attr.needParamDebug)
+            {
+                return;
+            }
+
+            var fields = type.GetFields();
+
+            var localIndex = 0;
+            foreach (var field in fields)
+            {
+                var fieldName = field.Name;
+
+                // 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);
+                    if (propertyAttr[0].displayName != "")
+                    {
+                        fieldName = propertyAttr[0].displayName;
+                    }
+                }
+
+                fieldName = strSubNameSpace + fieldName;
+
+                debugViewMaterialStrings[index] = new GUIContent(fieldName);
+                debugViewMaterialValues[index] = attr.paramDefinesStart + (int)localIndex;
+                index++;
+                localIndex++;
+            }
+        }
+
+        void FillWithPropertiesEnum(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, string prefix, ref int index)
+        {
+            var names = Enum.GetNames(type);
+
+            var localIndex = 0;
+            foreach (var value in Enum.GetValues(type))
+            {
+                var valueName = prefix + names[localIndex];
+
+                debugViewMaterialStrings[index] = new GUIContent(valueName);
+                debugViewMaterialValues[index] = (int)value;
+                index++;
+                localIndex++;
+            }
+        }
+
+        string GetSubNameSpaceName(Type type)
+        {
+            return type.Namespace.Substring(type.Namespace.LastIndexOf((".")) + 1) + "/";
+        }
+
+        void BuildDebugRepresentation()
+        {
+            if (!isDebugViewMaterialInit)
+            {
+                var varyingNames = Enum.GetNames(typeof(Attributes.DebugViewVarying));
+                debugViewMaterialVaryingStrings = new GUIContent[varyingNames.Length];
+                debugViewMaterialVaryingValues = new int[varyingNames.Length];
+                var gbufferNames = Enum.GetNames(typeof(Attributes.DebugViewGbuffer));
+                debugViewMaterialGBufferStrings = new GUIContent[gbufferNames.Length + typeof(Lit.BSDFData).GetFields().Length];
+                debugViewMaterialGBufferValues = new int[gbufferNames.Length + typeof(Lit.BSDFData).GetFields().Length];
+
+                var num = typeof(Builtin.BuiltinData).GetFields().Length * 2 // BuildtinData are duplicated for each material
+                    + typeof(Lit.SurfaceData).GetFields().Length
+                    + typeof(Unlit.SurfaceData).GetFields().Length
+                    + 1; // None
+
+                debugViewMaterialStrings = new GUIContent[num];
+                debugViewMaterialValues = new int[num];
+
+                num = typeof(Lit.BSDFData).GetFields().Length
+                    + typeof(Unlit.BSDFData).GetFields().Length
+                    + 1; // None
+
+                debugViewEngineStrings = new GUIContent[num];
+                debugViewEngineValues = new int[num];
+
+
+                // Special case for None since it cannot be inferred from SurfaceDAta/BuiltinData
+                debugViewMaterialStrings[0] = new GUIContent("None");
+                debugViewMaterialValues[0] = 0;
+                var index = 1;
+                // 0 is a reserved number and should not be used (allow to track error)
+                FillWithProperties(typeof(Builtin.BuiltinData), debugViewMaterialStrings, debugViewMaterialValues, GetSubNameSpaceName(typeof(Lit.SurfaceData)), ref index);
+                FillWithProperties(typeof(Lit.SurfaceData), debugViewMaterialStrings, debugViewMaterialValues, GetSubNameSpaceName(typeof(Lit.SurfaceData)), ref index);
+                FillWithProperties(typeof(Builtin.BuiltinData), debugViewMaterialStrings, debugViewMaterialValues, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);
+                FillWithProperties(typeof(Unlit.SurfaceData), debugViewMaterialStrings, debugViewMaterialValues, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);
+
+                // Engine
+                debugViewEngineStrings[0] = new GUIContent("None");
+                debugViewEngineValues[0] = 0;
+                index = 1;
+                FillWithProperties(typeof(Lit.BSDFData), debugViewEngineStrings, debugViewEngineValues, GetSubNameSpaceName(typeof(Lit.BSDFData)), ref index);
+                FillWithProperties(typeof(Unlit.BSDFData), debugViewEngineStrings, debugViewEngineValues, GetSubNameSpaceName(typeof(Unlit.BSDFData)), ref index);
+
+                index = 0;
+                FillWithPropertiesEnum(typeof(Attributes.DebugViewVarying), debugViewMaterialVaryingStrings, debugViewMaterialVaryingValues, "", ref index);
+                index = 0;
+                FillWithPropertiesEnum(typeof(Attributes.DebugViewGbuffer), debugViewMaterialGBufferStrings, debugViewMaterialGBufferValues, "", ref index);
+                FillWithProperties(typeof(Lit.BSDFData), debugViewMaterialGBufferStrings, debugViewMaterialGBufferValues, "", ref index);
+
+                isDebugViewMaterialInit = true;
+            }
+        }
     }
 
     namespace Attributes
         public enum DebugViewVarying
         {
+            None = 0,
             Texcoord0 = 1,
             Texcoord1,
             Texcoord2,
         [GenerateHLSL]
         public enum DebugViewGbuffer
         {
+            None = 0,
             Depth = DebugViewVarying.VertexColorAlpha + 1,
             BakeDiffuseLightingWithAlbedoPlusEmissive,
         }
     public class MaterialDebugSettings
     {
-        public int debugViewMaterial = 0;
+        public int debugViewMaterial { get { return m_DebugViewMaterial; } }
+        public int debugViewEngine { get { return m_DebugViewEngine; } }
+        public Attributes.DebugViewVarying debugViewVarying { get { return m_DebugViewVarying; } }
+        public int debugViewGBuffer { get { return m_DebugViewGBuffer; } }
+
+        int                             m_DebugViewMaterial = 0; // No enum there because everything is generated from materials.
+        int                             m_DebugViewEngine = 0;  // No enum there because everything is generated from BSDFData
+        Attributes.DebugViewVarying     m_DebugViewVarying = Attributes.DebugViewVarying.None;
+        int                             m_DebugViewGBuffer = 0; // Can't use GBuffer enum here because the values are actually split between this enum and values from Lit.BSDFData
+
+        public int GetDebugMaterialIndex()
+        {
+            // This value is used in the shader for the actual debug display.
+            // There is only one uniform parameter for that so we just add all of them
+            // They are all mutually exclusive so return the sum will return the right index.
+            return m_DebugViewGBuffer + m_DebugViewMaterial + m_DebugViewEngine + (int)m_DebugViewVarying;
+        }
+
+        public void DisableMaterialDebug()
+        {
+            m_DebugViewMaterial = 0;
+            m_DebugViewEngine = 0;
+            m_DebugViewVarying = Attributes.DebugViewVarying.None;
+            m_DebugViewGBuffer = 0;
+        }
+
+        public void SetDebugViewMaterial(int value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewMaterial = value;
+        }
+
+        public void SetDebugViewEngine(int value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewEngine = value;
+        }
+
+        public void SetDebugViewVarying(Attributes.DebugViewVarying value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewVarying = value;
+        }
+
+        public void SetDebugViewGBuffer(int value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewGBuffer = value;
+        }
+
+
+        public bool IsDebugDisplayEnabled()
+        {
+            return (m_DebugViewEngine != 0 || m_DebugViewMaterial != 0 || m_DebugViewVarying != Attributes.DebugViewVarying.None || m_DebugViewGBuffer != 0);
+        }
     }
 
     [Serializable]
     [Serializable]
     public class LightingDebugSettings
     {
+        public bool IsDebugDisplayEnabled()
+        {
+            return debugLightingMode != DebugLightingMode.None;
+        }
+
+        public DebugLightingMode    debugLightingMode = DebugLightingMode.None;
         public bool                 enableShadows = true;
         public ShadowMapDebugMode   shadowDebugMode = ShadowMapDebugMode.None;
         public uint                 shadowMapIndex = 0;

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

 #ifndef DEBUGDISPLAY_CS_HLSL
 #define DEBUGDISPLAY_CS_HLSL
 //
-// UnityEngine.Experimental.Rendering.HDPipeline.DebugDisplayMode:  static fields
+// UnityEngine.Experimental.Rendering.HDPipeline.DebugLightingMode:  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)
+#define DEBUGLIGHTINGMODE_NONE (0)
+#define DEBUGLIGHTINGMODE_DIFFUSE_LIGHTING (1)
+#define DEBUGLIGHTINGMODE_SPECULAR_LIGHTING (2)
+#define DEBUGLIGHTINGMODE_VISUALIZE_CASCADE (3)
+#define DEBUGVIEWVARYING_NONE (0)
 #define DEBUGVIEWVARYING_TEXCOORD0 (1)
 #define DEBUGVIEWVARYING_TEXCOORD1 (2)
 #define DEBUGVIEWVARYING_TEXCOORD2 (3)
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewGbuffer:  static fields
 //
+#define DEBUGVIEWGBUFFER_NONE (0)
 #define DEBUGVIEWGBUFFER_DEPTH (10)
 #define DEBUGVIEWGBUFFER_BAKE_DIFFUSE_LIGHTING_WITH_ALBEDO_PLUS_EMISSIVE (11)
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.hlsl

 #include "DebugDisplay.cs.hlsl"
 
 // Set of parameters available when switching to debug shader mode
-int _DebugDisplayMode; // Match enum DebugDisplayMode
+int _DebugLightingMode; // Match enum DebugLightingMode
 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

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

                 int maxLights = 32;
                 if (tileCoord.y < LIGHTCATEGORY_COUNT && tileCoord.x < maxLights + 3)
                 {
-                    PositionInputs mousePosInput = GetPositionInput(_MousePixelCoord, _ScreenSize.zw, uint2(0,0));
+                    PositionInputs mousePosInput = GetPositionInput(_MousePixelCoord, _ScreenSize.zw, mouseTileCoord);
                     float depthMouse = LOAD_TEXTURE2D(_MainDepthTexture, mousePosInput.unPositionSS).x;
                     UpdatePositionInput(depthMouse, _InvViewProjMatrix, _ViewProjMatrix, mousePosInput);
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

     {
         private class Styles
         {
+            public static GUIContent defaults = new GUIContent("Defaults");
+            public static GUIContent defaultDiffuseMaterial = new GUIContent("Default Diffuse Material", "Material to use when creating objects");
+            public static GUIContent defaultShader = new GUIContent("Default Shader", "Shader to use when creating materials");
+
             public readonly GUIContent settingsLabel = new GUIContent("Settings");
 
             // Rendering Settings
             public readonly GUIContent shadowsAtlasHeight = new GUIContent("Atlas height");
 
             // Subsurface Scattering Settings
-            public readonly GUIContent[] sssProfiles             = new GUIContent[SubsurfaceScatteringSettings.maxNumProfiles] { new GUIContent("Profile #0"), new GUIContent("Profile #1"), new GUIContent("Profile #2"), new GUIContent("Profile #3"), new GUIContent("Profile #4"), new GUIContent("Profile #5"), new GUIContent("Profile #6"), new GUIContent("Profile #7") };
+            public readonly GUIContent[] sssProfiles             = new GUIContent[SSSConstants.SSS_PROFILES_MAX] { new GUIContent("Profile #0"), new GUIContent("Profile #1"), new GUIContent("Profile #2"), new GUIContent("Profile #3"), new GUIContent("Profile #4"), new GUIContent("Profile #5"), new GUIContent("Profile #6"), new GUIContent("Profile #7") };
             public readonly GUIContent   sssNumProfiles          = new GUIContent("Number of profiles");
 
             // Tile pass Settings
             public readonly GUIContent skyParams = new GUIContent("Sky 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 bool isDebugViewMaterialInit = false;
-            public GUIContent[] debugViewMaterialStrings = null;
-            public int[] debugViewMaterialValues = null;
+            public readonly GUIContent debugViewEngine = new GUIContent("DebugView Engine", "Display various properties of Materials.");
+            public readonly GUIContent debugViewMaterialVarying = new GUIContent("DebugView Attributes", "Display varying input of Materials.");
+            public readonly GUIContent debugViewMaterialGBuffer = new GUIContent("DebugView GBuffer", "Display GBuffer properties.");
 
             // Rendering Debug
             public readonly GUIContent renderingDebugSettings = new GUIContent("Rendering Debug");
             // Lighting Debug
             public readonly GUIContent lightingDebugSettings = new GUIContent("Lighting Debug");
             public readonly GUIContent shadowDebugEnable = new GUIContent("Enable Shadows");
+            public readonly GUIContent lightingVisualizationMode = new GUIContent("Lighting Debug Mode");
+            public readonly GUIContent[] debugViewLightingStrings = { new GUIContent("None"), new GUIContent("Diffuse Lighting"), new GUIContent("Specular Lighting"), new GUIContent("Visualize Cascades") };
+            public readonly int[] debugViewLightingValues = { (int)DebugLightingMode.None, (int)DebugLightingMode.DiffuseLighting, (int)DebugLightingMode.SpecularLighting, (int)DebugLightingMode.VisualizeCascade };
-            public readonly GUIContent shadowDebugVisualizeShadowIndex = new GUIContent("Visualize Shadow Index");            
+            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");
                 return s_Styles;
             }
         }
+
+        private SerializedProperty m_DefaultDiffuseMaterial;
+        private SerializedProperty m_DefaultShader;
-        SerializedProperty m_DebugDisplayMode = null;
-
-        // Material Debug
-        SerializedProperty m_MaterialDebugMode = null;
 
         // Rendering Debug
         SerializedProperty m_DisplayOpaqueObjects = null;
 
         private void InitializeProperties()
         {
+            m_DefaultDiffuseMaterial = serializedObject.FindProperty("m_DefaultDiffuseMaterial");
+            m_DefaultShader = serializedObject.FindProperty("m_DefaultShader");
+
-            m_DebugDisplayMode = FindProperty(x => x.debugDisplaySettings.debugDisplayMode);
-
-            // Material debug
-            m_MaterialDebugMode = FindProperty(x => x.debugDisplaySettings.materialDebugSettings.debugViewMaterial);
 
             // Rendering debug
             m_DisplayOpaqueObjects = FindProperty(x => x.debugDisplaySettings.renderingDebugSettings.displayOpaqueObjects);
             return serializedObject.FindProperty(path);
         }
 
-        string GetSubNameSpaceName(Type type)
-        {
-            return type.Namespace.Substring(type.Namespace.LastIndexOf((".")) + 1) + "/";
-        }
-
-        void FillWithProperties(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, bool isBSDFData, string strSubNameSpace, ref int index)
-        {
-            var attributes = type.GetCustomAttributes(true);
-            // Get attribute to get the start number of the value for the enum
-            var attr = attributes[0] as GenerateHLSL;
-
-            if (!attr.needParamDebug)
-            {
-                return;
-            }
-
-            var fields = type.GetFields();
-
-            var localIndex = 0;
-            foreach (var field in fields)
-            {
-                var fieldName = field.Name;
-
-                // 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);
-                    if (propertyAttr[0].displayName != "")
-                    {
-                        fieldName = propertyAttr[0].displayName;
-                    }
-                }
-
-                fieldName = (isBSDFData ? "Engine/" : "") + strSubNameSpace + fieldName;
-
-                debugViewMaterialStrings[index] = new GUIContent(fieldName);
-                debugViewMaterialValues[index] = attr.paramDefinesStart + (int)localIndex;
-                index++;
-                localIndex++;
-            }
-        }
-
-        void FillWithPropertiesEnum(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, string prefix, bool isBSDFData, ref int index)
-        {
-            var names = Enum.GetNames(type);
-
-            var localIndex = 0;
-            foreach (var value in Enum.GetValues(type))
-            {
-                var valueName = (isBSDFData ? "Engine/" : "" + prefix) + names[localIndex];
-
-                debugViewMaterialStrings[index] = new GUIContent(valueName);
-                debugViewMaterialValues[index] = (int)value;
-                index++;
-                localIndex++;
-            }
-        }
-
         static void HackSetDirty(RenderPipelineAsset asset)
         {
             EditorUtility.SetDirty(asset);
 
             // Debug Display settings
             EditorGUI.indentLevel++;
-            EditorGUILayout.PropertyField(m_DebugDisplayMode, styles.debugDisplayMode);
-            if ((DebugDisplayMode)m_DebugDisplayMode.intValue == DebugDisplayMode.ViewMaterial)
-            {
-                MaterialDebugSettingsUI(renderContext);
-            }
-            else
-            {
-                LightingDebugSettingsUI(renderContext, renderpipelineInstance);
-            }            
+            MaterialDebugSettingsUI(renderContext);
+            LightingDebugSettingsUI(renderContext, renderpipelineInstance);
 
             EditorGUILayout.Space();
 
         private void MaterialDebugSettingsUI(HDRenderPipeline renderContext)
         {
+            HDRenderPipeline hdPipe = target as HDRenderPipeline;
+
+
+            bool dirty = false;
-
-            if (!styles.isDebugViewMaterialInit)
+            int value = EditorGUILayout.IntPopup(styles.debugViewMaterial, hdPipe.debugDisplaySettings.materialDebugSettings.debugViewMaterial, DebugDisplaySettings.debugViewMaterialStrings, DebugDisplaySettings.debugViewMaterialValues);
+            if (EditorGUI.EndChangeCheck())
-                var varyingNames = Enum.GetNames(typeof(Attributes.DebugViewVarying));
-                var gbufferNames = Enum.GetNames(typeof(Attributes.DebugViewGbuffer));
-
-                var num = varyingNames.Length
-                    + gbufferNames.Length
-                    + typeof(Builtin.BuiltinData).GetFields().Length * 2       // BuildtinData are duplicated for each material
-                    + typeof(Lit.SurfaceData).GetFields().Length
-                    + typeof(Lit.BSDFData).GetFields().Length
-                    + typeof(Unlit.SurfaceData).GetFields().Length
-                    + typeof(Unlit.BSDFData).GetFields().Length;
-
-                styles.debugViewMaterialStrings = new GUIContent[num];
-                styles.debugViewMaterialValues = new int[num];
-
-                var index = 0;
-
-                // 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);
-                FillWithProperties(typeof(Builtin.BuiltinData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);
-                FillWithProperties(typeof(Unlit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);
-
-                // Engine
-                FillWithPropertiesEnum(typeof(Attributes.DebugViewGbuffer), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, "", true, ref index);
-                FillWithProperties(typeof(Lit.BSDFData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, true, "", ref index);
-                FillWithProperties(typeof(Unlit.BSDFData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, true, "", ref index);
+                hdPipe.debugDisplaySettings.SetDebugViewMaterial(value);
+                dirty = true;
+            }
-                styles.isDebugViewMaterialInit = true;
+            EditorGUI.BeginChangeCheck();
+            value = EditorGUILayout.IntPopup(styles.debugViewEngine, hdPipe.debugDisplaySettings.materialDebugSettings.debugViewEngine, DebugDisplaySettings.debugViewEngineStrings, DebugDisplaySettings.debugViewEngineValues);
+            if (EditorGUI.EndChangeCheck())
+            {
+                hdPipe.debugDisplaySettings.SetDebugViewEngine(value);
+                dirty = true;
-            EditorGUI.showMixedValue = m_MaterialDebugMode.hasMultipleDifferentValues;
-            m_MaterialDebugMode.intValue = EditorGUILayout.IntPopup(styles.debugViewMaterial, m_MaterialDebugMode.intValue, styles.debugViewMaterialStrings, styles.debugViewMaterialValues);
-            EditorGUI.showMixedValue = false;
+            EditorGUI.BeginChangeCheck();
+            value = EditorGUILayout.IntPopup(styles.debugViewMaterialVarying, (int)hdPipe.debugDisplaySettings.materialDebugSettings.debugViewVarying, DebugDisplaySettings.debugViewMaterialVaryingStrings, DebugDisplaySettings.debugViewMaterialVaryingValues);
+            if (EditorGUI.EndChangeCheck())
+            {
+                hdPipe.debugDisplaySettings.SetDebugViewVarying((Attributes.DebugViewVarying)value);
+                dirty = true;
+            }
+            EditorGUI.BeginChangeCheck();
+            value = EditorGUILayout.IntPopup(styles.debugViewMaterialGBuffer, (int)hdPipe.debugDisplaySettings.materialDebugSettings.debugViewGBuffer, DebugDisplaySettings.debugViewMaterialGBufferStrings, DebugDisplaySettings.debugViewMaterialGBufferValues);
-                HackSetDirty(renderContext); // Repaint
+                hdPipe.debugDisplaySettings.SetDebugViewGBuffer(value);
+                dirty = true;
+
+            if(dirty)
+                HackSetDirty(renderContext); // Repaint
+
             EditorGUI.indentLevel--;
         }
 
 
             EditorGUILayout.PropertyField(m_NumProfiles, styles.sssNumProfiles);
 
-            for (int i = 0, n = Math.Min(m_Profiles.arraySize, SubsurfaceScatteringSettings.maxNumProfiles); i < n; i++)
+            for (int i = 0, n = Math.Min(m_Profiles.arraySize, SSSConstants.SSS_PROFILES_MAX); i < n; i++)
             {
                 SerializedProperty profile = m_Profiles.GetArrayElementAtIndex(i);
                 EditorGUILayout.PropertyField(profile, styles.sssProfiles[i]);
             if (!m_ShowLightingDebug.boolValue)
                 return;
 
-            EditorGUI.BeginChangeCheck();
+            HDRenderPipeline hdPipe = target as HDRenderPipeline;
+            bool dirty = false;
+            EditorGUI.BeginChangeCheck();
             EditorGUI.indentLevel++;
             EditorGUILayout.PropertyField(m_DebugShadowEnabled, styles.shadowDebugEnable);
             EditorGUILayout.PropertyField(m_ShadowDebugMode, styles.shadowDebugVisualizationMode);
                     EditorGUILayout.IntSlider(m_ShadowDebugShadowMapIndex, 0, renderpipelineInstance.GetCurrentShadowCount() - 1, styles.shadowDebugVisualizeShadowIndex);
                 }
             }
+            if (EditorGUI.EndChangeCheck())
+            {
+                dirty = true;
+            }
-            if (!m_DebugDisplayMode.hasMultipleDifferentValues)
+            EditorGUI.BeginChangeCheck();
+            int value = EditorGUILayout.IntPopup(styles.lightingVisualizationMode, (int)hdPipe.debugDisplaySettings.lightingDebugSettings.debugLightingMode, styles.debugViewLightingStrings, styles.debugViewLightingValues);
+            if (EditorGUI.EndChangeCheck())
+            {
+                hdPipe.debugDisplaySettings.SetDebugLightingMode((DebugLightingMode)value);
+                dirty = true;
+            }
+
+            EditorGUI.BeginChangeCheck();
+            if (hdPipe.debugDisplaySettings.GetDebugLightingMode() == DebugLightingMode.DiffuseLighting)
-                if ((DebugDisplayMode)m_DebugDisplayMode.intValue == DebugDisplayMode.DiffuseLighting)
-                {
-                    EditorGUI.indentLevel++;
-                    EditorGUILayout.PropertyField(m_LightingDebugAlbedo, styles.lightingDebugAlbedo);
-                    EditorGUI.indentLevel--;
-                }
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_LightingDebugAlbedo, styles.lightingDebugAlbedo);
+                EditorGUI.indentLevel--;
+            }
-                if ((DebugDisplayMode)m_DebugDisplayMode.intValue == DebugDisplayMode.SpecularLighting)
+            if (hdPipe.debugDisplaySettings.GetDebugLightingMode() == DebugLightingMode.SpecularLighting)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_LightingDebugOverrideSmoothness, styles.lightingDebugOverrideSmoothness);
+                if (!m_LightingDebugOverrideSmoothness.hasMultipleDifferentValues && m_LightingDebugOverrideSmoothness.boolValue == true)
-                    EditorGUILayout.PropertyField(m_LightingDebugOverrideSmoothness, styles.lightingDebugOverrideSmoothness);
-                    if (!m_LightingDebugOverrideSmoothness.hasMultipleDifferentValues && m_LightingDebugOverrideSmoothness.boolValue == true)
-                    {
-                        EditorGUI.indentLevel++;
-                        EditorGUILayout.PropertyField(m_LightingDebugOverrideSmoothnessValue, styles.lightingDebugOverrideSmoothnessValue);
-                        EditorGUI.indentLevel--;
-                    }
+                    EditorGUILayout.PropertyField(m_LightingDebugOverrideSmoothnessValue, styles.lightingDebugOverrideSmoothnessValue);
+                EditorGUI.indentLevel--;
             }
 
             EditorGUILayout.PropertyField(m_LightingDebugDisplaySkyReflection, styles.lightingDisplaySkyReflection);
 
             if (EditorGUI.EndChangeCheck())
             {
+                dirty = true;
+            }
+
+            if(dirty)
-            }
         }
 
         private void SettingsUI(HDRenderPipeline renderContext)
                 return;
 
             serializedObject.Update();
+
+            EditorGUILayout.LabelField(Styles.defaults, EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_DefaultDiffuseMaterial, Styles.defaultDiffuseMaterial);
+            EditorGUILayout.PropertyField(m_DefaultShader, Styles.defaultShader);
+            EditorGUI.indentLevel--;
 
             DebuggingUI(renderContext, renderpipelineInstance);
             SettingsUI(renderContext);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

             }
         }
 
+        [MenuItem("HDRenderPipeline/Swap standard and SSS material IDs")]
+        static void SwapStandardAndSssMaterialIds()
+        {
+            try
+            {
+                Object[] materials = Resources.FindObjectsOfTypeAll<Material>();
+                for (int i = 0, length = materials.Length; i < length; i++)
+                {
+                    Material mat = materials[i] as Material;
+
+                    EditorUtility.DisplayProgressBar(
+                        "Updating materials...",
+                        string.Format("{0} / {1}", i, length),
+                        i / (float)(length - 1));
+
+                    if (mat.shader.name == "HDRenderPipeline/Lit" || mat.shader.name == "HDRenderPipeline/LitTessellation")
+                    {
+                        int matID = (int)mat.GetFloat("_MaterialID");
+
+                        if (matID == 0)
+                        {
+                            matID = 1;
+                            mat.SetInt("_MaterialID", matID);
+                            EditorUtility.SetDirty(mat);
+                        }
+                        else if (matID == 1)
+                        {
+                            matID = 0;
+                            mat.SetInt("_MaterialID", matID);
+                            EditorUtility.SetDirty(mat);
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                EditorUtility.ClearProgressBar();
+            }
+        }
+
         [MenuItem("HDRenderPipeline/Debug/Remove tessellation materials (not reversible)")]
         static void RemoveTessellationMaterials()
         {

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.asset

     displayMaterialDebug: 1
     displayRenderingDebug: 0
     displayLightingDebug: 0
-    debugDisplayMode: 0
-    materialDebugSettings:
-      debugViewMaterial: 1
+      debugLightingMode: 0
       enableShadows: 1
       shadowDebugMode: 0
       shadowMapIndex: 0
     numProfiles: 7
     profiles:
     - {fileID: 11400000, guid: d6ee4403015766f4093158d69216c0bf, type: 2}
-    - {fileID: 0}
+    - {fileID: 11400000, guid: 906339bac2066fc4aa22a3652e1283ef, type: 2}
     - {fileID: 0}
     - {fileID: 0}
     - {fileID: 0}
     enabled: 1
     shadowAtlasWidth: 4096
     shadowAtlasHeight: 4096
-    maxShadowDistance: 1000
+    maxShadowDistance: 400
     directionalLightCascadeCount: 4
     directionalLightCascades: {x: 0.05, y: 0.2, z: 0.3}
     directionalLightNearPlaneOffset: 5
     m_ShadowCascadeSplit2: 0.3
     m_ShadowNearPlaneOffset: 5
   m_SkySettings: {fileID: 0}
+  m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
+    type: 2}
+  m_DefaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 using UnityEngine.Rendering;
 using System;
 using System.Linq;
+using UnityEngine.Experimental.PostProcessing;
 using UnityEngine.Experimental.Rendering.HDPipeline.TilePass;
 
 #if UNITY_EDITOR
             }
         }
 
+        [SerializeField] private Material m_DefaultDiffuseMaterial;
+        [SerializeField] private Shader m_DefaultShader;
+
+        public Material DefaultDiffuseMaterial
+        {
+            get { return m_DefaultDiffuseMaterial; }
+            private set { m_DefaultDiffuseMaterial = value; }
+        }
+        public override Shader GetDefaultShader()
+        {
+            return m_DefaultShader;
+        }
+
+        public override Material GetDefaultMaterial()
+        {
+            return m_DefaultDiffuseMaterial;
+        }
+
+        public override Material GetDefaultParticleMaterial()
+        {
+            return m_DefaultDiffuseMaterial;
+        }
+
+        public override Material GetDefaultLineMaterial()
+        {
+            return m_DefaultDiffuseMaterial;
+        }
+
+        public override Material GetDefaultTerrainMaterial()
+        {
+            return m_DefaultDiffuseMaterial;
+        }
+
+        public override Material GetDefaultUIMaterial()
+        {
+            return m_DefaultDiffuseMaterial;
+        }
+
+        public override Material GetDefaultUIOverdrawMaterial()
+        {
+            return m_DefaultDiffuseMaterial;
+        }
+
+        public override Material GetDefaultUIETC1SupportedMaterial()
+        {
+            return m_DefaultDiffuseMaterial;
+        }
+
+        public override Material GetDefault2DMaterial()
+        {
+            return m_DefaultDiffuseMaterial;
+        }
+
         public void ApplyDebugDisplaySettings()
         {
             m_ShadowSettings.enabled = debugDisplaySettings.lightingDebugSettings.enableShadows;
             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.SetGlobalInt("_DebugViewMaterial", (int)debugDisplaySettings.GetDebugMaterialIndex());
+            Shader.SetGlobalInt("_DebugLightingMode", (int)debugDisplaySettings.GetDebugLightingMode());
             Shader.SetGlobalVector("_DebugLightingAlbedo", debugAlbedo);
             Shader.SetGlobalVector("_DebugLightingSmoothness", debugSmoothness);
         }
         private RenderTargetIdentifier m_CameraDepthStencilBufferRT;
         private RenderTargetIdentifier m_CameraDepthStencilBufferCopyRT;
 
+        // Post-processing context (recycled on every frame to avoid GC alloc)
+        readonly PostProcessRenderContext m_PostProcessContext;
+
-        ShadowRenderPass m_ShadowPass;
-        ShadowOutput m_ShadowsResult = new ShadowOutput();
-
-        public int GetCurrentShadowCount() { return m_ShadowsResult.shadowLights == null ? 0 : m_ShadowsResult.shadowLights.Length; }
+        public int GetCurrentShadowCount() { return m_LightLoop.GetCurrentShadowCount(); }
 
         readonly SkyManager m_SkyManager = new SkyManager();
         private readonly BaseLightLoop m_LightLoop;
             m_CameraFilteringBufferRT           = new RenderTargetIdentifier(m_CameraFilteringBuffer);
 
             m_FilterSubsurfaceScattering = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CombineSubsurfaceScattering");
-            m_FilterSubsurfaceScattering.DisableKeyword("FILTER_HORIZONTAL_AND_COMBINE");
+            m_FilterSubsurfaceScattering.DisableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
-            m_FilterAndCombineSubsurfaceScattering.EnableKeyword("FILTER_HORIZONTAL_AND_COMBINE");
+            m_FilterAndCombineSubsurfaceScattering.EnableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
-            m_ShadowPass = new ShadowRenderPass(owner.shadowSettings);
-
             // Init Gbuffer description
             m_gbufferManager.gbufferCount = m_LitRenderLoop.GetMaterialGBufferCount();
             RenderTextureFormat[] RTFormat;
 
             m_SkyManager.Build();
             m_SkyManager.skySettings = owner.skySettingsToUse;
+
+            m_PostProcessContext = new PostProcessRenderContext();
         }
 
         void InitializeDebugMaterials()
             m_DebugDisplayLatlong = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugDisplayLatlong");
         }
 
+        public void OnSceneLoad()
+        {
+            // Recreate the textures which went NULL, and set 'isInit' to 'false'.
+            m_LitRenderLoop.Build();
+        }
+
         public override void Dispose()
         {
             base.Dispose();
 
             // Broadcast SSS parameters to all shaders.
             Shader.SetGlobalInt("_EnableSSS", debugDisplaySettings.renderingDebugSettings.enableSSS ? 1 : 0);
-            Shader.SetGlobalInt("_TransmissionFlags",   sssParameters.transmissionFlags);
+            cmd.SetGlobalFloatArray("_TransmissionType",   sssParameters.transmissionType);
             Shader.SetGlobalInt("_TexturingModeFlags",  sssParameters.texturingModeFlags);
             cmd.SetGlobalFloatArray("_ThicknessRemaps", sssParameters.thicknessRemaps);
             cmd.SetGlobalVectorArray("_TintColors",     sssParameters.tintColors);
         private void CopyDepthBufferIfNeeded(ScriptableRenderContext renderContext)
         {
             var cmd = new CommandBuffer() { name = NeedDepthBufferCopy() ? "Copy DepthBuffer" : "Set DepthBuffer"};
-            
+
             if (NeedDepthBufferCopy())
             {
                 using (new Utilities.ProfilingSample("Copy depth-stencil buffer", renderContext))
 
             Camera camera = cameras.OrderByDescending(x => x.tag == "MainCamera").FirstOrDefault();
             if (camera == null)
+            {
+                renderContext.Submit();
+            }
 
             // Set camera constant buffer
             // TODO...
+            {
+                renderContext.Submit();
+            }
-            m_ShadowPass.UpdateCullingParameters(ref cullingParams);
+            m_LightLoop.UpdateCullingParameters( ref cullingParams );
 
             var cullResults = CullResults.Cull(ref cullingParams, renderContext);
 
                 CopyDepthBufferIfNeeded(renderContext);
             }
 
-            if (debugDisplaySettings.debugDisplayMode == DebugDisplayMode.ViewMaterial)
+            if (debugDisplaySettings.IsDebugMaterialDisplayEnabled())
-                using (new Utilities.ProfilingSample("Shadow", renderContext))
-                {
-                    m_ShadowPass.Render(renderContext, cullResults, out m_ShadowsResult);
-                }
-
-                renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
-
-                        m_LightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera, ref m_ShadowsResult);
+                        m_LightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera);
                         m_LightLoop.RenderShadows(renderContext, cullResults);
                         renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
                         m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT); // TODO: Use async compute here to run light culling during shadow
                 // Material that are always forward are unlit and complex (Like Hair) and don't require sorting, so it is ok to split them.
                 RenderForward(cullResults, camera, renderContext, true); // Render deferred or forward opaque
                 RenderForwardOnlyOpaque(cullResults, camera, renderContext);
+
+                RenderLightingDebug(hdCamera, renderContext, m_CameraColorBufferRT);
 
                 // If full forward rendering, we did just rendered everything, so we can copy the depth buffer
                 // If Deferred nothing needs copying anymore.
                     // Instead we chose to apply distortion at the end after we cumulate distortion vector and desired blurriness. This
                     RenderDistortion(cullResults, camera, renderContext);
 
-                    FinalPass(camera, renderContext);
+                    RenderPostProcesses(camera, renderContext);
                 }
             }
 
                 return;
             }
 
-            string passName = debugDisplaySettings.IsDebugDisplayEnable() ? "GBufferDebugDisplay" : "GBuffer";
+            string passName = debugDisplaySettings.IsDebugDisplayEnabled() ? "GBufferDebugDisplay" : "GBuffer";
 
             using (new Utilities.ProfilingSample(passName, renderContext))
             {
             m_FilterSubsurfaceScattering.SetVectorArray("_FilterKernels", sssParameters.filterKernels);
             m_FilterSubsurfaceScattering.SetVectorArray("_HalfRcpWeightedVariances", sssParameters.halfRcpWeightedVariances);
             cmd.SetGlobalTexture("_IrradianceSource", m_CameraSubsurfaceBufferRT);
-            Utilities.DrawFullScreen(cmd, m_FilterSubsurfaceScattering, hdCamera,
-                m_CameraFilteringBufferRT, m_CameraDepthStencilBufferRT);
+            Utilities.DrawFullScreen(cmd, m_FilterSubsurfaceScattering, hdCamera, m_CameraFilteringBufferRT, m_CameraDepthStencilBufferRT);
+
+            // when recombining the lighting, we apply albedo. This need to be modified in case of debug display with diffuse lighting only.
+            Utilities.SetKeyword(m_FilterAndCombineSubsurfaceScattering, "DEBUG_DISPLAY", debugDisplaySettings.IsDebugDisplayEnabled());
-            Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, hdCamera,
-                m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+            Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, hdCamera, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
 
             context.ExecuteCommandBuffer(cmd);
             cmd.Dispose();
             return m_SkyManager.ExportSkyToTexture();
         }
 
+        void RenderLightingDebug(HDCamera camera, ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer)
+        {
+            if (m_LightLoop != null)
+                m_LightLoop.RenderLightingDebug(camera, renderContext, colorBuffer);
+        }
+
         void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
         {
             // TODO: Currently we can't render opaque object forward when deferred is enabled
 
-            string passName = debugDisplaySettings.IsDebugDisplayEnable() ? "ForwardDisplayDebug" : "Forward";
+            string passName = debugDisplaySettings.IsDebugDisplayEnabled() ? "ForwardDisplayDebug" : "Forward";
 
             using (new Utilities.ProfilingSample(passName, renderContext))
             {
         // Render material that are forward opaque only (like eye), this include unlit material
         void RenderForwardOnlyOpaque(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext)
         {
-            string passName = debugDisplaySettings.IsDebugDisplayEnable() ? "ForwardOnlyOpaqueDisplayDebug" : "ForwardOnlyOpaque";
+            string passName = debugDisplaySettings.IsDebugDisplayEnabled() ? "ForwardOnlyOpaqueDisplayDebug" : "ForwardOnlyOpaque";
 
             using (new Utilities.ProfilingSample(passName, renderContext))
             {
             }
         }
 
-        void FinalPass(Camera camera, ScriptableRenderContext renderContext)
+        void RenderPostProcesses(Camera camera, ScriptableRenderContext renderContext)
-            using (new Utilities.ProfilingSample("Final", renderContext))
+            using (new Utilities.ProfilingSample("Post-processing", 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
+                var postProcessLayer = camera.GetComponent<PostProcessLayer>();
+                var cmd = new CommandBuffer { name = "" };
-                var localPostProcess = camera.GetComponent<PostProcessingSRP>();
+                if (postProcessLayer != null && postProcessLayer.enabled)
+                {
+                    cmd.SetGlobalTexture("_CameraDepthTexture", GetDepthTexture());
-                bool localActive = localPostProcess != null && localPostProcess.enabled;
+                    var context = m_PostProcessContext;
+                    context.Reset();
+                    context.source = m_CameraColorBufferRT;
+                    context.destination = BuiltinRenderTextureType.CameraTarget;
+                    context.command = cmd;
+                    context.camera = camera;
+                    context.sourceFormat = RenderTextureFormat.ARGBHalf; // ?
+                    context.flip = true;
-                if (!localActive)
+                    postProcessLayer.Render(context);
+                }
+                else
-                    var cmd = new CommandBuffer { name = "" };
-                    renderContext.ExecuteCommandBuffer(cmd);
-                    cmd.Dispose();
-                    return;
-                localPostProcess.Render(camera, renderContext, m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
+                renderContext.ExecuteCommandBuffer(cmd);
+                cmd.Dispose();
             }
         }
 
             {
                 if (lightingDebug.shadowDebugMode == ShadowMapDebugMode.VisualizeShadowMap)
                 {
+#if SHADOWS_OLD
                     uint visualizeShadowIndex = Math.Min(lightingDebug.shadowMapIndex, (uint)(GetCurrentShadowCount() - 1));
                     ShadowLight shadowLight = m_ShadowsResult.shadowLights[visualizeShadowIndex];
                     for (int slice = 0; slice < shadowLight.shadowSliceCount; ++slice)
 
                         NextOverlayCoord(ref x, ref y, overlaySize, camera.pixelWidth);
                     }
+#endif
                 }
                 else if (lightingDebug.shadowDebugMode == ShadowMapDebugMode.VisualizeAtlas)
                 {
             }
 
             renderContext.ExecuteCommandBuffer(debugCB);
-        }
-
-        // Function to prepare light structure for GPU lighting
-        void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput)
-        {
-            // build per tile light lists
-            if (m_LightLoop != null)
-                m_LightLoop.PrepareLightsForGPU(shadowSettings, cullResults, camera, ref shadowOutput);
         }
 
         void InitAndClearBuffer(Camera camera, ScriptableRenderContext renderContext)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs

     };
 
 
-    // TODO: we may have to add various parameters here for shadow - was suppose to be coupled with a light loop
-    // A point light is 6x PunctualShadowData
-    [GenerateHLSL]
-    public struct ShadowData
-    {
-        // World to ShadowMap matrix
-        // Include scale and bias for shadow atlas if any
-        public Matrix4x4 worldToShadow;
-
-        public float bias;
-        public float quality;
-        public float unused;
-        public float unused2;
-        public Vector4 invResolution;
-    };
-
     [GenerateHLSL]
     public enum EnvShapeType
     {

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

     int cookieIndex;
 };
 
-// Generated from UnityEngine.Experimental.Rendering.HDPipeline.ShadowData
-// PackingRules = Exact
-struct ShadowData
-{
-    float4x4 worldToShadow;
-    float bias;
-    float quality;
-    float unused;
-    float unused2;
-    float4 invResolution;
-};
-
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.EnvLightData
 // PackingRules = Exact
 struct EnvLightData
 int GetCookieIndex(DirectionalLightData value)
 {
 	return value.cookieIndex;
-}
-
-//
-// Accessors for UnityEngine.Experimental.Rendering.HDPipeline.ShadowData
-//
-float4x4 GetWorldToShadow(ShadowData value)
-{
-	return value.worldToShadow;
-}
-float GetBias(ShadowData value)
-{
-	return value.bias;
-}
-float GetQuality(ShadowData value)
-{
-	return value.quality;
-}
-float GetUnused(ShadowData value)
-{
-	return value.unused;
-}
-float GetUnused2(ShadowData value)
-{
-	return value.unused2;
-}
-float4 GetInvResolution(ShadowData value)
-{
-	return value.invResolution;
 }
 
 //

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop.cs

-using UnityEngine;
+using UnityEngine;
 using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 
         public virtual void NewFrame() {}
 
-        public virtual void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput) {}
+        public virtual int GetCurrentShadowCount() { return 0; }
+        public virtual void UpdateCullingParameters( ref CullingParameters cullingParams ) {}
+        public virtual void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera) {}
-
+        
         // 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) {}
 
                                                     bool outputSplitLightingForSSS) { }
 
         public virtual void RenderForward(Camera camera, ScriptableRenderContext renderContext, bool renderOpaque) {}
+
+        public virtual void RenderLightingDebug(HDCamera hdCamera, ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer) {}
 
         public Light GetCurrentSunLight() { return m_CurrentSunLight;  }
     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Lighting.hlsl

 #include "../Lighting/LightDefinition.cs.hlsl"
 #include "../Lighting/LightUtilities.hlsl"
 
-#include "../Shadow/Shadow.hlsl"
+#define SHADOW_TILEPASS
+#include "../../ShaderLibrary/Shadow/Shadow.hlsl"
+#undef SHADOW_TILEPASS
 
 #if defined(LIGHTLOOP_SINGLE_PASS) || defined(LIGHTLOOP_TILE_PASS)
 #include "../Lighting/TilePass/TilePass.hlsl"

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TileLightLoopProducer.cs

             [Range(0.0f, 1.0f)]
             public float specularGlobalDimmer = 1.0f;
 
-            public enum TileDebug : int { None = 0, Punctual = 1, Area = 2, AreaAndPunctual = 3, Environment = 4, EnvironmentAndPunctual = 5, EnvironmentAndArea = 6, EnvironmentAndAreaAndPunctual = 7, FeatureVariants = 8 };
+            public enum TileDebug : int { None = 0, Punctual = 1, Area = 2, AreaAndPunctual = 3, Projector = 4, ProjectorAndPunctual = 5, ProjectorAndArea = 6, ProjectorAndAreaAndPunctual = 7,
+                Environment = 8, EnvironmentAndPunctual = 9, EnvironmentAndArea = 10, EnvironemntAndAreaAndPunctual = 11,
+                EnvironmentAndProjector = 12, EnvironmentAndProjectorAndPunctual = 13, EnvironmentAndProjectorAndArea = 14, EnvironmentAndProjectorAndAreaAndPunctual = 15,
+                FeatureVariants = 16 }; //TODO: we should probably make this checkboxes
             public TileDebug tileDebugByCategory;
 
             public static TileSettings defaultSettings = new TileSettings

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

 #ifndef __FEATURE_FLAGS_H__
 #define __FEATURE_FLAGS_H__
 
-static const uint FEATURE_FLAG_ALL_MATERIALS = FEATURE_FLAG_MATERIAL_LIT_STANDARD | FEATURE_FLAG_MATERIAL_LIT_SSS | FEATURE_FLAG_MATERIAL_LIT_CLEAR_COAT | FEATURE_FLAG_MATERIAL_LIT_SPECULAR | FEATURE_FLAG_MATERIAL_LIT_ANISO;
+static const uint FEATURE_FLAG_ALL_MATERIALS = FEATURE_FLAG_MATERIAL_LIT_STANDARD | FEATURE_FLAG_MATERIAL_LIT_SSS | FEATURE_FLAG_MATERIAL_LIT_SPECULAR | FEATURE_FLAG_MATERIAL_LIT_ANISO;
 
 static const uint FeatureVariantFlags[NUM_FEATURE_VARIANTS] =
 {

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_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
-}
-
+#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

-//#define SHADOWS_ENABLED
-//#define SHADOWS_FIXSHADOWIDX
-using UnityEngine.Rendering;
+using UnityEngine.Rendering;
-#if SHADOWS_ENABLED
-    using ShadowExp;
-
     class ShadowSetup : IDisposable
     {
         // shadow related stuff
 
         public ShadowSetup(ShadowSettings shadowSettings, out IShadowManager shadowManager)
         {
-            s_ShadowDataBuffer      = new ComputeBuffer(k_MaxShadowDataSlots, System.Runtime.InteropServices.Marshal.SizeOf(typeof(ShadowExp.ShadowData)));
-            s_ShadowPayloadBuffer   = new ComputeBuffer(k_MaxShadowDataSlots * k_MaxPayloadSlotsPerShadowData, System.Runtime.InteropServices.Marshal.SizeOf(typeof(ShadowExp.ShadowData)));
+            s_ShadowDataBuffer      = new ComputeBuffer( k_MaxShadowDataSlots, System.Runtime.InteropServices.Marshal.SizeOf( typeof( ShadowData ) ) );
+            s_ShadowPayloadBuffer   = new ComputeBuffer( k_MaxShadowDataSlots * k_MaxPayloadSlotsPerShadowData, System.Runtime.InteropServices.Marshal.SizeOf( typeof( ShadowPayload ) ) );
             ShadowAtlas.AtlasInit atlasInit;
             atlasInit.baseInit.width           = (uint)shadowSettings.shadowAtlasWidth;
             atlasInit.baseInit.height          = (uint)shadowSettings.shadowAtlasHeight;
-            atlasInit.baseInit.clearColor      = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+            atlasInit.baseInit.samplerState    = SamplerState.Default();
+            atlasInit.baseInit.comparisonSamplerState = ComparisonSamplerState.Default();
+            atlasInit.baseInit.clearColor      = new Vector4( 0.0f, 0.0f, 0.0f, 0.0f );
-            atlasInit.baseInit.shadowSupport   = ShadowmapBase.ShadowSupport.Directional;
+            atlasInit.baseInit.shadowSupport   = ShadowmapBase.ShadowSupport.Directional | ShadowmapBase.ShadowSupport.Point | ShadowmapBase.ShadowSupport.Spot;
-            var atlasInit2 = atlasInit;
-            atlasInit2.baseInit.shadowSupport  = ShadowmapBase.ShadowSupport.Point | ShadowmapBase.ShadowSupport.Spot;
-            m_Shadowmaps = new ShadowmapBase[] { new ShadowExp.ShadowAtlas(ref atlasInit), new ShadowExp.ShadowAtlas(ref atlasInit2) };
+            var varianceInit = atlasInit;
+            varianceInit.baseInit.shadowmapFormat = ShadowVariance.GetFormat( false, false, true );
+
+            var varianceInit2 = varianceInit;
+            varianceInit2.baseInit.shadowmapFormat = ShadowVariance.GetFormat( true, true, false );
+
+            var varianceInit3 = varianceInit;
+            varianceInit3.baseInit.shadowmapFormat = ShadowVariance.GetFormat( true, false, true );
+
+            m_Shadowmaps = new ShadowmapBase[] { new ShadowVariance( ref varianceInit ), new ShadowVariance( ref varianceInit2 ), new ShadowVariance( ref varianceInit3 ), new ShadowAtlas( ref atlasInit ) };
-                    ShadowExp.ShadowData[] sds;
+                    ShadowData[] sds;
                     sc.GetShadowDatas(out sds, out offset, out count);
                     Debug.Assert(offset == 0);
                     s_ShadowDataBuffer.SetData(sds);   // unfortunately we can't pass an offset or count to this function
                     // bind textures
                     uint offset, count;
                     RenderTargetIdentifier[] tex;
-                    sc.GetTex2DArrays(out tex, out offset, out count);
-                    cb.SetGlobalTexture("_ShadowmapExp_Dir", tex[0]);
-                    cb.SetGlobalTexture("_ShadowmapExp_PointSpot", tex[1]);
+                    sc.GetTex2DArrays( out tex, out offset, out count );
+                    cb.SetGlobalTexture( "_ShadowmapExp_VSM_0", tex[0] );
+                    cb.SetGlobalTexture( "_ShadowmapExp_VSM_1", tex[1] );
+                    cb.SetGlobalTexture( "_ShadowmapExp_VSM_2", tex[2] );
+                    cb.SetGlobalTexture( "_ShadowmapExp_PCF"  , tex[3] );
                     // TODO: Currently samplers are hard coded in ShadowContext.hlsl, so we can't really set them here
                 };
 
             scInit.storage.maxTex2DArraySlots        = 4;
-            scInit.storage.maxTexCubeArraySlots      = 2;
-            scInit.storage.maxComparisonSamplerSlots = 2;
-            scInit.storage.maxSamplerSlots           = 2;
+            scInit.storage.maxTexCubeArraySlots      = 0;
+            scInit.storage.maxComparisonSamplerSlots = 1;
+            scInit.storage.maxSamplerSlots           = 4;
-            m_ShadowMgr = new ShadowExp.ShadowManager(shadowSettings, ref scInit, m_Shadowmaps);
+            m_ShadowMgr = new ShadowManager(shadowSettings, ref scInit, m_Shadowmaps);
+            // set global overrides - these need to match the override specified in ShadowDispatch.hlsl
+            bool useGlobalOverrides = true;
+            m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Point        , ShadowAlgorithm.PCF, ShadowVariant.V4, ShadowPrecision.High, useGlobalOverrides );
+            m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Spot         , ShadowAlgorithm.PCF, ShadowVariant.V4, ShadowPrecision.High, useGlobalOverrides );
+            m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Directional  , ShadowAlgorithm.PCF, ShadowVariant.V4, ShadowPrecision.High, useGlobalOverrides );
             shadowManager = m_ShadowMgr;
         }
 
             {
                 (m_Shadowmaps[0] as ShadowAtlas).Dispose();
                 (m_Shadowmaps[1] as ShadowAtlas).Dispose();
+                (m_Shadowmaps[2] as ShadowAtlas).Dispose();
+                (m_Shadowmaps[3] as ShadowAtlas).Dispose();
-            Utilities.SafeRelease(s_ShadowDataBuffer);
-            Utilities.SafeRelease(s_ShadowPayloadBuffer);
+            if (s_ShadowDataBuffer != null)
+                s_ShadowDataBuffer.Release();
+            if (s_ShadowPayloadBuffer != null)
+                s_ShadowPayloadBuffer.Release();
-#endif
 
     namespace TilePass
     {
             Material m_SingleDeferredMaterialSRT   = null;
             Material m_SingleDeferredMaterialMRT   = null;
 
-#if (SHADOWS_ENABLED)
-            FrameId                 m_FrameId;
+            FrameId                 m_FrameId = new FrameId();
             ShadowSetup             m_ShadowSetup; // doesn't actually have to reside here, it would be enough to pass the IShadowManager in from the outside
             IShadowManager          m_ShadowMgr;
             List<int>               m_ShadowRequests = new List<int>();
                     m_ShadowMgr = null;
                 }
             }
-
-#endif
 
 
             int GetNumTileFtplX(Camera camera)
                 Utilities.SelectKeyword(m_DeferredDirectMaterialSRT, tileKeywords, 0);
                 m_DeferredDirectMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredDirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.Standard);
-                m_DeferredDirectMaterialSRT.SetInt("_StencilCmp", 4 /* LEqual */);
+                m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_DeferredDirectMaterialSRT.SetInt("_StencilCmp", 2 /* Less */); // Shade if stencil is not 0 and not SSS
                 m_DeferredDirectMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_DeferredDirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
                 Utilities.SelectKeyword(m_DeferredIndirectMaterialSRT, tileKeywords, 1);
                 m_DeferredIndirectMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredIndirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.Standard);
-                m_DeferredIndirectMaterialSRT.SetInt("_StencilCmp", 4 /* LEqual */);
+                m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_DeferredIndirectMaterialSRT.SetInt("_StencilCmp", 2 /* Less */); // Shade if stencil is not 0 and not SSS
                 m_DeferredIndirectMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_DeferredIndirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.One); // Additive color & alpha source
 
                 Utilities.SelectKeyword(m_DeferredAllMaterialSRT, tileKeywords, 2);
                 m_DeferredAllMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredAllMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilBits.Standard);
-                m_DeferredAllMaterialSRT.SetInt("_StencilCmp", 4 /* LEqual */);
+                m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_DeferredAllMaterialSRT.SetInt("_StencilCmp", 2 /* Less */); // Shade if stencil is not 0 and not SSS
                 m_DeferredAllMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_DeferredAllMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
                 m_SingleDeferredMaterialSRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
                 m_SingleDeferredMaterialSRT.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
                 m_SingleDeferredMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)StencilBits.Standard);
-                m_SingleDeferredMaterialSRT.SetInt("_StencilCmp", 4 /* LEqual */);
+                m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_SingleDeferredMaterialSRT.SetInt("_StencilCmp", 2 /* Less */); // Shade if stencil is not 0 and not SSS
                 m_SingleDeferredMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_SingleDeferredMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
                 UnityEditor.SceneView.onSceneGUIDelegate += OnSceneGUI;
 #endif
 
-#if (SHADOWS_ENABLED)
-#endif
+                DeinitShadowSystem();
+
 #if UNITY_EDITOR
                 UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
 #endif
                 return new Vector3(light.finalColor.r, light.finalColor.g, light.finalColor.b);
             }
 
-            // Return number of added shadow
-            public int GetShadows(VisibleLight light, int lightIndex, ref ShadowOutput shadowOutput, ShadowSettings shadowSettings)
-            {
-                for (int sliceIndex = 0; sliceIndex < shadowOutput.GetShadowSliceCountLightIndex(lightIndex); ++sliceIndex)
-                {
-                    ShadowData shadowData = new ShadowData();
-
-                    int shadowSliceIndex = shadowOutput.GetShadowSliceIndex(lightIndex, sliceIndex);
-                    shadowData.worldToShadow = shadowOutput.shadowSlices[shadowSliceIndex].shadowTransform.transpose; // Transpose for hlsl reading ?
-
-                    shadowData.bias = light.light.shadowBias;
-                    shadowData.invResolution = new Vector4(1.0f / shadowSettings.shadowAtlasWidth, 1.0f / shadowSettings.shadowAtlasHeight, 0.0f, 0.0f);
-                    m_lightList.shadows.Add(shadowData);
-                }
-
-                return shadowOutput.GetShadowSliceCountLightIndex(lightIndex);
-            }
-
-            public bool GetDirectionalLightData(ShadowSettings shadowSettings, GPULightType gpuLightType, VisibleLight light, AdditionalLightData additionalData, int lightIndex, ref ShadowOutput shadowOutput, ref int directionalShadowcount)
+            public bool GetDirectionalLightData(ShadowSettings shadowSettings, GPULightType gpuLightType, VisibleLight light, AdditionalLightData additionalData, int lightIndex)
             {
                 var directionalLightData = new DirectionalLightData();
 
                     directionalLightData.tileCookie = (light.light.cookie.wrapMode == TextureWrapMode.Repeat);
                     directionalLightData.cookieIndex = m_CookieTexArray.FetchSlice(light.light.cookie);
                 }
-
-                bool hasDirectionalShadows = light.light.shadows != LightShadows.None && shadowOutput.GetShadowSliceCountLightIndex(lightIndex) != 0;
-                bool hasDirectionalNotReachMaxLimit = directionalShadowcount == 0; // Only one cascade shadow allowed
-
-                // If we have not found a directional shadow casting light yet, we register the last directional anyway as "sun".
-                if (directionalShadowcount == 0)
+                // fix up shadow information
+                int shadowIdx;
+                if (m_ShadowIndices.TryGetValue(lightIndex, out shadowIdx))
-                    m_CurrentSunLight = light.light;
-                }
-
-                if (hasDirectionalShadows && hasDirectionalNotReachMaxLimit) // Note  < MaxShadows should be check at shadowOutput creation
-                {
-                    // Always choose the directional shadow casting light if it exists.
+                    directionalLightData.shadowIndex = shadowIdx;
-
-                    directionalLightData.shadowIndex = m_lightList.shadows.Count;
-                    directionalShadowcount += GetShadows(light, lightIndex, ref shadowOutput, shadowSettings);
-
-                    // Fill split information for shaders
-                    for (int s = 0; s < k_MaxCascadeCount; ++s)
-                    {
-                        m_lightList.directionalShadowSplitSphereSqr[s] = shadowOutput.directionalShadowSplitSphereSqr[s];
-                    }
+                m_CurrentSunLight = m_CurrentSunLight == null ? light.light : m_CurrentSunLight;
 
                 m_lightList.directionalLights.Add(directionalLightData);
 
                 return 1.0f - Mathf.Clamp01((distanceToCamera - distanceFadeNear) / (fadeDistance - distanceFadeNear));
             }
 
-            public bool GetLightData(ShadowSettings shadowSettings, Camera camera, GPULightType gpuLightType, VisibleLight light, AdditionalLightData additionalData, int lightIndex, ref ShadowOutput shadowOutput, ref int shadowCount)
+            public bool GetLightData(ShadowSettings shadowSettings, Camera camera, GPULightType gpuLightType, VisibleLight light, AdditionalLightData additionalData, int lightIndex)
             {
                 var lightData = new LightData();
 
                         lightData.cookieIndex = m_CookieTexArray.FetchSlice(light.light.cookie);
                     }
                 }
-
-                // Setup shadow data arrays
-                // In case lightData.shadowDimmer == 0.0 we need to avoid rendering the shadow map... see how it can be done with the culling (and more specifically, how can we do that BEFORE sending for shadows)
-                bool hasShadows = lightData.shadowDimmer > 0.0f && distanceToCamera < shadowSettings.maxShadowDistance && light.light.shadows != LightShadows.None && shadowOutput.GetShadowSliceCountLightIndex(lightIndex) != 0;
-                bool hasNotReachMaxLimit = shadowCount + (lightData.lightType == GPULightType.Point ? 6 : 1) <= k_MaxShadowOnScreen;
-
-                // TODO: Read the comment about shadow limit/management at the beginning of this loop
-                if (hasShadows && hasNotReachMaxLimit)
+                // fix up shadow information
+                int shadowIdx;
+                if (m_ShadowIndices.TryGetValue(lightIndex, out shadowIdx))
-                    // When we have a point light, we assumed that there is 6 consecutive PunctualShadowData
-                    lightData.shadowIndex = m_lightList.shadows.Count;
-                    shadowCount += GetShadows(light, lightIndex, ref shadowOutput, shadowSettings);
+                    lightData.shadowIndex = shadowIdx;
-
                 if (additionalData.archetype != LightArchetype.Punctual)
                 {
                     lightData.size = new Vector2(additionalData.lightLength, additionalData.lightWidth);
                 m_lightList.bounds.Add(bound);
                 m_lightList.lightVolumes.Add(lightVolumeData);
             }
+            public override int GetCurrentShadowCount()
+            {
+                return m_ShadowRequests.Count;
+            }
-            public override void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput)
+            public override void UpdateCullingParameters(ref CullingParameters cullingParams)
+            {
+                m_ShadowMgr.UpdateCullingParameters( ref cullingParams );
+            }
+
+            public override void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera)
-#if (SHADOWS_ENABLED)
                     // 0. deal with shadows
                     {
                         m_FrameId.frameCount++;
                         int lcnt = cullResults.visibleLights.Length;
                         for (int i = 0; i < lcnt; ++i)
                         {
-                            if (cullResults.visibleLights[i].light.shadows != LightShadows.None)
-                                m_ShadowRequests.Add(i);
+                            VisibleLight vl = cullResults.visibleLights[i];
+                            AdditionalLightData ald = vl.light.GetComponent<AdditionalLightData>();
+                            if( vl.light.shadows != LightShadows.None && ald != null && ald.shadowDimmer > 0.0f )
+                                m_ShadowRequests.Add( i );
-                        uint    originalRequestCount = shadowRequestCount;
                         m_ShadowMgr.ProcessShadowRequests(m_FrameId, cullResults, camera, cullResults.visibleLights,
                             ref shadowRequestCount, shadowRequests, out shadowDataIndices);
 
                             m_ShadowIndices.Add(shadowRequests[i], shadowDataIndices[i]);
                         }
                     }
-#endif
+
                     float oldSpecularGlobalDimmer = m_PassSettings.specularGlobalDimmer;
                     // Change some parameters in case of "special" rendering (can be preview, reflection, etc.
                     if (camera.cameraType == CameraType.Reflection)
                         var additionalData = light.light.GetComponent<AdditionalLightData>();
 
                         if (additionalData == null)
-                        {
-                            // Don't display warning for the preview windows
-                            if (camera.cameraType != CameraType.Preview)
-                            {
-                                Debug.LogWarningFormat(light.light, "Light entity {0} has no additional data, will be rendered using default values.", light.light.name);
-                            }
-                        }
-                    // Note: LightType.Area is offline only, use for baking, no need to test it
-                    if (additionalData.archetype == LightArchetype.Punctual)
-                    {
-                        switch (light.lightType)
+                        // Note: LightType.Area is offline only, use for baking, no need to test it
+                        if (additionalData.archetype == LightArchetype.Punctual)
-                            case LightType.Point:
-                                if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
-                                    continue;
-                                lightCategory = LightCategory.Punctual;
-                                gpuLightType = GPULightType.Point;
-                                lightVolumeType = LightVolumeType.Sphere;
-                                break;
+                            switch (light.lightType)
+                            {
+                                case LightType.Point:
+                                    if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
+                                        continue;
+                                    lightCategory = LightCategory.Punctual;
+                                    gpuLightType = GPULightType.Point;
+                                    lightVolumeType = LightVolumeType.Sphere;
+                                    break;
-                            case LightType.Spot:
-                                if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
-                                    continue;
-                                lightCategory = LightCategory.Punctual;
-                                gpuLightType = GPULightType.Spot;
-                                lightVolumeType = LightVolumeType.Cone;
-                                break;
+                                case LightType.Spot:
+                                    if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
+                                        continue;
+                                    lightCategory = LightCategory.Punctual;
+                                    gpuLightType = GPULightType.Spot;
+                                    lightVolumeType = LightVolumeType.Cone;
+                                    break;
-                            case LightType.Directional:
-                                if (directionalLightcount >= k_MaxDirectionalLightsOnScreen)
-                                    continue;
-                                lightCategory = LightCategory.Punctual;
-                                gpuLightType = GPULightType.Directional;
-                                // No need to add volume, always visible
-                                lightVolumeType = LightVolumeType.Count; // Count is none
-                                break;
+                                case LightType.Directional:
+                                    if (directionalLightcount >= k_MaxDirectionalLightsOnScreen)
+                                        continue;
+                                    lightCategory = LightCategory.Punctual;
+                                    gpuLightType = GPULightType.Directional;
+                                    // No need to add volume, always visible
+                                    lightVolumeType = LightVolumeType.Count; // Count is none
+                                    break;
-                            default:
-                                Debug.Assert(false, "TODO: encountered an unknown LightType.");
-                                break;
+                                default:
+                                    Debug.Assert(false, "TODO: encountered an unknown LightType.");
+                                    break;
+                            }
-                    }
-                    else
-                    {
-                        switch (additionalData.archetype)
+                        else
-                            case LightArchetype.Area:
-                                if (areaLightCount >= k_MaxAreaLightsOnScreen) { continue; }
-                                lightCategory   = LightCategory.Area;
-                                gpuLightType    = (additionalData.lightWidth > 0) ? GPULightType.Rectangle : GPULightType.Line;
-                                lightVolumeType = LightVolumeType.Box;
-                                break;
-                            case LightArchetype.Projector:
-                                if (projectorLightCount >= k_MaxProjectorLightsOnScreen) { continue; }
-                                lightCategory = LightCategory.Projector;
-                                switch (light.lightType)
-                                {
-                                    case LightType.Directional:
-                                        gpuLightType    = GPULightType.ProjectorOrtho;
-                                        lightVolumeType = LightVolumeType.Box;
-                                        break;
-                                    case LightType.Spot:
-                                        gpuLightType    = GPULightType.ProjectorPyramid;
-                                        lightVolumeType = LightVolumeType.Cone;
-                                        break;
-                                    default:
-                                        Debug.Assert(false, "Projectors can only be Spot or Directional lights.");
-                                        break;
-                                }
-                                break;
-                            default:
-                                Debug.Assert(false, "TODO: encountered an unknown LightArchetype.");
-                                break;
+                            switch (additionalData.archetype)
+                            {
+                                case LightArchetype.Area:
+                                    if (areaLightCount >= k_MaxAreaLightsOnScreen) { continue; }
+                                    lightCategory   = LightCategory.Area;
+                                    gpuLightType    = (additionalData.lightWidth > 0) ? GPULightType.Rectangle : GPULightType.Line;
+                                    lightVolumeType = LightVolumeType.Box;
+                                    break;
+                                case LightArchetype.Projector:
+                                    if (projectorLightCount >= k_MaxProjectorLightsOnScreen) { continue; }
+                                    lightCategory = LightCategory.Projector;
+                                    switch (light.lightType)
+                                    {
+                                        case LightType.Directional:
+                                            gpuLightType    = GPULightType.ProjectorOrtho;
+                                            lightVolumeType = LightVolumeType.Box;
+                                            break;
+                                        case LightType.Spot:
+                                            gpuLightType    = GPULightType.ProjectorPyramid;
+                                            lightVolumeType = LightVolumeType.Cone;
+                                            break;
+                                        default:
+                                            Debug.Assert(false, "Projectors can only be Spot or Directional lights.");
+                                            break;
+                                    }
+                                    break;
+                                default:
+                                    Debug.Assert(false, "TODO: encountered an unknown LightArchetype.");
+                                    break;
+                            }
-                    }
-#if (SHADOWS_ENABLED)
-                    uint shadow = m_ShadowIndices.ContainsKey(lightIndex) ? 1u : 0;
-                    // 5 bit (0x1F) light category, 5 bit (0x1F) GPULightType, 5 bit (0x1F) lightVolume, 1 bit for shadow casting, 16 bit index
-                    sortKeys[sortCount++] = (uint)lightCategory << 27 | (uint)gpuLightType << 22 | (uint)lightVolumeType << 17 | shadow << 16 | (uint)lightIndex;
-#else
-                        // 5 bit (0x1F) light category, 5 bit (0x1F) GPULightType, 6 bit (0x3F) lightVolume, 16 bit index
-                        sortKeys[sortCount++] = (uint)lightCategory << 27 | (uint)gpuLightType << 22 | (uint)lightVolumeType << 16 | (uint)lightIndex;
-#endif
+                        uint shadow = m_ShadowIndices.ContainsKey(lightIndex) ? 1u : 0;
+                        // 5 bit (0x1F) light category, 5 bit (0x1F) GPULightType, 5 bit (0x1F) lightVolume, 1 bit for shadow casting, 16 bit index
+                        sortKeys[sortCount++] = (uint)lightCategory << 27 | (uint)gpuLightType << 22 | (uint)lightVolumeType << 17 | shadow << 16 | (uint)lightIndex;
                     }
 
                     Array.Sort(sortKeys);
                     // will be use...)
                     // The lightLoop is in charge, not the shadow pass.
                     // For now we will still apply the maximum of shadow here but we don't apply the sorting by priority + slot allocation yet
-                    int directionalShadowcount = 0;
-                    int shadowCount = 0;
+                    m_CurrentSunLight = null;
 
                     // 2. Go thought all lights, convert them to GPU format.
                     // Create simultaneously data for culling (LigthVolumeData and rendering)
                         uint sortKey = sortKeys[sortIndex];
                         LightCategory lightCategory = (LightCategory)((sortKey >> 27) & 0x1F);
                         GPULightType gpuLightType = (GPULightType)((sortKey >> 22) & 0x1F);
-#if (SHADOWS_ENABLED)
-#else
-                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0x3F);
-#endif
                         int lightIndex = (int)(sortKey & 0xFFFF);
 
                         var light = cullResults.visibleLights[lightIndex];
                         if (gpuLightType == GPULightType.Directional)
                         {
-                            if (GetDirectionalLightData(shadowSettings, gpuLightType, light, additionalData, lightIndex, ref shadowOutput, ref directionalShadowcount))
+                            if (GetDirectionalLightData(shadowSettings, gpuLightType, light, additionalData, lightIndex))
-
-#if (SHADOWS_ENABLED && SHADOWS_FIXSHADOWIDX)
-                            // fix up shadow information
-                            int shadowIdxDir;
-                            if (m_ShadowIndices.TryGetValue(lightIndex, out shadowIdxDir))
-                            {
-                                var lightData = m_lightList.directionalLights[m_lightList.directionalLights.Count - 1];
-                                lightData.shadowIndex = shadowIdxDir;
-                                m_lightList.directionalLights[m_lightList.directionalLights.Count - 1] = lightData;
-                            }
-#endif
-
-                        if (GetLightData(shadowSettings, camera, gpuLightType, light, additionalData, lightIndex, ref shadowOutput, ref shadowCount))
+                        if(GetLightData(shadowSettings, camera, gpuLightType, light, additionalData, lightIndex))
                         {
                             switch (lightCategory)
                             {
                             // Then culling side. Must be call in this order as we pass the created Light data to the function
                             GetLightVolumeDataAndBound(lightCategory, gpuLightType, lightVolumeType, light, m_lightList.lights[m_lightList.lights.Count - 1], worldToView);
                         }
-
-#if (SHADOWS_ENABLED && SHADOWS_FIXSHADOWIDX)
-                        // fix up shadow information
-                        int shadowIdx;
-                        if (m_ShadowIndices.TryGetValue(lightIndex, out shadowIdx))
-                        {
-                            var lightData = m_lightList.lights[m_lightList.lights.Count - 1];
-                            lightData.shadowIndex = shadowIdx;
-                            m_lightList.lights[m_lightList.lights.Count - 1] = lightData;
-                        }
-#endif
                     }
 
                     // Sanity check
 
             private void BindGlobalParams(CommandBuffer cmd, ComputeShader computeShader, int kernelIndex, Camera camera, ScriptableRenderContext loop)
             {
-#if (SHADOWS_ENABLED)
-#endif
+
                 SetGlobalBuffer("g_vLightListGlobal", !usingFptl ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
 
                 SetGlobalTexture("_CookieTextures", m_CookieTexArray.GetTexCache());
             {
                 var cmd = new CommandBuffer { name = "Push Global Parameters" };
 
-#if (SHADOWS_ENABLED)
-#endif
+
                 SetGlobalPropertyRedirect(computeShader, kernelIndex, cmd);
                 BindGlobalParams(cmd, computeShader, kernelIndex, camera, loop);
                 SetGlobalPropertyRedirect(null, 0, null);
 
             public override void RenderShadows(ScriptableRenderContext renderContext, CullResults cullResults)
             {
-#if (SHADOWS_ENABLED)
-#endif
             }
 
             private void SetupDebugDisplayMode(bool debugDisplayEnable)
                 Utilities.SetKeyword(m_SingleDeferredMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
             }
 
-            public override void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
-                                                        DebugDisplaySettings debugDisplaySettings,
-                                                        RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthStencilTexture,
-                                                        bool outputSplitLightingForSSS)
+            public override void RenderLightingDebug(HDCamera hdCamera, ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer)
-                var bUseClusteredForDeferred = !usingFptl;
+                if (m_PassSettings.tileDebugByCategory == TileLightLoopProducer.TileSettings.TileDebug.None)
+                    return;
+
+                var cmd = new CommandBuffer();
+                cmd.name = "Tiled Lighting Debug";
+
+                bool bUseClusteredForDeferred = !usingFptl;
+
+                int w = hdCamera.camera.pixelWidth;
+                int h = hdCamera.camera.pixelHeight;
+                int numTilesX = (w + 15) / 16;
+                int numTilesY = (h + 15) / 16;
+                int numTiles = numTilesX * numTilesY;
 
                 Vector2 mousePixelCoord = Input.mousePosition;
 #if UNITY_EDITOR
                 }
 #endif
 
+                // Debug tiles
+                PushGlobalParams(hdCamera.camera, renderContext, null, 0);
+                if (m_PassSettings.tileDebugByCategory == TileLightLoopProducer.TileSettings.TileDebug.FeatureVariants)
+                {
+                    if (GetFeatureVariantsEnabled())
+                    {
+                        // featureVariants
+                        Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewTilesMaterial);
+                        m_DebugViewTilesMaterial.SetInt("_NumTiles", numTiles);
+                        m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_PassSettings.tileDebugByCategory);
+                        m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
+                        m_DebugViewTilesMaterial.SetBuffer("g_TileList", s_TileList);
+                        m_DebugViewTilesMaterial.SetBuffer("g_DispatchIndirectBuffer", s_DispatchIndirectBuffer);
+                        m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                        m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                        m_DebugViewTilesMaterial.DisableKeyword("SHOW_LIGHT_CATEGORIES");
+                        m_DebugViewTilesMaterial.EnableKeyword("SHOW_FEATURE_VARIANTS");
+                        cmd.SetRenderTarget(colorBuffer);
+                        cmd.DrawProcedural(Matrix4x4.identity, m_DebugViewTilesMaterial, 0, MeshTopology.Triangles, numTiles * 6);
+                    }
+                }
+                else if (m_PassSettings.tileDebugByCategory != TileLightLoopProducer.TileSettings.TileDebug.None)
+                {
+                    // lightCategories
+                    Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewTilesMaterial);
+                    m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_PassSettings.tileDebugByCategory);
+                    m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
+                    m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                    m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                    m_DebugViewTilesMaterial.EnableKeyword("SHOW_LIGHT_CATEGORIES");
+                    m_DebugViewTilesMaterial.DisableKeyword("SHOW_FEATURE_VARIANTS");
+
+                    cmd.Blit(null, colorBuffer, m_DebugViewTilesMaterial, 0);
+                }
+                SetGlobalPropertyRedirect(null, 0, null);
+
+                renderContext.ExecuteCommandBuffer(cmd);
+                cmd.Dispose();
+            }
+
+            public override void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
+                                                        DebugDisplaySettings debugDisplaySettings,
+                                                        RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthStencilTexture,
+                                                        bool outputSplitLightingForSSS)
+            {
+                var bUseClusteredForDeferred = !usingFptl;
+
                 using (new Utilities.ProfilingSample((m_PassSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLightingForSSS ? " MRT" : ""), renderContext))
                 {
                     var cmd = new CommandBuffer();
 
-                    SetupDebugDisplayMode(debugDisplaySettings.IsDebugDisplayEnable());
+                    SetupDebugDisplayMode(debugDisplaySettings.IsDebugDisplayEnabled());
 
                     if (!m_PassSettings.enableTileAndCluster)
                     {
                         }
                         else
                         {
-                            // 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));
+                            // The stencil test uses a LESS comparison mode.
+                            // If asked to disable SSS, we set the material ID of SSS materials to Standard, and shade all pixels with non-zero stencil values.
+                            m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)(debugDisplaySettings.renderingDebugSettings.enableSSS ? StencilBits.SSS : 0));
+
                             Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
                         }
                     }
 
                         if (m_PassSettings.enableComputeLightEvaluation)
                         {
-                            bool enableFeatureVariants = GetFeatureVariantsEnabled() && !debugDisplaySettings.IsDebugDisplayEnable();
+                            bool enableFeatureVariants = GetFeatureVariantsEnabled() && !debugDisplaySettings.IsDebugDisplayEnabled();
 
                             int numVariants = 1;
                             if (enableFeatureVariants)
                                 }
                                 else
                                 {
-                                    if (debugDisplaySettings.IsDebugDisplayEnable())
+                                    if (debugDisplaySettings.IsDebugDisplayEnabled())
                                     {
                                         kernel = usingFptl ? s_shadeOpaqueDirectFptlDebugDisplayKernel : s_shadeOpaqueDirectClusteredDebugDisplayKernel;
                                     }
                                 PushGlobalParams(camera, renderContext, shadeOpaqueShader, kernel);
 
                                 // 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"));
                                 Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_InvViewProjMatrix", invViewProjection);
                                 Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_ViewProjMatrix", viewProjection);
                                 Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "g_mInvScrProjection", Shader.GetGlobalMatrix("g_mInvScrProjection"));
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenSize", Shader.GetGlobalVector("_ScreenSize"));
+                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenSize", hdCamera.screenSize);
                                 cmd.SetComputeIntParam(shadeOpaqueShader, "_UseTileLightList", Shader.GetGlobalInt("_UseTileLightList"));
 
                                 cmd.SetComputeVectorParam(shadeOpaqueShader, "_Time", Shader.GetGlobalVector("_Time"));
                                 }
                                 else
                                 {
-                                    // 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));
+                                    // The stencil test uses a LESS comparison mode.
+                                    // If asked to disable SSS, we set the material ID of SSS materials to Standard, and shade all pixels with non-zero stencil values.
+                                    m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)(debugDisplaySettings.renderingDebugSettings.enableSSS ? StencilBits.SSS : 0));
+                                    m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)(debugDisplaySettings.renderingDebugSettings.enableSSS ? StencilBits.SSS : 0));
+
-                                    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
                                 {
-                                    // 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));
+                                    // The stencil test uses a LESS comparison mode.
+                                    // If asked to disable SSS, we set the material ID of SSS materials to Standard, and shade all pixels with non-zero stencil values.
+                                    m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)(debugDisplaySettings.renderingDebugSettings.enableSSS ? StencilBits.NonSSS : StencilBits.SSS));
+
-                            }
-                        }
-
-                        if (m_PassSettings.tileDebugByCategory != TileLightLoopProducer.TileSettings.TileDebug.None)
-                        {
-                            // Debug tiles
-                            PushGlobalParams(camera, renderContext, null, 0);
-                            if (m_PassSettings.tileDebugByCategory == TileLightLoopProducer.TileSettings.TileDebug.FeatureVariants)
-                            {
-                                if (GetFeatureVariantsEnabled())
-                                {
-                                    // featureVariants
-                                    Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewTilesMaterial);
-                                    m_DebugViewTilesMaterial.SetInt("_NumTiles", numTiles);
-                                    m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_PassSettings.tileDebugByCategory);
-                                    m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
-                                    m_DebugViewTilesMaterial.SetBuffer("g_TileList", s_TileList);
-                                    m_DebugViewTilesMaterial.SetBuffer("g_DispatchIndirectBuffer", s_DispatchIndirectBuffer);
-                                    m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                                    m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                                    m_DebugViewTilesMaterial.DisableKeyword("SHOW_LIGHT_CATEGORIES");
-                                    m_DebugViewTilesMaterial.EnableKeyword("SHOW_FEATURE_VARIANTS");
-                                    cmd.SetRenderTarget(colorBuffers[0]);
-                                    cmd.DrawProcedural(Matrix4x4.identity, m_DebugViewTilesMaterial, 0, MeshTopology.Triangles, numTiles * 6);
-                                }
-                            }
-                            else if (m_PassSettings.tileDebugByCategory != TileLightLoopProducer.TileSettings.TileDebug.None)
-                            {
-                                // lightCategories
-                                Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewTilesMaterial);
-                                m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_PassSettings.tileDebugByCategory);
-                                m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
-                                m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                                m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                                m_DebugViewTilesMaterial.EnableKeyword("SHOW_LIGHT_CATEGORIES");
-                                m_DebugViewTilesMaterial.DisableKeyword("SHOW_FEATURE_VARIANTS");
-
-                                cmd.Blit(null, colorBuffers[0], m_DebugViewTilesMaterial, 0);
                             }
                         }
                     }

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

 {
     int sampleShadow;
     int sampleReflection;
-#ifdef SHADOWS_USE_SHADOWCTXT
-#endif
-
-#ifndef SHADOWS_USE_SHADOWCTXT
-
-//-----------------------------------------------------------------------------
-// Shadow sampling function
-// ----------------------------------------------------------------------------
-
-float GetPunctualShadowAttenuation(LightLoopContext lightLoopContext, uint lightType, float3 positionWS, int index, float3 L, float2 unPositionSS)
-{
-    int faceIndex = 0;
-    if (lightType == GPULIGHTTYPE_POINT)
-    {
-        GetCubeFaceID(L, faceIndex);
-    }
-
-    ShadowData shadowData = _ShadowDatas[index + faceIndex];
-
-    // Note: scale and bias of shadow atlas are included in ShadowTransform but could be apply here.
-    float4 positionTXS = mul(float4(positionWS, 1.0), shadowData.worldToShadow);
-    positionTXS.xyz /= positionTXS.w;
-    // positionTXS.z -=  shadowData.bias;
-    positionTXS.z -= 0.001; // Apply a linear bias
-
-#if UNITY_REVERSED_Z
-    positionTXS.z = 1.0 - positionTXS.z;
-#endif
-
-    // float3 shadowPosDX = ddx_fine(positionTXS);
-    // float3 shadowPosDY = ddy_fine(positionTXS);
-
-    return SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, positionTXS);
-}
-
-// Gets the cascade weights based on the world position of the fragment and the positions of the split spheres for each cascade.
-// Returns an invalid split index if past shadowDistance (ie 4 is invalid for cascade)
-int GetSplitSphereIndexForDirshadows(float3 positionWS, float4 dirShadowSplitSpheres[4])
-{
-    float3 fromCenter0 = positionWS.xyz - dirShadowSplitSpheres[0].xyz;
-    float3 fromCenter1 = positionWS.xyz - dirShadowSplitSpheres[1].xyz;
-    float3 fromCenter2 = positionWS.xyz - dirShadowSplitSpheres[2].xyz;
-    float3 fromCenter3 = positionWS.xyz - dirShadowSplitSpheres[3].xyz;
-    float4 distances2 = float4(dot(fromCenter0, fromCenter0), dot(fromCenter1, fromCenter1), dot(fromCenter2, fromCenter2), dot(fromCenter3, fromCenter3));
-
-    float4 dirShadowSplitSphereSqRadii;
-    dirShadowSplitSphereSqRadii.x = dirShadowSplitSpheres[0].w;
-    dirShadowSplitSphereSqRadii.y = dirShadowSplitSpheres[1].w;
-    dirShadowSplitSphereSqRadii.z = dirShadowSplitSpheres[2].w;
-    dirShadowSplitSphereSqRadii.w = dirShadowSplitSpheres[3].w;
-
-    if (distances2.w > dirShadowSplitSphereSqRadii.w)
-        return -1;
-
-    float4 weights = float4(distances2 < dirShadowSplitSphereSqRadii);
-    weights.yzw = saturate(weights.yzw - weights.xyz);
-
-    return int(4.0 - dot(weights, float4(4.0, 3.0, 2.0, 1.0)));
-}
-
-
-float GetDirectionalShadowAttenuation(LightLoopContext lightLoopContext, float3 positionWS, int index, float3 L, float2 unPositionSS)
-{
-    // Note Index is 0 for now, but else we need to provide the correct index in _DirShadowSplitSpheres and _ShadowDatas
-    int shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _DirShadowSplitSpheres);
-    if (shadowSplitIndex == -1)
-        return 1.0;
-
-    ShadowData shadowData = _ShadowDatas[shadowSplitIndex];
-
-    // Note: scale and bias of shadow atlas are included in ShadowTransform but could be apply here.
-    float4 positionTXS = mul(float4(positionWS, 1.0), shadowData.worldToShadow);
-    positionTXS.xyz /= positionTXS.w;
-    // positionTXS.z -=  shadowData.bias;
-    positionTXS.z -= 0.003; // Apply a linear bias
-
-#if UNITY_REVERSED_Z
-    positionTXS.z = 1.0 - positionTXS.z;
-#endif
-
-    float4 vShadow3x3PCFTerms0;
-    float4 vShadow3x3PCFTerms1;
-    float4 vShadow3x3PCFTerms2;
-    float4 vShadow3x3PCFTerms3;
-
-    float flTexelEpsilonX = shadowData.invResolution.x;
-    float flTexelEpsilonY = shadowData.invResolution.y;
-    vShadow3x3PCFTerms0 = float4(20.0f / 267.0f, 33.0f / 267.0f, 55.0f / 267.0f, 0.0f);
-    vShadow3x3PCFTerms1 = float4(flTexelEpsilonX, flTexelEpsilonY, -flTexelEpsilonX, -flTexelEpsilonY);
-    vShadow3x3PCFTerms2 = float4(flTexelEpsilonX, flTexelEpsilonY, 0.0f, 0.0f);
-    vShadow3x3PCFTerms3 = float4(-flTexelEpsilonX, -flTexelEpsilonY, 0.0f, 0.0f);
-
-    // float3 shadowPosDX = ddx_fine(positionTXS);
-    // float3 shadowPosDY = ddy_fine(positionTXS);
-
-    //return SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, positionTXS);
-
-    float4 v20Taps;
-    v20Taps.x = SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, float3(positionTXS.xy + vShadow3x3PCFTerms1.xy, positionTXS.z)).x; //  1  1
-    v20Taps.y = SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, float3(positionTXS.xy + vShadow3x3PCFTerms1.zy, positionTXS.z)).x; // -1  1
-    v20Taps.z = SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, float3(positionTXS.xy + vShadow3x3PCFTerms1.xw, positionTXS.z)).x; //  1 -1
-    v20Taps.w = SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, float3(positionTXS.xy + vShadow3x3PCFTerms1.zw, positionTXS.z)).x; // -1 -1
-    float flSum = dot(v20Taps.xyzw, float4(0.25, 0.25, 0.25, 0.25));
-    if ((flSum == 0.0) || (flSum == 1.0))
-        return flSum;
-    flSum *= vShadow3x3PCFTerms0.x * 4.0;
-
-    float4 v33Taps;
-    v33Taps.x = SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, float3(positionTXS.xy + vShadow3x3PCFTerms2.xz, positionTXS.z)).x; //  1  0
-    v33Taps.y = SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, float3(positionTXS.xy + vShadow3x3PCFTerms3.xz, positionTXS.z)).x; // -1  0
-    v33Taps.z = SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, float3(positionTXS.xy + vShadow3x3PCFTerms3.zy, positionTXS.z)).x; //  0 -1
-    v33Taps.w = SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, float3(positionTXS.xy + vShadow3x3PCFTerms2.zy, positionTXS.z)).x; //  0  1
-    flSum += dot(v33Taps.xyzw, vShadow3x3PCFTerms0.yyyy);
-
-    flSum += SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, positionTXS).x * vShadow3x3PCFTerms0.z;
-
-    return flSum;
-
-}
-#endif
 
 //-----------------------------------------------------------------------------
 // Cookie sampling functions

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

-//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
 // LightLoop
 // ----------------------------------------------------------------------------
 
-    if (_DebugDisplayMode == DEBUGDISPLAYMODE_DIFFUSE_LIGHTING)
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_DIFFUSE_LIGHTING)
-    else if (_DebugDisplayMode == DEBUGDISPLAYMODE_SPECULAR_LIGHTING)
+    else if (_DebugLightingMode == DEBUGLIGHTINGMODE_SPECULAR_LIGHTING)
-    else if (_DebugDisplayMode == DEBUGDISPLAYMODE_VISUALIZE_CASCADE)
+    else if (_DebugLightingMode == DEBUGLIGHTINGMODE_VISUALIZE_CASCADE)
     {
         specularLighting = float3(0.0, 0.0, 0.0);
 
             float3(1.0, 1.0, 0.0)
         };
 
-#ifdef SHADOWS_USE_SHADOWCTXT
-        float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, 0, float3(0.0, 0.0, 0.0), float2(0.0, 0.0));
-#else
-        float shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, 0, float3(0.0, 0.0, 0.0), float2(0.0, 0.0));
-#endif
+        float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, float3(0.0, 1.0, 0.0 ), 0, float3(0.0, 0.0, 0.0), float2(0.0, 0.0));
+        float4 dirShadowSplitSpheres[4];
+        uint payloadOffset = EvalShadow_LoadSplitSpheres(lightLoopContext.shadowContext, 0, dirShadowSplitSpheres);
+        int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows(positionWS, dirShadowSplitSpheres);
-        int shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _DirShadowSplitSpheres);
         if (shadowSplitIndex == -1)
             diffuseLighting = float3(0.0, 0.0, 0.0);
         else
                 out float3 specularLighting)
 {
     LightLoopContext context;
-#ifndef SHADOWS_USE_SHADOWCTXT
-    ZERO_INITIALIZE(LightLoopContext, context);
-#else
-#endif
 
     diffuseLighting = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
                 out float3 specularLighting)
 {
     LightLoopContext context;
-#ifndef SHADOWS_USE_SHADOWCTXT
-    ZERO_INITIALIZE(LightLoopContext, context);
-#else
-#endif
 
     diffuseLighting = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);

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

         _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
 
         // Stencil state
-        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.Standard
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.NonSSS (fixed at compile time)
 
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0

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

         _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
 
         // Stencil state
-        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.Standard
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.NonSSS (fixed at compile time)
 
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0

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

 using System;
 using UnityEngine;
 using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
 
         // Properties
         // Material ID
-        protected MaterialProperty materialID = null;
-        protected const string kMaterialID = "_MaterialID";
+        protected MaterialProperty materialID  = null;
+        protected const string     kMaterialID = "_MaterialID";
+
+        protected const string     kStencilRef = "_StencilRef";
 
         // Wind
         protected MaterialProperty windEnable = null;
             bool depthOffsetEnable = material.GetFloat(kDepthOffsetEnable) > 0.0f;
             SetKeyword(material, "_DEPTHOFFSET_ON", depthOffsetEnable);
 
-            int stencilRef = (int)UnityEngine.Experimental.Rendering.HDPipeline.StencilBits.Standard; // See 'StencilBits'.
+            // Set the reference value for the stencil test.
+            int stencilRef = (int)StencilBits.NonSSS;
-                int materialID = (int)material.GetFloat(kMaterialID);
-
-                switch (materialID)
+                if ((int)material.GetFloat(kMaterialID) == (int)UnityEngine.Experimental.Rendering.HDPipeline.Lit.MaterialId.LitSSS)
-                    case (int)UnityEngine.Experimental.Rendering.HDPipeline.Lit.MaterialId.LitSSS:
-                        stencilRef = (int)UnityEngine.Experimental.Rendering.HDPipeline.StencilBits.SSS;
-                        break;
-                    case (int)UnityEngine.Experimental.Rendering.HDPipeline.Lit.MaterialId.LitStandard:
-                        stencilRef = (int)UnityEngine.Experimental.Rendering.HDPipeline.StencilBits.Standard;
-                        break;
-                    default:
-                        stencilRef = 1 + materialID;
-                        break;
+                    stencilRef = (int)StencilBits.SSS;
-            material.SetInt("_StencilRef", stencilRef);
+            material.SetInt(kStencilRef, stencilRef);
 
             bool enablePerPixelDisplacement = material.GetFloat(kEnablePerPixelDisplacement) > 0.0f;
             SetKeyword(material, "_PER_PIXEL_DISPLACEMENT", enablePerPixelDisplacement);

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

 using UnityEngine.Rendering;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Experimental.Rendering.HDPipeline;
+using UnityEngine.Experimental.Rendering.HDPipeline.Lit;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
             public static GUIContent thicknessText = new GUIContent("Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
             public static GUIContent thicknessMapText = new GUIContent("Thickness map", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
 
+            // Specular color
+            public static GUIContent specularColorText = new GUIContent("Specular Color", "Specular color (RGB)");
+
             // Emissive
             public static string lightingText = "Inputs Lighting";
             public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
             UseEmissiveMask,
         }
 
-        public enum MaterialIDType
-        {
-            Standard = 0,
-            SubsurfaceScattering = 1,
-            ClearCoat = 2,
-            SpecularColor = 3
-        }
-
         protected MaterialProperty UVBase = null;
         protected const string kUVBase = "_UVBase";
         protected MaterialProperty TexWorldScale = null;
         protected const string kAnisotropy = "_Anisotropy";
         protected MaterialProperty anisotropyMap = null;
         protected const string kAnisotropyMap = "_AnisotropyMap";
+        protected MaterialProperty specularColor = null;
+        protected const string kSpecularColor = "_SpecularColor";
+        protected MaterialProperty specularColorMap = null;
+        protected const string kSpecularColorMap = "_SpecularColorMap";
 
         protected MaterialProperty UVDetail = null;
         protected const string kUVDetail = "_UVDetail";
             tangentMap = FindProperty(kTangentMap, props);
             anisotropy = FindProperty(kAnisotropy, props);
             anisotropyMap = FindProperty(kAnisotropyMap, props);
+            specularColor = FindProperty(kSpecularColor, props);
+            specularColorMap = FindProperty(kSpecularColorMap, props);
 
             // Details
             UVDetail = FindProperty(kUVDetail, props);
                 EditorGUI.indentLevel--;
             }
 
-            if ((MaterialIDType)materialID.floatValue == MaterialIDType.Standard)
-            {
-                ShaderStandardInputGUI();
-            }
-            else if ((MaterialIDType)materialID.floatValue == MaterialIDType.SubsurfaceScattering)
+            switch ((MaterialId)materialID.floatValue)
-                ShaderSSSInputGUI(material);
+                case MaterialId.LitSSS:
+                    ShaderSSSInputGUI(material);
+                    break;
+                case MaterialId.LitStandard:
+                    ShaderStandardInputGUI();
+                    break;
+                case MaterialId.LitSpecular:
+                    m_MaterialEditor.TexturePropertySingleLine(Styles.specularColorText, specularColorMap, specularColor);
+                    break;
+                default:
+                    Debug.Assert(false, "Encountered an unsupported MaterialID.");
+                    break;
             }
 
             EditorGUILayout.Space();
             SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));
             SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
             SetKeyword(material, "_SUBSURFACE_RADIUS_MAP", material.GetTexture(kSubsurfaceRadiusMap));
-            SetKeyword(material, "_THICKNESS_MAP", material.GetTexture(kThicknessMap));
+            SetKeyword(material, "_THICKNESSMAP", material.GetTexture(kThicknessMap));
+            SetKeyword(material, "_SPECULARCOLORMAP", material.GetTexture(kSpecularColorMap));
 
             bool needUV2 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV2 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0;
             bool needUV3 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV3 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0;

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

         [GenerateHLSL(PackingRules.Exact)]
         public enum MaterialId
         {
-            LitStandard = 0,
-            LitSSS = 1,
-            LitClearCoat = 2,
-            LitSpecular = 3,
-            LitAniso = 4 // Should be the last as it is not setup by the users but generated based on anisotropy property
+            LitSSS      = 0,
+            LitStandard = 1,
+            LitSpecular = 2,
+            LitUnused   = 3,
+            LitAniso    = 4 // Should be the last as it is not setup by the users but generated based on anisotropy property
-            public static uint FEATURE_FLAG_MATERIAL_LIT_STANDARD = 1 << 12;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_SSS = 1 << 13;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_CLEAR_COAT = 1 << 14;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_SPECULAR = 1 << 15;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_ANISO = 1 << 16;
+            public static uint FEATURE_FLAG_MATERIAL_LIT_SSS      = 1 << 12;
+            public static uint FEATURE_FLAG_MATERIAL_LIT_STANDARD = 1 << 13;
+            public static uint FEATURE_FLAG_MATERIAL_LIT_SPECULAR = 1 << 14;
+            public static uint FEATURE_FLAG_MATERIAL_LIT_ANISO    = 1 << 15;
         }
 
         //-----------------------------------------------------------------------------
             [SurfaceDataAttributes("Subsurface Profile")]
             public int subsurfaceProfile;
 
-            // Clearcoat
-            [SurfaceDataAttributes("Coat Normal", true)]
-            public Vector3 coatNormalWS;
-            [SurfaceDataAttributes("Coat Smoothness")]
-            public float coatPerceptualSmoothness;
-
             // SpecColor
             [SurfaceDataAttributes("Specular Color", false, true)]
             public Vector3 specularColor;
         // BSDFData
         //-----------------------------------------------------------------------------
+
+        [GenerateHLSL(PackingRules.Exact)]
+        public enum TransmissionType
+        {
+            None = 0,
+            Regular = 1,
+            ThinObject = 2,
+        };
 
         [GenerateHLSL(PackingRules.Exact, false, true, 1030)]
         public struct BSDFData
             public float   subsurfaceRadius;
             public float   thickness;
             public int     subsurfaceProfile;
-            public bool    enableTransmission; // Read from the SSS profile
-            public Vector3 transmittance;
-
-            // Clearcoat
-            [SurfaceDataAttributes("", true)]
-            public Vector3 coatNormalWS;
-            public float coatRoughness;
+            public TransmissionType transmissionType; // Compute from the SSS profile. 0 is none, 1 is regular transmission, 2 is thin transmission
+            public Vector3 transmittance; // Compute from SSS profile
 
             // SpecColor
             // fold into fresnel0
             {
                 m_InitPreFGD = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
 
-                // TODO: switch to RGBA64 when it becomes available.
-                m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
+                // For DisneyDiffuse integration values goes from (0.5 to 1.53125). GGX need 0 to 1. Use float format.
+                m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear);
+                m_PreIntegratedFGD.hideFlags = HideFlags.DontSave;
                 m_PreIntegratedFGD.Create();
 
                 m_LtcData = new Texture2DArray(k_LtcLUTResolution, k_LtcLUTResolution, 3, TextureFormat.RGBAHalf, false /*mipmap*/, true /* linear */)

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

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit.MaterialId:  static fields
 //
-#define MATERIALID_LIT_STANDARD (0)
-#define MATERIALID_LIT_SSS (1)
-#define MATERIALID_LIT_CLEAR_COAT (2)
-#define MATERIALID_LIT_SPECULAR (3)
+#define MATERIALID_LIT_SSS (0)
+#define MATERIALID_LIT_STANDARD (1)
+#define MATERIALID_LIT_SPECULAR (2)
+#define MATERIALID_LIT_UNUSED (3)
-#define FEATURE_FLAG_MATERIAL_LIT_STANDARD (4096)
-#define FEATURE_FLAG_MATERIAL_LIT_SSS (8192)
-#define FEATURE_FLAG_MATERIAL_LIT_CLEAR_COAT (16384)
-#define FEATURE_FLAG_MATERIAL_LIT_SPECULAR (32768)
-#define FEATURE_FLAG_MATERIAL_LIT_ANISO (65536)
+#define FEATURE_FLAG_MATERIAL_LIT_SSS (4096)
+#define FEATURE_FLAG_MATERIAL_LIT_STANDARD (8192)
+#define FEATURE_FLAG_MATERIAL_LIT_SPECULAR (16384)
+#define FEATURE_FLAG_MATERIAL_LIT_ANISO (32768)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit.SurfaceData:  static fields
 #define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS (1010)
 #define DEBUGVIEW_LIT_SURFACEDATA_THICKNESS (1011)
 #define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE (1012)
-#define DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS (1013)
-#define DEBUGVIEW_LIT_SURFACEDATA_COAT_PERCEPTUAL_SMOOTHNESS (1014)
-#define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR (1015)
+#define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR (1013)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.Lit.TransmissionType:  static fields
+//
+#define TRANSMISSIONTYPE_NONE (0)
+#define TRANSMISSIONTYPE_REGULAR (1)
+#define TRANSMISSIONTYPE_THIN_OBJECT (2)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit.BSDFData:  static fields
 #define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS (1042)
 #define DEBUGVIEW_LIT_BSDFDATA_THICKNESS (1043)
 #define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE (1044)
-#define DEBUGVIEW_LIT_BSDFDATA_ENABLE_TRANSMISSION (1045)
+#define DEBUGVIEW_LIT_BSDFDATA_TRANSMISSION_TYPE (1045)
-#define DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS (1047)
-#define DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS (1048)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit.GBufferMaterial:  static fields
     float subsurfaceRadius;
     float thickness;
     int subsurfaceProfile;
-    float3 coatNormalWS;
-    float coatPerceptualSmoothness;
     float3 specularColor;
 };
 
     float subsurfaceRadius;
     float thickness;
     int subsurfaceProfile;
-    bool enableTransmission;
+    int transmissionType;
-    float3 coatNormalWS;
-    float coatRoughness;
 };
 
 //
         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;
         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);
+        case DEBUGVIEW_LIT_BSDFDATA_TRANSMISSION_TYPE:
+            result = GetIndexColor(bsdfdata.transmissionType);
-            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;
     }
 }

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

 
 // SurfaceData is define in Lit.cs which generate Lit.cs.hlsl
 #include "Lit.cs.hlsl"
+#include "SubsurfaceScatteringProfile.cs.hlsl"
 
 // In case we pack data uint16 buffer we need to change the output render target format to uint16
 // TODO: Is there a way to automate these output type based on the format declare in lit.cs ?
 #define LTC_LUT_SCALE  ((LTC_LUT_SIZE - 1) * rcp(LTC_LUT_SIZE))
 #define LTC_LUT_OFFSET (0.5 * rcp(LTC_LUT_SIZE))
 
+#define MIN_N_DOT_V           0.0001                       // The minimum value of 'NdotV'
+
-#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
+#define CENTIMETERS_TO_METERS 0.01
-uint   _EnableSSS;                                         // Globally toggles subsurface scattering on/off
-uint   _TransmissionFlags;                                 // 1 bit/profile; 0 = inf. thick, 1 = supports transmission
-uint   _TexturingModeFlags;                                // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
-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
+uint    _EnableSSS;                                              // Globally toggles subsurface scattering on/off
+uint    _TexturingModeFlags;                                     // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
+float    _TransmissionType[SSS_PROFILES_MAX];                    // transmissionType enum - TODO: no int array in Unity :(
+float4  _TintColors[SSS_PROFILES_MAX];                           // For transmission; alpha is unused
+float   _ThicknessRemaps[SSS_PROFILES_MAX][2];                   // Remap: 0 = start, 1 = end - start
+float4  _HalfRcpVariancesAndLerpWeights[SSS_PROFILES_MAX][2];    // 2x Gaussians per color channel, A is the the associated interpolation weight
 
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
 void ApplyDebugToBSDFData(inout BSDFData bsdfData)
 {
 #ifdef DEBUG_DISPLAY
-    if (_DebugDisplayMode == DEBUGDISPLAYMODE_SPECULAR_LIGHTING)
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_SPECULAR_LIGHTING)
     {
         bool overrideSmoothness = _DebugLightingSmoothness.x != 0.0;
         float overrideSmoothnessValue = _DebugLightingSmoothness.y;
         }
     }
 
-    if (_DebugDisplayMode == DEBUGDISPLAYMODE_DIFFUSE_LIGHTING)
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_DIFFUSE_LIGHTING)
     {
         bsdfData.diffuseColor = _DebugLightingAlbedo.xyz;
     }
-void ConfigureTexturingForSSS(inout BSDFData bsdfData)
-{
-    bool performPostScatterTexturing = IsBitSet(_TexturingModeFlags, bsdfData.subsurfaceProfile);
-
-    // It's either post-scatter, or pre- and post-scatter texturing.
-    bsdfData.diffuseColor = performPostScatterTexturing ? float3(1, 1, 1)
-                                                        : sqrt(bsdfData.diffuseColor);
-}
-
 // Evaluates transmittance for a linear combination of two normalized 2D Gaussians.
 // Computes results for each color channel separately.
 // Ref: Real-Time Realistic Skin Translucency (2010), equation 9 (modified).
     // Thickness and SSS radius are decoupled for artists.
     // In theory, we should modify the thickness by the inverse of the radius scale of the profile.
     // thickness /= radiusScale;
-    thickness /= SSS_UNIT_CONVERSION;
+    thickness /= CENTIMETERS_TO_METERS;
 
     float t2 = thickness * thickness;
 
     return transmittance * tintColor;
 }
 
+void FillMaterialIdStandardData(float3 baseColor, float specular, float metallic, float roughness, float3 normalWS, float3 tangentWS, float anisotropy, inout BSDFData bsdfData)
+{
+    bsdfData.diffuseColor = baseColor * (1.0 - metallic);
+    bsdfData.fresnel0 = lerp(float3(specular.xxx), baseColor, metallic);
+
+    // TODO: encode specular
+
+    bsdfData.tangentWS = tangentWS;
+    bsdfData.bitangentWS = cross(normalWS, tangentWS);
+    ConvertAnisotropyToRoughness(roughness, anisotropy, bsdfData.roughnessT, bsdfData.roughnessB);
+    bsdfData.anisotropy = anisotropy;
+}
+
+void FillMaterialIdSSSData(float3 baseColor, int subsurfaceProfile, float subsurfaceRadius, float thickness, inout BSDFData bsdfData)
+{
+    bsdfData.diffuseColor = baseColor;
+
+    // TODO take from subsurfaceProfile
+    bsdfData.fresnel0 = 0.04; // Should be 0.028 for the skin
+    bsdfData.subsurfaceProfile = subsurfaceProfile;
+    bsdfData.subsurfaceRadius  = CENTIMETERS_TO_METERS * subsurfaceRadius + 0.0001;
+    bsdfData.thickness         = CENTIMETERS_TO_METERS * (_ThicknessRemaps[subsurfaceProfile][0] +
+                                                          _ThicknessRemaps[subsurfaceProfile][1] * thickness);
+
+    bsdfData.transmissionType = (int)_TransmissionType[subsurfaceProfile];
+
+    if (bsdfData.transmissionType != TRANSMISSIONTYPE_NONE)
+    {
+        bsdfData.transmittance = ComputeTransmittance(  _HalfRcpVariancesAndLerpWeights[subsurfaceProfile][0].xyz,
+                                                        _HalfRcpVariancesAndLerpWeights[subsurfaceProfile][0].w,
+                                                        _HalfRcpVariancesAndLerpWeights[subsurfaceProfile][1].xyz,
+                                                        _HalfRcpVariancesAndLerpWeights[subsurfaceProfile][1].w,
+                                                        _TintColors[subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
+    }
+
+    #ifndef SSS_FILTER_HORIZONTAL_AND_COMBINE // When doing the SSS comine pass, we must not apply the modification of diffuse color
+    // Handle post-scatter, or pre- and post-scatter texturing.
+    // We modify diffuseColor here so it affect all the lighting + GI (lightprobe / lightmap) (Need to be done also in GBuffer pass) + transmittance
+    // diffuseColor will be solely use during lighting pass. The other contribution will be apply in subsurfacescattering convolution.
+    bool performPostScatterTexturing = IsBitSet(_TexturingModeFlags, subsurfaceProfile);
+    bsdfData.diffuseColor = performPostScatterTexturing ? float3(1.0, 1.0, 1.0) : sqrt(bsdfData.diffuseColor);
+    #endif
+}
+
 //-----------------------------------------------------------------------------
 // conversion function for forward
 //-----------------------------------------------------------------------------
 
     if (bsdfData.materialId == MATERIALID_LIT_STANDARD)
     {
-        bsdfData.diffuseColor = surfaceData.baseColor * (1.0 - surfaceData.metallic);
-        bsdfData.fresnel0 = lerp(float3(surfaceData.specular, surfaceData.specular, surfaceData.specular), surfaceData.baseColor, surfaceData.metallic);
-
-        bsdfData.tangentWS   = surfaceData.tangentWS;
-        bsdfData.bitangentWS = cross(surfaceData.normalWS, surfaceData.tangentWS);
-        ConvertAnisotropyToRoughness(bsdfData.roughness, surfaceData.anisotropy, bsdfData.roughnessT, bsdfData.roughnessB);
-        bsdfData.anisotropy = surfaceData.anisotropy;
-
-        bsdfData.materialId = surfaceData.anisotropy > 0 ? MATERIALID_LIT_ANISO : bsdfData.materialId;
+        FillMaterialIdStandardData(surfaceData.baseColor, surfaceData.specular, surfaceData.metallic, bsdfData.roughness, surfaceData.normalWS, surfaceData.tangentWS, surfaceData.anisotropy, bsdfData);
+        bsdfData.materialId = surfaceData.anisotropy > 0.0 ? MATERIALID_LIT_ANISO : bsdfData.materialId;
-        bsdfData.diffuseColor = surfaceData.baseColor;
-        // TODO take from subsurfaceProfile
-        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 + 0.0001;
-        bsdfData.thickness         = SSS_UNIT_CONVERSION * (_ThicknessRemaps[bsdfData.subsurfaceProfile][0] +
-                                                            _ThicknessRemaps[bsdfData.subsurfaceProfile][1] * surfaceData.thickness);
-        bsdfData.enableTransmission = IsBitSet(_TransmissionFlags, bsdfData.subsurfaceProfile);
-        if (bsdfData.enableTransmission)
-        {
-            bsdfData.transmittance = ComputeTransmittance(_HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].xyz,
-                                                          _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].w,
-                                                          _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].xyz,
-                                                          _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].w,
-                                                          _TintColors[bsdfData.subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
-        }
-    }
-    else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
-    {
-        bsdfData.diffuseColor = surfaceData.baseColor * (1.0 - surfaceData.metallic);
-        bsdfData.fresnel0 = lerp(float3(surfaceData.specular, surfaceData.specular, surfaceData.specular), surfaceData.baseColor, surfaceData.metallic);
-        bsdfData.coatNormalWS = surfaceData.coatNormalWS;
-        bsdfData.coatRoughness = PerceptualSmoothnessToRoughness(surfaceData.coatPerceptualSmoothness);
+        FillMaterialIdSSSData(surfaceData.baseColor, surfaceData.subsurfaceProfile, surfaceData.subsurfaceRadius, surfaceData.thickness, bsdfData);
     }
     else if (bsdfData.materialId == MATERIALID_LIT_SPECULAR)
     {
 
-#ifdef OUTPUT_SPLIT_LIGHTING
-    ConfigureTexturingForSSS(bsdfData);
-#endif
     ApplyDebugToBSDFData(bsdfData);
 
     return bsdfData;
 // conversion function for deferred
 //-----------------------------------------------------------------------------
 
+// Tetra encoding 10:10 + 2 seems equivalent to oct 11:11, as oct is cheaper use that. Let here for future testing in reflective scene for comparison
+//#define USE_NORMAL_TETRAHEDRON_ENCODING
+
 // Encode SurfaceData (BSDF parameters) into GBuffer
 // Must be in sync with RT declared in HDRenderPipeline.cs ::Rebuild
 void EncodeIntoGBuffer( SurfaceData surfaceData,
     outGBuffer0 = float4(surfaceData.baseColor, surfaceData.specularOcclusion);
 
     // RT1 - 10:10:10:2
-    // Encode normal on 20bit with oct compression
-    float2 octNormalWS = PackNormalOctEncode(surfaceData.normalWS);
-    // TODO: Store 2 bit of flag into perceptualSmoothness (one for SSR, other is free (deferred planar reflection ID ? / MatID extension ?)
-    outGBuffer1 = float4(octNormalWS * 0.5 + 0.5, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness), PackMaterialId(surfaceData.materialId));
+#ifdef USE_NORMAL_TETRAHEDRON_ENCODING
+    // Encode normal on 20bit + 2bit (faceIndex) with tetrahedal compression
+    uint faceIndex;
+    float2 tetraNormalWS = PackNormalTetraEncode(surfaceData.normalWS, faceIndex);
+    // Store faceIndex on two bits with perceptualRoughness
+    outGBuffer1 = float4(tetraNormalWS * 0.5 + 0.5, PackFloatInt10bit(PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness), faceIndex, 4.0), PackMaterialId(surfaceData.materialId));
+#else
+    // Encode normal on 20bit with oct compression + 2bit of sign
+    float2 octNormalWS = PackNormalOctEncode(surfaceData.normalWS);
+    // To have more precision encode the sign of xy in a separate uint
+    uint octNormalSign = (octNormalWS.x > 0.0 ? 1 : 0) + (octNormalWS.y > 0.0 ? 2 : 0);
+    // Store octNormalSign on two bits with perceptualRoughness
+    outGBuffer1 = float4(abs(octNormalWS), PackFloatInt10bit(PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness), octNormalSign, 4.0), PackMaterialId(surfaceData.materialId));
+#endif
 
     // RT2 - 8:8:8:8
     if (surfaceData.materialId == MATERIALID_LIT_STANDARD)
     }
     else if (surfaceData.materialId == MATERIALID_LIT_SSS)
     {
-        outGBuffer2 = float4(surfaceData.subsurfaceRadius, surfaceData.thickness, 0.0, surfaceData.subsurfaceProfile * rcp(SSS_N_PROFILES - 1));
-    }
-    else if (surfaceData.materialId == MATERIALID_LIT_CLEAR_COAT)
-    {
-        // Encode coat normal on 16bit with oct compression
-        float2 octCoatNormalWS = PackNormalOctEncode(surfaceData.coatNormalWS);
-        // TODO: store metal and specular together, specular should be an enum (fixed value)
-        outGBuffer2 = float4(octCoatNormalWS * 0.5 + 0.5, PerceptualSmoothnessToRoughness(surfaceData.coatPerceptualSmoothness), surfaceData.metallic);
+        outGBuffer2 = float4(surfaceData.subsurfaceRadius, surfaceData.thickness, 0.0, surfaceData.subsurfaceProfile * rcp(SSS_PROFILES_MAX - 1));
     }
     else if (surfaceData.materialId == MATERIALID_LIT_SPECULAR)
     {
     float3 baseColor = inGBuffer0.rgb;
     bsdfData.specularOcclusion = inGBuffer0.a;
 
-    bsdfData.normalWS = UnpackNormalOctEncode(float2(inGBuffer1.r * 2.0 - 1.0, inGBuffer1.g * 2.0 - 1.0));
-    bsdfData.perceptualRoughness = inGBuffer1.b;
+#ifdef USE_NORMAL_TETRAHEDRON_ENCODING
+    uint faceIndex;
+    UnpackFloatInt10bit(inGBuffer1.b, 4.0, bsdfData.perceptualRoughness, faceIndex);
+    bsdfData.normalWS = UnpackNormalTetraEncode(inGBuffer1.xy * 2.0 - 1.0, faceIndex);
+#else
+    uint octNormalSign;
+    UnpackFloatInt10bit(inGBuffer1.b, 4.0, bsdfData.perceptualRoughness, octNormalSign);
+    inGBuffer1.r *= (octNormalSign & 1) ? 1.0 : -1.0;
+    inGBuffer1.g *= (octNormalSign & 2) ? 1.0 : -1.0;
+    bsdfData.normalWS = UnpackNormalOctEncode(float2(inGBuffer1.r, inGBuffer1.g));
+#endif
+
-    int supportsClearCoat = (featureFlags & (MATERIALID_LIT_CLEAR_COAT)) != 0;
-    if(supportsStandard + supportsSSS + supportsClearCoat + supportsSpecular > 1)
+    if(supportsStandard + supportsSSS + supportsSpecular > 1)
     {
         bsdfData.materialId = UnpackMaterialId(inGBuffer1.a);   // only fetch materialid if it is not statically known from feature flags
     }
         if(supportsStandard) bsdfData.materialId = MATERIALID_LIT_STANDARD;
         else if(supportsSSS) bsdfData.materialId = MATERIALID_LIT_SSS;
-        else if(supportsClearCoat) bsdfData.materialId = MATERIALID_LIT_CLEAR_COAT;
         else bsdfData.materialId = MATERIALID_LIT_SPECULAR;
     }
 
-        // TODO extract spec
-        float specular = 0.04;
+        float specular = 0.04; // TODO extract spec
-
-        bsdfData.diffuseColor = baseColor * (1.0 - metallic);
-        bsdfData.fresnel0 = lerp(float3(specular, specular, specular), baseColor, metallic);
-
-        bsdfData.tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
-        bsdfData.bitangentWS = cross(bsdfData.normalWS, bsdfData.tangentWS);
-        ConvertAnisotropyToRoughness(bsdfData.roughness, anisotropy, bsdfData.roughnessT, bsdfData.roughnessB);
-        bsdfData.anisotropy = anisotropy;
+        float3 tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
+        FillMaterialIdStandardData(baseColor, specular, metallic, bsdfData.roughness, bsdfData.normalWS, tangentWS, anisotropy, bsdfData);
 
         if ((featureFlags & FEATURE_FLAG_MATERIAL_LIT_ANISO) && (featureFlags & FEATURE_FLAG_MATERIAL_LIT_STANDARD) == 0 || anisotropy > 0)
         {
     else if (supportsSSS && bsdfData.materialId == MATERIALID_LIT_SSS)
     {
-        bsdfData.diffuseColor = baseColor;
-        // TODO take from subsurfaceProfile
-        bsdfData.fresnel0 = 0.04; /* 0.028 ? */
-        bsdfData.subsurfaceProfile = (SSS_N_PROFILES - 0.9) * inGBuffer2.a; // Need to bias for integers to round trip through the G-buffer
-        // Make the Std. Dev. of 1 correspond to the effective radius of 1 cm (three-sigma rule).
-        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);
-        if (bsdfData.enableTransmission)
-        {
-            bsdfData.transmittance = ComputeTransmittance(_HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].xyz,
-                                                          _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].w,
-                                                          _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].xyz,
-                                                          _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].w,
-                                                          _TintColors[bsdfData.subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
-        }
-    }
-    else if (supportsClearCoat && bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
-    {
-        float metallic = inGBuffer2.a;
-        // TODO extract spec
-        float specular = 0.04;
-
-        bsdfData.diffuseColor = baseColor * (1.0 - metallic);
-        bsdfData.fresnel0 = lerp(float3(specular, specular, specular), baseColor, metallic);
-        bsdfData.coatNormalWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
-        bsdfData.coatRoughness = inGBuffer2.b;
+        int subsurfaceProfile = (SSS_PROFILES_MAX - 0.9) * inGBuffer2.a;
+        float subsurfaceRadius = inGBuffer2.r;
+        float thickness = inGBuffer2.g;
+        FillMaterialIdSSSData(baseColor, subsurfaceProfile, subsurfaceRadius, thickness, bsdfData);
     }
     else if (supportsSpecular && bsdfData.materialId == MATERIALID_LIT_SPECULAR)
     {
 
     bakeDiffuseLighting = inGBuffer3.rgb;
 
-#ifdef OUTPUT_SPLIT_LIGHTING
-    ConfigureTexturingForSSS(bsdfData);
-#endif
     ApplyDebugToBSDFData(bsdfData);
 }
 
     {
         featureFlags |= FEATURE_FLAG_MATERIAL_LIT_SSS;
     }
-    else if (materialId == MATERIALID_LIT_CLEAR_COAT)
-    {
-        featureFlags |= FEATURE_FLAG_MATERIAL_LIT_CLEAR_COAT;
-    }
     else if (materialId == MATERIALID_LIT_SPECULAR)
     {
         featureFlags |= FEATURE_FLAG_MATERIAL_LIT_SPECULAR;
 struct PreLightData
 {
     // General
-    float NdotV;
+    float NdotV;                         // Geometric version (not clamped)
 
     // GGX iso
     float ggxLambdaV;
     float anisoGGXLambdaV;
 
     // IBL
-    float3 iblDirWS;    // Dominant specular direction, used for IBL in EvaluateBSDF_Env()
+    float3 iblDirWS;                     // Dominant specular direction, used for IBL in EvaluateBSDF_Env()
-    float3 specularFGD; // Store preconvole BRDF for both specular and diffuse
+    float3 specularFGD;                  // Store preconvoled BRDF for both specular and diffuse
     float diffuseFGD;
 
     // area light
 {
     PreLightData preLightData;
 
-    // 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
+    float NdotV = dot(bsdfData.normalWS, V);
+
+    float3 iblNormalWS = GetViewShiftedNormal(bsdfData.normalWS, V, NdotV, MIN_N_DOT_V);
+
+    preLightData.NdotV = NdotV;      // Store the unaltered (geometric) version
+    NdotV = max(NdotV, MIN_N_DOT_V); // Use the modified (clamped) version
+
+    float3 iblR = reflect(-V, iblNormalWS);
-    preLightData.ggxLambdaV = GetSmithJointGGXLambdaV(preLightData.NdotV, bsdfData.roughness);
+    preLightData.ggxLambdaV = GetSmithJointGGXLambdaV(NdotV, bsdfData.roughness);
 
     // GGX aniso
     if (bsdfData.materialId == MATERIALID_LIT_ANISO)
-        preLightData.anisoGGXLambdaV = GetSmithJointGGXAnisoLambdaV(preLightData.TdotV, preLightData.BdotV, preLightData.NdotV, bsdfData.roughnessT, bsdfData.roughnessB);
+        preLightData.anisoGGXLambdaV = GetSmithJointGGXAnisoLambdaV(preLightData.TdotV, preLightData.BdotV, NdotV, bsdfData.roughnessT, bsdfData.roughnessB);
-        iblNormalWS = GetAnisotropicModifiedNormal(bsdfData.bitangentWS, iblNormalWS, V, bsdfData.anisotropy);
+        float3 anisoIblNormalWS = GetAnisotropicModifiedNormal(bsdfData.bitangentWS, iblNormalWS, V, bsdfData.anisotropy);
+        iblR = reflect(-V, anisoIblNormalWS);
-    GetPreIntegratedFGD(preLightData.NdotV, bsdfData.perceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD);
+    GetPreIntegratedFGD(NdotV, bsdfData.perceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD);
-    // We need to take into account the modified normal for faking anisotropic here.
-    float3 iblR = reflect(-V, iblNormalWS);
-    preLightData.iblDirWS = GetSpecularDominantDir(bsdfData.normalWS, iblR, bsdfData.roughness, preLightData.NdotV);
+    preLightData.iblDirWS = GetSpecularDominantDir(iblNormalWS, iblR, bsdfData.roughness, NdotV);
-    float theta = FastACos(preLightData.NdotV);
+    float theta = FastACos(NdotV);
     float2 uv = LTC_LUT_OFFSET + LTC_LUT_SCALE * float2(bsdfData.perceptualRoughness, theta * INV_HALF_PI);
 
     // Get the inverse LTC matrix for GGX
             out float3 diffuseLighting,
             out float3 specularLighting)
 {
-    float NdotL    = saturate(dot(bsdfData.normalWS, L));
-    float NdotV    = preLightData.NdotV;
+    // Optimized math. Ref: PBR Diffuse Lighting for GGX + Smith Microsurfaces (slide 114).
+    float NdotL    = saturate(dot(bsdfData.normalWS, L)); // Must have the same value without the clamp
+    float NdotV    = preLightData.NdotV;                  // Get the unaltered (geometric) version
-    // 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 invLenLV = rsqrt(abs(2 * LdotV + 2));           // invLenLV = rcp(length(L + V))
+
+    NdotV          = max(NdotV, MIN_N_DOT_V);             // Use the modified (clamped) version
 
     float3 F = F_Schlick(bsdfData.fresnel0, LdotH);
 
         bsdfData.roughnessB = ClampRoughnessForAnalyticalLights(bsdfData.roughnessB);
 
         #ifdef LIT_USE_BSDF_PRE_LAMBDAV
-        Vis = V_SmithJointGGXAnisoLambdaV(  preLightData.TdotV, preLightData.BdotV, NdotV, TdotL, BdotL, NdotL,
-                                            bsdfData.roughnessT, bsdfData.roughnessB, preLightData.anisoGGXLambdaV);
+        Vis = V_SmithJointGGXAnisoLambdaV(preLightData.TdotV, preLightData.BdotV, NdotV, TdotL, BdotL, NdotL,
+                                          bsdfData.roughnessT, bsdfData.roughnessB, preLightData.anisoGGXLambdaV);
-        Vis = V_SmithJointGGXAniso( preLightData.TdotV, preLightData.BdotV, NdotV, TdotL, BdotL, NdotL,
-                                    bsdfData.roughnessT, bsdfData.roughnessB);
+        Vis = V_SmithJointGGXAniso(preLightData.TdotV, preLightData.BdotV, NdotV, TdotL, BdotL, NdotL,
+                                   bsdfData.roughnessT, bsdfData.roughnessB);
         #endif
 
         D = D_GGXAniso(TdotH, BdotH, NdotH, bsdfData.roughnessT, bsdfData.roughnessB);
 
     [branch] if (lightData.shadowIndex >= 0)
     {
-#ifdef SHADOWS_USE_SHADOWCTXT
-        shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#else
-        shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#endif
+        shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, bsdfData.normalWS, lightData.shadowIndex, L, posInput.unPositionSS);
         illuminance *= shadow;
     }
 
         specularLighting *= (cookie.rgb * lightData.color) * (illuminance * lightData.specularScale);
     }
 
-    [branch] if (bsdfData.enableTransmission)
+    [branch] if (bsdfData.transmissionType != TRANSMISSIONTYPE_NONE)
     {
         // Reverse the normal + do some wrap lighting to have a nicer transition between regular lighting and transmittance
         // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
-        // For low thickness, we can reuse the shadowing status for the back of the object.
-        shadow       = (bsdfData.thickness <= SSS_LOW_THICKNESS) ? shadow : 1;
+        // For thin material we can reuse the shadowing status for the back of the object.
+        shadow       = (bsdfData.transmissionType == TRANSMISSIONTYPE_THIN_OBJECT) ? shadow : 1;
         illuminance *= shadow * cookie.a;
 
         // The difference between the Disney Diffuse and the Lambertian BRDF for transmission is negligible.
     [branch] if (lightData.shadowIndex >= 0)
     {
         float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
-#ifdef SHADOWS_USE_SHADOWCTXT
-        shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
-#else
-        shadow = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
-#endif
+        shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, bsdfData.normalWS, lightData.shadowIndex, L, posInput.unPositionSS);
         shadow = lerp(1.0, shadow, lightData.shadowDimmer);
 
         illuminance *= shadow;
         specularLighting *= (cookie.rgb * lightData.color) * (illuminance * lightData.specularScale);
     }
 
-    [branch] if (bsdfData.enableTransmission)
+    [branch] if (bsdfData.transmissionType != TRANSMISSIONTYPE_NONE)
     {
         // Reverse the normal + do some wrap lighting to have a nicer transition between regular lighting and transmittance
         // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
 
-        // For low thickness, we can reuse the shadowing status for the back of the object.
-        shadow       = (bsdfData.thickness <= SSS_LOW_THICKNESS) ? shadow : 1;
+        // For thin material we can reuse the shadowing status for the back of the object.
+        shadow = (bsdfData.transmissionType == TRANSMISSIONTYPE_THIN_OBJECT) ? shadow : 1;
         illuminance *= shadow * cookie.a;
 
         // The difference between the Disney Diffuse and the Lambertian BRDF for transmission is negligible.
 
     [branch] if (lightData.shadowIndex >= 0)
     {
-#ifdef SHADOWS_USE_SHADOWCTXT
-        shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#else
-        shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#endif
+        shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, bsdfData.normalWS, lightData.shadowIndex, L, posInput.unPositionSS);
         illuminance *= shadow;
     }
 
         specularLighting *= (cookie.rgb * lightData.color) * (illuminance * lightData.specularScale);
     }
 
-    [branch] if (bsdfData.enableTransmission)
+    [branch] if (bsdfData.transmissionType != TRANSMISSIONTYPE_NONE)
     {
         // Reverse the normal + do some wrap lighting to have a nicer transition between regular lighting and transmittance
         // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
 
-        // For low thickness, we can reuse the shadowing status for the back of the object.
-        shadow       = (bsdfData.thickness <= SSS_LOW_THICKNESS) ? shadow : 1;
+        // For thin material we can reuse the shadowing status for the back of the object.
+        shadow = (bsdfData.transmissionType == TRANSMISSIONTYPE_THIN_OBJECT) ? shadow : 1;
         illuminance *= shadow * cookie.a;
 
         // The difference between the Disney Diffuse and the Lambertian BRDF for transmission is negligible.
         float  sinLT = length(cross(L, T));
         float  NdotL = saturate(dot(bsdfData.normalWS, L));
 
-        float3 lightDiff, lightSpec;
+        if (NdotL > 0)
+        {
+            float3 lightDiff, lightSpec;
-        BSDF(V, L, positionWS, preLightData, bsdfData, lightDiff, lightSpec);
+            BSDF(V, L, positionWS, preLightData, bsdfData, lightDiff, lightSpec);
-        // The value of the specular BSDF could be infinite.
-        // Summing up infinities leads to NaNs.
-        lightSpec = min(lightSpec, FLT_MAX);
-
-        diffuseLighting  += lightDiff * (sinLT / dist2 * NdotL);
-        specularLighting += lightSpec * (sinLT / dist2 * NdotL);
+            diffuseLighting  += lightDiff * (sinLT / dist2 * NdotL);
+            specularLighting += lightSpec * (sinLT / dist2 * NdotL);
+        }
     }
 
     // The factor of 2 is due to the fact: Integral{0, 2 PI}{max(0, cos(x))dx} = 2.
         ltcValue = LTCEvaluate(P1, P2, B, preLightData.ltcXformDisneyDiffuse);
     #endif
 
-        if (ltcValue == 0.0)
-        {
-            // The light is below the horizon.
-            return;
-        }
-
     #ifndef LIT_DIFFUSE_LAMBERT_BRDF
         ltcValue *= preLightData.ltcDisneyDiffuseMagnitude;
     #endif
     float3 unL = lightData.positionWS - positionWS;
 
     [branch]
-    if (dot(lightData.forward, unL) >= 0)
+    if (dot(lightData.forward, unL) >= 0.0001)
     {
         // The light is back-facing.
         return;
         ltcValue = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, preLightData.ltcXformDisneyDiffuse);
     #endif
 
-        if (ltcValue == 0.0)
-        {
-            // The polygon is either back-facing, or has been completely clipped.
-            return;
-        }
-
     #ifndef LIT_DIFFUSE_LAMBERT_BRDF
         ltcValue *= preLightData.ltcDisneyDiffuseMagnitude;
     #endif
                                     uint sampleCount = 4096)
 {
     float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
+    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
     float3   acc          = float3(0.0, 0.0, 0.0);
 
     // Add some jittering on Hammersley2d
             float LdotH = dot(L, H);
             // Note: we call DisneyDiffuse that require to multiply by Albedo / PI. Divide by PI is already taken into account
             // in weightOverPdf of ImportanceSampleLambert call.
-            float disneyDiffuse = DisneyDiffuse(preLightData.NdotV, NdotL, LdotH, bsdfData.perceptualRoughness);
+            float disneyDiffuse = DisneyDiffuse(NdotV, NdotL, LdotH, bsdfData.perceptualRoughness);
 
             // diffuse Albedo is apply here as describe in ImportanceSampleLambert function
             float4 val = SampleEnv(lightLoopContext, lightData.envIndex, L, 0);
                                   uint sampleCount = 4096)
 {
     float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
+    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
     float3   acc          = float3(0.0, 0.0, 0.0);
 
     // Add some jittering on Hammersley2d
         // GGX BRDF
         if (bsdfData.materialId == MATERIALID_LIT_ANISO)
         {
-            ImportanceSampleAnisoGGX(u, V, localToWorld, bsdfData.roughnessT, bsdfData.roughnessB, preLightData.NdotV, L, VdotH, NdotL, weightOverPdf);
+            ImportanceSampleAnisoGGX(u, V, localToWorld, bsdfData.roughnessT, bsdfData.roughnessB, NdotV, L, VdotH, NdotL, weightOverPdf);
-            ImportanceSampleGGX(u, V, localToWorld, bsdfData.roughness, preLightData.NdotV, L, VdotH, NdotL, weightOverPdf);
+            ImportanceSampleGGX(u, V, localToWorld, bsdfData.roughness, NdotV, L, VdotH, NdotL, weightOverPdf);
         }
 
 

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

         _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
+        _SpecularColor("SpecularColor", Color) = (1, 1, 1, 1)
+        _SpecularColorMap("SpecularColorMap", 2D) = "white" {}
+
         // Wind
         [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
         _InitialBend("Initial Bend", float) = 1.0
         _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
 
-        //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
-        //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
-
-        //_CoatRoughness("CoatRoughness", Range(0.0, 1.0)) = 0
-        //_CoatRoughnessMap("CoatRoughnessMap", 2D) = "white" {}
-
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
         // Following options are for the GUI inspector and different from the input parameters above
         _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
 
         // Stencil state
-        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.Standard
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.NonSSS
 
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
 
-        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2, Specular Color, 3)] _MaterialID("MaterialId", Int) = 0
+        [Enum(Subsurface Scattering, 0, Standard, 1, Specular Color, 2)] _MaterialID("MaterialId", Int) = 1 // MaterialId.LitStandard
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
     #pragma shader_feature _ANISOTROPYMAP
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
-    #pragma shader_feature _THICKNESS_MAP
+    #pragma shader_feature _THICKNESSMAP
+    #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _VERTEX_WIND
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

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

     surfaceData.tangentWS = input.worldToTangent[0].xyz;
 #endif
     // Init other parameters
-    surfaceData.materialId = 0;
+    surfaceData.materialId = 1; // MaterialId.LitStandard
-    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
-    surfaceData.coatPerceptualSmoothness = 1.0;
     surfaceData.specularColor = float3(0.0, 0.0, 0.0);
 
     GetNormalAndTangentWS(input, V, normalTS, surfaceData.normalWS, surfaceData.tangentWS);

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

     surfaceData.subsurfaceRadius *= SAMPLE_UVMAPPING_TEXTURE2D(_SubsurfaceRadiusMap, sampler_SubsurfaceRadiusMap, layerTexCoord.base).r;
 #endif
 
-#ifdef _THICKNESS_MAP
+#ifdef _THICKNESSMAP
-    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
-    surfaceData.coatPerceptualSmoothness = 1.0;
-    surfaceData.specularColor = float3(0.0, 0.0, 0.0);
+    surfaceData.specularColor = _SpecularColor.rgb;
+#ifdef _SPECULARCOLORMAP
+    surfaceData.specularColor *= SAMPLE_UVMAPPING_TEXTURE2D(_SpecularColorMap, sampler_SpecularColorMap, layerTexCoord.base).rgb;
+#endif
-    // Layered shader only support materialId 0
-    surfaceData.materialId = 0;
+    // Layered shader only supports the standard material
+    surfaceData.materialId = 1; // MaterialId.LitStandard
 
     // All these parameters are ignore as they are re-setup outside of the layers function
     surfaceData.tangentWS = float3(0.0, 0.0, 0.0);
     surfaceData.thickness = 0.0;
     surfaceData.subsurfaceProfile = 0;
 
-    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
-    surfaceData.coatPerceptualSmoothness = 0.0;
     surfaceData.specularColor = float3(0.0, 0.0, 0.0);
 
 #endif // #if !defined(LAYERED_LIT_SHADER)

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

 TEXTURE2D(_ThicknessMap);
 SAMPLER2D(sampler_ThicknessMap);
 
-// float _CoatCoverage;
-//TEXTURE2D(_CoatCoverageMap);
-//SAMPLER2D(sampler_CoatCoverageMap);
-
-// float _CoatRoughness;
-//TEXTURE2D(_CoatRoughnessMap);
-//SAMPLER2D(sampler_CoatRoughnessMap);
+float4 _SpecularColor;
+TEXTURE2D(_SpecularColorMap);
+SAMPLER2D(sampler_SpecularColorMap);
 
 float _TexWorldScale;
 float4 _UVMappingMask;

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

         _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
+        _SpecularColor("SpecularColor", Color) = (1, 1, 1, 1)
+        _SpecularColorMap("SpecularColorMap", 2D) = "white" {}
+
         // Wind
         [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
         _InitialBend("Initial Bend", float) = 1.0
         _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
 
-        //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
-        //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
-
-        //_CoatRoughness("CoatRoughness", Range(0.0, 1.0)) = 0
-        //_CoatRoughnessMap("CoatRoughnessMap", 2D) = "white" {}
-
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
         // Following options are for the GUI inspector and different from the input parameters above
         _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
 
         // Stencil state
-        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.Standard
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.NonSSS
 
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
 
-        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2, Specular Color, 3)] _MaterialID("MaterialId", Int) = 0
+        [Enum(Subsurface Scattering, 0, Standard, 1, Specular Color, 2)] _MaterialID("MaterialId", Int) = 1 // MaterialId.LitStandard
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
     #pragma shader_feature _ANISOTROPYMAP
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
-    #pragma shader_feature _THICKNESS_MAP
+    #pragma shader_feature _THICKNESSMAP
+    #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _VERTEX_WIND
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

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

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #pragma shader_feature _ SSS_PRE_SCATTER_TEXTURING SSS_POST_SCATTER_TEXTURING
-
-            #pragma multi_compile _ FILTER_HORIZONTAL_AND_COMBINE
+            #pragma multi_compile _ SSS_FILTER_HORIZONTAL_AND_COMBINE
+            #pragma multi_compile _ DEBUG_DISPLAY
 
             //-------------------------------------------------------------------------------------
             // Include
+            #include "../../../Debug/DebugDisplay.hlsl"
+
             #include "../../../ShaderConfig.cs.hlsl"
             #include "../../../ShaderVariables.hlsl"
             #define UNITY_MATERIAL_LIT // Needs to be defined before including Material.hlsl
                 float stepSizeY  = rcp(fragheight);
 
                 // Compute the filtering direction.
-            #ifdef FILTER_HORIZONTAL_AND_COMBINE
+            #ifdef SSS_FILTER_HORIZONTAL_AND_COMBINE
                 float  stepSize      = stepSizeX;
                 float2 unitDirection = float2(1, 0);
             #else
                     totalWeight     += sampleWeight;
                 }
 
-            #ifdef FILTER_HORIZONTAL_AND_COMBINE
+            #ifdef SSS_FILTER_HORIZONTAL_AND_COMBINE
                 bool performPostScatterTexturing = IsBitSet(_TexturingModeFlags, profileID);
 
                 // It's either post-scatter, or pre- and post-scatter texturing.

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

 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
+    [GenerateHLSL]
+    public class SSSConstants
+    {
+        public const int SSS_PROFILES_MAX = 8;
+    }
+
     [Serializable]
     public class SubsurfaceScatteringProfile : ScriptableObject
     {
 
         [ColorUsage(false, true, 0.05f, 2.0f, 1.0f, 1.0f)]
-        public Color         stdDev1;
+        public Color            scatterDistance1;
-        public Color         stdDev2;
-        public float         lerpWeight;
-        public TexturingMode texturingMode;
-        public bool          enableTransmission;
-        public Color         tintColor;
-        public Vector2       thicknessRemap;
+        public Color            scatterDistance2;
+        public float            lerpWeight;
+        public TexturingMode    texturingMode;
+        public bool             enableTransmission;
+        public bool             enableThinObject;
+        public Color            tintColor;
+        public Vector2          thicknessRemap;
-        public int           settingsIndex;
+        public int              settingsIndex;
-        Vector4[]            m_FilterKernel;
+        Vector4[]               m_FilterKernel;
-        Vector3[]            m_HalfRcpVariances;
+        Vector3[]               m_HalfRcpVariances;
-        Vector4              m_HalfRcpWeightedVariances;
+        Vector4                 m_HalfRcpWeightedVariances;
-            stdDev1            = new Color(0.3f, 0.3f, 0.3f, 0.0f);
-            stdDev2            = new Color(0.6f, 0.6f, 0.6f, 0.0f);
-            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
+            scatterDistance1    = new Color(0.3f, 0.3f, 0.3f, 0.0f);
+            scatterDistance2    = new Color(0.6f, 0.6f, 0.6f, 0.0f);
+            lerpWeight          = 0.5f;
+            texturingMode       = TexturingMode.PreAndPostScatter;
+            enableTransmission  = false;
+            enableThinObject  = false;
+            tintColor           = Color.white;
+            thicknessRemap      = new Vector2(0, 1);
+            settingsIndex       = SubsurfaceScatteringSettings.neutralProfileID; // Updated by SubsurfaceScatteringSettings.OnValidate() once assigned
 
             UpdateKernelAndVarianceData();
         }
                 m_HalfRcpVariances = new Vector3[2];
             }
 
+            // Apply the three-sigma rule.
+            Color stdDev1 = scatterDistance1 * (1.0f / 3.0f);
+            Color stdDev2 = scatterDistance2 * (1.0f / 3.0f);
+
             // Our goal is to blur the image using a filter which is represented
             // as a product of a linear combination of two normalized 1D Gaussians
             // as suggested by Jimenez et al. in "Separable Subsurface Scattering".
     [Serializable]
     public class SubsurfaceScatteringSettings : ISerializationCallbackReceiver
     {
-        public const int maxNumProfiles   = 8;
-        public const int neutralProfileID = maxNumProfiles - 1;
+        public const int neutralProfileID = SSSConstants.SSS_PROFILES_MAX - 1;
-        [NonSerialized] public int           texturingModeFlags; // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
-        [NonSerialized] public int           transmissionFlags;  // 1 bit/profile; 0 = inf. thick, 1 = supports transmission
-        [NonSerialized] public Vector4[]     tintColors;         // For transmission; alpha is unused
-        [NonSerialized] public float[]       thicknessRemaps;
+        [NonSerialized] public int           texturingModeFlags;    // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
+        [NonSerialized] public float[]       transmissionType;      // TODO: no int array suppport in shader in Unity :(
+        [NonSerialized] public Vector4[]     tintColors;            // For transmission; alpha is unused
+        [NonSerialized] public float[]       thicknessRemaps;       // Remap: 0 = start, 1 = end - start
         [NonSerialized] public Vector4[]     halfRcpVariancesAndLerpWeights;
         [NonSerialized] public Vector4[]     halfRcpWeightedVariances;
         [NonSerialized] public Vector4[]     filterKernels;
             numProfiles                    = 1;
             profiles                       = new SubsurfaceScatteringProfile[numProfiles];
             profiles[0]                    = null;
+            transmissionType                = null;
-            transmissionFlags              = 0;
             tintColors                     = null;
             thicknessRemaps                = null;
             halfRcpVariancesAndLerpWeights = null;
         public void OnValidate()
         {
             // Reserve one slot for the neutral profile.
-            numProfiles = Math.Min(profiles.Length, maxNumProfiles - 1);
+            numProfiles = Math.Min(profiles.Length, SSSConstants.SSS_PROFILES_MAX - 1);
 
             if (profiles.Length != numProfiles)
             {
                 // Skip unassigned profiles.
                 if (profiles[i] == null) continue;
 
-                c.r = Mathf.Clamp(profiles[i].stdDev1.r, 0.05f, 2.0f);
-                c.g = Mathf.Clamp(profiles[i].stdDev1.g, 0.05f, 2.0f);
-                c.b = Mathf.Clamp(profiles[i].stdDev1.b, 0.05f, 2.0f);
+                c.r = Mathf.Clamp(profiles[i].scatterDistance1.r, 0.05f, 2.0f);
+                c.g = Mathf.Clamp(profiles[i].scatterDistance1.g, 0.05f, 2.0f);
+                c.b = Mathf.Clamp(profiles[i].scatterDistance1.b, 0.05f, 2.0f);
-                profiles[i].stdDev1 = c;
+                profiles[i].scatterDistance1 = c;
-                c.r = Mathf.Clamp(profiles[i].stdDev2.r, 0.05f, 2.0f);
-                c.g = Mathf.Clamp(profiles[i].stdDev2.g, 0.05f, 2.0f);
-                c.b = Mathf.Clamp(profiles[i].stdDev2.b, 0.05f, 2.0f);
+                c.r = Mathf.Clamp(profiles[i].scatterDistance2.r, 0.05f, 2.0f);
+                c.g = Mathf.Clamp(profiles[i].scatterDistance2.g, 0.05f, 2.0f);
+                c.b = Mathf.Clamp(profiles[i].scatterDistance2.b, 0.05f, 2.0f);
-                profiles[i].stdDev2 = c;
+                profiles[i].scatterDistance2 = c;
 
                 profiles[i].lerpWeight = Mathf.Clamp01(profiles[i].lerpWeight);
 
 
         public void UpdateCache()
         {
-            texturingModeFlags = 0;
-            transmissionFlags  = 0;
+            texturingModeFlags  = 0;
-            if (tintColors == null || tintColors.Length != maxNumProfiles)
+            if (transmissionType == null || transmissionType.Length != (SSSConstants.SSS_PROFILES_MAX))
-                tintColors = new Vector4[maxNumProfiles];
+                transmissionType = new float[SSSConstants.SSS_PROFILES_MAX];
-            if (thicknessRemaps == null || thicknessRemaps.Length != (maxNumProfiles * 2))
+            if (tintColors == null || tintColors.Length != SSSConstants.SSS_PROFILES_MAX)
-                thicknessRemaps = new float[maxNumProfiles * 2];
+                tintColors = new Vector4[SSSConstants.SSS_PROFILES_MAX];
-            if (halfRcpVariancesAndLerpWeights == null || halfRcpVariancesAndLerpWeights.Length != (maxNumProfiles * 2))
+            if (thicknessRemaps == null || thicknessRemaps.Length != (SSSConstants.SSS_PROFILES_MAX * 2))
-                halfRcpVariancesAndLerpWeights = new Vector4[maxNumProfiles * 2];
+                thicknessRemaps = new float[SSSConstants.SSS_PROFILES_MAX * 2];
-            if (halfRcpWeightedVariances == null || halfRcpWeightedVariances.Length != maxNumProfiles)
+            if (halfRcpVariancesAndLerpWeights == null || halfRcpVariancesAndLerpWeights.Length != (SSSConstants.SSS_PROFILES_MAX * 2))
-                halfRcpWeightedVariances = new Vector4[maxNumProfiles];
+                halfRcpVariancesAndLerpWeights = new Vector4[SSSConstants.SSS_PROFILES_MAX * 2];
-            if (filterKernels == null || filterKernels.Length != (maxNumProfiles * SubsurfaceScatteringProfile.numSamples))
+            if (halfRcpWeightedVariances == null || halfRcpWeightedVariances.Length != SSSConstants.SSS_PROFILES_MAX)
+            {
+                halfRcpWeightedVariances = new Vector4[SSSConstants.SSS_PROFILES_MAX];
+            }
+
+            if (filterKernels == null || filterKernels.Length != (SSSConstants.SSS_PROFILES_MAX * SubsurfaceScatteringProfile.numSamples))
-                filterKernels = new Vector4[maxNumProfiles * SubsurfaceScatteringProfile.numSamples];
+                filterKernels = new Vector4[SSSConstants.SSS_PROFILES_MAX * SubsurfaceScatteringProfile.numSamples];
             }
 
             for (int i = 0; i < numProfiles; i++)
 
                 texturingModeFlags |= ((int)profiles[i].texturingMode) << i;
-                transmissionFlags  |= (profiles[i].enableTransmission ? 1 : 0) << i;
+                if (profiles[i].enableTransmission)
+                {
+                    transmissionType[i] = (float)(profiles[i].enableThinObject ? Lit.TransmissionType.ThinObject :Lit.TransmissionType.Regular);
+                }
+                else
+                {
+                    transmissionType[i] = (float)Lit.TransmissionType.None;
+                }
 
                 tintColors[i]                               = profiles[i].tintColor;
                 thicknessRemaps[2 * i]                      = profiles[i].thicknessRemap.x;
     {
         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 the 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 for thickness values from the remap.");
+            public readonly GUIContent   sssTransmittancePreview2   = new GUIContent("Can be thought of as a cross section of a slab of material illuminated by a white light from the left.");
+            public readonly GUIContent   sssProfileScatterDistance1 = new GUIContent("Scatter Distance #1", "The radius (in centimeters) of the 1st Gaussian filter, one per color channel. Alpha is ignored. The blur is energy-preserving, so a wide filter results in a large area with small contributions of individual samples. Smaller values increase the sharpness.");
+            public readonly GUIContent   sssProfileScatterDistance2 = new GUIContent("Scatter Distance #2", "The radius (in centimeters) of the 2nd Gaussian filter, one per color channel. Alpha is ignored. The blur is energy-preserving, so a wide filter results in a large area with small contributions of individual samples. Smaller values increase the sharpness.");
+            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]
             {
                 new GUIContent("Pre- and post-scatter", "Texturing is performed during both the lighting and the SSS passes. Slightly blurs the diffuse texture. Choose this mode if your diffuse texture contains little to no SSS lighting."),
                 new GUIContent("Post-scatter", "Texturing is performed only during the SSS pass. Effectively preserves the sharpness of the diffuse texture. Choose this mode if your diffuse texture already contains SSS lighting (e.g. a photo of skin).")
-            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 GUIContent   sssProfileThinObject    = new GUIContent("Enable Thin Object", "Define is the object is thin (paper, leaf) or not. Allow to get cheap transmission and shadow.");
+            public readonly GUIContent   sssProfileMinMaxThickness = new GUIContent("Min-Max Thickness", "Shows the values of the thickness remap below (in centimeters).");
+            public readonly GUIContent   sssProfileThicknessRemap  = new GUIContent("Thickness Remap", "Remaps the thickness parameter from [0, 1] to the desired range (in centimeters).");
 
             public readonly GUIStyle     centeredMiniBoldLabel     = new GUIStyle(GUI.skin.label);
 
 
         private RenderTexture      m_ProfileImage, m_TransmittanceImage;
         private Material           m_ProfileMaterial, m_TransmittanceMaterial;
-        private SerializedProperty m_StdDev1, m_StdDev2, m_LerpWeight, m_TintColor,
+        private SerializedProperty m_ScatterDistance1, m_ScatterDistance2, m_LerpWeight, m_TintColor, m_ThinObject,
-            m_StdDev1        = serializedObject.FindProperty("stdDev1");
-            m_StdDev2        = serializedObject.FindProperty("stdDev2");
-            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_ScatterDistance1 = serializedObject.FindProperty("scatterDistance1");
+            m_ScatterDistance2 = serializedObject.FindProperty("scatterDistance2");
+            m_LerpWeight       = serializedObject.FindProperty("lerpWeight");
+            m_TexturingMode    = serializedObject.FindProperty("texturingMode");
+            m_Transmission     = serializedObject.FindProperty("enableTransmission");
+            m_ThinObject     = serializedObject.FindProperty("enableThinObject");
+            m_TintColor        = serializedObject.FindProperty("tintColor");
+            m_ThicknessRemap   = serializedObject.FindProperty("thicknessRemap");
 
             m_ProfileMaterial       = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawGaussianProfile");
             m_TransmittanceMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawTransmittanceGraph");
 
             EditorGUI.BeginChangeCheck();
             {
-                EditorGUILayout.PropertyField(m_StdDev1,      styles.sssProfileStdDev1);
-                EditorGUILayout.PropertyField(m_StdDev2,      styles.sssProfileStdDev2);
-                EditorGUILayout.PropertyField(m_LerpWeight,   styles.sssProfileLerpWeight);
+                EditorGUILayout.PropertyField(m_ScatterDistance1, styles.sssProfileScatterDistance1);
+                EditorGUILayout.PropertyField(m_ScatterDistance2, styles.sssProfileScatterDistance2);
+                EditorGUILayout.PropertyField(m_LerpWeight,       styles.sssProfileLerpWeight);
-                EditorGUILayout.PropertyField(m_Transmission, styles.sssProfileTransmission);
-                EditorGUILayout.PropertyField(m_TintColor,    styles.sssProfileTintColor);
+                EditorGUILayout.PropertyField(m_Transmission,     styles.sssProfileTransmission);
+                EditorGUILayout.PropertyField(m_TintColor,        styles.sssProfileTintColor);
+
+                EditorGUILayout.PropertyField(m_ThinObject,     styles.sssProfileThinObject);
 
                 EditorGUILayout.PropertyField(m_ThicknessRemap, styles.sssProfileMinMaxThickness);
                 Vector2 thicknessRemap = m_ThicknessRemap.vector2Value;
                 EditorGUILayout.Space();
             }
 
+            // Apply the three-sigma rule.
+            Color stdDev1 = m_ScatterDistance1.colorValue * (1.0f / 3.0f);
+            Color stdDev2 = m_ScatterDistance2.colorValue * (1.0f / 3.0f);
+
-            m_ProfileMaterial.SetColor("_StdDev1",    m_StdDev1.colorValue);
-            m_ProfileMaterial.SetColor("_StdDev2",    m_StdDev2.colorValue);
+            m_ProfileMaterial.SetColor("_StdDev1",    stdDev1);
+            m_ProfileMaterial.SetColor("_StdDev2",    stdDev2);
             m_ProfileMaterial.SetFloat("_LerpWeight", m_LerpWeight.floatValue);
             EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(256, 256), m_ProfileImage, m_ProfileMaterial, ScaleMode.ScaleToFit, 1.0f);
 
+            EditorGUILayout.LabelField(styles.sssTransmittancePreview2, EditorStyles.centeredGreyMiniLabel);
-            m_TransmittanceMaterial.SetColor("_StdDev1",         m_StdDev1.colorValue);
-            m_TransmittanceMaterial.SetColor("_StdDev2",         m_StdDev2.colorValue);
-            m_TransmittanceMaterial.SetFloat("_LerpWeight",      m_LerpWeight.floatValue);
+            m_TransmittanceMaterial.SetColor("_StdDev1", stdDev1);
+            m_TransmittanceMaterial.SetColor("_StdDev2", stdDev2);
+            m_TransmittanceMaterial.SetFloat("_LerpWeight", m_LerpWeight.floatValue);
-            m_TransmittanceMaterial.SetVector("_TintColor",      m_TintColor.colorValue);
+            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/SSSProfile/FoliageSSSProfile.asset

   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}
+  scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+  scatterDistance2: {r: 0.6, g: 0.6, b: 0.6, a: 0}
+  enableThinObject: 1
-  - {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}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.00000001629312}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.034422863}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.07085508}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.112142384}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.16452742}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.25364923}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.03442289}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.07085508}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.11214242}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.16452742}
+  - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.2536493}
-  - {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}
+  - {x: 49.999992, y: 49.999992, z: 49.999992}
+  - {x: 12.499998, y: 12.499998, z: 12.499998}
+  m_HalfRcpWeightedVariances: {x: 22.222221, y: 22.222221, z: 22.222221, w: 22.222221}

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/SceneSettings.cs

         void OnEnable()
         {
             SceneSettingsManager.instance.AddSceneSettings(this);
+
+            HDRenderPipelineInstance hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipelineInstance;
+
+            if (hdPipeline != null)
+            {
+                hdPipeline.OnSceneLoad();
+            }
         }
 
         void OnDisable()

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassForward.hlsl

 #endif
 
 #ifdef DEBUG_DISPLAY
-    if (_DebugDisplayMode == DEBUGDISPLAYMODE_VIEW_MATERIAL)
+    if (_DebugViewMaterial != 0)
     {
         float3 result = float3(1.0, 0.0, 1.0);
         bool needLinearToSRGB = false;

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl

 
     // Output UV coordinate in vertex shader
     if (unity_MetaVertexControl.x)
-    {
-        // OpenGL right now needs to actually use incoming vertex position,
-        // so use it in a very dummy way
-        //v.positionOS.z = vertex.z > 0 ? 1.0e-4 : 0.0;
-    }
+
-    {
-        // OpenGL right now needs to actually use incoming vertex position,
-        // so use it in a very dummy way
-        //v.positionOS.z = vertex.z > 0 ? 1.0e-4 : 0.0;
-    }
+
+    // Zero out the Z component. However, OpenGL right now needs to actually use the incoming vertex
+    // position, so also take this opportunity to create a dependence on it.
+    inputMesh.positionOS.z = inputMesh.positionOS.z > 0 ? 1.0e-4 : 0.0;
 
     float3 positionWS = TransformObjectToWorld(inputMesh.positionOS);
     output.vmesh.positionCS = TransformWorldToHClip(positionWS);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyRenderer.cs

             m_ProceduralSkyMaterial.SetFloat("_WorldRayleighNearScatterPush", -Mathf.Pow(Mathf.Abs(param.worldRayleighNearScatterPush), param.worldScaleExponent) * Mathf.Sign(param.worldRayleighNearScatterPush));
             m_ProceduralSkyMaterial.SetFloat("_WorldRayleighDensity", -param.worldRayleighDensity / 100000f);
             m_ProceduralSkyMaterial.SetFloat("_WorldMieDensity", -param.worldMieDensity / 100000f);
+            m_ProceduralSkyMaterial.SetFloat("_SkyDepth", 1.0f / param.maxSkyDistance);
 
             var rayleighColorM20 = param.worldRayleighColorRamp.Evaluate(0.00f);
             var rayleighColorM10 = param.worldRayleighColorRamp.Evaluate(0.25f);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkySettings.cs

         // public Shader atmosphericShader = null;
         // public Shader occlusionShader   = null;
         public float worldScaleExponent    = 1.0f;
+        public float maxSkyDistance        = 4000.0f;
         public ScatterDebugMode debugMode  = ScatterDebugMode.None;
 
         // Camera   m_currentCamera;
             heightRayleighNearScatterPush = Mathf.Clamp(heightRayleighNearScatterPush, -200f, 300f);
 
             worldScaleExponent            = Mathf.Clamp(worldScaleExponent, 1f, 2f);
+            maxSkyDistance                = Mathf.Clamp(maxSkyDistance, 1.0f, 1000000.0f);
 
             /*
             occlusionBias                = Mathf.Clamp01(occlusionBias);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/Resources/SkyProcedural.shader

 
             float4x4 _InvViewProjMatrix;
 
+            float _SkyDepth;
+
             float _DisableSkyOcclusionTest;
 
             float _FlipY;
                 // input.positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
 
-                // An arbitrary value attempting to match the size of the sky mesh from the Blacksmith demo.
-                const float skyDepth = 0.00025;
-
-                    float depthRaw     = max(skyDepth, LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).r);
-                    float skyTexWeight = (depthRaw > skyDepth) ? 0.0 : 1.0;
+                    float depthRaw     = max(_SkyDepth, LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).r);
+                    float skyTexWeight = (depthRaw > _SkyDepth) ? 0.0 : 1.0;
-                    float depthRaw     = skyDepth;
+                    float depthRaw     = _SkyDepth;
-                    depthRaw     = skyDepth;
+                    depthRaw     = _SkyDepth;
                     skyTexWeight = 1.0;
                 }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

         SkyRenderer             m_Renderer = null;
         int                     m_SkyParametersHash = -1;
         bool                    m_NeedLowLevelUpdateEnvironment = false;
-        bool                    m_UpdateRequired = true;
+        int                     m_UpdatedFramesRequired = 2; // The first frame after the scene load is currently not rendered correctly
         float                   m_CurrentUpdateTime = 0.0f;
 
         bool                    m_useMIS = false;
 
                 m_SkyParametersHash = -1;
                 m_SkySettings = value;
-                m_UpdateRequired = true;
+                m_UpdatedFramesRequired = 2;
 
                 if (value != null)
                 {
                     m_SkyboxConditionalCdfRT.Create();
                 }
 
-                m_UpdateRequired = true; // Special case. Even if update mode is set to OnDemand, we need to regenerate the environment after destroying the texture.
+                m_UpdatedFramesRequired = 2; // Special case. Even if update mode is set to OnDemand, we need to regenerate the environment after destroying the texture.
             }
 
             m_CubemapScreenSize = new Vector4((float)resolution, (float)resolution, 1.0f / (float)resolution, 1.0f / (float)resolution);
 
         public void RequestEnvironmentUpdate()
         {
-            m_UpdateRequired = true;
+            m_UpdatedFramesRequired = Math.Max(m_UpdatedFramesRequired, 1);
         }
 
         public void UpdateEnvironment(HDCamera camera, Light sunLight, ScriptableRenderContext renderContext)
                     m_BuiltinParameters.sunLight = sunLight;
 
                     if (
-                        (skySettings.updateMode == EnvironementUpdateMode.OnDemand && m_UpdateRequired) ||
+                        m_UpdatedFramesRequired > 0 ||
                         (skySettings.updateMode == EnvironementUpdateMode.OnChanged && skySettings.GetHash() != m_SkyParametersHash) ||
                         (skySettings.updateMode == EnvironementUpdateMode.Realtime && m_CurrentUpdateTime > skySettings.updatePeriod)
                         )
                         RenderCubemapGGXConvolution(renderContext, m_BuiltinParameters, skySettings, m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT);
 
                         m_NeedLowLevelUpdateEnvironment = true;
-                        m_UpdateRequired = false;
+                        m_UpdatedFramesRequired--;
                         m_SkyParametersHash = skySettings.GetHash();
                         m_CurrentUpdateTime = 0.0f;
                     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

     [Flags]
     public enum StencilBits
     {
-        None      = 0,
-        SSS       = 0 + Lit.MaterialId.LitSSS,       // 1
-        Standard  = 2 + Lit.MaterialId.LitStandard,  // 2
-        ClearCoat = 1 + Lit.MaterialId.LitClearCoat, // 3
-        All       = 255 // 0xff
+        None   = 0,                         // 0
+        SSS    = 1 + Lit.MaterialId.LitSSS, // 1
+        NonSSS = 2 + Lit.MaterialId.LitSSS, // 2
+        All    = 255                        // 0xFF
     }
 
     public class Utilities

Assets/ScriptableRenderPipeline/HDRenderPipeline/Wind/3DNoise.psd.meta

 fileFormatVersion: 2
 guid: fcecce6d2c9be8d418a27f0658a2210d
-timeCreated: 1490775966
+timeCreated: 1493292037
 licenseType: Pro
 TextureImporter:
   fileIDToRecycleName: {}
     linearTexture: 0
     fadeOut: 0
     borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
     mipMapFadeDistanceStart: 1
     mipMapFadeDistanceEnd: 3
   bumpmap:
     allowsAlphaSplitting: 0
     overridden: 0
   - buildTarget: PS4
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: iPhone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: tvOS
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: WebGL
     maxTextureSize: 2048
     textureFormat: -1
     textureCompression: 0

Assets/ScriptableRenderPipeline/ShaderLibrary/AreaLighting.hlsl

 #ifndef UNITY_AREA_LIGHTING_INCLUDED
 #define UNITY_AREA_LIGHTING_INCLUDED
 
-#define SPHERE_LIGHT_APPROXIMATION
+#define APPROXIMATE_POLY_LIGHT_AS_SPHERE_LIGHT
+#define APPROXIMATE_SPHERE_LIGHT_NUMERICALLY
 
 // Not normalized by the factor of 1/TWO_PI.
 float3 ComputeEdgeFactor(float3 V1, float3 V2)
 // N.b.: this function accounts for horizon clipping.
 float DiffuseSphereLightIrradiance(float sinSqSigma, float cosOmega)
 {
-    float irradiance;
+#ifdef APPROXIMATE_SPHERE_LIGHT_NUMERICALLY
+    float x = sinSqSigma;
+    float y = cosOmega;
-#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);
+    // Use a numerical fit found in Mathematica. Mean absolute error: 0.00476944.
+    // You can use the following Mathematica code to reproduce our results:
+    // t = Flatten[Table[{x, y, f[x, y]}, {x, 0, 0.999999, 0.001}, {y, -0.999999, 0.999999, 0.002}], 1]
+    // m = NonlinearModelFit[t, x * (y + e) * (0.5 + (y - e) * (a + b * x + c * x^2 + d * x^3)), {a, b, c, d, e}, {x, y}]
+    return saturate(x * (0.9245867471551246 + y) * (0.5 + (-0.9245867471551246 + y) * (0.5359050373687144 + x * (-1.0054221851257754 + x * (1.8199061187417047 - x * 1.3172081704209504)))));
+#else
+    #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 sinSigma = sqrt(sinSqSigma);
+        float sinGamma = sqrt(sinSqGamma);
+        float cosGamma = sqrt(cosSqGamma);
+
+        float sigma = asin(sinSigma);
+        float omega = acos(cosOmega);
+        float gamma = asin(sinGamma);
-    float sigma = asin(sinSigma);
-    float omega = acos(cosOmega);
-    float gamma = asin(sinGamma);
+        if (omega >= HALF_PI + sigma)
+        {
+            // Full horizon occlusion (case #4).
+            return 0;
+        }
-    if (omega < 0 || omega >= HALF_PI + sigma)
-    {
-        // Full horizon occlusion (case #4).
-        return 0;
-    }
+        float e = sinSqSigma * cosOmega;
-    float e = sinSqSigma * cosOmega;
+        [branch]
+        if (omega < HALF_PI - sigma)
+        {
+            // No horizon occlusion (case #1).
+            return 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)));
-    [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).
+                return saturate(e + INV_PI * (g - h));
+            }
+            else
+            {
+                // Partial horizon occlusion (case #3).
+                return saturate(INV_PI * (g + h));
+            }
+        }
+    #else // Ref: Moving Frostbite to Physically Based Rendering, page 47 (2015, optimized).
+        float cosSqOmega = cosOmega * cosOmega;                     // y^2
-        if (omega < HALF_PI)
+        [branch]
+        if (cosSqOmega > sinSqSigma)                                // (y^2)>x
-            // Partial horizon occlusion (case #2).
-            irradiance = e + INV_PI * (g - h);
+            return saturate(sinSqSigma * cosOmega);                 // Clip[x*y,{0,1}]
-            // 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;
+            float cotSqSigma = rcp(sinSqSigma) - 1;                 // 1/x-1
+            float tanSqSigma = rcp(cotSqSigma);                     // x/(1-x)
+            float sinSqOmega = 1 - cosSqOmega;                      // 1-y^2
-    [branch]
-    if (cosSqOmega > sinSqSigma)
-    {
-        irradiance = sinSqSigma * saturate(cosOmega);
-    }
-    else
-    {
-        float cotanOmega = cosOmega * rsqrt(1 - cosSqOmega);
+            float w = sinSqOmega * tanSqSigma;                      // (1-y^2)*(x/(1-x))
+            float x = -cosOmega * rsqrt(w);                         // -y*Sqrt[(1/x-1)/(1-y^2)]
+            float y = sqrt(sinSqOmega * tanSqSigma - cosSqOmega);   // Sqrt[(1-y^2)*(x/(1-x))-y^2]
+            float z = y * cotSqSigma;                               // Sqrt[(1-y^2)*(x/(1-x))-y^2]*(1/x-1)
-        float x = rcp(sinSqSigma) - 1;
-        float y = -cotanOmega * sqrt(x);
-        float z = sqrt(1 - cosSqOmega * rcp(sinSqSigma));
+            float a = cosOmega * acos(x) - z;                       // y*ArcCos[-y*Sqrt[(1/x-1)/(1-y^2)]]-Sqrt[(1-y^2)*(x/(1-x))-y^2]*(1/x-1)
+            float b = atan(y);                                      // ArcTan[Sqrt[(1-y^2)*(x/(1-x))-y^2]]
-        irradiance = INV_PI * ((cosOmega * acos(y) - z * sqrt(x)) * sinSqSigma + atan(z * rsqrt(x)));
-    }
+            // Replacing max() with saturate() results in a 12 cycle SGPR forwarding stall on PS4.
+            return max(INV_PI * (a * sinSqSigma + b), 0);           // (a/Pi)*x+(b/Pi)
+        }
+    #endif
-    return max(irradiance, 0);
-#ifdef SPHERE_LIGHT_APPROXIMATION
-    for (int i = 0; i < 4; i++)
+#ifdef APPROXIMATE_POLY_LIGHT_AS_SPHERE_LIGHT
+    [unroll]
+    for (uint i = 0; i < 4; i++)
     {
         L[i] = normalize(L[i]);
     }
+    [unroll]
     for (uint edge = 0; edge < 4; edge++)
     {
         float3 V1 = L[edge];
     }
 
+    // Clamp invalid values to avoid visual artifacts.
-    float sinSqSigma = sqrt(f2);
+    float sinSqSigma = min(sqrt(f2), 0.999);
     float cosOmega   = clamp(F.z * rsqrt(f2), -1, 1);
 
     return DiffuseSphereLightIrradiance(sinSqSigma, cosOmega);

Assets/ScriptableRenderPipeline/ShaderLibrary/CommonLighting.hlsl

 // Helper functions
 //-----------------------------------------------------------------------------
 
-// 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)
+// 'NdotV' can become negative for visible pixels due to the perspective projection, normal mapping and decals.
+// This can produce visible artifacts under specular lighting, both direct (overly dark/bright pixels) and indirect (incorrect cubemap direction).
+// One way of avoiding these artifacts is to limit the value of 'NdotV' to a small positive number,
+// and calculate the reflection vector for the cubemap fetch using a normal shifted into view.
+float3 GetViewShiftedNormal(float3 N, float3 V, float NdotV, float minNdotV)
-    float NdotV = dot(N, V);
-    const float limit = 0.0001; // Epsilon value that avoid divide by 0 (several BSDF divide by NdotV)
-
-    if (NdotV < limit)
+    if (NdotV < minNdotV)
-        // We do not renormalize the normal because { abs(length(N) - 1.0) < limit } + It is use for cubemap
-        N    += (-NdotV + limit) * V;
-        NdotV = limit;
+        // We do not renormalize the normal to save a few clock cycles.
+        // The magnitude difference is typically negligible, and the normal is only used to compute
+        // the reflection vector for the IBL cube map fetch (which does not depend on the magnitude).
+        N += (-NdotV + minNdotV) * V;
-    return NdotV;
+    return N;
 }
 
 // Generates an orthonormal basis from a unit vector.

Assets/ScriptableRenderPipeline/ShaderLibrary/ImageBasedLighting.hlsl

         {
             float3 H = normalize(L + V);
             float LdotH = dot(L, H);
-            float disneyDiffuse = DisneyDiffuse(NdotV, NdotL, LdotH, RoughnessToPerceptualRoughness(roughness));
+            float disneyDiffuse = DisneyDiffuseNoPI(NdotV, NdotL, LdotH, RoughnessToPerceptualRoughness(roughness));
 
             acc.z += disneyDiffuse * weightOverPdf;
         }

Assets/ScriptableRenderPipeline/ShaderLibrary/Packing.hlsl

 // Normal packing
 //-----------------------------------------------------------------------------
 
-float3 PackNormalCartesian(float3 n)
-{
-    return n * 0.5 + 0.5;
-}
-
-float3 UnpackNormalCartesian(float3 n)
-{
-    return normalize(n * 2.0 - 1.0);
-}
-
 float3 PackNormalMaxComponent(float3 n)
 {
     // TODO: use max3
     return normalize(n);
 }
 
+// Tetrahedral encoding - Looks like Tetra encoding 10:10 + 2 is similar to oct 11:11, as oct is cheaper prefer it
+// To generate the basisNormal below we use these 4 vertex of a regular tetrahedron
+// v0 = float3(1.0, 0.0, -1.0 / sqrt(2.0));
+// v1 = float3(-1.0, 0.0, -1.0 / sqrt(2.0));
+// v2 = float3(0.0, 1.0, 1.0 / sqrt(2.0));
+// v3 = float3(0.0, -1.0, 1.0 / sqrt(2.0));
+// Then we normalize the average of each face's vertices
+// normalize(v0 + v1 + v2), etc...
+static const float3 tetraBasisNormal[4] =
+{
+    float3(0., 0.816497, -0.57735),
+    float3(-0.816497, 0., 0.57735),
+    float3(0.816497, 0., 0.57735),
+    float3(0., -0.816497, -0.57735)
+};
+
+// Then to get the local matrix (with z axis rotate to basisNormal) use GetLocalFrame(basisNormal[xxx])
+static const float3x3 tetraBasisArray[4] =
+{
+    float3x3(-1., 0., 0.,0., 0.57735, 0.816497,0., 0.816497, -0.57735),
+    float3x3(0., -1., 0.,0.57735, 0., 0.816497,-0.816497, 0., 0.57735),
+    float3x3(0., 1., 0.,-0.57735, 0., 0.816497,0.816497, 0., 0.57735),
+    float3x3(1., 0., 0.,0., -0.57735, 0.816497,0., -0.816497, -0.57735)
+};
+
+// Return [-1..1] vector2 oriented in plane of the faceIndex of a regular tetrahedron
+float2 PackNormalTetraEncode(float3 n, out uint faceIndex)
+{
+    // Retrieve the tetrahedra's face for the normal direction
+    // It is the one with the greatest dot value with face normal
+    float dot0 = dot(n, tetraBasisNormal[0]);
+    float dot1 = dot(n, tetraBasisNormal[1]);
+    float dot2 = dot(n, tetraBasisNormal[2]);
+    float dot3 = dot(n, tetraBasisNormal[3]);
+
+    float maxi0 = max(dot0, dot1);
+    float maxi1 = max(dot2, dot3);
+    float maxi = max(maxi0, maxi1);
+
+    // Get the index from the greatest dot
+    if (maxi == dot0)
+        faceIndex = 0;
+    else if (maxi == dot1)
+        faceIndex = 1;
+    else if (maxi == dot2)
+        faceIndex = 2;
+    else //(maxi == dot3)
+        faceIndex = 3;
+
+    // Rotate n into this local basis
+    n = mul(tetraBasisArray[faceIndex], n);
+
+    // Project n onto the local plane
+    return n.xy;
+}
+
+// Assume f [-1..1]
+float3 UnpackNormalTetraEncode(float2 f, uint faceIndex)
+{
+    // Recover n from local plane
+    float3 n = float3(f.xy, sqrt(1.0 - dot(f.xy, f.xy)));
+    // Inverse of transform PackNormalTetraEncode (just swap order in mul as we have a rotation)
+    return mul(n, tetraBasisArray[faceIndex]);
+}
+
+// Unpack from normal map
 float3 UnpackNormalRGB(float4 packedNormal, float scale = 1.0)
 {
     float3 normal;

Assets/ScriptableRenderPipeline/common/Camera/CameraSwitcher.cs

         private Quaternion m_OriginalCameraRotation;
         private Camera m_CurrentCamera = null;
 
-        private float m_MessageDuration = 1.0f;
-        private float m_MessageTimer = 1000.0f;
-
-        private static string kDebugNext = "Debug Next";
-        private static string kDebugPrevious = "Debug Previous";
-        private string[] m_RequiredInputButtons = { kDebugNext, kDebugPrevious };
-        private bool m_Valid = true;
+        GUIContent[]    m_CameraNames = null;
+        int[]           m_CameraIndices = null;
 
         void OnEnable()
         {
-            m_Valid = Debugging.CheckRequiredInputButtonMapping(m_RequiredInputButtons);
-        }
+            if(m_OriginalCamera == null)
+            {
+                Debug.LogError("Camera Switcher needs a Camera component attached");
+                return;
+            }
-        int GetCameraCount()
-        {
-            return m_Cameras.Length + 1; // We need +1 for handling the original camera.
-        }
+            m_CurrentCameraIndex = GetCameraCount() - 1;
-        void NextCamera()
-        {
-            m_CurrentCameraIndex = (m_CurrentCameraIndex + 1) % GetCameraCount();
+            m_CameraNames = new GUIContent[GetCameraCount()];
+            m_CameraIndices = new int[GetCameraCount()];
+
+            for (int i = 0; i < m_Cameras.Length; ++i)
+            {
+                Camera cam = m_Cameras[i];
+                if (cam != null)
+                {
+                    m_CameraNames[i] = new GUIContent(cam.name);
+                }
+                else
+                {
+                    m_CameraNames[i] = new GUIContent("null");
+                }
+                m_CameraIndices[i] = i;
+            }
+
+            m_CameraNames[GetCameraCount() - 1] = new GUIContent("Original Camera");
+            m_CameraIndices[GetCameraCount() - 1] = GetCameraCount() - 1;
+
+            DebugMenuManager.instance.AddDebugItem<int>("Camera", "Camera Switcher", () => m_CurrentCameraIndex, (value) => SetCameraIndex((int)value), false, new DebugItemDrawerIntEnum(m_CameraNames, m_CameraIndices));
-        void PreviousCamera()
+        int GetCameraCount()
-            m_CurrentCameraIndex = m_CurrentCameraIndex - 1;
-            if (m_CurrentCameraIndex == -1)
-                m_CurrentCameraIndex = m_Cameras.Length;
+            return m_Cameras.Length + 1; // We need +1 for handling the original camera.
         }
 
         Camera GetNextCamera()
                 return m_Cameras[m_CurrentCameraIndex];
         }
 
-        void Update()
+        void SetCameraIndex(int index)
-            if (m_Valid && Debugging.debugControlEnabled && m_OriginalCamera != null)
+            if(index > 0 || index < GetCameraCount())
-                m_MessageTimer += Time.deltaTime;
-                bool needUpdateCamera = false;
-                if (Input.GetButtonDown(kDebugNext))
-                {
-                    NextCamera();
-                    needUpdateCamera = true;
-                }
+                m_CurrentCameraIndex = index;
-                if (Input.GetButtonDown(kDebugPrevious))
+                if (m_CurrentCamera == m_OriginalCamera)
-                    PreviousCamera();
-                    needUpdateCamera = true;
+                    m_OriginalCameraPosition = m_OriginalCamera.transform.position;
+                    m_OriginalCameraRotation = m_OriginalCamera.transform.rotation;
-                if (needUpdateCamera)
+                m_CurrentCamera = GetNextCamera();
+
+                if (m_CurrentCamera != null)
-                    m_MessageTimer = 0.0f;
-
+                    // If we witch back to the original camera, put back the transform in it.
-                        m_OriginalCameraPosition = m_OriginalCamera.transform.position;
-                        m_OriginalCameraRotation = m_OriginalCamera.transform.rotation;
+                        m_OriginalCamera.transform.position = m_OriginalCameraPosition;
+                        m_OriginalCamera.transform.rotation = m_OriginalCameraRotation;
-                    m_CurrentCamera = GetNextCamera();
-
-                    if (m_CurrentCamera != null)
-                    {
-                        // If we witch back to the original camera, put back the transform in it.
-                        if (m_CurrentCamera == m_OriginalCamera)
-                        {
-                            m_OriginalCamera.transform.position = m_OriginalCameraPosition;
-                            m_OriginalCamera.transform.rotation = m_OriginalCameraRotation;
-                        }
-
-                        transform.position = m_CurrentCamera.transform.position;
-                        transform.rotation = m_CurrentCamera.transform.rotation;
-                    }
-                }
-
-                if (m_MessageTimer < m_MessageDuration)
-                {
-                    string cameraName = m_CurrentCamera != null ? m_CurrentCamera.name : "NULL";
-                    string message = string.Format("Switching to camera : {0}", cameraName);
-                    Debugging.PushDebugMessage(message);
+                    transform.position = m_CurrentCamera.transform.position;
+                    transform.rotation = m_CurrentCamera.transform.rotation;
                 }
             }
         }

Assets/ScriptableRenderPipeline/common/CubeToSpherical.shader

     uint2 pixCoord = ((uint2) i.vertex.xy);
 
     half3 dir = SphericalTexCoordinateToDirection(i.texcoord.xy);
-    half3 res = UNITY_SAMPLE_TEXCUBE_LOD(_srcCubeTexture, dir, (float) _cubeMipLvl).xyz;
-
-    return half4(res,1.0);
+    
+    return (half4) UNITY_SAMPLE_TEXCUBE_LOD(_srcCubeTexture, dir, (float) _cubeMipLvl);
 }
 
 ENDCG

Assets/ScriptableRenderPipeline/common/Debugging/DebugItemDrawer.cs

         protected DebugMenuItem m_MenuItem = null;
 
         // Label for simple GUI items
-        GUIContent m_Label;
-        List<GUIContent> m_EnumStrings = null;
-        List<int> m_EnumValues = null;
+        protected GUIContent m_Label;
+        protected List<GUIContent> m_EnumStrings = null;
+        protected List<int> m_EnumValues = null;
 
         public DebugItemDrawer()
         {
             }
             else if (m_MenuItem.GetItemType().BaseType == typeof(System.Enum))
             {
-                newItemUI = new DebugMenuEnumItemUI(parent, menuItem, m_Label.text, m_EnumStrings, m_EnumValues);
+                newItemUI = new DebugMenuEnumItemUI(parent, menuItem, m_Label.text, m_EnumStrings.ToArray(), m_EnumValues.ToArray());
             }
 
             return newItemUI;
-        void DrawBoolItem()
+        bool DrawBoolItem()
         {
             bool value = (bool)m_MenuItem.GetValue();
             if (m_MenuItem.readOnly)
                 if (EditorGUI.EndChangeCheck())
                 {
                     m_MenuItem.SetValue(value);
+                    return true;
+
+            return false;
-        void DrawIntItem()
+        bool DrawIntItem()
         {
             int value = (int)m_MenuItem.GetValue();
             if (m_MenuItem.readOnly)
                 if (EditorGUI.EndChangeCheck())
                 {
                     m_MenuItem.SetValue(value);
+                    return true;
+
+            return false;
-        void DrawUIntItem()
+        bool DrawUIntItem()
         {
             int value = (int)(uint)m_MenuItem.GetValue();
             if (m_MenuItem.readOnly)
                 {
                     value = System.Math.Max(0, value);
                     m_MenuItem.SetValue((uint)value);
+                    return true;
+
+            return false;
-        void DrawFloatItem()
+        bool DrawFloatItem()
         {
             float value = (float)m_MenuItem.GetValue();
             if(m_MenuItem.readOnly)
                 if (EditorGUI.EndChangeCheck())
                 {
                     m_MenuItem.SetValue(value);
+                    return true;
+
+            return false;
-        void DrawColorItem()
+        bool DrawColorItem()
         {
             EditorGUI.BeginChangeCheck();
             Color value = EditorGUILayout.ColorField(m_Label, (Color)m_MenuItem.GetValue());
+                return true;
+
+            return false;
-        void DrawEnumItem()
+        bool DrawEnumItem()
         {
             EditorGUI.BeginChangeCheck();
             int value = EditorGUILayout.IntPopup(m_Label, (int)m_MenuItem.GetValue(), m_EnumStrings.ToArray(), m_EnumValues.ToArray());
+                return true;
+
+            return false;
-        public virtual void OnEditorGUI()
+        public virtual bool OnEditorGUI()
-                DrawBoolItem();
+                return DrawBoolItem();
-                DrawIntItem();
+                return DrawIntItem();
-                DrawUIntItem();
+                return DrawUIntItem();
-                DrawFloatItem();
+                return DrawFloatItem();
-                DrawColorItem();
+                return DrawColorItem();
-                DrawEnumItem();
+                return DrawEnumItem();
+
+            return false;
         }
 #endif
 }
         }
 
 #if UNITY_EDITOR
-        public override void OnEditorGUI()
+        public override bool OnEditorGUI()
         {
             EditorGUI.BeginChangeCheck();
             float value = EditorGUILayout.Slider(m_MenuItem.name, (float)m_MenuItem.GetValue(), m_Min, m_Max);
+                return true;
+
+            return false;
+
+    public class DebugItemDrawerIntEnum
+        : DebugItemDrawer
+    {
+        GUIContent[]    m_EnumStrings = null;
+        int[]           m_EnumValues = null;
+
+        public DebugItemDrawerIntEnum(GUIContent[] enumStrings, int[] enumValues)
+        {
+            m_EnumStrings = enumStrings;
+            m_EnumValues = enumValues;
+        }
+
+        public override DebugMenuItemUI BuildGUI(GameObject parent, DebugMenuItem menuItem)
+        {
+            return new DebugMenuEnumItemUI(parent, menuItem, m_Label.text, m_EnumStrings, m_EnumValues);
+        }
+
+#if UNITY_EDITOR
+        public override bool OnEditorGUI()
+        {
+            UnityEditor.EditorGUI.BeginChangeCheck();
+            int value = UnityEditor.EditorGUILayout.IntPopup(m_Label, (int)m_MenuItem.GetValue(), m_EnumStrings, m_EnumValues);
+            if (UnityEditor.EditorGUI.EndChangeCheck())
+            {
+                m_MenuItem.SetValue(value);
+                return true;
+            }
+
+            return false;
+        }
+#endif
+    }
+
 }

Assets/ScriptableRenderPipeline/common/Debugging/DebugMenuItemUI.cs

     public class DebugMenuEnumItemUI : DebugMenuSimpleItemUI
     {
         int                 m_CurrentValueIndex = 0;
-        List<GUIContent>    m_ValueNames;
-        List<int>           m_Values;
+        GUIContent[]        m_ValueNames;
+        int[]               m_Values;
-        public DebugMenuEnumItemUI(GameObject parent, DebugMenuItem menuItem, string name, List<GUIContent> valueNames, List<int> values)
+        public DebugMenuEnumItemUI(GameObject parent, DebugMenuItem menuItem, string name, GUIContent[] valueNames, int[] values)
             : base(parent, menuItem, name)
         {
             m_Values = values;
 
         private int FindIndexForValue(int value)
         {
-            for(int i = 0 ; i < m_Values.Count ; ++i)
+            for(int i = 0 ; i < m_Values.Length ; ++i)
             {
                 if (m_Values[i] == value)
                     return i;
 
         public override void OnIncrement()
         {
-            m_CurrentValueIndex = (m_CurrentValueIndex + 1) % m_Values.Count;
-            m_MenuItem.SetValue(m_CurrentValueIndex);
+            m_CurrentValueIndex = (m_CurrentValueIndex + 1) % m_Values.Length;
+            m_MenuItem.SetValue(m_Values[m_CurrentValueIndex]);
             Update();
         }
 
             if (m_CurrentValueIndex < 0)
-                m_CurrentValueIndex = m_Values.Count - 1;
+                m_CurrentValueIndex = m_Values.Length - 1;
-            m_MenuItem.SetValue(m_CurrentValueIndex);
+            m_MenuItem.SetValue(m_Values[m_CurrentValueIndex]);
             Update();
         }
     }

Assets/ScriptableRenderPipeline/common/Debugging/Debugging.cs

 {
     public class Debugging : MonoBehaviour
     {
-        private static bool m_DebugControlEnabled = false;
-        public static bool debugControlEnabled { get { return m_DebugControlEnabled;  } }
-
-        private float m_DebugControlEnabledMsgTime = 3.0f;
-        private float m_DebugControlEnabledMsgTimer = 0.0f;
-
-        private bool m_DebugKeyUp1 = false;
-        private bool m_DebugKeyUp2 = false;
-        private bool m_CanReceiveInput = true;
-
-        private static string kEnableDebugBtn1 = "Enable Debug Button 1";
-        private static string kEnableDebugBtn2 = "Enable Debug Button 2";
-        private string[] m_RequiredInputButtons = { kEnableDebugBtn1, kEnableDebugBtn2 };
-        private bool m_Valid = true;
 
         public static void PushDebugMessage(string message)
         {
             return inputsOk;
         }
 
-        void OnEnable()
-        {
-            m_Valid = CheckRequiredInputButtonMapping(m_RequiredInputButtons);
-        }
-
-        void Update()
-        {
-            //if (m_Valid)
-            //{
-            //    m_DebugControlEnabledMsgTimer += Time.deltaTime;
-
-            //    bool enableDebug = Input.GetButton(kEnableDebugBtn1) && Input.GetButton(kEnableDebugBtn2) || Input.GetKey(KeyCode.LeftControl) && Input.GetKey(KeyCode.Backspace);
-
-            //    if (m_CanReceiveInput && enableDebug)
-            //    {
-            //        m_DebugControlEnabled = !m_DebugControlEnabled;
-            //        m_DebugControlEnabledMsgTimer = 0.0f;
-            //        m_CanReceiveInput = false;
-            //        m_DebugKeyUp1 = false;
-            //        m_DebugKeyUp2 = false;
-            //    }
-
-            //    if (Input.GetButtonUp(kEnableDebugBtn1))
-            //    {
-            //        m_DebugKeyUp1 = true;
-            //    }
-            //    if (Input.GetButtonUp(kEnableDebugBtn2))
-            //    {
-            //        m_DebugKeyUp2 = true;
-            //    }
-
-            //    // For keyboard you want to be able to keep ctrl pressed.
-            //    if (Input.GetKeyUp(KeyCode.Backspace))
-            //    {
-            //        m_DebugKeyUp1 = m_DebugKeyUp2 = true;
-            //    }
-
-            //    m_CanReceiveInput = m_DebugKeyUp1 && m_DebugKeyUp2;
-
-            //    if (m_DebugControlEnabledMsgTimer < m_DebugControlEnabledMsgTime)
-            //    {
-            //        if (m_DebugControlEnabled)
-            //            PushDebugMessage("Debug Controls Enabled");
-            //        else
-            //            PushDebugMessage("Debug Controls Disabled");
-            //    }
-            //}
-        }
 
         void OnGUI()
         {

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

             using(new EditorGUILayout.VerticalScope())
             {
                 DebugMenu activeMenu = m_DebugMenu.GetDebugMenu(m_DebugMenu.activeMenuIndex);
+                bool needRepaint = false;
-                    activeMenu.GetDebugMenuItem(i).drawer.OnEditorGUI();
+                    needRepaint = needRepaint || activeMenu.GetDebugMenuItem(i).drawer.OnEditorGUI();
+
+                if (needRepaint)
+                    UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
             }
         }
     }

Assets/ScriptableRenderPipeline/common/TextureCache.cs

                 var probeFormat = TextureFormat.BC6H;
 
                 // On editor the texture is uncompressed when operating against mobile build targets
-#if UNITY_2017_2_OR_NEWER
+//#if UNITY_2017_2_OR_NEWER
-#else
-                if (SystemInfo.SupportsTextureFormat(probeFormat) && !TextureCache.isMobileBuildTarget)
-                    format = probeFormat;
-#endif
+//#else
+//                if (SystemInfo.SupportsTextureFormat(probeFormat) && !TextureCache.isMobileBuildTarget)
+//                    format = probeFormat;
+//#endif
 
                 return format;
             }
         {
             get
             {
-#if UNITY_2017_2_OR_NEWER
+//#if UNITY_2017_2_OR_NEWER
-#else
-                return (SystemInfo.supportsCubemapArrayTextures && !TextureCache.isMobileBuildTarget);
-#endif
+//#else
+//                return (SystemInfo.supportsCubemapArrayTextures && !TextureCache.isMobileBuildTarget);
+//#endif
             }
         }
 
             {
                 sliceIndex = m_LocatorInSliceArray[texId];
                 bFoundAvailOrExistingSlice = true;
-
+#if UNITY_EDITOR
                 if(m_TextureCacheVersion!=s_GlobalTextureCacheVersion)
                 {
                     m_TextureCacheVersion++;
+#endif
                 //assert(m_SliceArray[sliceIndex].TexID==TexID);
             }
 

Assets/ScriptableRenderPipeline/fptl/FptlLighting.cs

-using UnityEngine.Rendering;
+using UnityEngine.Rendering;
+    class ShadowSetup : IDisposable
+    {
+        // shadow related stuff
+        const int k_MaxShadowDataSlots              = 64;
+        const int k_MaxPayloadSlotsPerShadowData    =  4;
+        ShadowmapBase[]         m_Shadowmaps;
+        ShadowManager           m_ShadowMgr;
+        static ComputeBuffer    s_ShadowDataBuffer;
+        static ComputeBuffer    s_ShadowPayloadBuffer;
+
+        public ShadowSetup(ShadowSettings shadowSettings, out IShadowManager shadowManager)
+        {
+            s_ShadowDataBuffer = new ComputeBuffer(k_MaxShadowDataSlots, System.Runtime.InteropServices.Marshal.SizeOf(typeof(ShadowData)));
+            s_ShadowPayloadBuffer = new ComputeBuffer(k_MaxShadowDataSlots * k_MaxPayloadSlotsPerShadowData, System.Runtime.InteropServices.Marshal.SizeOf(typeof(ShadowPayload)));
+            ShadowAtlas.AtlasInit atlasInit;
+            atlasInit.baseInit.width                  = (uint)shadowSettings.shadowAtlasWidth;
+            atlasInit.baseInit.height                 = (uint)shadowSettings.shadowAtlasHeight;
+            atlasInit.baseInit.slices                 = 1;
+            atlasInit.baseInit.shadowmapBits          = 32;
+            atlasInit.baseInit.shadowmapFormat        = RenderTextureFormat.Shadowmap;
+            atlasInit.baseInit.samplerState           = SamplerState.Default();
+            atlasInit.baseInit.comparisonSamplerState = ComparisonSamplerState.Default();
+            atlasInit.baseInit.clearColor             = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+            atlasInit.baseInit.maxPayloadCount        = 0;
+            atlasInit.baseInit.shadowSupport          = ShadowmapBase.ShadowSupport.Directional | ShadowmapBase.ShadowSupport.Point | ShadowmapBase.ShadowSupport.Spot;
+            atlasInit.shaderKeyword                   = null;
+            atlasInit.cascadeCount                    = shadowSettings.directionalLightCascadeCount;
+            atlasInit.cascadeRatios                   = shadowSettings.directionalLightCascades;
+
+            m_Shadowmaps = new ShadowmapBase[] { new ShadowAtlas(ref atlasInit) };
+
+            ShadowContext.SyncDel syncer = (ShadowContext sc) =>
+                {
+                    // update buffers
+                    uint offset, count;
+                    ShadowData[] sds;
+                    sc.GetShadowDatas(out sds, out offset, out count);
+                    Debug.Assert(offset == 0);
+                    s_ShadowDataBuffer.SetData(sds); // unfortunately we can't pass an offset or count to this function
+                    ShadowPayload[] payloads;
+                    sc.GetPayloads(out payloads, out offset, out count);
+                    Debug.Assert(offset == 0);
+                    s_ShadowPayloadBuffer.SetData(payloads);
+                };
+
+            // binding code. This needs to be in sync with ShadowContext.hlsl
+            ShadowContext.BindDel binder = (ShadowContext sc, CommandBuffer cb) =>
+                {
+                    // bind buffers
+                    cb.SetGlobalBuffer("_ShadowDatasExp", s_ShadowDataBuffer);
+                    cb.SetGlobalBuffer("_ShadowPayloads", s_ShadowPayloadBuffer);
+                    // bind textures
+                    uint offset, count;
+                    RenderTargetIdentifier[] tex;
+                    sc.GetTex2DArrays(out tex, out offset, out count);
+                    cb.SetGlobalTexture("_ShadowmapExp_PCF", tex[0]);
+                    // TODO: Currently samplers are hard coded in ShadowContext.hlsl, so we can't really set them here
+                };
+
+            ShadowContext.CtxtInit scInit;
+            scInit.storage.maxShadowDataSlots        = k_MaxShadowDataSlots;
+            scInit.storage.maxPayloadSlots           = k_MaxShadowDataSlots * k_MaxPayloadSlotsPerShadowData;
+            scInit.storage.maxTex2DArraySlots        = 1;
+            scInit.storage.maxTexCubeArraySlots      = 0;
+            scInit.storage.maxComparisonSamplerSlots = 1;
+            scInit.storage.maxSamplerSlots           = 0;
+            scInit.dataSyncer                        = syncer;
+            scInit.resourceBinder                    = binder;
+
+            m_ShadowMgr = new ShadowManager(shadowSettings, ref scInit, m_Shadowmaps);
+            // set global overrides - these need to match the override specified in ShadowDispatch.hlsl
+            m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Point        , ShadowAlgorithm.PCF, ShadowVariant.V1, ShadowPrecision.High, true );
+            m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Spot         , ShadowAlgorithm.PCF, ShadowVariant.V1, ShadowPrecision.High, true );
+            m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Directional  , ShadowAlgorithm.PCF, ShadowVariant.V1, ShadowPrecision.High, true );
+            shadowManager = m_ShadowMgr;
+        }
+        public void Dispose()
+        {
+            if (m_Shadowmaps != null)
+            {
+                (m_Shadowmaps[0] as ShadowAtlas).Dispose();
+                m_Shadowmaps = null;
+            }
+            m_ShadowMgr = null;
+
+            if( s_ShadowDataBuffer != null )
+                s_ShadowDataBuffer.Release();
+            if( s_ShadowPayloadBuffer != null )
+                s_ShadowPayloadBuffer.Release();
+        }
+    }
+
     public class FptlLightingInstance : RenderPipeline
     {
         private readonly FptlLighting m_Owner;
 
         [SerializeField]
         ShadowSettings m_ShadowSettings = ShadowSettings.Default;
-        ShadowRenderPass m_ShadowPass;
+        ShadowSetup    m_ShadowSetup;
+        IShadowManager m_ShadowMgr;
+        FrameId        m_FrameId = new FrameId();
+
+        List<int>               m_ShadowRequests = new List<int>();
+        Dictionary<int, int>    m_ShadowIndices = new Dictionary<int,int>();
+
+        void InitShadowSystem(ShadowSettings shadowSettings)
+        {
+            m_ShadowSetup = new ShadowSetup(shadowSettings, out m_ShadowMgr);
+        }
+
+        void DeinitShadowSystem()
+        {
+            if (m_ShadowSetup != null)
+            {
+                m_ShadowSetup.Dispose();
+                m_ShadowSetup = null;
+                m_ShadowMgr = null;
+            }
+        }
+
 
         [SerializeField]
         TextureSettings m_TextureSettings = TextureSettings.Default;
         const float k_DirectionalLightPullbackDistance = 10000.0f;
 
         [NonSerialized]
-        private int m_WarnedTooManyLights = 0;
-
         private TextureCache2D m_CookieTexArray;
         private TextureCacheCubemap m_CubeCookieTexArray;
         private TextureCacheCubemap m_CubeReflTexArray;
             }
 
             ClearComputeBuffers();
+
+            DeinitShadowSystem();
         }
 
         void ClearComputeBuffers()
             m_MatWorldToShadow = new Matrix4x4[k_MaxLights * k_MaxShadowmapPerLights];
             m_DirShadowSplitSpheres = new Vector4[k_MaxDirectionalSplit];
             m_Shadow3X3PCFTerms = new Vector4[4];
-            m_ShadowPass = new ShadowRenderPass(m_ShadowSettings);
+            InitShadowSystem(m_ShadowSettings);
 
             m_SkyboxHelper = new SkyboxHelper();
             m_SkyboxHelper.CreateMesh();
             return camera.projectionMatrix * GetFlipMatrix();
         }
 
-        static int UpdateDirectionalLights(Camera camera, IList<VisibleLight> visibleLights)
+        static int UpdateDirectionalLights(Camera camera, IList<VisibleLight> visibleLights, Dictionary<int,int> shadowIndices)
         {
             var dirLightCount = 0;
             var lights = new List<DirectionalLight>();
                     vy = worldToView.MultiplyVector(vy);
                     vz = worldToView.MultiplyVector(vz);
 
-                    l.shadowLightIndex = (light.light.shadows != LightShadows.None) ? (uint)nLight : 0xffffffff;
-
+                    int shadowIdx;
+                    l.shadowLightIndex = shadowIndices.TryGetValue((int)nLight, out shadowIdx) ? (uint)shadowIdx : 0x80000000;
                     l.lightAxisX = vx;
                     l.lightAxisY = vy;
                     l.lightAxisZ = vz;
             return dirLightCount;
         }
 
-        void UpdateShadowConstants(IList<VisibleLight> visibleLights, ref ShadowOutput shadow)
+        int GenerateSourceLightBuffers(Camera camera, CullResults inputs)
-            var nNumLightsIncludingTooMany = 0;
-
-            var numLights = 0;
-
-            var lightShadowIndex_LightParams = new Vector4[k_MaxLights];
-            var lightFalloffParams = new Vector4[k_MaxLights];
-
-            for (int nLight = 0; nLight < visibleLights.Count; nLight++)
+            // 0. deal with shadows
-                nNumLightsIncludingTooMany++;
-                if (nNumLightsIncludingTooMany > k_MaxLights)
-                    continue;
-
-                var light = visibleLights[nLight];
-                var lightType = light.lightType;
-                var position = light.light.transform.position;
-                var lightDir = light.light.transform.forward.normalized;
-
-                // Setup shadow data arrays
-                var hasShadows = shadow.GetShadowSliceCountLightIndex(nLight) != 0;
-
-                if (lightType == LightType.Directional)
+                m_FrameId.frameCount++;
+                // get the indices for all lights that want to have shadows
+                m_ShadowRequests.Clear();
+                m_ShadowRequests.Capacity = inputs.visibleLights.Length;
+                int lcnt = inputs.visibleLights.Length;
+                for (int i = 0; i < lcnt; ++i)
-                    lightShadowIndex_LightParams[numLights] = new Vector4(0, 0, 1, 1);
-                    lightFalloffParams[numLights] = new Vector4(0.0f, 0.0f, float.MaxValue, (float)lightType);
-
-                    if (hasShadows)
-                    {
-                        for (int s = 0; s < k_MaxDirectionalSplit; ++s)
-                        {
-                            m_DirShadowSplitSpheres[s] = shadow.directionalShadowSplitSphereSqr[s];
-                        }
-                    }
+                    VisibleLight vl = inputs.visibleLights[i];
+                    if (vl.light.shadows != LightShadows.None && vl.light.GetComponent<AdditionalLightData>().shadowDimmer > 0.0f)
+                        m_ShadowRequests.Add(i);
-                else if (lightType == LightType.Point)
-                {
-                    lightShadowIndex_LightParams[numLights] = new Vector4(0, 0, 1, 1);
-                    lightFalloffParams[numLights] = new Vector4(1.0f, 0.0f, light.range * light.range, (float)lightType);
-                }
-                else if (lightType == LightType.Spot)
-                {
-                    lightShadowIndex_LightParams[numLights] = new Vector4(0, 0, 1, 1);
-                    lightFalloffParams[numLights] = new Vector4(1.0f, 0.0f, light.range * light.range, (float)lightType);
-                }
+                // pass this list to a routine that assigns shadows based on some heuristic
+                uint shadowRequestCount = (uint)m_ShadowRequests.Count;
+                int[] shadowRequests = m_ShadowRequests.ToArray();
+                int[] shadowDataIndices;
+                m_ShadowMgr.ProcessShadowRequests(m_FrameId, inputs, camera, inputs.visibleLights,
+                    ref shadowRequestCount, shadowRequests, out shadowDataIndices);
-                if (hasShadows)
+                // update the visibleLights with the shadow information
+                m_ShadowIndices.Clear();
+                for (uint i = 0; i < shadowRequestCount; i++)
-                    // Enable shadows
-                    lightShadowIndex_LightParams[numLights].x = 1;
-                    for (int s = 0; s < shadow.GetShadowSliceCountLightIndex(nLight); ++s)
-                    {
-                        var shadowSliceIndex = shadow.GetShadowSliceIndex(nLight, s);
-                        m_MatWorldToShadow[numLights * k_MaxShadowmapPerLights + s] = shadow.shadowSlices[shadowSliceIndex].shadowTransform.transpose;
-                    }
-                }
-
-                numLights++;
-            }
-
-            // Warn if too many lights found
-            if (nNumLightsIncludingTooMany > k_MaxLights)
-            {
-                if (nNumLightsIncludingTooMany > m_WarnedTooManyLights)
-                {
-                    Debug.LogError("ERROR! Found " + nNumLightsIncludingTooMany + " runtime lights! Valve renderer supports up to " + k_MaxLights +
-                        " active runtime lights at a time!\nDisabling " + (nNumLightsIncludingTooMany - k_MaxLights) + " runtime light" +
-                        ((nNumLightsIncludingTooMany - k_MaxLights) > 1 ? "s" : "") + "!\n");
-                }
-                m_WarnedTooManyLights = nNumLightsIncludingTooMany;
-            }
-            else
-            {
-                if (m_WarnedTooManyLights > 0)
-                {
-                    m_WarnedTooManyLights = 0;
-                    Debug.Log("SUCCESS! Found " + nNumLightsIncludingTooMany + " runtime lights which is within the supported number of lights, " + k_MaxLights + ".\n\n");
+                    m_ShadowIndices.Add(shadowRequests[i], shadowDataIndices[i]);
-            // PCF 3x3 Shadows
-            var flTexelEpsilonX = 1.0f / m_ShadowSettings.shadowAtlasWidth;
-            var flTexelEpsilonY = 1.0f / m_ShadowSettings.shadowAtlasHeight;
-            m_Shadow3X3PCFTerms[0] = new Vector4(20.0f / 267.0f, 33.0f / 267.0f, 55.0f / 267.0f, 0.0f);
-            m_Shadow3X3PCFTerms[1] = new Vector4(flTexelEpsilonX, flTexelEpsilonY, -flTexelEpsilonX, -flTexelEpsilonY);
-            m_Shadow3X3PCFTerms[2] = new Vector4(flTexelEpsilonX, flTexelEpsilonY, 0.0f, 0.0f);
-            m_Shadow3X3PCFTerms[3] = new Vector4(-flTexelEpsilonX, -flTexelEpsilonY, 0.0f, 0.0f);
-        }
-
-        int GenerateSourceLightBuffers(Camera camera, CullResults inputs)
-        {
             var probes = inputs.visibleReflectionProbes;
             //ReflectionProbe[] probes = Object.FindObjectsOfType<ReflectionProbe>();
 
                 light.color.Set(cl.finalColor.r, cl.finalColor.g, cl.finalColor.b);
                 light.sliceIndex = 0;
                 light.lightModel = (uint)LightDefinitions.DIRECT_LIGHT;
-                light.shadowLightIndex = shadowLightIndex;
+
+                int shadowIdx;
+                light.shadowLightIndex = m_ShadowIndices.TryGetValue( (int) shadowLightIndex, out shadowIdx ) ? (uint) shadowIdx : 0x80000000;
                 shadowLightIndex++;
 
                 var bHasCookie = cl.light.cookie != null;
                 if (!CullResults.GetCullingParameters(camera, out cullingParams))
                     continue;
 
-                m_ShadowPass.UpdateCullingParameters(ref cullingParams);
+                m_ShadowMgr.UpdateCullingParameters( ref cullingParams );
 
                 var cullResults = CullResults.Cull(ref cullingParams, renderContext);
                 ExecuteRenderLoop(camera, cullResults, renderContext);
             // do anything we need to do upon a new frame.
             NewFrame();
 
-#pragma warning disable 162 // warning CS0162: Unreachable code detected
-            if (!k_UseAsyncCompute) RenderShadowMaps(cullResults, loop);
-#pragma warning restore 162
             // generate g-buffer before shadows to leverage async compute
             // forward opaques just write to depth.
             loop.SetupCameraProperties(camera);
             var numLights = GenerateSourceLightBuffers(camera, cullResults);
             BuildPerTileLightLists(camera, loop, numLights, projscr, invProjscr);
 
-            // render shadow maps (for mobile shadow map rendering should happen before we render g-buffer).
-            // on GCN it needs to be after to leverage async compute since we need the depth-buffer for optimal light list building.
-            if (k_UseAsyncCompute)
-            {
-                RenderShadowMaps(cullResults, loop);
-                loop.SetupCameraProperties(camera);
-            }
+
+            m_ShadowMgr.RenderShadows( m_FrameId, loop, cullResults, cullResults.visibleLights );
+            m_ShadowMgr.SyncData();
+            m_ShadowMgr.BindResources( loop );
-            var numDirLights = UpdateDirectionalLights(camera, cullResults.visibleLights);
+            var numDirLights = UpdateDirectionalLights(camera, cullResults.visibleLights, m_ShadowIndices);
             PushGlobalParams(camera, loop, CameraToWorld(camera), projscr, invProjscr, numDirLights);
 
             // do deferred lighting
 
         void RenderShadowMaps(CullResults cullResults, ScriptableRenderContext loop)
         {
-            ShadowOutput shadows;
-            m_ShadowPass.Render(loop, cullResults, out shadows);
-            UpdateShadowConstants(cullResults.visibleLights, ref shadows);
         }
 
         void ResizeIfNecessary(int curWidth, int curHeight)

Assets/ScriptableRenderPipeline/fptl/LightingTemplate.hlsl

 #define CUBEMAPFACE_POSITIVE_Z 4
 #define CUBEMAPFACE_NEGATIVE_Z 5
 
+#define SHADOW_FPTL
+#	if defined(SHADER_API_D3D11)
+#		include "../ShaderLibrary/API/D3D11.hlsl"
+#	elif defined(SHADER_API_PSSL)
+#		include "../ShaderLibrary/API/PSSL.hlsl"
+#	elif defined(SHADER_API_XBOXONE)
+#		include "../ShaderLibrary/API/D3D11.hlsl"
+#		include "../ShaderLibrary/API/D3D11_1.hlsl"
+#	elif defined(SHADER_API_METAL)
+#		include "../ShaderLibrary/API/Metal.hlsl"
+#	else
+#		error unsupported shader api
+#	endif
+#	include "../ShaderLibrary/API/Validate.hlsl"
+#	include "../ShaderLibrary/Shadow/Shadow.hlsl"
+#undef SHADOW_FPTL
+
 CBUFFER_START(ShadowLightData)
 
 float4 g_vShadow3x3PCFTerms0;
 
 StructuredBuffer<DirectionalLight> g_dirLightData;
 
-
-#define DECLARE_SHADOWMAP( tex ) Texture2D tex; SamplerComparisonState sampler##tex
-#ifdef REVERSE_ZBUF
-    #define SAMPLE_SHADOW( tex, coord ) tex.SampleCmpLevelZero( sampler##tex, (coord).xy, (coord).z )
-#else
-    #define SAMPLE_SHADOW( tex, coord ) tex.SampleCmpLevelZero( sampler##tex, (coord).xy, 1.0-(coord).z )
-#endif
-
-DECLARE_SHADOWMAP(g_tShadowBuffer);
-
-float ComputeShadow_PCF_3x3_Gaussian(float3 vPositionWs, float4x4 matWorldToShadow)
-{
-    float4 vPositionTextureSpace = mul(float4(vPositionWs.xyz, 1.0), matWorldToShadow);
-    vPositionTextureSpace.xyz /= vPositionTextureSpace.w;
-
-    float2 shadowMapCenter = vPositionTextureSpace.xy;
-
-    if ((shadowMapCenter.x < 0.0f) || (shadowMapCenter.x > 1.0f) || (shadowMapCenter.y < 0.0f) || (shadowMapCenter.y > 1.0f))
-        return 1.0f;
-
-    float objDepth = saturate(257.0 / 256.0 - vPositionTextureSpace.z);
-
-    float4 v20Taps;
-    v20Taps.x = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.xy, objDepth)).x; //  1  1
-    v20Taps.y = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.zy, objDepth)).x; // -1  1
-    v20Taps.z = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.xw, objDepth)).x; //  1 -1
-    v20Taps.w = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.zw, objDepth)).x; // -1 -1
-    float flSum = dot(v20Taps.xyzw, float4(0.25, 0.25, 0.25, 0.25));
-    if ((flSum == 0.0) || (flSum == 1.0))
-        return flSum;
-    flSum *= g_vShadow3x3PCFTerms0.x * 4.0;
-
-    float4 v33Taps;
-    v33Taps.x = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms2.xz, objDepth)).x; //  1  0
-    v33Taps.y = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms3.xz, objDepth)).x; // -1  0
-    v33Taps.z = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms3.zy, objDepth)).x; //  0 -1
-    v33Taps.w = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms2.zy, objDepth)).x; //  0  1
-    flSum += dot(v33Taps.xyzw, g_vShadow3x3PCFTerms0.yyyy);
-
-    flSum += SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy, objDepth)).x * g_vShadow3x3PCFTerms0.z;
-
-    return flSum;
-}
-
-//---------------------------------------------------------------------------------------------------------------------------------------------------------
-/**
-* Gets the cascade weights based on the world position of the fragment and the positions of the split spheres for each cascade.
-* Returns an invalid split index if past shadowDistance (ie 4 is invalid for cascade)
-*/
-float GetSplitSphereIndexForDirshadows(float3 wpos)
-{
-    float3 fromCenter0 = wpos.xyz - g_vDirShadowSplitSpheres[0].xyz;
-    float3 fromCenter1 = wpos.xyz - g_vDirShadowSplitSpheres[1].xyz;
-    float3 fromCenter2 = wpos.xyz - g_vDirShadowSplitSpheres[2].xyz;
-    float3 fromCenter3 = wpos.xyz - g_vDirShadowSplitSpheres[3].xyz;
-    float4 distances2 = float4(dot(fromCenter0, fromCenter0), dot(fromCenter1, fromCenter1), dot(fromCenter2, fromCenter2), dot(fromCenter3, fromCenter3));
-
-    float4 vDirShadowSplitSphereSqRadii;
-    vDirShadowSplitSphereSqRadii.x = g_vDirShadowSplitSpheres[0].w;
-    vDirShadowSplitSphereSqRadii.y = g_vDirShadowSplitSpheres[1].w;
-    vDirShadowSplitSphereSqRadii.z = g_vDirShadowSplitSpheres[2].w;
-    vDirShadowSplitSphereSqRadii.w = g_vDirShadowSplitSpheres[3].w;
-    fixed4 weights = float4(distances2 < vDirShadowSplitSphereSqRadii);
-    weights.yzw = saturate(weights.yzw - weights.xyz);
-    return 4 - dot(weights, float4(4, 3, 2, 1));
-}
-
-float SampleShadow(uint type, float3 vPositionWs, float3 vPositionToLightDirWs, uint lightIndex)
-{
-    float flShadowScalar = 1.0;
-    int shadowSplitIndex = 0;
-
-    if (type == DIRECTIONAL_LIGHT)
-    {
-        shadowSplitIndex = GetSplitSphereIndexForDirshadows(vPositionWs);
-    }
-
-    else if (type == SPHERE_LIGHT)
-    {
-        float3 absPos = abs(vPositionToLightDirWs);
-        shadowSplitIndex = (vPositionToLightDirWs.z > 0) ? CUBEMAPFACE_NEGATIVE_Z : CUBEMAPFACE_POSITIVE_Z;
-        if (absPos.x > absPos.y)
-        {
-            if (absPos.x > absPos.z)
-            {
-                shadowSplitIndex = (vPositionToLightDirWs.x > 0) ? CUBEMAPFACE_NEGATIVE_X : CUBEMAPFACE_POSITIVE_X;
-            }
-        }
-        else
-        {
-            if (absPos.y > absPos.z)
-            {
-                shadowSplitIndex = (vPositionToLightDirWs.y > 0) ? CUBEMAPFACE_NEGATIVE_Y : CUBEMAPFACE_POSITIVE_Y;
-            }
-        }
-    }
-
-    flShadowScalar = ComputeShadow_PCF_3x3_Gaussian(vPositionWs.xyz, g_matWorldToShadow[lightIndex * MAX_SHADOWMAP_PER_LIGHT + shadowSplitIndex]);
-    return flShadowScalar;
-}
-
-
 float3 ExecuteLightList(uint start, uint numLights, float3 vP, float3 vPw, float3 Vworld)
 {
     UnityIndirect ind;
 
+	ShadowContext shadowContext = InitShadowContext();
 
     float3 ints = 0;
 
         float atten = 1;
 
-        [branch]
-        if (lightData.shadowLightIndex != 0xffffffff)
-        {
-            float shadowScalar = SampleShadow(DIRECTIONAL_LIGHT, vPw, 0, lightData.shadowLightIndex);
-            atten *= shadowScalar;
-        }
-
+		int shadowIdx = asint(lightData.shadowLightIndex);
+		[branch]
+		if (shadowIdx >= 0)
+		{
+			float shadow = GetDirectionalShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, 0.0.xxx);
+			atten *= shadow;
+		}
+        
         UnityLight light;
         light.color.xyz = lightData.color.xyz * atten;
         light.dir.xyz = mul((float3x3) g_mViewToWorld, -lightData.lightAxisZ).xyz;
             }
             atten *= angularAtt.w*(fProjVec>0.0);                           // finally apply this to the dist att.
 
-            const bool bHasShadow = (lgtDat.flags&HAS_SHADOW)!=0;
-            [branch]if(bHasShadow)
-            {
-                float shadowScalar = SampleShadow(SPOT_LIGHT, vPw, 0, lgtDat.shadowLightIndex);
-                atten *= shadowScalar;
-            }
+			int shadowIdx = asint(lgtDat.shadowLightIndex);
+			[branch]
+			if (shadowIdx >= 0)
+			{
+				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, 0.0.xxx);
+				atten *= shadow;
+			}
 
             UnityLight light;
             light.color.xyz = lgtDat.color.xyz*atten*angularAtt.xyz;
                 atten *= cookieColor.w;
             }
 
-            const bool bHasShadow = (lgtDat.flags&HAS_SHADOW)!=0;
-            [branch]if(bHasShadow)
-            {
-                float shadowScalar = SampleShadow(SPHERE_LIGHT, vPw, vLw, lgtDat.shadowLightIndex);
-                atten *= shadowScalar;
-            }
+			int shadowIdx = asint(lgtDat.shadowLightIndex);
+			[branch]
+			if (shadowIdx >= 0)
+			{
+				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, vLw);
+				atten *= shadow;
+			}
 
             UnityLight light;
             light.color.xyz = lgtDat.color.xyz*atten*cookieColor.xyz;

Assets/ScriptableRenderPipeline/fptl/RegularForwardLightingUtils.hlsl

 
 
 StructuredBuffer<SFiniteLightData> g_vLightData;
-Buffer<uint> g_vLightListMeshInst;          // build on CPU if in use. direct lights first, then reflection probes.
+StructuredBuffer<uint> g_vLightListMeshInst;          // build on CPU if in use. direct lights first, then reflection probes. (don't support Buffer yet in unity, so using structured)
 
 uniform int g_numLights;
 uniform int g_numReflectionProbes;

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/DragonStatue.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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_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}
+        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}
     - _DistortionDepthTest: 0
     - _DistortionEnable: 0
     - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
-    - _MaterialID: 0
-    - _StencilRef: 1
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalDetailMul: 0.347
+    - _PPDLodThreshold: 5
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
     - _Smoothness: 1
     - _SmoothnessAO: 0
     - _SmoothnessAv: 0.499
     - _SrcBlend: 1
+    - _StencilRef: 2
+    - _Stiffness: 1
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _Tess: 8
     - _TessFar: 1
     - _TessellationObjectScale: 1
     - _TessellationShapeFactor: 0.75
     - _TexWorldScale: 1
+    - _Thickness: 1
     - _Tiling: 1
     - _TilingDetail: 6
     - _UVBase: 0
     m_Colors:
     - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
     - _Color: {r: 0.9862069, g: 0.9862069, b: 0.9862069, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Lit_Blue.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Lit_Green.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Lit_Red.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _SpecularOcclusionMap:
         m_Texture: {fileID: 2800000, guid: b24f69ff4ace9194fb0d9eee4f5cf1a4, type: 3}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Lit_White.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_0.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_1.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.1
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_2.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.2
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_3.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.3
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_4.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.4
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_5.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_6.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.6
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_7.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.7
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_8.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.8
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_9.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.9
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth1_1.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 1
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 1
     - _Metallic: 1
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_0.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_1.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.1
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_2.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.2
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_3.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.3
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_4.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.4
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_5.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_6.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.6
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_7.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.7
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_8.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.8
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_9.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.9
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric1_0.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 1
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Parallax Occlusion Mapping/Material/POM - Rock.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Parallax Occlusion Mapping/Material/POM - Wood triplanar.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 1
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Parallax Occlusion Mapping/Material/POM - Wood.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 1
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Tessellation/Material/Tessellation - Rock.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Tessellation/Material/Tessellation - Wood.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 64
     - _PPDMinSamples: 1
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/Triplanar/Material/Wood triplanar.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 1
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, 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_DoubleSidedFlip.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 1
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 2
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 0.892
     - _Glossiness: 0.507
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 1
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, 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

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _HeightScale: 1
     - _HorizonFade: 1
     - _InitialBend: 1
-    - _MaterialID: 1
+    - _MaterialID: 0
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, 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_DoubleSidedMirror.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 3
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 0.892
     - _Glossiness: 0.507
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 1
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, 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/Prefabs/Materials.meta

-fileFormatVersion: 2
+fileFormatVersion: 2
 guid: ee9aedf6876b41c459d476afd81ab708
 folderAsset: yes
 timeCreated: 1492083994

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

-fileFormatVersion: 2
+fileFormatVersion: 2
 guid: babcbb0e8a80beb4ca87d6a963225ae6
 folderAsset: yes
 timeCreated: 1492083990

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/CubeTransparent.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 0
     - _Mode: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
     - _SurfaceType: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_a00_s00.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedLigthing: 1
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 1
     - _Mettalic: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_a00_s01.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
     - _DoubleSidedLigthing: 1
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _Drag: 1
+    - _EnableWind: 0
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _HorizonFade: 1
-    - _MaterialID: 0
+    - _InitialBend: 1
+    - _MaterialID: 1
     - _Metalic: 0
     - _Metallic: 1
     - _Mettalic: 0
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Stiffness: 1
     - _SubSurfaceRadius: 0
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}