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

Assets/ScriptableRenderPipeline.meta

 fileFormatVersion: 2
-guid: 7f2fa2efb8ce343069fc5393536094ad
+guid: 403e54624681147459c529bbda90360e
 folderAsset: yes
 timeCreated: 1466769773
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline.meta

 fileFormatVersion: 2
-guid: 4c38eac64d0e8344d85c9f309419d619
+guid: a75de3f722a762f4daf65be08cd9c5c6
 folderAsset: yes
 timeCreated: 1483548930
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs

 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [Serializable]
-    public class GlobalDebugParameters
+    public class GlobalDebugSettings
     {
         public float debugOverlayRatio = 0.33f;
         public bool displayMaterialDebug = false;
-        public MaterialDebugParameters materialDebugParameters = new MaterialDebugParameters();
-        public LightingDebugParameters lightingDebugParameters = new LightingDebugParameters();
-        public RenderingDebugParameters renderingDebugParametrs = new RenderingDebugParameters();
+        public MaterialDebugSettings materialDebugSettings = new MaterialDebugSettings();
+        public LightingDebugSettings lightingDebugSettings = new LightingDebugSettings();
+        public RenderingDebugSettings renderingDebugSettings = new RenderingDebugSettings();
-            lightingDebugParameters.OnValidate();
+            lightingDebugSettings.OnValidate();
-    public class MaterialDebugParameters
+    public class MaterialDebugSettings
-    public class RenderingDebugParameters
+    public class RenderingDebugSettings
     {
         public bool displayOpaqueObjects = true;
         public bool displayTransparentObjects = true;
     }
 
     [Serializable]
-    public class LightingDebugParameters
+    public class LightingDebugSettings
     {
         public bool                 enableShadows = true;
         public ShadowDebugMode      shadowDebugMode = ShadowDebugMode.None;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor.meta

 fileFormatVersion: 2
-guid: ab51b986e84ae98449eab2308fbe74db
+guid: 6170264326b703040b82caf4f14a7567
 folderAsset: yes
 timeCreated: 1479127051
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

             // Sky Settings
             public readonly GUIContent skyParams = new GUIContent("Sky Settings");
 
-            // Global debug parameters
+            // Global debug Settings
             public readonly GUIContent debugging = new GUIContent("Debugging");
             public readonly GUIContent debugOverlayRatio = new GUIContent("Overlay Ratio");
 
             public int[] debugViewMaterialValues = null;
 
             // Rendering Debug
-            public readonly GUIContent renderingDebugParameters = new GUIContent("Rendering Debug");
+            public readonly GUIContent renderingDebugSettings = new GUIContent("Rendering Debug");
-            public readonly GUIContent lightingDebugParameters = new GUIContent("Lighting Debug");
+            public readonly GUIContent lightingDebugSettings = new GUIContent("Lighting Debug");
             public readonly GUIContent shadowDebugEnable = new GUIContent("Enable Shadows");
             public readonly GUIContent shadowDebugVisualizationMode = new GUIContent("Shadow Debug Mode");
             public readonly GUIContent shadowDebugVisualizeShadowIndex = new GUIContent("Visualize Shadow Index");
         SerializedProperty m_LightingDebugOverrideSmoothnessValue = null;
         SerializedProperty m_LightingDebugAlbedo = null;
 
-        // Rendering Parameters
+        // Rendering Settings
         SerializedProperty m_RenderingUseForwardOnly = null;
         SerializedProperty m_RenderingUseDepthPrepass = null;
 
-            m_DebugOverlayRatio = FindProperty(x => x.globalDebugParameters.debugOverlayRatio);
-            m_ShowLightingDebug = FindProperty(x => x.globalDebugParameters.displayLightingDebug);
-            m_ShowRenderingDebug = FindProperty(x => x.globalDebugParameters.displayRenderingDebug);
-            m_ShowMaterialDebug = FindProperty(x => x.globalDebugParameters.displayMaterialDebug);
+            m_DebugOverlayRatio = FindProperty(x => x.globalDebugSettings.debugOverlayRatio);
+            m_ShowLightingDebug = FindProperty(x => x.globalDebugSettings.displayLightingDebug);
+            m_ShowRenderingDebug = FindProperty(x => x.globalDebugSettings.displayRenderingDebug);
+            m_ShowMaterialDebug = FindProperty(x => x.globalDebugSettings.displayMaterialDebug);
-            m_MaterialDebugMode = FindProperty(x => x.globalDebugParameters.materialDebugParameters.debugViewMaterial);
+            m_MaterialDebugMode = FindProperty(x => x.globalDebugSettings.materialDebugSettings.debugViewMaterial);
-            m_DisplayOpaqueObjects = FindProperty(x => x.globalDebugParameters.renderingDebugParametrs.displayOpaqueObjects);
-            m_DisplayTransparentObjects = FindProperty(x => x.globalDebugParameters.renderingDebugParametrs.displayTransparentObjects);
-            m_EnableDistortion = FindProperty(x => x.globalDebugParameters.renderingDebugParametrs.enableDistortion);
+            m_DisplayOpaqueObjects = FindProperty(x => x.globalDebugSettings.renderingDebugSettings.displayOpaqueObjects);
+            m_DisplayTransparentObjects = FindProperty(x => x.globalDebugSettings.renderingDebugSettings.displayTransparentObjects);
+            m_EnableDistortion = FindProperty(x => x.globalDebugSettings.renderingDebugSettings.enableDistortion);
-            m_DebugShadowEnabled = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.enableShadows);
-            m_ShadowDebugMode = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.shadowDebugMode);
-            m_ShadowDebugShadowMapIndex = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.shadowMapIndex);
-            m_LightingDebugMode = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.lightingDebugMode);
-            m_LightingDebugOverrideSmoothness = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.overrideSmoothness);
-            m_LightingDebugOverrideSmoothnessValue = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.overrideSmoothnessValue);
-            m_LightingDebugAlbedo = FindProperty(x => x.globalDebugParameters.lightingDebugParameters.debugLightingAlbedo);
+            m_DebugShadowEnabled = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.enableShadows);
+            m_ShadowDebugMode = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.shadowDebugMode);
+            m_ShadowDebugShadowMapIndex = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.shadowMapIndex);
+            m_LightingDebugMode = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.lightingDebugMode);
+            m_LightingDebugOverrideSmoothness = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.overrideSmoothness);
+            m_LightingDebugOverrideSmoothnessValue = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.overrideSmoothnessValue);
+            m_LightingDebugAlbedo = FindProperty(x => x.globalDebugSettings.lightingDebugSettings.debugLightingAlbedo);
-            m_RenderingUseForwardOnly = FindProperty(x => x.renderingParameters.useForwardRenderingOnly);
-            m_RenderingUseDepthPrepass = FindProperty(x => x.renderingParameters.useDepthPrepass);
+            m_RenderingUseForwardOnly = FindProperty(x => x.renderingSettings.useForwardRenderingOnly);
+            m_RenderingUseDepthPrepass = FindProperty(x => x.renderingSettings.useDepthPrepass);
 
         }
 
         {
             EditorGUILayout.LabelField(styles.debugging);
 
-            // Global debug parameters
+            // Global debug settings
-            MaterialDebugParametersUI(renderContext);
-            RenderingDebugParametersUI(renderContext);
-            LightingDebugParametersUI(renderContext, renderpipelineInstance);
+            MaterialDebugSettingsUI(renderContext);
+            RenderingDebugSettingsUI(renderContext);
+            LightingDebugSettingsUI(renderContext, renderpipelineInstance);
 
             EditorGUILayout.Space();
 
 
-        private void MaterialDebugParametersUI(HDRenderPipeline renderContext)
+        private void MaterialDebugSettingsUI(HDRenderPipeline renderContext)
         {
             m_ShowMaterialDebug.boolValue = EditorGUILayout.Foldout(m_ShowMaterialDebug.boolValue, styles.materialDebugLabel);
             if (!m_ShowMaterialDebug.boolValue)
             EditorGUI.indentLevel--;
         }
 
-        private void RenderingDebugParametersUI(HDRenderPipeline renderContext)
+        private void RenderingDebugSettingsUI(HDRenderPipeline renderContext)
-            m_ShowRenderingDebug.boolValue = EditorGUILayout.Foldout(m_ShowRenderingDebug.boolValue, styles.renderingDebugParameters);
+            m_ShowRenderingDebug.boolValue = EditorGUILayout.Foldout(m_ShowRenderingDebug.boolValue, styles.renderingDebugSettings);
             if (!m_ShowRenderingDebug.boolValue)
                 return;
 
             }
         }
 
-        private void LightingDebugParametersUI(HDRenderPipeline renderContext, HDRenderPipelineInstance renderpipelineInstance)
+        private void LightingDebugSettingsUI(HDRenderPipeline renderContext, HDRenderPipelineInstance renderpipelineInstance)
-            m_ShowLightingDebug.boolValue = EditorGUILayout.Foldout(m_ShowLightingDebug.boolValue, styles.lightingDebugParameters);
+            m_ShowLightingDebug.boolValue = EditorGUILayout.Foldout(m_ShowLightingDebug.boolValue, styles.lightingDebugSettings);
             if (!m_ShowLightingDebug.boolValue)
                 return;
 
                 HackSetDirty(renderContext); // Repaint
             }
 
-
-            SkySettingsUI(renderContext);
-            ShadowParametersUI(renderContext);
-            TextureParametersUI(renderContext);
-            RendereringParametersUI(renderContext);
+            ShadowSettingsUI(renderContext);
+            TextureSettingsUI(renderContext);
+            RendereringSettingsUI(renderContext);
-        private void SkySettingsUI(HDRenderPipeline pipe)
+        private void ShadowSettingsUI(HDRenderPipeline renderContext)
-
-            EditorGUILayout.LabelField(styles.skyParams);
-            EditorGUI.BeginChangeCheck();
-            EditorGUI.indentLevel++;
-            pipe.skyParameters = (SkyParameters)EditorGUILayout.ObjectField(new GUIContent("Sky Settings"), pipe.skyParameters, typeof(SkyParameters), false);
-            EditorGUI.indentLevel--;
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                HackSetDirty(pipe); // Repaint
-            }
-        }
-
-        private void ShadowParametersUI(HDRenderPipeline renderContext)
-        {
-            EditorGUILayout.Space();
-            var shadowParameters = renderContext.shadowSettings;
+            var shadowSettings = renderContext.shadowSettings;
-            shadowParameters.shadowAtlasWidth = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasWidth, shadowParameters.shadowAtlasWidth));
-            shadowParameters.shadowAtlasHeight = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasHeight, shadowParameters.shadowAtlasHeight));
+            shadowSettings.shadowAtlasWidth = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasWidth, shadowSettings.shadowAtlasWidth));
+            shadowSettings.shadowAtlasHeight = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasHeight, shadowSettings.shadowAtlasHeight));
 
             if (EditorGUI.EndChangeCheck())
             {
         }
 
-        private void RendereringParametersUI(HDRenderPipeline renderContext)
+        private void RendereringSettingsUI(HDRenderPipeline renderContext)
         {
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(styles.renderingSettingsLabel);
             EditorGUI.indentLevel--;
         }
 
-        private void TextureParametersUI(HDRenderPipeline renderContext)
+        private void TextureSettingsUI(HDRenderPipeline renderContext)
-            var textureParameters = renderContext.textureSettings;
+            var textureSettings = renderContext.textureSettings;
-            textureParameters.spotCookieSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.spotCookieSize, textureParameters.spotCookieSize), 16, 1024));
-            textureParameters.pointCookieSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.pointCookieSize, textureParameters.pointCookieSize), 16, 1024));
-            textureParameters.reflectionCubemapSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.reflectionCubemapSize, textureParameters.reflectionCubemapSize), 64, 1024));
+            textureSettings.spotCookieSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.spotCookieSize, textureSettings.spotCookieSize), 16, 1024));
+            textureSettings.pointCookieSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.pointCookieSize, textureSettings.pointCookieSize), 16, 1024));
+            textureSettings.reflectionCubemapSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.reflectionCubemapSize, textureSettings.reflectionCubemapSize), 64, 1024));
-                renderContext.textureSettings = textureParameters;
+                renderContext.textureSettings = textureSettings;
                 HackSetDirty(renderContext); // Repaint
             }
             EditorGUI.indentLevel--;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

 using UnityEngine;
+using UnityEditor;
+using UnityEngine.SceneManagement;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+        // This script is a helper for the artits to re-synchronise all layered materials
         [MenuItem("HDRenderPipeline/Synchronize all Layered materials")]
         static void SynchronizeAllLayeredMaterial()
         {
                 if (mat.shader.name == "HDRenderPipeline/LayeredLit" || mat.shader.name == "HDRenderPipeline/LayeredLitTessellation")
                 {
                     LayeredLitGUI.SynchronizeAllLayers(mat);
+                    EditorUtility.SetDirty(mat);
+            }
+        }
+
+        static void RemoveMaterialKeywords(Material material)
+        {
+            string[] keywordsToRemove = material.shaderKeywords;
+            foreach (var keyword in keywordsToRemove) 
+            {
+                material.DisableKeyword(keyword);
+            }
+        }
+
+        // The goal of this script is to help maintenance of data that have already been produced but need to update to the latest shader code change.
+        // In case the shader code have change and the inspector have been update with new kind of keywords we need to regenerate the set of keywords use by the material.
+        // This script will remove all keyword of a material and trigger the inspector that will re-setup all the used keywords.
+        // It require that the inspector of the material have a static function call that update all keyword based on material properties.
+        [MenuItem("HDRenderPipeline/Reset all materials keywords")]
+        static void ResetAllMaterialKeywords()
+        {
+            try
+            {
+                Object[] materials = Resources.FindObjectsOfTypeAll<Material>();
+                for (int i = 0, length = materials.Length; i < length; i++)
+                {
+                    Material mat = materials[i] as Material;
+
+                    EditorUtility.DisplayProgressBar(
+                        "Setup materials Keywords...",
+                        string.Format("{0} / {1} materials cleaned.", i, length),
+                        i / (float)(length - 1));
+
+                    if (mat.shader.name == "HDRenderPipeline/LayeredLit" || mat.shader.name == "HDRenderPipeline/LayeredLitTessellation")
+                    {
+                        // We remove all keyword already present
+                        RemoveMaterialKeywords(mat);
+                        LayeredLitGUI.SetupMaterialKeywordsAndPass(mat);
+                        EditorUtility.SetDirty(mat);
+                    }
+                    else if (mat.shader.name == "HDRenderPipeline/Lit" || mat.shader.name == "HDRenderPipeline/LitTessellation")
+                    {
+                        // We remove all keyword already present
+                        RemoveMaterialKeywords(mat);
+                        LitGUI.SetupMaterialKeywordsAndPass(mat);
+                        EditorUtility.SetDirty(mat);
+                    }
+                    else if (mat.shader.name == "HDRenderPipeline/Unlit")
+                    {
+                        // We remove all keyword already present
+                        RemoveMaterialKeywords(mat);
+                        UnlitGUI.SetupMaterialKeywordsAndPass(mat);
+                        EditorUtility.SetDirty(mat);
+                    }                    
+                }
+            }
+            finally
+            {
+                EditorUtility.ClearProgressBar();
             }
         }
     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.asset

   m_GameObject: {fileID: 0}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: d440c0deec24a2f478b3e9021cb66c29, type: 3}
+  m_Script: {fileID: 11500000, guid: f365a473b136bef4797c7281a02cd510, type: 3}
-  globalDebugParameters:
+  globalDebugSettings:
-    materialDebugParameters:
+    materialDebugSettings:
-    lightingDebugParameters:
+    lightingDebugSettings:
       enableShadows: 1
       shadowDebugMode: 0
       shadowMapIndex: 0
       debugLightingAlbedo: {r: 0.5, g: 0.5, b: 0.5, a: 1}
-    renderingDebugParametrs:
+    renderingDebugSettings:
-  renderingParameters:
+  renderingSettings:
     useForwardRenderingOnly: 0
     useDepthPrepass: 0
   m_ShadowSettings:
-    maxShadowDistance: 1000
+    maxShadowDistance: 400
     directionalLightCascadeCount: 4
     directionalLightCascades: {x: 0.05, y: 0.2, z: 0.3}
     directionalLightNearPlaneOffset: 5
     m_ShadowCascadeSplit1: 0.2
     m_ShadowCascadeSplit2: 0.3
     m_ShadowNearPlaneOffset: 5
-  m_SkyParameters: {fileID: 0}
+  m_SkySettings: {fileID: 0}

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.asset.meta

 fileFormatVersion: 2
 guid: e185fecca3c73cd47a09f1092663ef32
-timeCreated: 1486896330
+timeCreated: 1486997164
 licenseType: Pro
 NativeFormatImporter:
   mainObjectFileID: 11400000

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
         // NOTE:
         // All those properties are public because of how HDRenderPipelineInspector retrieve those properties via serialization/reflection
+        // Those that are not will be refatored later.
-        public GlobalDebugParameters globalDebugParameters = new GlobalDebugParameters();
+        public GlobalDebugSettings globalDebugSettings = new GlobalDebugSettings();
-        public RenderingParameters                      renderingParameters = new RenderingParameters();
+        public RenderingSettings                        renderingSettings = new RenderingSettings();
         [SerializeField] ShadowSettings                 m_ShadowSettings = ShadowSettings.Default;
         public SubsurfaceScatteringParameters           localSssParameters;
         [SerializeField] TextureSettings                m_TextureSettings = TextureSettings.Default;
 
         // Renderer Settings (per "scene")
         [SerializeField] private CommonSettings.Settings    m_CommonSettings = CommonSettings.Settings.s_Defaultsettings;
-        [SerializeField] private SkyParameters              m_SkyParameters;
+        [SerializeField] private SkySettings                m_SkySettings;
 
         public CommonSettings.Settings commonSettingsToUse
         {
             }
         }
 
-        public SkyParameters skyParameters
+        public SkySettings skySettings
-            get { return m_SkyParameters; }
-            set { m_SkyParameters = value; }
+            get { return m_SkySettings; }
+            set { m_SkySettings = value; }
-        public SkyParameters skyParametersToUse
+        public SkySettings skySettingsToUse
-                if (SkyParametersSingleton.overrideSettings)
-                    return SkyParametersSingleton.overrideSettings;
+                if (SkySettingsSingleton.overrideSettings)
+                    return SkySettingsSingleton.overrideSettings;
-                return m_SkyParameters;
+                return m_SkySettings;
             }
         }
         
                 return localSssParameters;
             }
         }
-        public void ApplyDebugParameters()
+        public void ApplyDebugSettings()
-            m_ShadowSettings.enabled = globalDebugParameters.lightingDebugParameters.enableShadows;
+            m_ShadowSettings.enabled = globalDebugSettings.lightingDebugSettings.enableShadows;
-            LightingDebugParameters lightDebugParameters = globalDebugParameters.lightingDebugParameters;
-            Vector4 debugModeAndAlbedo = new Vector4((float)lightDebugParameters.lightingDebugMode, lightDebugParameters.debugLightingAlbedo.r, lightDebugParameters.debugLightingAlbedo.g, lightDebugParameters.debugLightingAlbedo.b);
-            Vector4 debugSmoothness = new Vector4(lightDebugParameters.overrideSmoothness ? 1.0f : 0.0f, lightDebugParameters.overrideSmoothnessValue, 0.0f, 0.0f);
+            LightingDebugSettings lightDebugSettings = globalDebugSettings.lightingDebugSettings;
+            Vector4 debugModeAndAlbedo = new Vector4((float)lightDebugSettings.lightingDebugMode, lightDebugSettings.debugLightingAlbedo.r, lightDebugSettings.debugLightingAlbedo.g, lightDebugSettings.debugLightingAlbedo.b);
+            Vector4 debugSmoothness = new Vector4(lightDebugSettings.overrideSmoothness ? 1.0f : 0.0f, lightDebugSettings.overrideSmoothnessValue, 0.0f, 0.0f);
             Shader.SetGlobalVector("_DebugLightModeAndAlbedo", debugModeAndAlbedo);
             Shader.SetGlobalVector("_DebugLightingSmoothness", debugSmoothness);
 
 
         public void OnValidate()
         {
-            globalDebugParameters.OnValidate();
+            globalDebugSettings.OnValidate();
-    public class RenderingParameters
+    public class RenderingSettings
     {
         public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
         public bool useDepthPrepass = false;
         public Matrix4x4 viewProjectionMatrix;
         public Matrix4x4 invViewProjectionMatrix;
         public Matrix4x4 invProjectionMatrix;
-        }
+    }
+
+    public class GBufferManager
+    {
+        public const int MaxGbuffer = 8;
-        public class GBufferManager
+        public void SetBufferDescription(int index, string stringId, RenderTextureFormat inFormat, RenderTextureReadWrite inSRGBWrite)
-            public const int MaxGbuffer = 8;
+            IDs[index] = Shader.PropertyToID(stringId);
+            RTIDs[index] = new RenderTargetIdentifier(IDs[index]);
+            formats[index] = inFormat;
+            sRGBWrites[index] = inSRGBWrite;
+        }
-            public void SetBufferDescription(int index, string stringId, RenderTextureFormat inFormat, RenderTextureReadWrite inSRGBWrite)
+        public void InitGBuffers(int width, int height, CommandBuffer cmd)
+        {
+            for (int index = 0; index < gbufferCount; index++)
-                IDs[index] = Shader.PropertyToID(stringId);
-                RTIDs[index] = new RenderTargetIdentifier(IDs[index]);
-                formats[index] = inFormat;
-                sRGBWrites[index] = inSRGBWrite;
+            /* RTs[index] = */
+            cmd.GetTemporaryRT(IDs[index], width, height, 0, FilterMode.Point, formats[index], sRGBWrites[index]);
+        }
-            public void InitGBuffers(int width, int height, CommandBuffer cmd)
+        public RenderTargetIdentifier[] GetGBuffers()
+        {
+            var colorMRTs = new RenderTargetIdentifier[gbufferCount];
+            for (int index = 0; index < gbufferCount; index++)
-                for (int index = 0; index < gbufferCount; index++)
-                {
-                /* RTs[index] = */
-                cmd.GetTemporaryRT(IDs[index], width, height, 0, FilterMode.Point, formats[index], sRGBWrites[index]);
-                }
+                colorMRTs[index] = RTIDs[index];
-            public RenderTargetIdentifier[] GetGBuffers()
-            {
-                var colorMRTs = new RenderTargetIdentifier[gbufferCount];
-                for (int index = 0; index < gbufferCount; index++)
-                {
-                    colorMRTs[index] = RTIDs[index];
-                }
+            return colorMRTs;
+        }
-                return colorMRTs;
-            }
-
-            /*
-            public void BindBuffers(Material mat)
+        /*
+        public void BindBuffers(Material mat)
+        {
+            for (int index = 0; index < gbufferCount; index++)
-                for (int index = 0; index < gbufferCount; index++)
-                {
-                    mat.SetTexture(IDs[index], RTs[index]);
-                }
+                mat.SetTexture(IDs[index], RTs[index]);
-            */
+        }
+        */
-            public int gbufferCount { get; set; }
-            int[] IDs = new int[MaxGbuffer];
-            RenderTargetIdentifier[] RTIDs = new RenderTargetIdentifier[MaxGbuffer];
-            RenderTextureFormat[] formats = new RenderTextureFormat[MaxGbuffer];
-            RenderTextureReadWrite[] sRGBWrites = new RenderTextureReadWrite[MaxGbuffer];
-        }
+        public int gbufferCount { get; set; }
+        int[] IDs = new int[MaxGbuffer];
+        RenderTargetIdentifier[] RTIDs = new RenderTargetIdentifier[MaxGbuffer];
+        RenderTextureFormat[] formats = new RenderTextureFormat[MaxGbuffer];
+        RenderTextureReadWrite[] sRGBWrites = new RenderTextureReadWrite[MaxGbuffer];
+    }
-        {
+    {
         private readonly HDRenderPipeline m_Owner;
 
         // TODO: Find a way to automatically create/iterate through deferred material
         readonly SkyManager m_SkyManager = new SkyManager();
         private readonly BaseLightLoop m_LightLoop;
 
-        private GlobalDebugParameters globalDebugParameters
+        private GlobalDebugSettings globalDebugSettings
-            get { return m_Owner.globalDebugParameters; }
+            get { return m_Owner.globalDebugSettings; }
         }
 
         public HDRenderPipelineInstance(HDRenderPipeline owner)
             if(m_LightLoop != null)
                 m_LightLoop.Build(owner.textureSettings);
 
-            m_SkyManager.skyParameters = owner.skyParametersToUse;
+            m_SkyManager.Build();
+            m_SkyManager.skySettings = owner.skySettingsToUse;
         }
 
         public override void Dispose()
             // TODO: This is the wrong way to handle resize/allocation. We can have several different camera here, mean that the loop on camera will allocate and deallocate
             // the below buffer which is bad. Best is to have a set of buffer for each camera that is persistent and reallocate resource if need
             // For now consider we have only one camera that go to this code, the main one.
-            m_SkyManager.skyParameters = m_Owner.skyParametersToUse;
+            m_SkyManager.skySettings = m_Owner.skySettingsToUse;
             m_SkyManager.Resize(camera.nearClipPlane, camera.farClipPlane); // TODO: Also a bad naming, here we just want to realloc texture if skyparameters change (usefull for lookdev)
 
             if (m_LightLoop == null)
             }
         }
 
-        public void PushGlobalParams(HDCamera hdCamera, ScriptableRenderContext renderContext)
+        public void PushGlobalParams(HDCamera hdCamera, ScriptableRenderContext renderContext, SubsurfaceScatteringParameters sssParameters)
         {
             if (m_SkyManager.IsSkyValid())
             {
                 Shader.SetGlobalInt("_EnvLightSkyEnabled", 0);
             }
 
+            // Broadcast SSS parameters to all shaders.
+            Shader.SetGlobalInt("_TransmissionFlags", sssParameters.transmissionFlags);
+            Shader.SetGlobalFloatArray("_ThicknessRemaps", sssParameters.thicknessRemaps);
+            Shader.SetGlobalVectorArray("_HalfRcpVariancesAndLerpWeights", sssParameters.halfRcpVariancesAndLerpWeights);
+
+            if (sssParameters.enableSSS)
+            {
+                Shader.EnableKeyword("_SUBSURFACE_SCATTERING");
+            }
+            else
+            {
+                Shader.DisableKeyword("_SUBSURFACE_SCATTERING");
+            }
+
             var cmd = new CommandBuffer {name = "Push Global Parameters"};
 
             cmd.SetGlobalVector("_ScreenSize", hdCamera.screenSize);
 
             GraphicsSettings.lightsUseLinearIntensity = true;
             GraphicsSettings.lightsUseColorTemperature = true;
-
-            m_SkyManager.Build();
 
             if (!m_LitRenderLoop.isInit)
                 m_LitRenderLoop.RenderInit(renderContext);
             if (m_LightLoop != null)
                 m_LightLoop.NewFrame();
 
-            m_Owner.ApplyDebugParameters();
+            m_Owner.ApplyDebugSettings();
             m_Owner.UpdateCommonSettings();
 
             // Set Frame constant buffer
                 cmd.Dispose();
             }
 
-            if (globalDebugParameters.materialDebugParameters.debugViewMaterial != 0)
+            if (globalDebugSettings.materialDebugSettings.debugViewMaterial != 0)
-            using (new Utilities.ProfilingSample("Shadow Pass", renderContext))
-            {
-                m_ShadowPass.Render(renderContext, cullResults, out m_ShadowsResult);
-            }
+                using (new Utilities.ProfilingSample("Shadow Pass", renderContext))
+                {
+                    m_ShadowPass.Render(renderContext, cullResults, out m_ShadowsResult);
+                }
-            renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
+                renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
-            if (m_LightLoop != null)
-            {
-                using (new Utilities.ProfilingSample("Build Light list", renderContext))
+                if (m_LightLoop != null)
-                    m_LightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera, ref m_ShadowsResult);
-                    m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT); // TODO: Use async compute here to run light culling during shadow
+                    using (new Utilities.ProfilingSample("Build Light list", renderContext))
+                    {
+                        m_LightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera, ref m_ShadowsResult);
+                        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
+                    }
-            }
-            PushGlobalParams(hdCamera, renderContext);
+                PushGlobalParams(hdCamera, renderContext, m_Owner.sssParameters);
-            // Caution: We require sun light here as some sky use the sun light to render, mean UpdateSkyEnvironment
-            // must be call after BuildGPULightLists.
-            // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
-            UpdateSkyEnvironment(hdCamera, renderContext);
+                // Caution: We require sun light here as some sky use the sun light to render, mean UpdateSkyEnvironment
+                // must be call after BuildGPULightLists.
+                // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
+                UpdateSkyEnvironment(hdCamera, renderContext);
-            RenderDeferredLighting(hdCamera, renderContext);
+                RenderDeferredLighting(hdCamera, renderContext, m_Owner.sssParameters.enableSSS);
-            // We compute subsurface scattering here. Therefore, no objects rendered afterwards will exhibit SSS.
-            // Currently, there is no efficient way to switch between SRT and MRT for the forward pass;
-            // therefore, forward-rendered objects do not output split lighting required for the SSS pass.
-            CombineSubsurfaceScattering(hdCamera, renderContext, m_Owner.sssParameters);
+                // We compute subsurface scattering here. Therefore, no objects rendered afterwards will exhibit SSS.
+                // Currently, there is no efficient way to switch between SRT and MRT for the forward pass;
+                // therefore, forward-rendered objects do not output split lighting required for the SSS pass.
+                CombineSubsurfaceScattering(hdCamera, renderContext, m_Owner.sssParameters);
-            // For opaque forward we have split rendering in two categories
-            // Material that are always forward and material that can be deferred or forward depends on render pipeline options (like switch to rendering forward only mode)
-            // 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);
+                // For opaque forward we have split rendering in two categories
+                // Material that are always forward and material that can be deferred or forward depends on render pipeline options (like switch to rendering forward only mode)
+                // 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);
-            // 'm_CameraDepthStencilBufferCopyRT' is a temporary copy of the depth textureand should be removed
-            // once we are able to read from the depth buffer during transparent pass.
-            using (new Utilities.ProfilingSample("Copy depth-stencil buffer after all opaque", renderContext))
-            {
-                var cmd = new CommandBuffer();
-                cmd.CopyTexture(m_CameraDepthStencilBufferRT, m_CameraDepthStencilBufferCopyRT);
-                renderContext.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
-            }
+                // 'm_CameraDepthStencilBufferCopyRT' is a temporary copy of the depth texture and should be removed
+                // once we are able to read from the depth buffer during transparent pass.
+                using (new Utilities.ProfilingSample("Copy depth-stencil buffer after all opaque", renderContext))
+                {
+                    var cmd = new CommandBuffer();
+                    cmd.CopyTexture(m_CameraDepthStencilBufferRT, m_CameraDepthStencilBufferCopyRT);
+                    renderContext.ExecuteCommandBuffer(cmd);
+                    cmd.Dispose();
+                }
-            RenderSky(hdCamera, renderContext);
+                RenderSky(hdCamera, renderContext);
-            // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
-            RenderForward(cullResults, camera, renderContext, false);
+                // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
+                RenderForward(cullResults, camera, renderContext, false);
-            RenderVelocity(cullResults, camera, renderContext); // Note we may have to render velocity earlier if we do temporalAO, temporal volumetric etc... Mean we will not take into account forward opaque in case of deferred rendering ?
+                // Planar and real time cubemap doesn't need post process and render in FP16
+                if (camera.cameraType == CameraType.Reflection)
+                {
+                    // Simple blit
+                    var cmd = new CommandBuffer { name = "Blit to final RT" };
+                    cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
+                    renderContext.ExecuteCommandBuffer(cmd);
+                    cmd.Dispose();
+                }
+                else
+                {
+                    RenderVelocity(cullResults, camera, renderContext); // Note we may have to render velocity earlier if we do temporalAO, temporal volumetric etc... Mean we will not take into account forward opaque in case of deferred rendering ?
-            // TODO: Check with VFX team.
-            // Rendering distortion here have off course lot of artifact.
-            // But resolving at each objects that write in distortion is not possible (need to sort transparent, render those that do not distort, then resolve, then etc...)
-            // Instead we chose to apply distortion at the end after we cumulate distortion vector and desired blurriness. This
-            RenderDistortion(cullResults, camera, renderContext);
+                    // TODO: Check with VFX team.
+                    // Rendering distortion here have off course lot of artifact.
+                    // But resolving at each objects that write in distortion is not possible (need to sort transparent, render those that do not distort, then resolve, then etc...)
+                    // 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);
+                    FinalPass(camera, renderContext);
+                }
             }
 
             RenderDebugOverlay(camera, renderContext);
 
         void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, string passName, RendererConfiguration rendererConfiguration = 0)
         {
-            if (!globalDebugParameters.renderingDebugParametrs.displayOpaqueObjects)
+            if (!globalDebugSettings.renderingDebugSettings.displayOpaqueObjects)
                 return;
 
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
 
         void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, string passName, RendererConfiguration rendererConfiguration = 0)
         {
-            if (!globalDebugParameters.renderingDebugParametrs.displayTransparentObjects)
+            if (!globalDebugSettings.renderingDebugSettings.displayTransparentObjects)
                 return;
 
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
         {
             // If we are forward only we will do a depth prepass
             // TODO: Depth prepass should be enabled based on light loop settings. LightLoop define if they need a depth prepass + forward only...
-            if (!m_Owner.renderingParameters.useDepthPrepass)
+            if (!m_Owner.renderingSettings.useDepthPrepass)
                 return;
 
             using (new Utilities.ProfilingSample("Depth Prepass", renderContext))
 
         void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext renderContext)
         {
-            if (m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
+            if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
             {
                 return ;
             }
-                bool debugLighting = globalDebugParameters.lightingDebugParameters.lightingDebugMode != LightingDebugMode.None;
+                bool debugLighting = globalDebugSettings.lightingDebugSettings.lightingDebugMode != LightingDebugMode.None;
 
                 // setup GBuffer for rendering
                 Utilities.SetRenderTarget(renderContext, m_gbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT);
         {
             // If we are forward only we don't need to render ForwardOnlyOpaqueDepthOnly object
             // But in case we request a prepass we render it
-            if (m_Owner.renderingParameters.ShouldUseForwardRenderingOnly() && !m_Owner.renderingParameters.useDepthPrepass)
+            if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly() && !m_Owner.renderingSettings.useDepthPrepass)
                 return;
 
             using (new Utilities.ProfilingSample("Forward opaque depth", renderContext))
             {
                 Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, Utilities.kClearAll, Color.black);
 
-                Shader.SetGlobalInt("_DebugViewMaterial", (int)globalDebugParameters.materialDebugParameters.debugViewMaterial);
+                Shader.SetGlobalInt("_DebugViewMaterial", (int)globalDebugSettings.materialDebugSettings.debugViewMaterial);
-            if (!m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
+            if (!m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
-                m_DebugViewMaterialGBuffer.SetFloat("_DebugViewMaterial", (float)globalDebugParameters.materialDebugParameters.debugViewMaterial);
+                m_DebugViewMaterialGBuffer.SetFloat("_DebugViewMaterial", (float)globalDebugSettings.materialDebugSettings.debugViewMaterial);
 
                 // m_gbufferManager.BindBuffers(m_DebugViewMaterialGBuffer);
                 // TODO: Bind depth textures
             }
         }
 
-        void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext)
+        void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext, bool enableSSS)
-            if (m_Owner.renderingParameters.ShouldUseForwardRenderingOnly() || m_LightLoop == null)
+            if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly() || m_LightLoop == null)
             {
                 return ;
             }
-            // Output split lighting for materials tagged with the SSS stencil bit.
-            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugParameters.lightingDebugParameters, colorRTs, m_CameraStencilBufferRT, true);
+            if (enableSSS)
+            {
+                // Output split lighting for materials tagged with the SSS stencil bit.
+                m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugSettings.lightingDebugSettings, colorRTs, m_CameraStencilBufferRT, true, enableSSS);
+            }
-            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugParameters.lightingDebugParameters, colorRTs, m_CameraStencilBufferRT, false);
+            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugSettings.lightingDebugSettings, colorRTs, m_CameraStencilBufferRT, false, enableSSS);
         }
 
         // Combines specular lighting and diffuse lighting with subsurface scattering.
-            if (m_Owner.renderingParameters.ShouldUseForwardRenderingOnly()) return;
+            if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly()) return;
-            // Load the kernel data.
-            Vector4[] kernelData = new Vector4[SubsurfaceScatteringParameters.maxNumProfiles * SubsurfaceScatteringProfile.numVectors];
-            for (int j = 0, m = sssParameters.profiles.Length; j < m; j++)
-            {
-                for (int i = 0, n = SubsurfaceScatteringProfile.numVectors; i < n; i++)
-                {
-                    kernelData[n * j + i] = sssParameters.profiles[j].filterKernel[i];
-                }
-            }
+            if (!sssParameters.enableSSS) return;
-            m_FilterSubsurfaceScattering.SetVectorArray("_FilterKernels", kernelData);
+            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_CameraStencilBufferRT);
-            m_FilterAndCombineSubsurfaceScattering.SetVectorArray("_FilterKernels", kernelData);
+            m_FilterAndCombineSubsurfaceScattering.SetVectorArray("_FilterKernels", sssParameters.filterKernels);
+            m_FilterAndCombineSubsurfaceScattering.SetVectorArray("_HalfRcpWeightedVariances", sssParameters.halfRcpWeightedVariances);
             cmd.SetGlobalTexture("_IrradianceSource", m_CameraFilteringBufferRT);
             Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, hdCamera,
                                      m_CameraColorBufferRT, m_CameraStencilBufferRT);
         {
             // TODO: Currently we can't render opaque object forward when deferred is enabled
             // miss option
-            if (!m_Owner.renderingParameters.ShouldUseForwardRenderingOnly() && renderOpaque)
+            if (!m_Owner.renderingSettings.ShouldUseForwardRenderingOnly() && renderOpaque)
                 return;
 
             using (new Utilities.ProfilingSample("Forward Pass", renderContext))
                 if (m_LightLoop != null)
                     m_LightLoop.RenderForward(camera, renderContext, renderOpaque);
 
-                bool debugLighting = globalDebugParameters.lightingDebugParameters.lightingDebugMode != LightingDebugMode.None;
+                bool debugLighting = globalDebugSettings.lightingDebugSettings.lightingDebugMode != LightingDebugMode.None;
 
                 string forwardPassName = debugLighting ? "ForwardDebugLighting" : "Forward";
                 if (renderOpaque)
                 if (m_LightLoop != null)
                     m_LightLoop.RenderForward(camera, renderContext, true);
 
-                bool debugLighting = globalDebugParameters.lightingDebugParameters.lightingDebugMode != LightingDebugMode.None;
+                bool debugLighting = globalDebugSettings.lightingDebugSettings.lightingDebugMode != LightingDebugMode.None;
                 RenderOpaqueRenderList(cullResults, camera, renderContext, debugLighting ? "ForwardOnlyOpaqueDebugLighting" : "ForwardOnlyOpaque", Utilities.kRendererConfigurationBakedLighting);
             }
         }
             using (new Utilities.ProfilingSample("Velocity Pass", renderContext))
             {
                 // If opaque velocity have been render during GBuffer no need to render it here
-                if ((ShaderConfig.s_VelocityInGbuffer == 1) || m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
+                if ((ShaderConfig.s_VelocityInGbuffer == 1) || m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
                     return ;
 
                 int w = camera.pixelWidth;
 
         void RenderDistortion(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext)
         {
-            if (!globalDebugParameters.renderingDebugParametrs.enableDistortion)
+            if (!globalDebugSettings.renderingDebugSettings.enableDistortion)
                 return ;
 
             using (new Utilities.ProfilingSample("Distortion Pass", renderContext))
             debugCB.name = "Debug Overlay";
 
             float x = 0;
-            float overlayRatio = globalDebugParameters.debugOverlayRatio;
+            float overlayRatio = globalDebugSettings.debugOverlayRatio;
-            LightingDebugParameters shadowDebug = globalDebugParameters.lightingDebugParameters;
+            LightingDebugSettings shadowDebug = globalDebugSettings.lightingDebugSettings;
 
             if (shadowDebug.shadowDebugMode != ShadowDebugMode.None)
             {
                     cmd.GetTemporaryRT(m_CameraDepthStencilBufferCopy,  w, h, 24, FilterMode.Point, RenderTextureFormat.Depth);
                     cmd.GetTemporaryRT(m_CameraStencilBuffer,           w, h, 24, FilterMode.Point, RenderTextureFormat.Depth);
 
-                    if (!m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
+                    if (!m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
                     {
                         m_gbufferManager.InitGBuffers(w, h, cmd);
                     }
                 }
 
                 // Clear GBuffers
-                if (!m_Owner.renderingParameters.ShouldUseForwardRenderingOnly())
+                if (!m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
                 {
                     using (new Utilities.ProfilingSample("Clear GBuffer", renderContext))
                     {

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs.meta

 fileFormatVersion: 2
-guid: d440c0deec24a2f478b3e9021cb66c29
+guid: f365a473b136bef4797c7281a02cd510
 timeCreated: 1483605696
 licenseType: Pro
 MonoImporter:

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting.meta

 fileFormatVersion: 2
-guid: 1c14e71d397fce047b1675fc26d0bb48
+guid: 3002976b0b09954499dd1f6e00169b06
 folderAsset: yes
 timeCreated: 1474297943
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop.cs

         public virtual void NewFrame() {}
 
         public virtual void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput) { }
+        public virtual void RenderShadows( ScriptableRenderContext renderContext, CullResults cullResults ) { }
         
         // TODO: this should not be part of the interface but for now make something working
         public virtual void BuildGPULightLists(Camera camera, ScriptableRenderContext loop, RenderTargetIdentifier cameraDepthBufferRT) { }
         public virtual void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
-                                                   LightingDebugParameters lightDebugParameters,
+                                                   LightingDebugSettings lightDebugParameters,
-                                                   bool outputSplitLighting) {}
+                                                   bool outputSplitLightingForSSS, bool enableSSS) {}
 
         public virtual void RenderForward(Camera camera, ScriptableRenderContext renderContext, bool renderOpaque) {}
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Lighting.hlsl

 #include "HDRenderPipeline/Lighting/LightDefinition.cs.hlsl"
 #include "HDRenderPipeline/Lighting/LightUtilities.hlsl"
 
+#include "HDRenderPipeline/Shadow/Shadow.hlsl"
+
-#include "HDRenderPipeline/Shadow/Shadow.hlsl"
 #include "HDRenderPipeline/Material/Material.hlsl"
 
 // LightLoop use evaluation BSDF function for light type define in Material.hlsl

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Resources.meta

 fileFormatVersion: 2
-guid: 8d7b73e3debb13b46a544563ce8f4a64
+guid: 0823a45531ce4ee45ab39bcbe1ea52a6
 folderAsset: yes
 timeCreated: 1479129942
 licenseType: Pro

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

         _SrcBlend("", Float) = 1
         _DstBlend("", Float) = 1
 
-        _StencilRef("_StencilRef", Int) = 0
+        _StencilRef("", Int) = 0
+        _StencilCmp("", Int) = 3
     }
 
     SubShader
             Stencil
             {
                 Ref  [_StencilRef]
-                Comp Equal
+                Comp [_StencilCmp]
                 Pass Keep
             }
 
 
                 PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
 
-                float3 diffuseLighting  = float3(0, 0, 0);
-                float3 specularLighting = float3(0, 0, 0);
-
-            #if UNITY_REVERSED_Z
-                float clearDepth = 0;
-            #else
-                float clearDepth = 1;
-            #endif
-
-                // Do not shade the far plane - wastes cycles and produces wrong results.
-                if (depth != clearDepth)
-                {
-                    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
-                }
+                float3 diffuseLighting;
+                float3 specularLighting;
+                LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
 
                 Outputs outputs;
             #ifdef OUTPUT_SPLIT_LIGHTING

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass.meta

 fileFormatVersion: 2
-guid: 8a355c056864a5d4cb26d9c3168ae0bb
+guid: 8d0d2ae5d51ae6e42a81b92e8693272f
 folderAsset: yes
 timeCreated: 1479218330
 licenseType: Pro

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

+//#define SHADOWS_ENABLED
+//#define SHADOWS_FIXSHADOWIDX
 using UnityEngine.Rendering;
 using System.Collections.Generic;
 using System;
+#if SHADOWS_ENABLED
+    using ShadowExp;
+
+    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( ShadowExp.ShadowData ) ) );
+            s_ShadowPayloadBuffer   = new ComputeBuffer( k_MaxShadowDataSlots * k_MaxPayloadSlotsPerShadowData, System.Runtime.InteropServices.Marshal.SizeOf( typeof( ShadowExp.ShadowData ) ) );
+            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.clearColor      = new Vector4( 0.0f, 0.0f, 0.0f, 0.0f );
+            atlasInit.baseInit.maxPayloadCount = 0;
+            atlasInit.baseInit.shadowSupport   = ShadowmapBase.ShadowSupport.Directional;
+            atlasInit.shaderKeyword            = null;
+            atlasInit.cascadeCount             = shadowSettings.directionalLightCascadeCount;
+            atlasInit.cascadeRatios            = shadowSettings.directionalLightCascades;
+                
+            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 ) };
+
+            ShadowContext.SyncDel syncer = (ShadowContext sc) =>
+                {
+                    // update buffers
+                    uint offset, count;
+                    ShadowExp.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_Dir", tex[0] );
+                    cb.SetGlobalTexture( "_ShadowmapExp_PointSpot", tex[1] );
+                    // 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        = 4;
+            scInit.storage.maxTexCubeArraySlots      = 2;
+            scInit.storage.maxComparisonSamplerSlots = 2;
+            scInit.storage.maxSamplerSlots           = 2;
+            scInit.dataSyncer                        = syncer;
+            scInit.resourceBinder                    = binder;
+
+            m_ShadowMgr = new ShadowExp.ShadowManager( shadowSettings, ref scInit, m_Shadowmaps );
+            shadowManager = m_ShadowMgr;
+        }
+        public void Dispose()
+        {
+            if( m_Shadowmaps != null )
+            {
+
+                (m_Shadowmaps[0] as ShadowAtlas).Dispose();
+                (m_Shadowmaps[1] as ShadowAtlas).Dispose();
+                m_Shadowmaps = null;
+            }
+            m_ShadowMgr = null;
+
+            Utilities.SafeRelease( s_ShadowDataBuffer );
+            Utilities.SafeRelease( s_ShadowPayloadBuffer );
+        }
+    }
+#endif
+
     namespace TilePass
     {
         //-----------------------------------------------------------------------------
 
             const int k_TileSize = 16;
 
+#if (SHADOWS_ENABLED)
+            // shadow related stuff
+            FrameId                 m_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>();
+            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;
+                }
+            }
+#endif
+
+
             int GetNumTileX(Camera camera)
             {
                 return (camera.pixelWidth + (k_TileSize - 1)) / k_TileSize;
                 Utilities.SelectKeyword(m_DeferredDirectMaterialSRT, tileKeywords, 0);
                 m_DeferredDirectMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredDirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.None);
+                m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.Standard);
+                m_DeferredDirectMaterialSRT.SetInt("_StencilCmp", 4 /* LEqual */);
                 m_DeferredDirectMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_DeferredDirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
                 m_DeferredDirectMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredDirectMaterialMRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_DeferredDirectMaterialMRT.SetInt("_StencilCmp", 3 /* Equal */);
                 m_DeferredDirectMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_DeferredDirectMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
                 m_DeferredIndirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.None);
+                m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.Standard);
+                m_DeferredIndirectMaterialSRT.SetInt("_StencilCmp", 4 /* LEqual */);
                 m_DeferredIndirectMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_DeferredIndirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.One); // Additive color & alpha source
 
                 m_DeferredIndirectMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredIndirectMaterialMRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_DeferredIndirectMaterialMRT.SetInt("_StencilCmp", 3 /* Equal */);
                 m_DeferredIndirectMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_DeferredIndirectMaterialMRT.SetInt("_DstBlend", (int)BlendMode.One); // Additive color & alpha source
 
                 m_DeferredAllMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilBits.None);
+                m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilBits.Standard);
+                m_DeferredAllMaterialSRT.SetInt("_StencilCmp", 4 /* LEqual */);
                 m_DeferredAllMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_DeferredAllMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
                 m_DeferredAllMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredAllMaterialMRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_DeferredAllMaterialMRT.SetInt("_StencilCmp", 3 /* Equal */);
                 m_DeferredAllMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_DeferredAllMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
                 m_SingleDeferredMaterialSRT.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
                 m_SingleDeferredMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)StencilBits.None);
+                m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)StencilBits.Standard);
+                m_SingleDeferredMaterialSRT.SetInt("_StencilCmp", 4 /* LEqual */);
                 m_SingleDeferredMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_SingleDeferredMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
                 m_SingleDeferredMaterialMRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_SingleDeferredMaterialMRT.SetInt("_StencilCmp", 3 /* Equal */);
                 m_SingleDeferredMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
                 m_SingleDeferredMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
 #if UNITY_EDITOR
                 UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
                 UnityEditor.SceneView.onSceneGUIDelegate += OnSceneGUI;
+#endif
+
+#if (SHADOWS_ENABLED)
+                InitShadowSystem(ShadowSettings.Default);
 #endif
             }
 
                 if (cullResults.visibleLights.Length == 0 && cullResults.visibleReflectionProbes.Length == 0)
                     return;
 
+#if (SHADOWS_ENABLED)
+                // 0. deal with shadows
+                {
+                    m_FrameId.frameCount++;
+                    // get the indices for all lights that want to have shadows
+                    m_ShadowRequests.Clear();
+                    m_ShadowRequests.Capacity = cullResults.visibleLights.Length;
+                    int lcnt = cullResults.visibleLights.Length;
+                    for( int i = 0; i < lcnt; ++i )
+                    {
+                        if( cullResults.visibleLights[i].light.shadows != LightShadows.None )
+                            m_ShadowRequests.Add( i );
+                    }
+                    // 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;
+                    uint    originalRequestCount = shadowRequestCount;
+                    m_ShadowMgr.ProcessShadowRequests( m_FrameId, cullResults, camera, cullResults.visibleLights, 
+                        ref shadowRequestCount, shadowRequests, out shadowDataIndices );
+
+                    // update the visibleLights with the shadow information
+                    m_ShadowIndices.Clear();
+                    for( uint i = 0; i < shadowRequestCount; i++ )
+                    {
+                        m_ShadowIndices.Add( shadowRequests[i], shadowDataIndices[i] );
+                    }
+                }
+#endif
+
                 // 1. Count the number of lights and sort all light by category, type and volume
                 int directionalLightcount = 0;
                 int punctualLightcount = 0;
                         }
                     }
 
+#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
+#endif
                 }
 
                 Array.Sort(sortKeys);
                     uint sortKey = sortKeys[sortIndex];
                     LightCategory lightCategory = (LightCategory)((sortKey >> 27) & 0x1F);
                     GPULightType gpuLightType = (GPULightType)((sortKey >> 22) & 0x1F);
+#if (SHADOWS_ENABLED)
+                    LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 17) & 0x1F);
+#else
+#endif
                     int lightIndex = (int)(sortKey & 0xFFFF);
 
                     var light = cullResults.visibleLights[lightIndex];
                     {
                         GetDirectionalLightData(shadowSettings, gpuLightType, light, additionalData, lightIndex, ref shadowOutput, ref directionalShadowcount);
 
+#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
                         continue;
                     }
 
                     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)
+                m_ShadowMgr.BindResources(loop);
+#endif
                 SetGlobalPropertyRedirect(computeShader, kernelIndex, cmd);
 
                 SetGlobalTexture("_CookieTextures", m_CookieTexArray.GetTexCache());
                 s_ConvexBoundsBuffer.SetData(m_lightList.bounds.ToArray());
                 s_LightVolumeDataBuffer.SetData(m_lightList.lightVolumes.ToArray());
 
-
+#if (SHADOWS_ENABLED)
+                // Shadows
+                m_ShadowMgr.SyncData();
+#endif
                 BindGlobalParams(cmd, null, 0, camera, loop);
 
                 SetGlobalPropertyRedirect(null, 0, null);
             }
 #endif
 
-            private void SetupRenderingForDebug(LightingDebugParameters lightDebugParameters)
+            public override void RenderShadows( ScriptableRenderContext renderContext, CullResults cullResults )
-                Utilities.SetKeyword(m_DeferredDirectMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredDirectMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredIndirectMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredIndirectMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredAllMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_DeferredAllMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_SingleDeferredMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
-                Utilities.SetKeyword(m_SingleDeferredMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+#if (SHADOWS_ENABLED)
+                // kick off the shadow jobs here
+                m_ShadowMgr.RenderShadows( m_FrameId, renderContext, cullResults, cullResults.visibleLights );
+#endif
+            }
+
+            private void SetupRenderingForDebug(LightingDebugSettings lightDebugSettings)
+            {
+                Utilities.SetKeyword(m_DeferredDirectMaterialSRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredDirectMaterialMRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredIndirectMaterialSRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredIndirectMaterialMRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredAllMaterialSRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredAllMaterialMRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_SingleDeferredMaterialSRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_SingleDeferredMaterialMRT, "LIGHTING_DEBUG", lightDebugSettings.lightingDebugMode != LightingDebugMode.None);
-                                                        LightingDebugParameters lightDebugParameters,
+                                                        LightingDebugSettings lightDebugSettings,
-                                                        bool outputSplitLighting)
+                                                        bool outputSplitLightingForSSS, bool enableSSS)
             {
                 var bUseClusteredForDeferred = !usingFptl;
 
 
                     SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
 
-                    if (lightDebugParameters.lightingDebugMode == LightingDebugMode.None)
+                    if (lightDebugSettings.lightingDebugMode == LightingDebugMode.None)
                         SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlKernel : s_shadeOpaqueClusteredKernel, cmd);
                     else
                         SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlDebugLightingKernel : s_shadeOpaqueClusteredDebugLightingKernel, cmd);
                     }
 
                     // Must be done after setting up the compute shader above.
-                    SetupRenderingForDebug(lightDebugParameters);
+                    SetupRenderingForDebug(lightDebugSettings);
-                        if (outputSplitLighting)
+                        if (outputSplitLightingForSSS)
+                            m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)(enableSSS ? StencilBits.Standard : StencilBits.SSS));
                             Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialSRT, hdCamera, colorBuffers[0], stencilBuffer);
                         }
                     }
                             // Pixel shader evaluation
                             if (m_PassSettings.enableSplitLightEvaluation)
                             {
-                                if (outputSplitLighting)
+                                if (outputSplitLightingForSSS)
                                 {
                                     Utilities.SelectKeyword(m_DeferredDirectMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
                                     Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialMRT, hdCamera, colorBuffers, stencilBuffer);
                                 }
                                 else
                                 {
+                                    m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)(enableSSS ? StencilBits.Standard : StencilBits.SSS));
+                                    m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)(enableSSS ? StencilBits.Standard : StencilBits.SSS));
                                     Utilities.SelectKeyword(m_DeferredIndirectMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
                                     Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialSRT, hdCamera, colorBuffers[0], stencilBuffer);
                                 }
-                                if (outputSplitLighting)
+                                if (outputSplitLightingForSSS)
                                 {
                                     Utilities.SelectKeyword(m_DeferredAllMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
                                     Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialMRT, hdCamera, colorBuffers, stencilBuffer);
+                                    m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)(enableSSS ? StencilBits.Standard : StencilBits.SSS));
                                     Utilities.SelectKeyword(m_DeferredAllMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
                                     Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialSRT, hdCamera, colorBuffers[0], stencilBuffer);
                                 }

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

 {
     int sampleShadow;
     int sampleReflection;
+#ifdef SHADOWS_USE_SHADOWCTXT
+	ShadowContext shadowContext;
+#endif
+
+#ifndef SHADOWS_USE_SHADOWCTXT
 
 //-----------------------------------------------------------------------------
 // Shadow sampling function
     // 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; // Apply a linear bias
-    positionTXS.z -= 0.001;
+    // positionTXS.z -=  shadowData.bias;
+    positionTXS.z -= 0.001; // Apply a linear bias
 
 #if UNITY_REVERSED_Z
     positionTXS.z = 1.0 - positionTXS.z;
     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
     // 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; // Apply a linear bias
-    positionTXS.z -= 0.003;
+    // positionTXS.z -=  shadowData.bias;
+    positionTXS.z -= 0.003; // Apply a linear bias
 
 #if UNITY_REVERSED_Z
     positionTXS.z = 1.0 - positionTXS.z;
     return flSum;
 
 }
+#endif
 
 //-----------------------------------------------------------------------------
 // Cookie sampling functions

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

                 out float3 specularLighting)
 {
     LightLoopContext context;
+#ifndef SHADOWS_USE_SHADOWCTXT
+#else
+	context.sampleShadow = 0;
+	context.sampleReflection = 0;
+	context.shadowContext = InitShadowContext();
+#endif
 
     diffuseLighting = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
     uint punctualLightStart;
     uint punctualLightCount;
     GetCountAndStart(posInput, LIGHTCATEGORY_PUNCTUAL, punctualLightStart, punctualLightCount);
-    for (i = 0; i < punctualLightCount; ++i)
+
+	for (i = 0; i < punctualLightCount; ++i)
     {
         float3 localDiffuseLighting, localSpecularLighting;
 
                 out float3 specularLighting)
 {
     LightLoopContext context;
-    ZERO_INITIALIZE(LightLoopContext, context);
+#ifndef SHADOWS_USE_SHADOWCTXT
+	ZERO_INITIALIZE(LightLoopContext, context);
+#else
+	context.sampleShadow = 0;
+	context.sampleReflection = 0;
+	context.shadowContext = InitShadowContext();
+#endif
 
     diffuseLighting = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassProducer.asset.meta

 fileFormatVersion: 2
 guid: bf8cd9ae03ff7d54c89603e67be0bfc5
-timeCreated: 1485857933
+timeCreated: 1486997442
 licenseType: Pro
 NativeFormatImporter:
   mainObjectFileID: 11400000

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material.meta

 fileFormatVersion: 2
-guid: 96af336cb096f854ea18990a1c0a4e19
+guid: 49844bc6823848a4087668ebd3367436
 folderAsset: yes
 timeCreated: 1474297943
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit.meta

 fileFormatVersion: 2
-guid: e173dfe6cd75d954b95306237244f6de
+guid: c526d3e6d7f3ce1408308bb431089d2d
 folderAsset: yes
 timeCreated: 1476653183
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/Editor/LayeredLitUI.cs

 
         Material[] m_MaterialLayers = new Material[kMaxLayerCount];
 
+        // Layer options
+        MaterialProperty layerCount = null;
+        const string kLayerCount = "_LayerCount";
-        MaterialProperty layerCount = null;
-        const string kLayerCount = "_LayerCount";
-        MaterialProperty[] layerTexWorldScale = new MaterialProperty[kMaxLayerCount];
-        MaterialProperty[] layerUVBase = new MaterialProperty[kMaxLayerCount];
-        MaterialProperty[] layerUVMappingMask = new MaterialProperty[kMaxLayerCount];
-        MaterialProperty[] layerUVMappingPlanar = new MaterialProperty[kMaxLayerCount];
-        MaterialProperty[] layerUVDetail = new MaterialProperty[kMaxLayerCount];
-        MaterialProperty[] layerUVDetailsMappingMask = new MaterialProperty[kMaxLayerCount];
-
-
+        MaterialProperty objectScaleAffectTile = null;
-        MaterialProperty objectScaleAffectTile = null;
+        MaterialProperty UVBlendMask = null;
-        MaterialProperty UVBlendMask = null;
-        const string kUVMappingPlanarBlendMask = "_UVMappingPlanarBlendMask";
-        MaterialProperty UVMappingPlanarBlendMask = null;
+        MaterialProperty layerTilingBlendMask = null;
-        MaterialProperty layerTilingBlendMask = null;
+        MaterialProperty texWorldScaleBlendMask = null;
-        MaterialProperty texWorldScaleBlendMask = null;
-        const string kLayerTiling = "_LayerTiling";
-        MaterialProperty[] layerTiling = new MaterialProperty[kMaxLayerCount];
+        MaterialProperty useMainLayerInfluence = null;
-        MaterialProperty useMainLayerInfluence = null;
-        const string kUseHeightBasedBlend = "_UseHeightBasedBlend";
+        const string kUseHeightBasedBlend = "_UseHeightBasedBlend";
+       
-        const string kUseDensityMode = "_UseDensityMode";
-        MaterialProperty useDensityMode = null;
+        // Properties for multiple layers inherit from referenced lit materials
+        MaterialProperty[] layerTexWorldScale = new MaterialProperty[kMaxLayerCount];
+        MaterialProperty[] layerUVBase = new MaterialProperty[kMaxLayerCount];
+        MaterialProperty[] layerUVMappingMask = new MaterialProperty[kMaxLayerCount];
+        MaterialProperty[] layerUVDetail = new MaterialProperty[kMaxLayerCount];
+        MaterialProperty[] layerUVDetailsMappingMask = new MaterialProperty[kMaxLayerCount];
+        // This one is specific to layer lit
+        MaterialProperty[] layerTiling = new MaterialProperty[kMaxLayerCount];
+        const string kLayerTiling = "_LayerTiling";
-        const string kOpacityAsDensity = "_OpacityAsDensity";
+        // Density/opacity mode
+        MaterialProperty useDensityMode = null;
+        const string kUseDensityMode = "_UseDensityMode";
+        const string kOpacityAsDensity = "_OpacityAsDensity";
+        MaterialProperty[] minimumOpacity = new MaterialProperty[kMaxLayerCount];
-        MaterialProperty[] minimumOpacity = new MaterialProperty[kMaxLayerCount];
+        // HeightmapMode control
+        MaterialProperty[] heightFactor = new MaterialProperty[kMaxLayerCount];
-        MaterialProperty[] heightFactor = new MaterialProperty[kMaxLayerCount];
+        MaterialProperty[] heightCenterOffset = new MaterialProperty[kMaxLayerCount];
-        MaterialProperty[] heightCenterOffset = new MaterialProperty[kMaxLayerCount];
-        const string kLayerHeightAmplitude = "_LayerHeightAmplitude";
+        const string kLayerHeightAmplitude = "_LayerHeightAmplitude";
+        MaterialProperty[] layerCenterOffset = new MaterialProperty[kMaxLayerCount];
-        MaterialProperty[] layerCenterOffset = new MaterialProperty[kMaxLayerCount];
+        MaterialProperty[] blendUsingHeight = new MaterialProperty[kMaxLayerCount - 1]; // Only in case of influence mode
-        MaterialProperty[] blendUsingHeight = new MaterialProperty[kMaxLayerCount - 1];
-        // influence
+        // Influence
+        MaterialProperty[] inheritBaseNormal = new MaterialProperty[kMaxLayerCount - 1];
-        MaterialProperty[] inheritBaseNormal = new MaterialProperty[kMaxLayerCount - 1];
-        const string kInheritBaseHeight = "_InheritBaseHeight";
-        const string kInheritBaseColor = "_InheritBaseColor";
+        const string kInheritBaseHeight = "_InheritBaseHeight";
-        const string kInheritBaseColorThreshold = "_InheritBaseColorThreshold";
+        const string kInheritBaseColor = "_InheritBaseColor";
+        const string kInheritBaseColorThreshold = "_InheritBaseColorThreshold";        
-        MaterialProperty layerEmissiveColor = null;
-        MaterialProperty layerEmissiveColorMap = null;
-        MaterialProperty layerEmissiveIntensity = null;
+        protected override void FindMaterialProperties(MaterialProperty[] props)
+        {
+            // Inherit from LitUI
+            horizonFade = FindProperty(kHorizonFade, props);
-        override protected void FindMaterialProperties(MaterialProperty[] props)
-        {
-            layerMaskMap = FindProperty(kLayerMaskMap, props);
+            layerMaskMap = FindProperty(kLayerMaskMap, props);
+            objectScaleAffectTile = FindProperty(kObjectScaleAffectTile, props);
+            UVBlendMask = FindProperty(kUVBlendMask, props);
+            layerTilingBlendMask = FindProperty(kLayerTilingBlendMask, props);
+            texWorldScaleBlendMask = FindProperty(kTexWorldScaleBlendMask, props);
+
-
-            objectScaleAffectTile = FindProperty(kObjectScaleAffectTile, props);
-            UVBlendMask = FindProperty(kUVBlendMask, props);
-            UVMappingPlanarBlendMask = FindProperty(kUVMappingPlanarBlendMask, props);
-            layerTilingBlendMask = FindProperty(kLayerTilingBlendMask, props);
-            texWorldScaleBlendMask = FindProperty(kTexWorldScaleBlendMask, props);
-                       
+       
-                layerUVMappingPlanar[i] = FindProperty(string.Format("{0}{1}", kUVMappingPlanar, i), props);
+                // Density/opacity mode
+                opacityAsDensity[i] = FindProperty(string.Format("{0}{1}", kOpacityAsDensity, i), props);
-                opacityAsDensity[i] = FindProperty(string.Format("{0}{1}", kOpacityAsDensity, i), props);
+           
+                // HeightmapMode control
                 heightFactor[i] = FindProperty(string.Format("{0}{1}", kHeightFactor, i), props);
                 heightCenterOffset[i] = FindProperty(string.Format("{0}{1}", kHeightCenterOffset, i), props);
                 layerHeightAmplitude[i] = FindProperty(string.Format("{0}{1}", kLayerHeightAmplitude, i), props);
                 {
                     blendUsingHeight[i - 1] = FindProperty(string.Format("{0}{1}", kBlendUsingHeight, i), props);
+                    // Influence
                     inheritBaseNormal[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseNormal, i), props);
                     inheritBaseHeight[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseHeight, i), props);
                     inheritBaseColor[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseColor, i), props);
 
-            layerEmissiveColor = FindProperty(kEmissiveColor, props);
-            layerEmissiveColorMap = FindProperty(kEmissiveColorMap, props);
-            layerEmissiveIntensity = FindProperty(kEmissiveIntensity, props);
+            // Reuse property from LitUI.cs
+            emissiveColor = FindProperty(kEmissiveColor, props);
+            emissiveColorMap = FindProperty(kEmissiveColorMap, props);
+            emissiveIntensity = FindProperty(kEmissiveIntensity, props);
         }
 
         int numLayer
         }
 
+        // This function is call by a script to help artists to ahve up to date material
+        // that why it is static
-            int layerCount = (int)material.GetFloat("_LayerCount");
+            int layerCount = (int)material.GetFloat(kLayerCount);
-            for (int i = 0 ; i < layerCount ; ++i)
+
+            // We could have no userData in the assets, so test if we have load something
+            if (layers != null)
-                SynchronizeLayerProperties(material, layers, i);
+                for (int i = 0; i < layerCount; ++i)
+                {
+                    SynchronizeLayerProperties(material, layers, i);
+                }
             }
         }
 
         // put the name in the exclusionList below
         static void SynchronizeLayerProperties(Material material, Material[] layers, int layerIndex)
         {
-            string[] exclusionList = { kTexWorldScale, kUVBase, kUVMappingMask, kUVMappingPlanar, kUVDetail, kUVDetailsMappingMask };
+            string[] exclusionList = { kTexWorldScale, kUVBase, kUVMappingMask, kUVDetail, kUVDetailsMappingMask };
 
             Material layerMaterial = layers[layerIndex];
 
                 }
             }
 
+            // We setup the masking map based on the enum for each layer.
+            // using mapping mask allow to reduce the number of generated combination for a very small increase in ALU
+            LayerUVBaseMapping layerUVBaseMapping = (LayerUVBaseMapping)layerUVBase[layerIndex].floatValue;
+
+            float X, Y, Z, W;
+            X = (layerUVBaseMapping == LayerUVBaseMapping.UV0) ? 1.0f : 0.0f;
+            Y = (layerUVBaseMapping == LayerUVBaseMapping.UV1) ? 1.0f : 0.0f;
+            Z = (layerUVBaseMapping == LayerUVBaseMapping.UV2) ? 1.0f : 0.0f;
+            W = (layerUVBaseMapping == LayerUVBaseMapping.UV3) ? 1.0f : 0.0f;
+            layerUVMappingMask[layerIndex].colorValue = (layerIndex == 0) ? new Color(1.0f, 0.0f, 0.0f, 0.0f) : new Color(X, Y, Z, W); // Special case for Main Layer and Blend Mask, only UV0. As Layer0 is share by both here, need to force X to 1.0 in all case
+
+            UVDetailMapping layerUVDetailMapping = (UVDetailMapping)layerUVDetail[layerIndex].floatValue;
+            X = (layerUVDetailMapping == UVDetailMapping.UV0) ? 1.0f : 0.0f;
+            Y = (layerUVDetailMapping == UVDetailMapping.UV1) ? 1.0f : 0.0f;
+            Z = (layerUVDetailMapping == UVDetailMapping.UV2) ? 1.0f : 0.0f;
+            W = (layerUVDetailMapping == UVDetailMapping.UV3) ? 1.0f : 0.0f;
+            layerUVDetailsMappingMask[layerIndex].colorValue = new Color(X, Y, Z, W);
+
             bool useDensityModeEnable = useDensityMode.floatValue != 0.0f;
             if (useDensityModeEnable)
             {
                 useHeightBasedBlend.floatValue = enabled ? 1.0f : 0.0f;
             }
 
-            m_MaterialEditor.ShaderProperty(objectScaleAffectTile, mainLayerModeInfluenceEnable ? styles.objectScaleAffectTileText2 : styles.objectScaleAffectTileText);            
+            m_MaterialEditor.ShaderProperty(objectScaleAffectTile, mainLayerModeInfluenceEnable ? styles.objectScaleAffectTileText2 : styles.objectScaleAffectTileText);
+
+            m_MaterialEditor.ShaderProperty(horizonFade, Styles.horizonFadeText);
 
             EditorGUILayout.Space();
 
 
             return layerChanged;
         }
-
-        protected override void SetupMaterialKeywords(Material material)
+        protected override bool ShouldEmissionBeEnabled(Material mat)
-            SetupCommonOptionsKeywords(material);
-            SetupLayersMappingKeywords(material);
-
-            for (int i = 0; i < kMaxLayerCount; ++i)
-            {
-                SetKeyword(material, "_NORMALMAP_TANGENT_SPACE" + i, ((NormalMapSpace)material.GetFloat(kNormalMapSpace + i)) == NormalMapSpace.TangentSpace);
-
-                SetKeyword(material, "_NORMALMAP" + i, material.GetTexture(kNormalMap + i));
-
-                SetKeyword(material, "_MASKMAP" + i, material.GetTexture(kMaskMap + i));
-
-                SetKeyword(material, "_SPECULAROCCLUSIONMAP" + i, material.GetTexture(kSpecularOcclusionMap + i));
-
-                SetKeyword(material, "_DETAIL_MAP" + i, material.GetTexture(kDetailMap + i));
-
-                SetKeyword(material, "_HEIGHTMAP0" + i, material.GetTexture(kHeightMap + i));
-            }
-
-            bool perPixelDisplacement = material.GetFloat(kEnablePerPixelDisplacement) == 1.0;
-            SetKeyword(material, "_PER_PIXEL_DISPLACEMENT", perPixelDisplacement);
-
-            SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
-
-            SetKeyword(material, "_MAIN_LAYER_INFLUENCE_MODE", material.GetFloat(kkUseMainLayerInfluence) != 0.0f);
-
-            VertexColorMode VCMode = (VertexColorMode)vertexColorMode.floatValue;
-            if (VCMode == VertexColorMode.Multiply)
-            {
-                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", true);
-                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", false);
-            }
-            else if (VCMode == VertexColorMode.Add)
-            {
-                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", false);
-                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", true);
-            }
-            else
-            {
-                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", false);
-                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", false);
-            }
+            return mat.GetFloat(kEmissiveIntensity) > 0.0f;
+        }
-            bool useHeightBasedBlend = material.GetFloat(kUseHeightBasedBlend) != 0.0f;
-            SetKeyword(material, "_HEIGHT_BASED_BLEND", useHeightBasedBlend);
-
-            bool useDensityModeEnable = material.GetFloat(kUseDensityMode) != 0.0f;
-            SetKeyword(material, "_DENSITY_MODE", useDensityModeEnable);
+        protected override void SetupMaterialKeywordsAndPassInternal(Material material)
+        {
+            SetupMaterialKeywordsAndPass(material);
-        void SetupLayersMappingKeywords(Material material)
+        static public void SetupLayersMappingKeywords(Material material)
         {
             // object scale affect tile
             SetKeyword(material, "_LAYER_TILING_UNIFORM_SCALE", material.GetFloat(kObjectScaleAffectTile) > 0.0f);
-            UVMappingPlanarBlendMask.floatValue = (UVBlendMaskMapping == LayerUVBaseMapping.Planar) ? 1.0f : 0.0f;
+            SetKeyword(material, "_LAYER_MAPPING_PLANAR_BLENDMASK", UVBlendMaskMapping == LayerUVBaseMapping.Planar);
+            int numLayer = (int)material.GetFloat(kLayerCount);
+
             // Layer
             if (numLayer == 4)
             {
                 SetKeyword(material, "_LAYEREDLIT_3_LAYERS", false);
             }
 
+            const string kLayerMappingPlanar = "_LAYER_MAPPING_PLANAR";
             const string kLayerMappingTriplanar = "_LAYER_MAPPING_TRIPLANAR";
 
             // We have to check for each layer if the UV2 or UV3 is needed.
             for (int i = 0 ; i < numLayer; ++i)
             {
-                // We setup the masking map based on the enum for each layer.
-                // using mapping mask allow to reduce the number of generated combination for a very small increase in ALU
-                string layerUVDetailParam = string.Format("{0}{1}", kUVDetail, i);
-                UVDetailMapping layerUVDetailMapping = (UVDetailMapping)material.GetFloat(layerUVDetailParam);
+                string currentLayerMappingPlanar = string.Format("{0}{1}", kLayerMappingPlanar, i);
+                SetKeyword(material, currentLayerMappingPlanar, layerUVBaseMapping == LayerUVBaseMapping.Planar);
-
-                float X, Y, Z, W;
-                X = (layerUVBaseMapping == LayerUVBaseMapping.UV0) ? 1.0f : 0.0f;
-                Y = (layerUVBaseMapping == LayerUVBaseMapping.UV1) ? 1.0f : 0.0f;
-                Z = (layerUVBaseMapping == LayerUVBaseMapping.UV2) ? 1.0f : 0.0f;
-                W = (layerUVBaseMapping == LayerUVBaseMapping.UV3) ? 1.0f : 0.0f;
-                layerUVMappingMask[i].colorValue = (i == 0) ? new Color(1.0f, 0.0f, 0.0f, 0.0f) : new Color(X, Y, Z, W); // Special case for Main Layer and Blend Mask, only UV0. As Layer0 is share by both here, need to force X to 1.0 in all case
-                layerUVMappingPlanar[i].floatValue = (layerUVBaseMapping == LayerUVBaseMapping.Planar) ? 1.0f : 0.0f; // Planar have priority on UV0
-
-                X = (layerUVDetailMapping == UVDetailMapping.UV0) ? 1.0f : 0.0f;
-                Y = (layerUVDetailMapping == UVDetailMapping.UV1) ? 1.0f : 0.0f;
-                Z = (layerUVDetailMapping == UVDetailMapping.UV2) ? 1.0f : 0.0f;
-                W = (layerUVDetailMapping == UVDetailMapping.UV3) ? 1.0f : 0.0f;
-                layerUVDetailsMappingMask[i].colorValue = new Color(X, Y, Z, W);
-
                 string uvBase = string.Format("{0}{1}", kUVBase, i);
                 string uvDetail = string.Format("{0}{1}", kUVDetail, i);
 
             }
         }
 
+        // All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if code change
+        static new public void SetupMaterialKeywordsAndPass(Material material)
+        {
+            SetupBaseLitKeywords(material);
+            SetupBaseLitMaterialPass(material);
+            SetupLayersMappingKeywords(material);
+
+            for (int i = 0; i < kMaxLayerCount; ++i)
+            {
+                SetKeyword(material, "_NORMALMAP_TANGENT_SPACE" + i, ((NormalMapSpace)material.GetFloat(kNormalMapSpace + i)) == NormalMapSpace.TangentSpace);
+
+                SetKeyword(material, "_NORMALMAP" + i, material.GetTexture(kNormalMap + i));
+
+                SetKeyword(material, "_MASKMAP" + i, material.GetTexture(kMaskMap + i));
+
+                SetKeyword(material, "_SPECULAROCCLUSIONMAP" + i, material.GetTexture(kSpecularOcclusionMap + i));
+
+                SetKeyword(material, "_DETAIL_MAP" + i, material.GetTexture(kDetailMap + i));
+
+                SetKeyword(material, "_HEIGHTMAP" + i, material.GetTexture(kHeightMap + i));
+            }
+
+            SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
+
+            SetKeyword(material, "_MAIN_LAYER_INFLUENCE_MODE", material.GetFloat(kkUseMainLayerInfluence) != 0.0f);
+
+            VertexColorMode VCMode = (VertexColorMode)material.GetFloat(kVertexColorMode);
+            if (VCMode == VertexColorMode.Multiply)
+            {
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", true);
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", false);
+            }
+            else if (VCMode == VertexColorMode.Add)
+            {
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", false);
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", true);
+            }
+            else
+            {
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", false);
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", false);
+            }
+
+            bool useHeightBasedBlend = material.GetFloat(kUseHeightBasedBlend) != 0.0f;
+            SetKeyword(material, "_HEIGHT_BASED_BLEND", useHeightBasedBlend);
+
+            bool useDensityModeEnable = material.GetFloat(kUseDensityMode) != 0.0f;
+            SetKeyword(material, "_DENSITY_MODE", useDensityModeEnable);
+        }
+
+
-            FindCommonOptionProperties(props);
+            FindBaseMaterialProperties(props);
-
+            // We should always do this call at the beginning
             m_MaterialEditor.serializedObject.Update();
 
             Material material = m_MaterialEditor.target as Material;
             bool optionsChanged = false;
             EditorGUI.BeginChangeCheck();
             {
-                ShaderOptionsGUI();
+                BaseMaterialPropertiesGUI();
                 EditorGUILayout.Space();
             }
             if (EditorGUI.EndChangeCheck())
             EditorGUILayout.Space();
             GUILayout.Label(Styles.lightingText, EditorStyles.boldLabel);
             EditorGUI.indentLevel++;
-            m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, layerEmissiveColorMap, layerEmissiveColor);
-            m_MaterialEditor.ShaderProperty(layerEmissiveIntensity, Styles.emissiveIntensityText);
-            m_MaterialEditor.LightmapEmissionProperty(1);
+            m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
+            m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);            
+            DoEmissionArea(material);
+            m_MaterialEditor.EnableInstancingField();
-                    SetupMaterialKeywords((Material)obj);
+                    SetupMaterialKeywordsAndPassInternal((Material)obj);
+                // SaveAssetsProcessor the referenced material in the users data
+            // We should always do this call at the end
             m_MaterialEditor.serializedObject.ApplyModifiedProperties();
         }
     }

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

         
         [ToggleOff]  _ObjectScaleAffectTile("_ObjectScaleAffectTile", Float) = 0.0
         [Enum(UV0, 0, Planar, 4, Triplanar, 5)] _UVBlendMask("UV Set for blendMask", Float) = 0
-        [HideInInspector] _UVMappingPlanarBlendMask("_UVMappingPlanarBlendMask", Float) = 0.0
         _TexWorldScaleBlendMask("Tiling", Float) = 1.0
 
         // Following are builtin properties
 
         _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
 
+        // Stencil state
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.Standard
+
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _BlendMode ("__blendmode", Float) = 0.0
         [HideInInspector] _CullMode("__cullmode", Float) = 2.0
         [HideInInspector] _ZTestMode("_ZTestMode", Int) = 8
 
-        [Enum(None, 0, DoubleSided, 1, DoubleSidedLigthingFlip, 2, DoubleSidedLigthingMirror, 3)] _DoubleSidedMode("Double sided mode", Float) = 0
+        [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
+        [ToggleOff] _DoubleSidedMirrorEnable("Double sided mirror enable", Float) = 1.0
+        [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
 
+        // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
+        // value that exist to identify if the GI emission need to be enabled.
+        // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
+        // TODO: Fix the code in legacy unity so we can customize the beahvior for GI
+        _EmissionColor("Color", Color) = (1, 1, 1)
+
         // WARNING
         // All the following properties that concern the UV mapping are the same as in the Lit shader.
         // This means that they will get overridden when synchronizing the various layers.
         [HideInInspector] _UVMappingMask0("_UVMappingMask0", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVMappingMask1("_UVMappingMask1", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVMappingMask2("_UVMappingMask2", Color) = (1, 0, 0, 0)
-        [HideInInspector] _UVMappingMask3("_UVMappingMask3", Color) = (1, 0, 0, 0)
-     
-        [HideInInspector] _UVMappingPlanar0("_UVMappingPlanar0", Float) = 0.0
-        [HideInInspector] _UVMappingPlanar1("_UVMappingPlanar1", Float) = 0.0
-        [HideInInspector] _UVMappingPlanar2("_UVMappingPlanar2", Float) = 0.0
-        [HideInInspector] _UVMappingPlanar3("_UVMappingPlanar3", Float) = 0.0        
+        [HideInInspector] _UVMappingMask3("_UVMappingMask3", Color) = (1, 0, 0, 0)     
 
         [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail0("UV Set for detail0", Float) = 0
         [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail1("UV Set for detail1", Float) = 0
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
-    #pragma shader_feature _ _DOUBLESIDED _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
+    #pragma shader_feature _DOUBLESIDED_ON
+    #pragma shader_feature _PER_PIXEL_DISPLACEMENT
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_BLENDMASK
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR0
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR1
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR2
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR3
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR_BLENDMASK _LAYER_MAPPING_TRIPLANAR_BLENDMASK
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR0 _LAYER_MAPPING_TRIPLANAR0
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR1 _LAYER_MAPPING_TRIPLANAR1
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR2 _LAYER_MAPPING_TRIPLANAR2
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR3 _LAYER_MAPPING_TRIPLANAR3
-    #pragma shader_feature _PER_PIXEL_DISPLACEMENT
     #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3
     #pragma shader_feature _EMISSIVE_COLOR
 
     //-------------------------------------------------------------------------------------
 
     #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
+    // Use surface gradient normal mapping as it handle correctly triplanar normal mapping and multiple UVSet
+    #define SURFACE_GRADIENT
 
     //-------------------------------------------------------------------------------------
     // Include
             Name "GBuffer"  // Name is not used
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
-            Cull  [_CullMode]
+            Cull [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
-            #include "../../Material/Material.hlsl"            
-            #include "../Lit/ShaderPass/LitSharePass.hlsl"    
+            #include "../../Material/Material.hlsl"
+            #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "../Lit/LitData.hlsl"
             #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
 
             Name "GBufferDebugLighting"  // Name is not used
             Tags{ "LightMode" = "GBufferDebugLighting" } // This will be only for opaque object based on the RenderQueue index
 
-            Cull[_CullMode]
+            Cull [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
 
             HLSLPROGRAM
 

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

         
         [ToggleOff]  _ObjectScaleAffectTile("_ObjectScaleAffectTile", Float) = 0.0
         [Enum(UV0, 0, Planar, 4, Triplanar, 5)] _UVBlendMask("UV Set for blendMask", Float) = 0
-        [HideInInspector] _UVMappingPlanarBlendMask("_UVMappingPlanarBlendMask", Float) = 0.0
         _TexWorldScaleBlendMask("Tiling", Float) = 1.0
 
         // Following are builtin properties
 
         _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
 
+        // Stencil state
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilBits.Standard
+
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _BlendMode ("__blendmode", Float) = 0.0
         [HideInInspector] _CullMode("__cullmode", Float) = 2.0
         [HideInInspector] _ZTestMode("_ZTestMode", Int) = 8
 
-        [Enum(None, 0, DoubleSided, 1, DoubleSidedLigthingFlip, 2, DoubleSidedLigthingMirror, 3)] _DoubleSidedMode("Double sided mode", Float) = 0
+        [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
+        [ToggleOff] _DoubleSidedMirrorEnable("Double sided mirror enable", Float) = 1.0
+        [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
+
+        // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
+        // value that exist to identify if the GI emission need to be enabled.
+        // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
+        // TODO: Fix the code in legacy unity so we can customize the beahvior for GI
+        _EmissionColor("Color", Color) = (1, 1, 1)
 
         // WARNING
         // All the following properties that concern the UV mapping are the same as in the Lit shader.
         [HideInInspector] _UVMappingMask0("_UVMappingMask0", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVMappingMask1("_UVMappingMask1", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVMappingMask2("_UVMappingMask2", Color) = (1, 0, 0, 0)
-        [HideInInspector] _UVMappingMask3("_UVMappingMask3", Color) = (1, 0, 0, 0)
-
-        [HideInInspector] _UVMappingPlanar0("_UVMappingPlanar0", Float) = 0.0
-        [HideInInspector] _UVMappingPlanar1("_UVMappingPlanar1", Float) = 0.0
-        [HideInInspector] _UVMappingPlanar2("_UVMappingPlanar2", Float) = 0.0
-        [HideInInspector] _UVMappingPlanar3("_UVMappingPlanar3", Float) = 0.0        
+        [HideInInspector] _UVMappingMask3("_UVMappingMask3", Color) = (1, 0, 0, 0)      
 
         [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail0("UV Set for detail0", Float) = 0
         [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail1("UV Set for detail1", Float) = 0
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
-    #pragma shader_feature _ _DOUBLESIDED _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
+    #pragma shader_feature _DOUBLESIDED_ON
+    #pragma shader_feature _PER_PIXEL_DISPLACEMENT
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_BLENDMASK
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR0
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR1
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR2
-    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR3
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR_BLENDMASK _LAYER_MAPPING_TRIPLANAR_BLENDMASK
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR0 _LAYER_MAPPING_TRIPLANAR0
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR1 _LAYER_MAPPING_TRIPLANAR1
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR2 _LAYER_MAPPING_TRIPLANAR2
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR3 _LAYER_MAPPING_TRIPLANAR3
-    #pragma shader_feature _PER_PIXEL_DISPLACEMENT
     #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3
     #pragma shader_feature _EMISSIVE_COLOR
 
 
     #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl    
     #define TESSELLATION_ON
+    // Use surface gradient normal mapping as it handle correctly triplanar normal mapping and multiple UVSet
+    #define SURFACE_GRADIENT
 
     //-------------------------------------------------------------------------------------
     // Include
             Name "GBuffer"  // Name is not used
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
-            Cull  [_CullMode]
+            Cull [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
 
             HLSLPROGRAM
 
             Name "GBufferDebugLighting"  // Name is not used
             Tags{ "LightMode" = "GBufferDebugLighting" } // This will be only for opaque object based on the RenderQueue index
 
-            Cull[_CullMode]
+            Cull [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
 
             HLSLPROGRAM
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit.meta

 fileFormatVersion: 2
-guid: d6cadd3aaf3ad6641b86e85a0929b245
+guid: 0d05f89ce69203543914d745c388e6bb
 folderAsset: yes
 timeCreated: 1476653183
 licenseType: Pro

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

 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
-    public abstract class BaseLitGUI : ShaderGUI
+    // A Material can be authored from the shader graph or by hand. When written by hand we need to provide an inspector.
+    // Such a Material will share some properties between it various variant (shader graph variant or hand authored variant).
+    // This is the purpose of BaseLitGUI. It contain all properties that are common to all Material based on Lit template.
+    // For the default hand written Lit material see LitUI.cs that contain specific properties for our default implementation.
+    public abstract class BaseLitGUI : BaseUnlitGUI
-        protected static class Styles
+        protected static class StylesBaseLit
-            public static string optionText = "Surface options";
-            public static string surfaceTypeText = "Surface Type";
-            public static string blendModeText = "Blend Mode";
-            public static string detailText = "Inputs Detail";
-            public static string textureControlText = "Input textures control";
-            public static string lightingText = "Inputs Lighting";
-
-            public static GUIContent alphaCutoffEnableText = new GUIContent("Alpha Cutoff Enable", "Threshold for alpha cutoff");
-            public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
-            public static GUIContent doubleSidedModeText = new GUIContent("Double Sided", "This will render the two face of the objects (disable backface culling)");
-            public static GUIContent distortionEnableText = new GUIContent("Distortion", "Enable distortion on this shader");
-            public static GUIContent distortionOnlyText = new GUIContent("Distortion Only", "This shader will only be use to render distortion");
-            public static GUIContent distortionDepthTestText = new GUIContent("Distortion Depth Test", "Enable the depth test for distortion");
+            public static GUIContent doubleSidedMirrorEnableText = new GUIContent("Mirror normal", "This will mirror the normal with vertex normal plane if enabled, else flip the normal");
-            public static GUIContent horizonFadeText = new GUIContent("Horizon Fade (Spec occlusion)", "horizon fade is use to control specular occlusion");            
-            public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
-            public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
+            // Material ID
+            public static GUIContent materialIDText = new GUIContent("Material type", "Subsurface Scattering: enable for translucent materials such as skin, vegetation, fruit, marble, wax and milk.");
-            public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel");
-            public static GUIContent UVBaseMappingText = new GUIContent("Base UV mapping", "");
-            public static GUIContent texWorldScaleText = new GUIContent("World scale", "Tiling factor applied to Planar/Trilinear mapping");
-            public static GUIContent normalMapSpaceText = new GUIContent("Normal/Tangent Map space", "");
+            // Per pixel displacement
-            public static GUIContent ppdMinSamplesText = new GUIContent("Minimum samples", "Minimun samples to use with per pixel displacement mapping");
-            public static GUIContent ppdMaxSamplesText = new GUIContent("Maximum samples", "Maximum samples to use with per pxiel displacement mapping");
+            public static GUIContent ppdMinSamplesText = new GUIContent("Minimum samples", "Minimum samples to use with per pixel displacement mapping");
+            public static GUIContent ppdMaxSamplesText = new GUIContent("Maximum samples", "Maximum samples to use with per pixel displacement mapping");
-            public static GUIContent detailMapModeText = new GUIContent("Detail Map with Normal", "Detail Map with AO / Height");
-            public static GUIContent UVDetailMappingText = new GUIContent("Detail UV mapping", "");
-            public static GUIContent emissiveColorModeText = new GUIContent("Emissive Color Usage", "Use emissive color or emissive mask");
-
-            public static string InputsText = "Inputs";
-
-            public static string InputsMapText = "";
-
-            public static GUIContent baseColorText = new GUIContent("Base Color + Opacity", "Albedo (RGB) and Opacity (A)");
-            public static GUIContent baseColorSmoothnessText = new GUIContent("Base Color + Smoothness", "Albedo (RGB) and Smoothness (A)");
-
-            public static GUIContent metallicText = new GUIContent("Metallic", "Metallic scale factor");
-            public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness scale factor");
-            public static GUIContent maskMapESText = new GUIContent("Mask Map - M(R), AO(G), E(B), S(A)", "Mask map");
-            public static GUIContent maskMapSText = new GUIContent("Mask Map - M(R), AO(G), S(A)", "Mask map");
-
-            public static GUIContent specularOcclusionMapText = new GUIContent("Specular Occlusion Map (RGBA)", "Specular Occlusion Map");
-
-            public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (DXT5) - Need to implement BC5");
- 
-            public static GUIContent heightMapText = new GUIContent("Height Map (R)", "Height Map");
-            public static GUIContent heightMapAmplitudeText = new GUIContent("Height Map Amplitude", "Height Map amplitude in world units.");
-            public static GUIContent heightMapCenterText = new GUIContent("Height Map Center", "Center of the heightmap in the texture (between 0 and 1)");
-
-            public static GUIContent tangentMapText = new GUIContent("Tangent Map", "Tangent Map (BC5) - DXT5 for test");
-            public static GUIContent anisotropyText = new GUIContent("Anisotropy", "Anisotropy scale factor");
-            public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map (B)", "Anisotropy");
-
-            public static GUIContent detailMapNormalText = new GUIContent("Detail Map A(R) Ny(G) S(B) Nx(A)", "Detail Map");
-            public static GUIContent detailMaskText = new GUIContent("Detail Mask (G)", "Mask for detailMap");
-            public static GUIContent detailAlbedoScaleText = new GUIContent("Detail AlbedoScale", "Detail Albedo Scale factor");
-            public static GUIContent detailNormalScaleText = new GUIContent("Detail NormalScale", "Normal Scale factor");
-            public static GUIContent detailSmoothnessScaleText = new GUIContent("Detail SmoothnessScale", "Smoothness Scale factor");
-            public static GUIContent detailHeightScaleText = new GUIContent("Detail HeightScale", "Height Scale factor");
-            public static GUIContent detailAOScaleText = new GUIContent("Detail AOScale", "AO Scale factor");
-
-            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
-            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
-
-            public static GUIContent emissiveWarning = new GUIContent("Emissive value is animated but the material has not been configured to support emissive. Please make sure the material itself has some amount of emissive.");
-            public static GUIContent emissiveColorWarning = new GUIContent("Ensure emissive color is non-black for emission to have effect.");
-
+            // Tessellation
             public static string tessellationModeText = "Tessellation Mode";
             public static readonly string[] tessellationModeNames = Enum.GetNames(typeof(TessellationMode));
 
             public static GUIContent tessellationFactorTriangleSizeText = new GUIContent("Triangle size", "Desired screen space sized of triangle (in pixel). Smaller value mean smaller triangle.");
             public static GUIContent tessellationShapeFactorText = new GUIContent("Shape factor", "Strength of Phong tessellation shape (lerp factor)");
             public static GUIContent tessellationBackFaceCullEpsilonText = new GUIContent("Triangle culling Epsilon", "If -1.0 back face culling is enabled for tessellation, higher number mean more aggressive culling and better performance");
-            public static GUIContent tessellationObjectScaleText = new GUIContent("Enable object scale", "Tesselation displacement will take into account the object scale - Only work with uniform positive scale");
-
-            public static GUIContent perPixelDisplacementText = new GUIContent("Per pixel displacement", "Per pixel displacement options");
-            
-
-            public static GUIContent materialIDText = new GUIContent("Material type", "Subsurface Scattering: enable for translucent materials such as skin, vegetation, fruit, marble, wax and milk.");
-            public static GUIContent subsurfaceProfileText = new GUIContent("Subsurface profile", "A profile determines the shape of the blur filter.");
-            public static GUIContent subsurfaceRadiusText = new GUIContent("Subsurface radius", "Determines the range of the blur.");
-            public static GUIContent subsurfaceRadiusMapText = new GUIContent("Subsurface radius map", "Determines the range of the blur.");
-            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.");
-        }
-
-        public enum SurfaceType
-        {
-            Opaque,
-            Transparent
-        }
-
-        public enum BlendMode
-        {
-            Lerp,
-            Add,
-            SoftAdd,
-            Multiply,
-            Premultiply
-        }
-
-        public enum DoubleSidedMode
-        {
-            None,
-            DoubleSided,
-            DoubleSidedLightingFlip,
-            DoubleSidedLightingMirror,
+            public static GUIContent tessellationObjectScaleText = new GUIContent("Enable object scale", "Tessellation displacement will take into account the object scale - Only work with uniform positive scale");
         }
 
         public enum TessellationMode
             DisplacementPhong,
         }
 
-        void SurfaceTypePopup()
-        {
-            EditorGUI.showMixedValue = surfaceType.hasMixedValue;
-            var mode = (SurfaceType)surfaceType.floatValue;
+        protected MaterialProperty doubleSidedMirrorEnable = null;
+        protected const string kDoubleSidedMirrorEnable = "_DoubleSidedMirrorEnable";
+        protected MaterialProperty depthOffsetEnable = null;
+        protected const string kDepthOffsetEnable = "_DepthOffsetEnable";
-            EditorGUI.BeginChangeCheck();
-            mode = (SurfaceType)EditorGUILayout.Popup(Styles.surfaceTypeText, (int)mode, Styles.surfaceTypeNames);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
-                surfaceType.floatValue = (float)mode;
-            }
+        // Properties
+        // Material ID
+        protected MaterialProperty materialID = null;
+        protected const string kMaterialID = "_MaterialID";
-            EditorGUI.showMixedValue = false;
-        }
+        // Per pixel displacement params
+        protected MaterialProperty enablePerPixelDisplacement = null;
+        protected const string kEnablePerPixelDisplacement = "_EnablePerPixelDisplacement";
+        protected MaterialProperty ppdMinSamples = null;
+        protected const string kPpdMinSamples = "_PPDMinSamples";
+        protected MaterialProperty ppdMaxSamples = null;
+        protected const string kPpdMaxSamples = "_PPDMaxSamples";
+        protected MaterialProperty ppdLodThreshold = null;
+        protected const string kPpdLodThreshold = "_PPDLodThreshold";
+
+        // tessellation params
+        protected MaterialProperty tessellationMode = null;
+        protected const string kTessellationMode = "_TessellationMode";
+        protected MaterialProperty tessellationFactor = null;
+        protected const string kTessellationFactor = "_TessellationFactor";
+        protected MaterialProperty tessellationFactorMinDistance = null;
+        protected const string kTessellationFactorMinDistance = "_TessellationFactorMinDistance";
+        protected MaterialProperty tessellationFactorMaxDistance = null;
+        protected const string kTessellationFactorMaxDistance = "_TessellationFactorMaxDistance";
+        protected MaterialProperty tessellationFactorTriangleSize = null;
+        protected const string kTessellationFactorTriangleSize = "_TessellationFactorTriangleSize";
+        protected MaterialProperty tessellationShapeFactor = null;
+        protected const string kTessellationShapeFactor = "_TessellationShapeFactor";
+        protected MaterialProperty tessellationBackFaceCullEpsilon = null;
+        protected const string kTessellationBackFaceCullEpsilon = "_TessellationBackFaceCullEpsilon";
+        protected MaterialProperty tessellationObjectScale = null;
+        protected const string kTessellationObjectScale = "_TessellationObjectScale";
-        private void BlendModePopup()
+        protected override void FindBaseMaterialProperties(MaterialProperty[] props)
-            EditorGUI.showMixedValue = blendMode.hasMixedValue;
-            var mode = (BlendMode)blendMode.floatValue;
+            base.FindBaseMaterialProperties(props);
+
+            doubleSidedMirrorEnable = FindProperty(kDoubleSidedMirrorEnable, props);
+            depthOffsetEnable = FindProperty(kDepthOffsetEnable, props);
-            EditorGUI.BeginChangeCheck();
-            mode = (BlendMode)EditorGUILayout.Popup(Styles.blendModeText, (int)mode, Styles.blendModeNames);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
-                blendMode.floatValue = (float)mode;
-            }
+            // MaterialID
+            materialID = FindProperty(kMaterialID, props, false);
+
+            // Per pixel displacement
+            enablePerPixelDisplacement = FindProperty(kEnablePerPixelDisplacement, props);
+            ppdMinSamples = FindProperty(kPpdMinSamples, props);
+            ppdMaxSamples = FindProperty(kPpdMaxSamples, props);
+            ppdLodThreshold = FindProperty(kPpdLodThreshold, props);
-            EditorGUI.showMixedValue = false;
+            // tessellation specific, silent if not found
+            tessellationMode = FindProperty(kTessellationMode, props, false);
+            tessellationFactor = FindProperty(kTessellationFactor, props, false);
+            tessellationFactorMinDistance = FindProperty(kTessellationFactorMinDistance, props, false);
+            tessellationFactorMaxDistance = FindProperty(kTessellationFactorMaxDistance, props, false);
+            tessellationFactorTriangleSize = FindProperty(kTessellationFactorTriangleSize, props, false);
+            tessellationShapeFactor = FindProperty(kTessellationShapeFactor, props, false);
+            tessellationBackFaceCullEpsilon = FindProperty(kTessellationBackFaceCullEpsilon, props, false);
+            tessellationObjectScale = FindProperty(kTessellationObjectScale, props, false);
         }
 
         void TessellationModePopup()
 
             EditorGUI.BeginChangeCheck();
-            mode = (TessellationMode)EditorGUILayout.Popup(Styles.tessellationModeText, (int)mode, Styles.tessellationModeNames);
+            mode = (TessellationMode)EditorGUILayout.Popup(StylesBaseLit.tessellationModeText, (int)mode, StylesBaseLit.tessellationModeNames);
             if (EditorGUI.EndChangeCheck())
             {
                 m_MaterialEditor.RegisterPropertyChangeUndo("Tessellation Mode");
             EditorGUI.showMixedValue = false;
         }
 
-        protected void ShaderOptionsGUI()
+        protected override void BaseMaterialPropertiesGUI()
-            EditorGUI.indentLevel++;
-            GUILayout.Label(Styles.optionText, EditorStyles.boldLabel);
-            SurfaceTypePopup();
-            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
-            {
-                BlendModePopup();
-                m_MaterialEditor.ShaderProperty(distortionEnable, Styles.distortionEnableText.text);
+            base.BaseMaterialPropertiesGUI();
-                if (distortionEnable.floatValue == 1.0)
-                {
-                    m_MaterialEditor.ShaderProperty(distortionOnly, Styles.distortionOnlyText.text);
-                    m_MaterialEditor.ShaderProperty(distortionDepthTest, Styles.distortionDepthTestText.text);
-                }
-            }
-            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, Styles.alphaCutoffEnableText.text);
-            if (alphaCutoffEnable.floatValue == 1.0)
+            // This follow double sided option
+            if (doubleSidedEnable.floatValue > 0.0f)
-                m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(doubleSidedMirrorEnable, StylesBaseLit.doubleSidedMirrorEnableText);
+                EditorGUI.indentLevel--;
-            m_MaterialEditor.ShaderProperty(doubleSidedMode, Styles.doubleSidedModeText.text);
-            m_MaterialEditor.ShaderProperty(enablePerPixelDisplacement, Styles.enablePerPixelDisplacementText);
-            if (enablePerPixelDisplacement.floatValue > 0.0)
+            if (materialID != null)
+                m_MaterialEditor.ShaderProperty(materialID, StylesBaseLit.materialIDText);
+
+            m_MaterialEditor.ShaderProperty(enablePerPixelDisplacement, StylesBaseLit.enablePerPixelDisplacementText);
+            if (enablePerPixelDisplacement.floatValue > 0.0f)
-                m_MaterialEditor.ShaderProperty(ppdMinSamples, Styles.ppdMinSamplesText);
-                m_MaterialEditor.ShaderProperty(ppdMaxSamples, Styles.ppdMaxSamplesText);
+                m_MaterialEditor.ShaderProperty(ppdMinSamples, StylesBaseLit.ppdMinSamplesText);
+                m_MaterialEditor.ShaderProperty(ppdMaxSamples, StylesBaseLit.ppdMaxSamplesText);
-                m_MaterialEditor.ShaderProperty(ppdLodThreshold, Styles.ppdLodThresholdText);
-                m_MaterialEditor.ShaderProperty(depthOffsetEnable, Styles.depthOffsetEnableText.text);
+                m_MaterialEditor.ShaderProperty(ppdLodThreshold, StylesBaseLit.ppdLodThresholdText);
+                m_MaterialEditor.ShaderProperty(depthOffsetEnable, StylesBaseLit.depthOffsetEnableText);
-
-            m_MaterialEditor.ShaderProperty(horizonFade, Styles.horizonFadeText);
+            // Display tessellation option if it exist
-                GUILayout.Label(Styles.tessellationText, EditorStyles.boldLabel);
+                GUILayout.Label(StylesBaseLit.tessellationText, EditorStyles.boldLabel);
-                m_MaterialEditor.ShaderProperty(tessellationFactor, Styles.tessellationFactorText);
-                m_MaterialEditor.ShaderProperty(tessellationFactorMinDistance, Styles.tessellationFactorMinDistanceText);
-                m_MaterialEditor.ShaderProperty(tessellationFactorMaxDistance, Styles.tessellationFactorMaxDistanceText);
+                m_MaterialEditor.ShaderProperty(tessellationFactor, StylesBaseLit.tessellationFactorText);
+                m_MaterialEditor.ShaderProperty(tessellationFactorMinDistance, StylesBaseLit.tessellationFactorMinDistanceText);
+                m_MaterialEditor.ShaderProperty(tessellationFactorMaxDistance, StylesBaseLit.tessellationFactorMaxDistanceText);
-                m_MaterialEditor.ShaderProperty(tessellationFactorTriangleSize, Styles.tessellationFactorTriangleSizeText);
+                m_MaterialEditor.ShaderProperty(tessellationFactorTriangleSize, StylesBaseLit.tessellationFactorTriangleSizeText);
-                    m_MaterialEditor.ShaderProperty(tessellationShapeFactor, Styles.tessellationShapeFactorText);
+                    m_MaterialEditor.ShaderProperty(tessellationShapeFactor, StylesBaseLit.tessellationShapeFactorText);
-                if ((DoubleSidedMode)doubleSidedMode.floatValue == DoubleSidedMode.None)
+                if (doubleSidedEnable.floatValue == 0.0)
-                    m_MaterialEditor.ShaderProperty(tessellationBackFaceCullEpsilon, Styles.tessellationBackFaceCullEpsilonText);
+                    m_MaterialEditor.ShaderProperty(tessellationBackFaceCullEpsilon, StylesBaseLit.tessellationBackFaceCullEpsilonText);
-                m_MaterialEditor.ShaderProperty(tessellationObjectScale, Styles.tessellationObjectScaleText);
+                m_MaterialEditor.ShaderProperty(tessellationObjectScale, StylesBaseLit.tessellationObjectScaleText);
-        protected void FindCommonOptionProperties(MaterialProperty[] props)
+        // All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if ocde change
+        static public void SetupBaseLitKeywords(Material material)
-            surfaceType = FindProperty(kSurfaceType, props);
-            blendMode = FindProperty(kBlendMode, props);
-            alphaCutoff = FindProperty(kAlphaCutoff, props);
-            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
-            doubleSidedMode = FindProperty(kDoubleSidedMode, props);
-            distortionEnable = FindProperty(kDistortionEnable, props);
-            distortionOnly = FindProperty(kDistortionOnly, props);
-            distortionDepthTest = FindProperty(kDistortionDepthTest, props);
-            depthOffsetEnable = FindProperty(kDepthOffsetEnable, props);
-            horizonFade = FindProperty(kHorizonFade, props);
+            SetupBaseUnlitKeywords(material);
-            // tessellation specific, silent if not found
-            tessellationMode = FindProperty(kTessellationMode, props, false);
-            tessellationFactor = FindProperty(kTessellationFactor, props, false);
-            tessellationFactorMinDistance = FindProperty(kTessellationFactorMinDistance, props, false);
-            tessellationFactorMaxDistance = FindProperty(kTessellationFactorMaxDistance, props, false);
-            tessellationFactorTriangleSize = FindProperty(kTessellationFactorTriangleSize, props, false);
-            tessellationShapeFactor = FindProperty(kTessellationShapeFactor, props, false);
-            tessellationBackFaceCullEpsilon = FindProperty(kTessellationBackFaceCullEpsilon, props, false);
-            tessellationObjectScale = FindProperty(kTessellationObjectScale, props, false);
+            bool doubleSidedEnable = material.GetFloat(kDoubleSidedEnable) > 0.0f;
+            bool doubleSidedMirrorEnable = material.GetFloat(kDoubleSidedMirrorEnable) > 0.0f;
-            // Per pixel displacement
-            enablePerPixelDisplacement = FindProperty(kEnablePerPixelDisplacement, props);
-            ppdMinSamples = FindProperty(kPpdMinSamples, props);
-            ppdMaxSamples = FindProperty(kPpdMaxSamples, props);
-            ppdLodThreshold = FindProperty(kPpdLodThreshold, props);
-        }
+            if (doubleSidedEnable)
+            {
+                if (doubleSidedMirrorEnable)
+                {
+                    // Mirror mode (in tangent space)
+                    material.SetVector("_DoubleSidedConstants", new Vector4(1.0f, 1.0f, -1.0f, 0.0f));
+                }
+                else
+                {
+                    // Flip mode (in tangent space)
+                    material.SetVector("_DoubleSidedConstants", new Vector4(-1.0f, -1.0f, -1.0f, 0.0f));
+                }
+            }
-        protected void SetupCommonOptionsKeywords(Material material)
-        {
-            bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
-            SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
-            BlendMode blendMode = (BlendMode)material.GetFloat(kBlendMode);
-            DoubleSidedMode doubleSidedMode = (DoubleSidedMode)material.GetFloat(kDoubleSidedMode);
+            bool depthOffsetEnable = material.GetFloat(kDepthOffsetEnable) > 0.0f;
+            SetKeyword(material, "_DEPTHOFFSET_ON", depthOffsetEnable);
-            if (surfaceType == SurfaceType.Opaque)
-            {
-                material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : "");
-                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                material.SetInt("_ZWrite", 1);
-                material.renderQueue = alphaTestEnable ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : -1;
-            }
-            else
+            int stencilRef = (int)UnityEngine.Experimental.Rendering.HDPipeline.StencilBits.Standard; // See 'StencilBits'.
+            if (material.HasProperty(kMaterialID))
-                material.SetOverrideTag("RenderType", "Transparent");
-                material.SetInt("_ZWrite", 0);
-                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                int materialID = (int)material.GetFloat(kMaterialID);
-                switch (blendMode)
+                switch (materialID)
-                    case BlendMode.Lerp:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                   case (int)UnityEngine.Experimental.Rendering.HDPipeline.Lit.MaterialId.LitSSS:
+                        stencilRef = (int)UnityEngine.Experimental.Rendering.HDPipeline.StencilBits.SSS;
-
-                    case BlendMode.Add:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        break;
-
-                    case BlendMode.SoftAdd:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        break;
-
-                    case BlendMode.Multiply:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                    case (int)UnityEngine.Experimental.Rendering.HDPipeline.Lit.MaterialId.LitStandard:
+                        stencilRef = (int)UnityEngine.Experimental.Rendering.HDPipeline.StencilBits.Standard;
-
-                    case BlendMode.Premultiply:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                    default:
+                        stencilRef = 1 + materialID;
-
-            if (doubleSidedMode == DoubleSidedMode.None)
-            {
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back);
-            }
-            else
-            {
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Off);
-            }
-
-            if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingFlip)
-            {
-
-                material.DisableKeyword("_DOUBLESIDED");
-                material.EnableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-            else if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingMirror)
-            {
-                material.DisableKeyword("_DOUBLESIDED");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.EnableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-            else if (doubleSidedMode == DoubleSidedMode.DoubleSided)
-            {
-                material.EnableKeyword("_DOUBLESIDED");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-            else
-            {
-                material.DisableKeyword("_DOUBLESIDED");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-
-            SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
-
-            bool distortionEnable = material.GetFloat(kDistortionEnable) == 1.0;
-            bool distortionOnly = material.GetFloat(kDistortionOnly) == 1.0;
-            bool distortionDepthTest = material.GetFloat(kDistortionDepthTest) == 1.0;
-            bool depthOffsetEnable = material.GetFloat(kDepthOffsetEnable) == 1.0;
-
-            if (distortionEnable)
-            {
-                material.SetShaderPassEnabled("DistortionVectors", true);
-            }
-            else
-            {
-                material.SetShaderPassEnabled("DistortionVectors", false);
-            }
-
-            if (distortionEnable && distortionOnly)
-            {
-                // Disable all passes except dbug material
-                material.SetShaderPassEnabled("GBuffer", false);
-                material.SetShaderPassEnabled("DebugViewMaterial", true);
-                material.SetShaderPassEnabled("Meta", false);
-                material.SetShaderPassEnabled("ShadowCaster", false);
-                material.SetShaderPassEnabled("DepthOnly", false);
-                material.SetShaderPassEnabled("MotionVectors", false);
-                material.SetShaderPassEnabled("Forward", false); 
-            }
-            else
-            {
-                material.SetShaderPassEnabled("GBuffer", true);
-                material.SetShaderPassEnabled("DebugViewMaterial", true);
-                material.SetShaderPassEnabled("Meta", true);
-                material.SetShaderPassEnabled("ShadowCaster", true);
-                material.SetShaderPassEnabled("DepthOnly", true);
-                material.SetShaderPassEnabled("MotionVectors", true);
-                material.SetShaderPassEnabled("Forward", true);
-            }
-
-            if (distortionDepthTest)
-            {
-                material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.LessEqual);
-            }
-            else
-            {
-                material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.Always);
-            }         
-
-            SetKeyword(material, "_DISTORTION_ON", distortionEnable);
-            SetKeyword(material, "_DEPTHOFFSET_ON", depthOffsetEnable);
+            material.SetInt("_StencilRef", stencilRef);
-            SetupEmissionGIFlags(material);
+            bool enablePerPixelDisplacement = material.GetFloat(kEnablePerPixelDisplacement) > 0.0f;
+            SetKeyword(material, "_PER_PIXEL_DISPLACEMENT", enablePerPixelDisplacement);
-            if (tessellationMode != null)
+            if (material.HasProperty(kTessellationMode))
             {
                 TessellationMode tessMode = (TessellationMode)material.GetFloat(kTessellationMode);
 
             }
         }
 
-        protected void SetKeyword(Material m, string keyword, bool state)
+        static public void SetupBaseLitMaterialPass(Material material)
-            if (state)
-                m.EnableKeyword(keyword);
-            else
-                m.DisableKeyword(keyword);
-        }
+            bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
+            bool distortionOnly = material.GetFloat(kDistortionOnly) > 0.0f;
-        public void ShaderPropertiesGUI(Material material)
-        {
-            // Use default labelWidth
-            EditorGUIUtility.labelWidth = 0f;
-
-            // Detect any changes to the material
-            EditorGUI.BeginChangeCheck();
+            if (distortionEnable && distortionOnly)
-                ShaderOptionsGUI();
-                EditorGUILayout.Space();
-
-                EditorGUILayout.Space();
-                ShaderInputGUI();
+                // Disable all passes except debug material
+                material.SetShaderPassEnabled("GBuffer", false);
+                material.SetShaderPassEnabled("DebugViewMaterial", true);
+                material.SetShaderPassEnabled("Meta", false);
+                material.SetShaderPassEnabled("ShadowCaster", false);
+                material.SetShaderPassEnabled("DepthOnly", false);
+                material.SetShaderPassEnabled("MotionVectors", false);
+                material.SetShaderPassEnabled("Forward", false);
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                foreach (var obj in m_MaterialEditor.targets)
-                    SetupMaterialKeywords((Material)obj);
-            }
-        }
-
-        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
-        {
-            FindCommonOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
-			FindMaterialProperties(props);
-
-            m_MaterialEditor = materialEditor;
-            Material material = materialEditor.target as Material;
-            ShaderPropertiesGUI(material);
-        }
-
-        // TODO: ? or remove
-        bool HasValidEmissiveKeyword(Material material)
-        {
-            /*
-            // Material animation might be out of sync with the material keyword.
-            // So if the emission support is disabled on the material, but the property blocks have a value that requires it, then we need to show a warning.
-            // (note: (Renderer MaterialPropertyBlock applies its values to emissionColorForRendering))
-            bool hasEmissionKeyword = material.IsKeywordEnabled ("_EMISSION");
-            if (!hasEmissionKeyword && ShouldEmissionBeEnabled (material, emissionColorForRendering.colorValue))
-                return false;
-                return true;
-            */
-
-            return true;
-        }
-
-        protected virtual void SetupEmissionGIFlags(Material material)
-        {
-            // Setup lightmap emissive flags
-            MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
-            if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
-                if (ShouldEmissionBeEnabled(material))
-                    flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
-                else
-                    flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
-
-                material.globalIlluminationFlags = flags;
+                material.SetShaderPassEnabled("GBuffer", true);
+                material.SetShaderPassEnabled("DebugViewMaterial", true);
+                material.SetShaderPassEnabled("Meta", true);
+                material.SetShaderPassEnabled("ShadowCaster", true);
+                material.SetShaderPassEnabled("DepthOnly", true);
+                material.SetShaderPassEnabled("MotionVectors", true);
+                material.SetShaderPassEnabled("Forward", true);
-
-        protected MaterialEditor m_MaterialEditor;
-
-        MaterialProperty surfaceType = null;
-        const string kSurfaceType = "_SurfaceType";
-        MaterialProperty alphaCutoffEnable = null;
-        const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
-        MaterialProperty blendMode = null;
-        const string kBlendMode = "_BlendMode";
-        MaterialProperty alphaCutoff = null;
-        const string kAlphaCutoff = "_AlphaCutoff";
-        MaterialProperty doubleSidedMode = null;
-        const string kDoubleSidedMode = "_DoubleSidedMode";
-        MaterialProperty distortionEnable = null;
-        const string kDistortionEnable = "_DistortionEnable";
-        MaterialProperty distortionOnly = null;
-        const string kDistortionOnly = "_DistortionOnly";
-        MaterialProperty distortionDepthTest = null;
-        const string kDistortionDepthTest = "_DistortionDepthTest";
-        MaterialProperty depthOffsetEnable = null;       
-        const string kDepthOffsetEnable = "_DepthOffsetEnable";
-        protected MaterialProperty horizonFade = null;
-        const string kHorizonFade = "_HorizonFade";
-
-        // tessellation params
-        protected MaterialProperty tessellationMode = null;
-        const string kTessellationMode = "_TessellationMode";
-        MaterialProperty tessellationFactor = null;
-        const string kTessellationFactor = "_TessellationFactor";
-        MaterialProperty tessellationFactorMinDistance = null;
-        const string kTessellationFactorMinDistance = "_TessellationFactorMinDistance";
-        MaterialProperty tessellationFactorMaxDistance = null;
-        const string kTessellationFactorMaxDistance = "_TessellationFactorMaxDistance";
-        MaterialProperty tessellationFactorTriangleSize = null;
-        const string kTessellationFactorTriangleSize = "_TessellationFactorTriangleSize";
-        MaterialProperty tessellationShapeFactor = null;
-        const string kTessellationShapeFactor = "_TessellationShapeFactor";
-        MaterialProperty tessellationBackFaceCullEpsilon = null;
-        const string kTessellationBackFaceCullEpsilon = "_TessellationBackFaceCullEpsilon";
-        MaterialProperty tessellationObjectScale = null;
-        const string kTessellationObjectScale = "_TessellationObjectScale";
-
-        // Per pixel displacement params
-        protected MaterialProperty enablePerPixelDisplacement = null;
-        protected const string kEnablePerPixelDisplacement = "_EnablePerPixelDisplacement";
-        protected MaterialProperty ppdMinSamples = null;
-        protected const string kPpdMinSamples = "_PPDMinSamples";
-        protected MaterialProperty ppdMaxSamples = null;
-        protected const string kPpdMaxSamples = "_PPDMaxSamples";
-        protected MaterialProperty ppdLodThreshold = null;
-        protected const string kPpdLodThreshold = "_PPDLodThreshold";
-
-        protected static string[] reservedProperties = new string[] { kSurfaceType, kBlendMode, kAlphaCutoff, kAlphaCutoffEnabled, kDoubleSidedMode };
-
-        protected abstract void FindMaterialProperties(MaterialProperty[] props);
-		protected abstract void ShaderInputGUI();
-        protected abstract void SetupMaterialKeywords(Material material);
-        protected abstract bool ShouldEmissionBeEnabled(Material material);
     }
 } // namespace UnityEditor

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

 {
     class LitGUI : BaseLitGUI
     {
+        protected static class Styles
+        {
+            public static string InputsText = "Inputs";
+
+            public static GUIContent baseColorText = new GUIContent("Base Color + Opacity", "Albedo (RGB) and Opacity (A)");
+            public static GUIContent baseColorSmoothnessText = new GUIContent("Base Color + Smoothness", "Albedo (RGB) and Smoothness (A)");
+
+            public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel");
+            public static GUIContent metallicText = new GUIContent("Metallic", "Metallic scale factor");
+            public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness scale factor");
+            public static GUIContent maskMapESText = new GUIContent("Mask Map - M(R), AO(G), E(B), S(A)", "Mask map");
+            public static GUIContent maskMapSText = new GUIContent("Mask Map - M(R), AO(G), S(A)", "Mask map");
+
+            public static GUIContent normalMapSpaceText = new GUIContent("Normal/Tangent Map space", "");
+            public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (DXT5) - Need to implement BC5");
+            public static GUIContent specularOcclusionMapText = new GUIContent("Specular Occlusion Map (RGBA)", "Specular Occlusion Map");
+            public static GUIContent horizonFadeText = new GUIContent("Horizon Fade (Spec occlusion)", "horizon fade is use to control specular occlusion");
+
+            public static GUIContent heightMapText = new GUIContent("Height Map (R)", "Height Map");
+            public static GUIContent heightMapAmplitudeText = new GUIContent("Height Map Amplitude", "Height Map amplitude in world units.");
+            public static GUIContent heightMapCenterText = new GUIContent("Height Map Center", "Center of the heightmap in the texture (between 0 and 1)");
+
+            public static GUIContent tangentMapText = new GUIContent("Tangent Map", "Tangent Map (BC5) - DXT5 for test");
+            public static GUIContent anisotropyText = new GUIContent("Anisotropy", "Anisotropy scale factor");
+            public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map (B)", "Anisotropy");
+
+            public static string textureControlText = "Input textures control";
+            public static GUIContent UVBaseMappingText = new GUIContent("Base UV mapping", "");
+            public static GUIContent texWorldScaleText = new GUIContent("World scale", "Tiling factor applied to Planar/Trilinear mapping");
+
+            // Details
+            public static string detailText = "Inputs Detail";
+            public static GUIContent detailMapModeText = new GUIContent("Detail Map with Normal", "Detail Map with AO / Height");
+            public static GUIContent UVDetailMappingText = new GUIContent("Detail UV mapping", "");
+            public static GUIContent detailMapNormalText = new GUIContent("Detail Map A(R) Ny(G) S(B) Nx(A)", "Detail Map");
+            public static GUIContent detailMaskText = new GUIContent("Detail Mask (G)", "Mask for detailMap");
+            public static GUIContent detailAlbedoScaleText = new GUIContent("Detail AlbedoScale", "Detail Albedo Scale factor");
+            public static GUIContent detailNormalScaleText = new GUIContent("Detail NormalScale", "Normal Scale factor");
+            public static GUIContent detailSmoothnessScaleText = new GUIContent("Detail SmoothnessScale", "Smoothness Scale factor");
+
+            // Subsurface
+            public static GUIContent subsurfaceProfileText = new GUIContent("Subsurface profile", "A profile determines the shape of the blur filter.");
+            public static GUIContent subsurfaceRadiusText = new GUIContent("Subsurface radius", "Determines the range of the blur.");
+            public static GUIContent subsurfaceRadiusMapText = new GUIContent("Subsurface radius map", "Determines the range of the blur.");
+            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.");
+
+            // Emissive
+            public static string lightingText = "Inputs Lighting";
+            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
+            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
+            public static GUIContent emissiveColorModeText = new GUIContent("Emissive Color Usage", "Use emissive color or emissive mask");
+
+            public static GUIContent normalMapSpaceWarning = new GUIContent("Object space normal can't be use with triplanar mapping.");            
+        }
+
         public enum UVBaseMapping
         {
             UV0,
         protected const string kTexWorldScale = "_TexWorldScale";
         protected MaterialProperty UVMappingMask = null;
         protected const string kUVMappingMask = "_UVMappingMask";
-        protected MaterialProperty UVMappingPlanar = null;
-        protected const string kUVMappingPlanar = "_UVMappingPlanar";      
-        protected MaterialProperty normalMapSpace = null;
-        protected const string kNormalMapSpace = "_NormalMapSpace";
-        protected MaterialProperty UVDetail = null;
-        protected const string kUVDetail = "_UVDetail";
-        protected MaterialProperty UVDetailsMappingMask = null;
-        protected const string kUVDetailsMappingMask = "_UVDetailsMappingMask";
-        protected MaterialProperty emissiveColorMode = null;
-        protected const string kEmissiveColorMode = "_EmissiveColorMode";
 
         protected MaterialProperty baseColor = null;
         protected const string kBaseColor = "_BaseColor";
         protected const string kMaskMap = "_MaskMap";
         protected MaterialProperty specularOcclusionMap = null;
         protected const string kSpecularOcclusionMap = "_SpecularOcclusionMap";
+        protected MaterialProperty horizonFade = null;
+        protected const string kHorizonFade = "_HorizonFade";
+        protected MaterialProperty normalMapSpace = null;
+        protected const string kNormalMapSpace = "_NormalMapSpace";
         protected MaterialProperty heightMap = null;
         protected const string kHeightMap = "_HeightMap";
         protected MaterialProperty heightAmplitude = null;
         protected MaterialProperty anisotropyMap = null;
         protected const string kAnisotropyMap = "_AnisotropyMap";
 
+        protected MaterialProperty UVDetail = null;
+        protected const string kUVDetail = "_UVDetail";
+        protected MaterialProperty UVDetailsMappingMask = null;
+        protected const string kUVDetailsMappingMask = "_UVDetailsMappingMask";
         protected MaterialProperty detailMap = null;
         protected const string kDetailMap = "_DetailMap";
         protected MaterialProperty detailMask = null;
         protected MaterialProperty detailSmoothnessScale = null;
         protected const string kDetailSmoothnessScale = "_DetailSmoothnessScale";
 
-        protected MaterialProperty emissiveColor = null;
-        protected const string kEmissiveColor = "_EmissiveColor";
-        protected MaterialProperty emissiveColorMap = null;
-        protected const string kEmissiveColorMap = "_EmissiveColorMap";
-        protected MaterialProperty emissiveIntensity = null;
-        protected const string kEmissiveIntensity = "_EmissiveIntensity";
-
-        protected MaterialProperty materialID           = null;
-        protected const string     kMaterialID          = "_MaterialID";
         protected MaterialProperty subsurfaceProfile    = null;
         protected const string     kSubsurfaceProfile   = "_SubsurfaceProfile";
         protected MaterialProperty subsurfaceRadius     = null;
         protected MaterialProperty thicknessMap         = null;
         protected const string     kThicknessMap        = "_ThicknessMap";
 
-        override protected void FindMaterialProperties(MaterialProperty[] props)
+        protected MaterialProperty emissiveColorMode = null;
+        protected const string kEmissiveColorMode = "_EmissiveColorMode";
+        protected MaterialProperty emissiveColor = null;
+        protected const string kEmissiveColor = "_EmissiveColor";
+        protected MaterialProperty emissiveColorMap = null;
+        protected const string kEmissiveColorMap = "_EmissiveColorMap";
+        protected MaterialProperty emissiveIntensity = null;
+        protected const string kEmissiveIntensity = "_EmissiveIntensity";
+
+        protected override void FindMaterialProperties(MaterialProperty[] props)
-            normalMapSpace = FindProperty(kNormalMapSpace, props);
-            emissiveColorMode = FindProperty(kEmissiveColorMode, props);
+            UVBase = FindProperty(kUVBase, props);
+            TexWorldScale = FindProperty(kTexWorldScale, props);
+            UVMappingMask = FindProperty(kUVMappingMask, props);
 
             baseColor = FindProperty(kBaseColor, props);
             baseColorMap = FindProperty(kBaseColorMap, props);
             specularOcclusionMap = FindProperty(kSpecularOcclusionMap, props);
+            horizonFade = FindProperty(kHorizonFade, props);
-            normalScale = FindProperty(kNormalScale, props);           
+            normalScale = FindProperty(kNormalScale, props);
+            normalMapSpace = FindProperty(kNormalMapSpace, props);
             heightMap = FindProperty(kHeightMap, props);
             heightAmplitude = FindProperty(kHeightAmplitude, props);
             heightCenter = FindProperty(kHeightCenter, props);
 
-            UVBase = FindProperty(kUVBase, props);
+            // Details
-            TexWorldScale = FindProperty(kTexWorldScale, props);
-            UVMappingMask = FindProperty(kUVMappingMask, props);
-            UVMappingPlanar = FindProperty(kUVMappingPlanar, props);
-            
             detailMap = FindProperty(kDetailMap, props);
             detailMask = FindProperty(kDetailMask, props);
             detailAlbedoScale = FindProperty(kDetailAlbedoScale, props);
+            // Sub surface
+            subsurfaceProfile = FindProperty(kSubsurfaceProfile, props);
+            subsurfaceRadius = FindProperty(kSubsurfaceRadius, props);
+            subsurfaceRadiusMap = FindProperty(kSubsurfaceRadiusMap, props);
+            thickness = FindProperty(kThickness, props);
+            thicknessMap = FindProperty(kThicknessMap, props);
+
+            // Emissive
+            emissiveColorMode = FindProperty(kEmissiveColorMode, props);
-
-            materialID          = FindProperty(kMaterialID,          props);
-            subsurfaceProfile   = FindProperty(kSubsurfaceProfile,   props);
-            subsurfaceRadius    = FindProperty(kSubsurfaceRadius,    props);
-            subsurfaceRadiusMap = FindProperty(kSubsurfaceRadiusMap, props);
-            thickness           = FindProperty(kThickness,           props);
-            thicknessMap        = FindProperty(kThicknessMap,        props);
         }
 
         protected void ShaderSSSInputGUI()
             m_MaterialEditor.TexturePropertySingleLine(Styles.anisotropyMapText, anisotropyMap);
         }
 
-        override protected void ShaderInputGUI()
-        {            
+        protected override void MaterialPropertiesGUI()
+        {
-            m_MaterialEditor.ShaderProperty(materialID, Styles.materialIDText);
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, baseColorMap, baseColor);
             m_MaterialEditor.ShaderProperty(metallic, Styles.metallicText);
                 m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapSText, maskMap);
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.specularOcclusionMapText, specularOcclusionMap);
+            m_MaterialEditor.ShaderProperty(horizonFade, Styles.horizonFadeText);
+
+            // Triplanar only work with tangent space normal
+            if ((NormalMapSpace)normalMapSpace.floatValue == NormalMapSpace.ObjectSpace && ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Triplanar))
+            {
+                EditorGUILayout.HelpBox(Styles.normalMapSpaceWarning.text, MessageType.Error);
+            }            
+
             m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap, normalScale);
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.heightMapText, heightMap);
             GUILayout.Label("    " + Styles.textureControlText, EditorStyles.label);
             m_MaterialEditor.ShaderProperty(UVBase, Styles.UVBaseMappingText);
             // UVSet0 is always set, planar and triplanar will override it.
-            UVMappingMask.colorValue = new Color(1.0f, 0.0f, 0.0f, 0.0f); // This is override in the shader anyway but just in case.
-            UVMappingPlanar.floatValue = ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Planar) ? 1.0f : 0.0f;
+            UVMappingMask.colorValue = new Color(1.0f, 0.0f, 0.0f, 0.0f); // This is override in the shader anyway but just in case.            
             if (((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Planar) || ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Triplanar))
             {
                 m_MaterialEditor.ShaderProperty(TexWorldScale, Styles.texWorldScaleText);
                 GUILayout.Label("       " + Styles.UVDetailMappingText.text + ": Triplanar");
             }
 
-            // IF planar/triplanar is not chose, setup the UVSet chosen
+            // Setup the UVSet for detail, if planar/triplanar is use for base, it will override the mapping of detail (See shader code)
             float X, Y, Z, W;
             X = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV0) ? 1.0f : 0.0f;
             Y = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV1) ? 1.0f : 0.0f;
                 m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
             }
 
-            m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);
-            m_MaterialEditor.LightmapEmissionProperty(MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);            
-            EditorGUI.indentLevel--;
+            m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);             
-            EditorGUILayout.Space();
+            // The parent Base.ShaderPropertiesGUI will call DoEmissionArea
-        public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
+        protected override bool ShouldEmissionBeEnabled(Material mat)
-            base.AssignNewShaderToMaterial(material, oldShader, newShader);
+            return mat.GetFloat(kEmissiveIntensity) > 0.0f;
-        protected override bool ShouldEmissionBeEnabled(Material mat)
+        protected override void SetupMaterialKeywordsAndPassInternal(Material material)
-            float emissiveIntensity = mat.GetFloat(kEmissiveIntensity);
-            var realtimeEmission = (mat.globalIlluminationFlags & MaterialGlobalIlluminationFlags.RealtimeEmissive) > 0;
-            return emissiveIntensity > 0.0f || realtimeEmission;
+            SetupMaterialKeywordsAndPass(material);
-        override protected void SetupMaterialKeywords(Material material)
+        // All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if code change
+        static public void SetupMaterialKeywordsAndPass(Material material)
-			SetupCommonOptionsKeywords(material);
+            SetupBaseLitKeywords(material);
+            SetupBaseLitMaterialPass(material);
+            SetKeyword(material, "_MAPPING_PLANAR", ((UVBaseMapping)material.GetFloat(kUVBase)) == UVBaseMapping.Planar);
-            bool perPixelDisplacement = material.GetFloat(kEnablePerPixelDisplacement) == 1.0;
-            SetKeyword(material, "_PER_PIXEL_DISPLACEMENT", perPixelDisplacement);
-
-			SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap) || material.GetTexture(kDetailMap)); // With details map, we always use a normal map and Unity provide a default (0, 0, 1) normal map for ir
+			
+            SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap) || material.GetTexture(kDetailMap)); // With details map, we always use a normal map and Unity provide a default (0, 0, 1) normal map for ir
 			SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap));
 			SetKeyword(material, "_SPECULAROCCLUSIONMAP", material.GetTexture(kSpecularOcclusionMap));
 			SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
 			SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
             SetKeyword(material, "_SUBSURFACE_RADIUS_MAP", material.GetTexture(kSubsurfaceRadiusMap));
             SetKeyword(material, "_THICKNESS_MAP", material.GetTexture(kThicknessMap));
-
 
             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;
                 material.DisableKeyword("_REQUIRE_UV2");
                 material.DisableKeyword("_REQUIRE_UV3");
             }
-
-            material.SetInt("_StencilRef", (int)material.GetFloat(kMaterialID)); // See 'StencilBits'.
          }
     }
 } // namespace UnityEditor

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

             // fold into fresnel0
 
             // SSS
-            public float subsurfaceRadius;
-            public float thickness;
-            public int   subsurfaceProfile;
+            public float   subsurfaceRadius;
+            public float   thickness;
+            public int     subsurfaceProfile;
+            public bool    enableTransmission;
+            public Vector3 transmittance;
 
             // Clearcoat
             public Vector3 coatNormalWS;

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

 #define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS (1042)
 #define DEBUGVIEW_LIT_BSDFDATA_THICKNESS (1043)
 #define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE (1044)
-#define DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS (1045)
-#define DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS (1046)
+#define DEBUGVIEW_LIT_BSDFDATA_ENABLE_TRANSMITTANCE (1045)
+#define DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE (1046)
+#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;
+	bool enableTransmission;
+	float3 transmittance;
 	float3 coatNormalWS;
 	float coatRoughness;
 };

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

 #define LTC_DISNEY_DIFFUSE_MATRIX_INDEX 1 // RGBA
 #define LTC_MULTI_GGX_FRESNEL_DISNEY_DIFFUSE_INDEX 2 // RGB, A unused
 
+// SSS parameters
+#define N_PROFILES 8
+uint   _TransmissionFlags;                             // One bit per profile; 1 = enabled
+float  _ThicknessRemaps[N_PROFILES][2];                // Remap: 0 = start, 1 = end - start
+float4 _HalfRcpVariancesAndLerpWeights[N_PROFILES][2]; // 2x Gaussians per color channel, A is the the associated interpolation weight
+
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
 //-----------------------------------------------------------------------------
 
 #endif
 }
+
+// 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).
+float3 ComputeTransmittance(float3 halfRcpVariance1, float lerpWeight1,
+                            float3 halfRcpVariance2, float lerpWeight2,
+                            float thickness, float radiusScale)
+{
+
+    // 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 *= 100;
+
+    float t2 = thickness * thickness;
+
+    // TODO: 6 exponentials is kind of expensive... Should we use a LUT instead?
+    // lerp(exp(-t2 * halfRcpVariance1), exp(-t2 * halfRcpVariance2), lerpWeight2)
+    return exp(-t2 * halfRcpVariance1) * lerpWeight1 + exp(-t2 * halfRcpVariance2) * lerpWeight2;
+}
+
 //-----------------------------------------------------------------------------
 // conversion function for forward
 //-----------------------------------------------------------------------------
     {
         bsdfData.diffuseColor = surfaceData.baseColor;
         bsdfData.fresnel0 = 0.028; // TODO take from subsurfaceProfile
-        bsdfData.subsurfaceRadius = surfaceData.subsurfaceRadius;
-        bsdfData.thickness = surfaceData.thickness;
+        bsdfData.subsurfaceRadius  = 0.01 * surfaceData.subsurfaceRadius;
+        bsdfData.thickness         = 0.01 * (_ThicknessRemaps[bsdfData.subsurfaceProfile][0] +
+                                             _ThicknessRemaps[bsdfData.subsurfaceProfile][1] * surfaceData.thickness);
+        bsdfData.enableTransmission = (1 << bsdfData.subsurfaceProfile) & _TransmissionFlags;
+        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,
+                                                          bsdfData.thickness, bsdfData.subsurfaceRadius);
+        }
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
     {
         bsdfData.diffuseColor = baseColor;
         bsdfData.fresnel0 = 0.028; // TODO take from subsurfaceProfile
-        bsdfData.subsurfaceRadius = inGBuffer2.r;
-        bsdfData.thickness = inGBuffer2.g;
-        bsdfData.subsurfaceProfile = inGBuffer2.a * 8.0;
+        bsdfData.subsurfaceProfile = 8.00 * inGBuffer2.a;
+        bsdfData.subsurfaceRadius  = 0.01 * inGBuffer2.r;
+        bsdfData.thickness         = 0.01 * (_ThicknessRemaps[bsdfData.subsurfaceProfile][0] +
+                                             _ThicknessRemaps[bsdfData.subsurfaceProfile][1] * inGBuffer2.g);
+        bsdfData.enableTransmission = (1 << bsdfData.subsurfaceProfile) & _TransmissionFlags;
+        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,
+                                                          bsdfData.thickness, bsdfData.subsurfaceRadius);
+        }
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
 #ifdef HAS_LIGHTLOOP
 
 //-----------------------------------------------------------------------------
-// BSDF share between directional light, punctual light and area light (reference) 
+// BSDF share between directional light, punctual light and area light (reference)
 //-----------------------------------------------------------------------------
 
 void BSDF(  float3 V, float3 L, float3 positionWS, PreLightData preLightData, BSDFData bsdfData,
     float3 L = -lightData.forward; // Lights are pointing backward in Unity
     float illuminance = saturate(dot(bsdfData.normalWS, L));
 
-    diffuseLighting    = float3(0.0, 0.0, 0.0);
-    specularLighting   = float3(0.0, 0.0, 0.0);
-    float3 cookieColor = float3(1.0, 1.0, 1.0);
+    diffuseLighting  = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+    float4 cookie    = float4(1.0, 1.0, 1.0, 1.0);
-        float shadowAttenuation = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
+#ifdef SHADOWS_USE_SHADOWCTXT
+		float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
+#else
+        float shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
+#endif
-        illuminance *= shadowAttenuation;
+        illuminance *= shadow;
     }
 
     [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
         coord = coord * 0.5 + 0.5;
 
         // Tile the texture if the 'repeat' wrap mode is enabled.
-        if (lightData.tileCookie) 
+        if (lightData.tileCookie)
-        float4 cookie = SampleCookie2D(lightLoopContext, coord, lightData.cookieIndex);
+        cookie = SampleCookie2D(lightLoopContext, coord, lightData.cookieIndex);
-        cookieColor  = cookie.rgb;
         illuminance *= cookie.a;
     }
 
-        diffuseLighting  *= (cookieColor * lightData.color) * (illuminance * lightData.diffuseScale);
-        specularLighting *= (cookieColor * lightData.color) * (illuminance * lightData.specularScale);
+
+        diffuseLighting  *= (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale);
+        specularLighting *= (cookie.rgb * lightData.color) * (illuminance * lightData.specularScale);
+    }
+
+    [branch] if (bsdfData.enableTransmission)
+    {
+        // Reverse the normal.
+        illuminance = saturate(dot(-bsdfData.normalWS, L));
+
+        [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
+        {
+            // TODO: factor out the biased position?
+            float3 biasedPositionWS = positionWS + bsdfData.normalWS * bsdfData.thickness;
+#ifdef SHADOWS_USE_SHADOWCTXT
+			float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, biasedPositionWS, lightData.shadowIndex, L, posInput.unPositionSS);
+#else
+			float shadow = GetDirectionalShadowAttenuation(lightLoopContext, biasedPositionWS, lightData.shadowIndex, L, posInput.unPositionSS);
+#endif
+
+            illuminance *= shadow;
+        }
+
+        illuminance *= cookie.a;
+
+        // The difference between the Disney Diffuse and the Lambertian BRDF for transmittance is negligible.
+        float3 backLight = (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale * Lambert());
+        // TODO: multiplication by 'diffuseColor' and 'transmittance' is the same for each light.
+        float3 transmittedLight = backLight * bsdfData.diffuseColor * bsdfData.transmittance;
+
+        // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
+        diffuseLighting += transmittedLight;
     }
 }
 
     attenuation *= GetAngleAttenuation(L, -lightData.forward, lightData.angleScale, lightData.angleOffset);
     float illuminance = saturate(dot(bsdfData.normalWS, L)) * attenuation;
 
-    diffuseLighting    = float3(0.0, 0.0, 0.0);
-    specularLighting   = float3(0.0, 0.0, 0.0);
-    float3 cookieColor = float3(1.0, 1.0, 1.0);
+    diffuseLighting  = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+    float4 cookie    = float4(1.0, 1.0, 1.0, 1.0);
 
     // TODO: measure impact of having all these dynamic branch here and the gain (or not) of testing illuminace > 0
 
     [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
     {
         float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
-        float shadowAttenuation = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
-        shadowAttenuation = lerp(1.0, shadowAttenuation, lightData.shadowDimmer);
+#ifdef SHADOWS_USE_SHADOWCTXT
+		float shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
+#else
+		float shadow = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
+#endif
+        shadow = lerp(1.0, shadow, lightData.shadowDimmer);
-        illuminance *= shadowAttenuation;
+        illuminance *= shadow;
     }
 
     [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
         // Rotate 'L' into the light space.
         // We perform the negation because lights are oriented backwards (-Z).
         float3 coord = mul(-L, transpose(lightToWorld));
-
-        float4 cookie;
 
         [branch] if (lightData.lightType == GPULIGHTTYPE_SPOT)
         {
             cookie = SampleCookieCube(lightLoopContext, coord, lightData.cookieIndex);
         }
 
-        cookieColor  = cookie.rgb;
         illuminance *= cookie.a;
     }
 
 
-        diffuseLighting  *= (cookieColor * lightData.color) * (illuminance * lightData.diffuseScale);
-        specularLighting *= (cookieColor * lightData.color) * (illuminance * lightData.specularScale);
+        diffuseLighting  *= (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale);
+        specularLighting *= (cookie.rgb * lightData.color) * (illuminance * lightData.specularScale);
+    }
+
+    [branch] if (bsdfData.enableTransmission)
+    {
+        // Reverse the normal.
+        illuminance = saturate(dot(-bsdfData.normalWS, L)) * attenuation;
+
+        [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
+        {
+            // TODO: factor out the common biased position?
+            float3 biasedPositionWS = positionWS + bsdfData.normalWS * bsdfData.thickness;
+            float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
+#ifdef SHADOWS_USE_SHADOWCTXT
+			float shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, biasedPositionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
+#else
+			float shadow = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, biasedPositionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
+#endif
+            shadow = lerp(1.0, shadow, lightData.shadowDimmer);
+
+            illuminance *= shadow;
+        }
+
+        illuminance *= cookie.a;
+
+        // The difference between the Disney Diffuse and the Lambertian BRDF for transmittance is negligible.
+        float3 backLight = (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale * Lambert());
+        // TODO: multiplication by 'diffuseColor' and 'transmittance' is the same for each light.
+        float3 transmittedLight = backLight * bsdfData.diffuseColor * bsdfData.transmittance;
+
+        // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
+        diffuseLighting += transmittedLight;
     }
 }
 

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

         _Anisotropy("Anisotropy", Range(0.0, 1.0)) = 0
         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 
-        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2, Specular Color, 3)] _MaterialID("MaterialId", Int) = 0
-        _Thickness("Thickness", Range(0.004, 1.0)) = 0.5
+        _Thickness("Thickness", Range(0.004, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
         //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
         _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
 
         // Stencil state
-        [HideInInspector] _StencilRef("_StencilRef", Int) = 0
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 1
 
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _CullMode("__cullmode", Float) = 2.0
         [HideInInspector] _ZTestMode("_ZTestMode", Int) = 8
 
-        // Material Id
-        [HideInInspector] _MaterialId("_MaterialId", FLoat) = 0
-
-        [Enum(None, 0, DoubleSided, 1, DoubleSidedLigthingFlip, 2, DoubleSidedLigthingMirror, 3)] _DoubleSidedMode("Double sided mode", Float) = 0
+        [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
+        [ToggleOff] _DoubleSidedMirrorEnable("Double sided mirror enable", Float) = 1.0
+        [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
-        [HideInInspector] _UVMappingPlanar("_UVMappingPlanar", Float) = 0
+
+        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2, Specular Color, 3)] _MaterialID("MaterialId", Int) = 0
+
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
         _PPDMaxSamples("Max sample for POM", Range(1.0, 64.0)) = 15
-        [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1        
+        [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
+
+        // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
+        // value that exist to identify if the GI emission need to be enabled.
+        // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
+        // TODO: Fix the code in legacy unity so we can customize the beahvior for GI
+        _EmissionColor("Color", Color) = (1, 1, 1)
     }
 
     HLSLINCLUDE
+    //#pragma enable_d3d11_debug_symbols
 
     //-------------------------------------------------------------------------------------
     // Variant
     #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
-    #pragma shader_feature _ _DOUBLESIDED _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
+    #pragma shader_feature _DOUBLESIDED_ON
+    #pragma shader_feature _PER_PIXEL_DISPLACEMENT
-    #pragma shader_feature _MAPPING_TRIPLANAR
+    #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR
-    #pragma shader_feature _PER_PIXEL_DISPLACEMENT
     #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3
     #pragma shader_feature _EMISSIVE_COLOR
 
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
     #pragma shader_feature _THICKNESS_MAP
+    #pragma shader_feature _SUBSURFACE_SCATTERING
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
     //-------------------------------------------------------------------------------------
 
     #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
+    // Use surface gradient normal mapping as it handle correctly triplanar normal mapping and multiple UVSet
+    #define SURFACE_GRADIENT
 
     //-------------------------------------------------------------------------------------
     // Include
             Name "GBuffer"  // Name is not used
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
-            Cull  [_CullMode]
+            Cull [_CullMode]
 
             Stencil
             {
             Name "GBufferDebugLighting"  // Name is not used
             Tags{ "LightMode" = "GBufferDebugLighting" } // This will be only for opaque object based on the RenderQueue index
 
-            Cull[_CullMode]
+            Cull [_CullMode]
-                Stencil
+            Stencil
-                Ref[_StencilRef]
+                Ref  [_StencilRef]
                 Comp Always
                 Pass Replace
             }

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

 //-------------------------------------------------------------------------------------
 // Fill SurfaceData/Builtin data function
 //-------------------------------------------------------------------------------------
+#include "ShaderLibrary/SampleUVMapping.hlsl"
-#include "../SampleLayer.hlsl"
 
 void GetBuiltinData(FragInputs input, SurfaceData surfaceData, float alpha, float depthOffset, out BuiltinData builtinData)
 {
     builtinData.depthOffset = depthOffset;
 }
 
+// Struct that gather UVMapping info of all layers + common calculation
+// This is use to abstract the mapping that can differ on layers
-    LayerUV base;
-    LayerUV details;
+    UVMapping base;
+    UVMapping details;
-    LayerUV base0;
-    LayerUV base1;
-    LayerUV base2;
-    LayerUV base3;
+    UVMapping base0;
+    UVMapping base1;
+    UVMapping base2;
+    UVMapping base3;
-    LayerUV details0;
-    LayerUV details1;
-    LayerUV details2;
-    LayerUV details3;
+    UVMapping details0;
+    UVMapping details1;
+    UVMapping details2;
+    UVMapping details3;
-    LayerUV blendMask;
+    UVMapping blendMask;
-    // triplanar weight
-    float3 triplanarWeights;
+    // Store information that will be share by all UVMapping
+    float3 vertexNormalWS; // TODO: store also object normal map for object triplanar
+    float3 triplanarWeights;    
+
+#ifdef SURFACE_GRADIENT
+    // tangent basis for each UVSet - up to 4 for now
+    float3 vertexTangentWS0, vertexBitangentWS0;
+    float3 vertexTangentWS1, vertexBitangentWS1;
+    float3 vertexTangentWS2, vertexBitangentWS2;
+    float3 vertexTangentWS3, vertexBitangentWS3;
+#endif
+#ifdef SURFACE_GRADIENT
+void GenerateLayerTexCoordBasisTB(FragInputs input, inout LayerTexCoord layerTexCoord)
+{
+    float3 vertexNormalWS = input.worldToTangent[2];
+
+    layerTexCoord.vertexTangentWS0 = input.worldToTangent[0];
+    layerTexCoord.vertexBitangentWS0 = input.worldToTangent[1];
+
+    // TODO: We should use relative camera position here - This will be automatic when we will move to camera relative space.
+    float3 dPdx = ddx_fine(input.positionWS);
+    float3 dPdy = ddy_fine(input.positionWS);
+
+    float3 sigmaX = dPdx - dot(dPdx, vertexNormalWS) * vertexNormalWS;
+    float3 sigmaY = dPdy - dot(dPdy, vertexNormalWS) * vertexNormalWS;
+    //float flipSign = dot(sigmaY, cross(nrmVertexNormal, sigmaX) ) ? -1.0 : 1.0;
+    float flipSign = dot(dPdy, cross(vertexNormalWS, dPdx)) < 0.0 ? -1.0 : 1.0; // gives same as the commented out line above
+
+    // TODO: Optimize! The compiler will not be able to remove the tangent space that are not use because it can't know due to our UVMapping constant we use for both base and details
+    // To solve this we should track which UVSet is use for normal mapping... Maybe not as simple as it sounds
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord1, layerTexCoord.vertexTangentWS1, layerTexCoord.vertexBitangentWS1);
+    #if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord2, layerTexCoord.vertexTangentWS2, layerTexCoord.vertexBitangentWS2);
+    #endif
+    #if defined(_REQUIRE_UV3)
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord3, layerTexCoord.vertexTangentWS3, layerTexCoord.vertexBitangentWS3);
+    #endif
+}
+#endif
+
+
+
 #ifndef LAYERED_LIT_SHADER
 
 #define SAMPLER_NORMALMAP_IDX sampler_NormalMap
 #endif
 #include "LitDataInternal.hlsl"
 
+// This maybe call directly by tessellation (domain) shader, thus all part regarding surface gradient must be done
+// in function with FragInputs input as parameters
+// layerTexCoord must have been initialize to 0 outside of this function
-                      float3 positionWS, float3 normalWS, out LayerTexCoord layerTexCoord)
+                      float3 positionWS, float3 vertexNormalWS, inout LayerTexCoord layerTexCoord)
-    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
+    layerTexCoord.vertexNormalWS = vertexNormalWS;
+    layerTexCoord.triplanarWeights = ComputeTriplanarWeights(vertexNormalWS);
-    bool isTriplanar = false;
-#ifdef _MAPPING_TRIPLANAR
-    // one weight for each direction XYZ - Use vertex normal for triplanar
-    layerTexCoord.triplanarWeights = ComputeTriplanarWeights(normalWS);
-    isTriplanar = true;
+    int mappingType = UV_MAPPING_UVSET;
+#if defined(_MAPPING_PLANAR)
+    mappingType = UV_MAPPING_PLANAR;
+#elif defined(_MAPPING_TRIPLANAR)
+    mappingType = UV_MAPPING_TRIPLANAR;
-    // Be sure that the compiler is aware that we don't touch UV1 to UV3 for main layer so it can optimize code
-    // Also we have always UVset to 1, if planar/triplanar is enable, it will override it.
+    // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code
-                            positionWS, normalWS,  _UVMappingPlanar > 0.0, isTriplanar, _TexWorldScale, layerTexCoord);
+                            positionWS, mappingType, _TexWorldScale, layerTexCoord);
+}
+
+// This is call only in this file
+// layerTexCoord must have been initialize to 0 outside of this function
+void GetLayerTexCoord(FragInputs input, inout LayerTexCoord layerTexCoord)
+{
+#ifdef SURFACE_GRADIENT
+    GenerateLayerTexCoordBasisTB(input, layerTexCoord);
+#endif
+
+    GetLayerTexCoord(   input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
+                        input.positionWS, input.worldToTangent[2].xyz, layerTexCoord);
 }
 
 float GetMaxDisplacement()
     float2 minUvSize = float2(FLT_MAX, FLT_MAX);
 
 #if defined(_HEIGHTMAP)
-    if (layerTexCoord.base.isTriplanar)
+    if (layerTexCoord.base.mappingType == UV_MAPPING_TRIPLANAR)
     {
         minUvSize = min(layerTexCoord.base.uvZY * _HeightMap_TexelSize.zw, minUvSize);
         minUvSize = min(layerTexCoord.base.uvXZ * _HeightMap_TexelSize.zw, minUvSize);
     bool isTriplanar = false;
 
 #if defined(_PER_PIXEL_DISPLACEMENT) &&  defined(_HEIGHTMAP)
+    // All variable are compile time value
-    isPlanar = layerTexCoord.base.isPlanar;
-    isTriplanar = layerTexCoord.base.isTriplanar;
+    isPlanar = layerTexCoord.base.mappingType == UV_MAPPING_PLANAR;
+    isTriplanar = layerTexCoord.base.mappingType == UV_MAPPING_TRIPLANAR;
 #endif
 
     if (ppdEnable)
 
         PerPixelHeightDisplacementParam ppdParam;
 
+        // planar/triplanar
+        float2 uvXZ;
+        float2 uvXY;
+        float2 uvZY;
+        GetTriplanarCoordinate(V, uvXZ, uvXY, uvZY);
+
+        // TODO: support object space planar/triplanar ?
+
-            // TODO: implement. Require 3 call to POM + dedicated viewDirTS based on triplanar convention
-            // apply the 3 offset on all layers
-            /*
+            float3 viewDirTS;
+            int numSteps;
-            ppdParam.uv = layerTexCoord.base0.uvZY;
+            // Perform a POM in each direction and modify appropriate texture coordinate
+            ppdParam.uv = layerTexCoord.base.uvZY;
+            viewDirTS = float3(V.x > 0.0 ? uvZY : -uvZY, V.x);
+            numSteps = (int)lerp(_PPDMaxSamples, _PPDMinSamples, viewDirTS.z);
+            float2 offsetZY = ParallaxOcclusionMapping(lod, _PPDLodThreshold, numSteps, viewDirTS, maxHeight, ppdParam);
-            float3 viewDirTS = ;
-            int numSteps = (int)lerp(_PPDMaxSamples, _PPDMinSamples, abs(viewDirTS.z));
-            ParallaxOcclusionMapping(lod, _PPDLodThreshold, numSteps, viewDirTS, maxHeight, ppdParam);
+            // Apply offset to all triplanar UVSet
+            layerTexCoord.base.uvZY += offsetZY;
+            layerTexCoord.details.uvZY += offsetZY;
-            (...)
-            */
+            ppdParam.uv = layerTexCoord.base.uvXZ;
+            viewDirTS = float3(V.y > 0.0 ? uvXZ : -uvXZ, V.y);
+            numSteps = (int)lerp(_PPDMaxSamples, _PPDMinSamples, viewDirTS.z);
+            float2 offsetXZ = ParallaxOcclusionMapping(lod, _PPDLodThreshold, numSteps, viewDirTS, maxHeight, ppdParam);
+
+            layerTexCoord.base.uvXZ += offsetXZ;
+            layerTexCoord.details.uvXZ += offsetXZ;
+
+            ppdParam.uv = layerTexCoord.base.uvXY;
+            viewDirTS = float3(V.z > 0.0 ? uvXY : -uvXY, V.z);
+            numSteps = (int)lerp(_PPDMaxSamples, _PPDMinSamples, viewDirTS.z);
+            float2 offsetXY = ParallaxOcclusionMapping(lod, _PPDLodThreshold, numSteps, viewDirTS, maxHeight, ppdParam);
+
+            layerTexCoord.base.uvXY += offsetXY;
+            layerTexCoord.details.uvXY += offsetXY;
-            ppdParam.uv = layerTexCoord.base.uv;
+            ppdParam.uv = layerTexCoord.base.uv; // For planar it is uv too, not uvXZ
+
+            #ifdef SURFACE_GRADIENT
+            // The TBN is not normalize, normalize it to do per pixel displacement
+            float3x3 worldToTangent = input.worldToTangent;
+            worldToTangent[1] = normalize(worldToTangent[1]);
+            worldToTangent[2] = normalize(worldToTangent[2]);
+            #else
+            float3x3 worldToTangent = input.worldToTangent;
+            #endif
-            // For planar the view vector is the world view vector (unless we want to support object triplanar ? and in this case used TransformWorldToObject)
-            // TODO: do we support object triplanar ? See ComputeLayerTexCoord
-            float3 viewDirTS = isPlanar ? float3(-V.xz, V.y) : TransformWorldToTangent(V, input.tangentToWorld);
+            float3 viewDirTS = isPlanar ? float3(uvXZ, V.y) : TransformWorldToTangent(V, worldToTangent);
-            // Apply offset to all UVSet
+            // Apply offset to all UVSet0 / planar
-            layerTexCoord.details.uv += offset;
+            layerTexCoord.details.uv += isPlanar ? offset : _UVDetailsMappingMask.x * offset; // Only apply offset if details map use UVSet0 _UVDetailsMappingMask.x will be 1 in this case, else 0
         }
     }
 }
 {
-    return (SAMPLE_LAYER_TEXTURE2D_LOD(_HeightMap, sampler_HeightMap, layerTexCoord.base, lod).r - _HeightCenter) * _HeightAmplitude;
+    return (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap, sampler_HeightMap, layerTexCoord.base, lod).r - _HeightCenter) * _HeightAmplitude;
+    ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal
+
-    GetLayerTexCoord(input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
-                     input.positionWS, input.tangentToWorld[2].xyz, layerTexCoord);
+    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
+    GetLayerTexCoord(input, layerTexCoord);
 
 
     ApplyPerPixelDisplacement(input, V, layerTexCoord);
     float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS);
     GetNormalAndTangentWS(input, V, normalTS, surfaceData.normalWS, surfaceData.tangentWS);
     // Done one time for all layered - cumulate with spec occ alpha for now
-    surfaceData.specularOcclusion *= GetHorizonOcclusion(V, surfaceData.normalWS, input.tangentToWorld[2].xyz, _HorizonFade);
+    surfaceData.specularOcclusion *= GetHorizonOcclusion(V, surfaceData.normalWS, input.worldToTangent[2].xyz, _HorizonFade);
 
     // Caution: surfaceData must be fully initialize before calling GetBuiltinData
     GetBuiltinData(input, surfaceData, alpha, depthOffset, builtinData);
     return result;
 }
 
-#define SURFACEDATA_BLEND_VECTOR3(surfaceData, name, mask) BlendLayeredVector3(surfaceData##0.##name, surfaceData##1.##name, surfaceData##2.##name, surfaceData##3.##name, mask);
-#define SURFACEDATA_BLEND_SCALAR(surfaceData, name, mask) BlendLayeredScalar(surfaceData##0.##name, surfaceData##1.##name, surfaceData##2.##name, surfaceData##3.##name, mask);
+#define SURFACEDATA_BLEND_VECTOR3(surfaceData, name, mask) BlendLayeredVector3(MERGE_NAME(surfaceData, 0) MERGE_NAME(., name), MERGE_NAME(surfaceData, 1) MERGE_NAME(., name), MERGE_NAME(surfaceData, 2) MERGE_NAME(., name), MERGE_NAME(surfaceData, 3) MERGE_NAME(., name), mask);
+#define SURFACEDATA_BLEND_SCALAR(surfaceData, name, mask) BlendLayeredScalar(MERGE_NAME(surfaceData, 0) MERGE_NAME(., name), MERGE_NAME(surfaceData, 1) MERGE_NAME(., name), MERGE_NAME(surfaceData, 2) MERGE_NAME(., name), MERGE_NAME(surfaceData, 3) MERGE_NAME(., name), mask);
-                      float3 positionWS, float3 normalWS, out LayerTexCoord layerTexCoord)
+                      float3 positionWS, float3 vertexNormalWS, inout LayerTexCoord layerTexCoord)
-    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
+    layerTexCoord.vertexNormalWS = vertexNormalWS;
+    layerTexCoord.triplanarWeights = ComputeTriplanarWeights(vertexNormalWS);
-#if defined(_LAYER_MAPPING_TRIPLANAR_BLENDMASK) || defined(_LAYER_MAPPING_TRIPLANAR0) || defined(_LAYER_MAPPING_TRIPLANAR1) || defined(_LAYER_MAPPING_TRIPLANAR2) || defined(_LAYER_MAPPING_TRIPLANAR3)
-    // one weight for each direction XYZ - Use vertex normal for triplanar
-    layerTexCoord.triplanarWeights = ComputeTriplanarWeights(normalWS);
+    int mappingType = UV_MAPPING_UVSET;
+#if defined(_LAYER_MAPPING_PLANAR_BLENDMASK)
+    mappingType = UV_MAPPING_PLANAR;
+#elif defined(_LAYER_MAPPING_TRIPLANAR_BLENDMASK)
+    mappingType = UV_MAPPING_TRIPLANAR;
-    bool isTriplanar = false;
-#ifdef _LAYER_MAPPING_TRIPLANAR_BLENDMASK
-    isTriplanar = true;
-#endif
+    // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer and blend mask so it can optimize code
+    // Note: Blend mask have its dedicated mapping and tiling. And as Main layer it only use UV0
+    _UVMappingMask0 = float4(1.0, 0.0, 0.0, 0.0);
-    // Be sure that the compiler is aware that we don't touch UV1 to UV3 for main layer so it can optimize code
-    _UVMappingMask0.yzw = float3(0.0, 0.0, 0.0);
-    // Note: Blend mask have its dedicated mapping adn tiling. And as Main layer it only use UV0
-    // To share code, we simply call the regular code from the main layer for it save the result, then do regular call for all layers.
+    // To share code, we simply call the regular code from the main layer for it then save the result, then do regular call for all layers.
-                            positionWS, normalWS, _UVMappingPlanarBlendMask > 0.0,  isTriplanar, _TexWorldScaleBlendMask, layerTexCoord, _LayerTilingBlendMask);
+                            positionWS, mappingType, _TexWorldScaleBlendMask, layerTexCoord, _LayerTilingBlendMask);
 
     layerTexCoord.blendMask = layerTexCoord.base0;
 
     tileObjectScale = length(float3(worldTransform._m00, worldTransform._m01, worldTransform._m02));
 #endif  
 
-    isTriplanar = false;
-#ifdef _LAYER_MAPPING_TRIPLANAR0
-    isTriplanar = true;
+    mappingType = UV_MAPPING_UVSET;
+#if defined(_LAYER_MAPPING_PLANAR0)
+    mappingType = UV_MAPPING_PLANAR;
+#elif defined(_LAYER_MAPPING_TRIPLANAR0)
+    mappingType = UV_MAPPING_TRIPLANAR;
-                            positionWS, normalWS, _UVMappingPlanar0 > 0.0, isTriplanar, _TexWorldScale0, layerTexCoord, _LayerTiling0
+                            positionWS, mappingType, _TexWorldScale0, layerTexCoord, _LayerTiling0
-    isTriplanar = false;
-#ifdef _LAYER_MAPPING_TRIPLANAR1
-    isTriplanar = true;
+    mappingType = UV_MAPPING_UVSET;
+#if defined(_LAYER_MAPPING_PLANAR1)
+    mappingType = UV_MAPPING_PLANAR;
+#elif defined(_LAYER_MAPPING_TRIPLANAR1)
+    mappingType = UV_MAPPING_TRIPLANAR;
-                            positionWS, normalWS, _UVMappingPlanar1 > 0.0, isTriplanar, _TexWorldScale1, layerTexCoord, _LayerTiling1 * tileObjectScale);
+                            positionWS, mappingType, _TexWorldScale1, layerTexCoord, _LayerTiling1 * tileObjectScale);
-    isTriplanar = false;
-#ifdef _LAYER_MAPPING_TRIPLANAR2
-    isTriplanar = true;
+    mappingType = UV_MAPPING_UVSET;
+#if defined(_LAYER_MAPPING_PLANAR2)
+    mappingType = UV_MAPPING_PLANAR;
+#elif defined(_LAYER_MAPPING_TRIPLANAR2)
+    mappingType = UV_MAPPING_TRIPLANAR;
-                            positionWS, normalWS, _UVMappingPlanar2 > 0.0, isTriplanar, _TexWorldScale2, layerTexCoord, _LayerTiling2 * tileObjectScale);
+                            positionWS, mappingType, _TexWorldScale2, layerTexCoord, _LayerTiling2 * tileObjectScale);
-    isTriplanar = false;
-#ifdef _LAYER_MAPPING_TRIPLANAR3
-    isTriplanar = true;
+    mappingType = UV_MAPPING_UVSET;
+#if defined(_LAYER_MAPPING_PLANAR3)
+    mappingType = UV_MAPPING_PLANAR;
+#elif defined(_LAYER_MAPPING_TRIPLANAR3)
+    mappingType = UV_MAPPING_TRIPLANAR;
-                            positionWS, normalWS, _UVMappingPlanar3 > 0.0, isTriplanar, _TexWorldScale3, layerTexCoord, _LayerTiling3 * tileObjectScale);
+                            positionWS, mappingType, _TexWorldScale3, layerTexCoord, _LayerTiling3 * tileObjectScale);
+}
+
+// This is call only in this file
+// layerTexCoord must have been initialize to 0 outside of this function
+void GetLayerTexCoord(FragInputs input, inout LayerTexCoord layerTexCoord)
+{
+#ifdef SURFACE_GRADIENT
+    GenerateLayerTexCoordBasisTB(input, layerTexCoord);
+#endif
+
+    GetLayerTexCoord(   input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
+                        input.positionWS, input.worldToTangent[2].xyz, layerTexCoord);
 }
 
 // This function is just syntaxic sugar to nullify height not used based on heightmap avaibility and layer
     // Blend mask are Main Layer A - Layer 1 R - Layer 2 G - Layer 3 B
     // Value for main layer is not use for blending itself but for alternate weighting like density.
     // Settings this specific Main layer blend mask in alpha allow to be transparent in case we don't use it and 1 is provide by default.
-    float4 blendMasks = useLodSampling ? SAMPLE_LAYER_TEXTURE2D_LOD(_LayerMaskMap, sampler_LayerMaskMap, layerTexCoord.blendMask, lod) : SAMPLE_LAYER_TEXTURE2D(_LayerMaskMap, sampler_LayerMaskMap, layerTexCoord.blendMask);
+    float4 blendMasks = useLodSampling ? SAMPLE_UVMAPPING_TEXTURE2D_LOD(_LayerMaskMap, sampler_LayerMaskMap, layerTexCoord.blendMask, lod) : SAMPLE_UVMAPPING_TEXTURE2D(_LayerMaskMap, sampler_LayerMaskMap, layerTexCoord.blendMask);
 
 #if defined(_LAYER_MASK_VERTEX_COLOR_MUL)
     blendMasks *= vertexColor;
     float2 minUvSize = float2(FLT_MAX, FLT_MAX);
 
 #if defined(_HEIGHTMAP0)
-    if (layerTexCoord.base0.isTriplanar)
+    if (layerTexCoord.base0.mappingType == UV_MAPPING_TRIPLANAR)
     {
         minUvSize = min(layerTexCoord.base0.uvZY * _HeightMap0_TexelSize.zw, minUvSize);
         minUvSize = min(layerTexCoord.base0.uvXZ * _HeightMap0_TexelSize.zw, minUvSize);
 #endif
 
 #if defined(_HEIGHTMAP1)
-    if (layerTexCoord.base1.isTriplanar)
+    if (layerTexCoord.base1.mappingType == UV_MAPPING_TRIPLANAR)
     {
         minUvSize = min(layerTexCoord.base1.uvZY * _HeightMap1_TexelSize.zw, minUvSize);
         minUvSize = min(layerTexCoord.base1.uvXZ * _HeightMap1_TexelSize.zw, minUvSize);
 
 #if _LAYER_COUNT >= 3
 #if defined(_HEIGHTMAP2)
-    if (layerTexCoord.base2.isTriplanar)
+    if (layerTexCoord.base2.mappingType == UV_MAPPING_TRIPLANAR)
     {
         minUvSize = min(layerTexCoord.base2.uvZY * _HeightMap2_TexelSize.zw, minUvSize);
         minUvSize = min(layerTexCoord.base2.uvXZ * _HeightMap2_TexelSize.zw, minUvSize);
 
 #if _LAYER_COUNT >= 4
 #if defined(_HEIGHTMAP3)
-    if (layerTexCoord.base3.isTriplanar)
+    if (layerTexCoord.base3.mappingType == UV_MAPPING_TRIPLANAR)
     {
         minUvSize = min(layerTexCoord.base3.uvZY * _HeightMap3_TexelSize.zw, minUvSize);
         minUvSize = min(layerTexCoord.base3.uvXZ * _HeightMap3_TexelSize.zw, minUvSize);
     // To know if we are planar or triplanar just need to check if any of the active heightmap layer is true as they are enforce to be the same mapping
 #if defined(_HEIGHTMAP0)
     ppdEnable = true;
-    isPlanar = layerTexCoord.base0.isPlanar;
-    isTriplanar = layerTexCoord.base0.isTriplanar;
+    isPlanar = layerTexCoord.base0.mappingType == UV_MAPPING_PLANAR;
+    isTriplanar = layerTexCoord.base0.mappingType == UV_MAPPING_TRIPLANAR;
-    isPlanar = layerTexCoord.base1.isPlanar;
-    isTriplanar = layerTexCoord.base1.isTriplanar;
+    isPlanar = layerTexCoord.base1.mappingType == UV_MAPPING_PLANAR;
+    isTriplanar = layerTexCoord.base1.mappingType == UV_MAPPING_TRIPLANAR;
-    isPlanar = layerTexCoord.base2.isPlanar;
-    isTriplanar = layerTexCoord.base2.isTriplanar;
+    isPlanar = layerTexCoord.base2.mappingType == UV_MAPPING_PLANAR;
+    isTriplanar = layerTexCoord.base2.mappingType == UV_MAPPING_TRIPLANAR;
 #endif
 #endif
 
-    isPlanar = layerTexCoord.base3.isPlanar;
-    isTriplanar = layerTexCoord.base3.isTriplanar;
+    isPlanar = layerTexCoord.base3.mappingType == UV_MAPPING_PLANAR;
+    isTriplanar = layerTexCoord.base3.mappingType == UV_MAPPING_TRIPLANAR;
 #endif
 #endif
 
             ppdParam.uv[2] = layerTexCoord.base2.uv;
             ppdParam.uv[3] = layerTexCoord.base3.uv;
 
+            #ifdef SURFACE_GRADIENT
+            // The TBN is not normalize, normalize it to do per pixel displacement
+            float3x3 worldToTangent = input.worldToTangent;
+            worldToTangent[1] = normalize(worldToTangent[1]);
+            worldToTangent[2] = normalize(worldToTangent[2]);
+            #else
+            float3x3 worldToTangent = input.worldToTangent;
+            #endif
+
-            float3 viewDirTS = isPlanar ? float3(-V.xz, V.y) : TransformWorldToTangent(V, input.tangentToWorld);
+            float3 viewDirTS = isPlanar ? float3(-V.xz, V.y) : TransformWorldToTangent(V, worldToTangent);
-            // Apply offset to all planar uvset
-            // _UVMappingPlanar0 will be 1.0 is planar is used - _UVMappingMask0.x will be 1.0 is UVSet0 is used;
-            float4 offsetWeights = isPlanar ? float4(_UVMappingPlanar0, _UVMappingPlanar1, _UVMappingPlanar2, _UVMappingPlanar3) : float4(_UVMappingMask0.x, _UVMappingMask1.x, _UVMappingMask2.x, _UVMappingMask3.x);
+            // Apply offset to all planar UV if applicable
+            float4 planarWeight = float4(   layerTexCoord.base0.mappingType == UV_MAPPING_PLANAR ? 1.0 : 0.0, 
+                                            layerTexCoord.base1.mappingType == UV_MAPPING_PLANAR ? 1.0 : 0.0,
+                                            layerTexCoord.base2.mappingType == UV_MAPPING_PLANAR ? 1.0 : 0.0,
+                                            layerTexCoord.base3.mappingType == UV_MAPPING_PLANAR ? 1.0 : 0.0);
+
+            // _UVMappingMask0.x will be 1.0 is UVSet0 is used;
+            float4 offsetWeights = isPlanar ? planarWeight : float4(_UVMappingMask0.x, _UVMappingMask1.x, _UVMappingMask2.x, _UVMappingMask3.x);
             
             layerTexCoord.base0.uv += offsetWeights.x * offset;
             layerTexCoord.base1.uv += offsetWeights.y * offset;
-            offsetWeights = isPlanar ? float4(_UVMappingPlanar0, _UVMappingPlanar1, _UVMappingPlanar2, _UVMappingPlanar3) : float4(_UVDetailsMappingMask0.x, _UVDetailsMappingMask1.x, _UVDetailsMappingMask2.x, _UVDetailsMappingMask3.x);
+            offsetWeights = isPlanar ? planarWeight : float4(_UVDetailsMappingMask0.x, _UVDetailsMappingMask1.x, _UVDetailsMappingMask2.x, _UVDetailsMappingMask3.x);
 
             layerTexCoord.details0.uv += offsetWeights.x * offset;
             layerTexCoord.details1.uv += offsetWeights.y * offset;
     ComputeMaskWeights(blendMasks, weights);
 
 #if defined(_HEIGHTMAP0) || defined(_HEIGHTMAP1) || defined(_HEIGHTMAP2) || defined(_HEIGHTMAP3)
-    float height0 = (SAMPLE_LAYER_TEXTURE2D_LOD(_HeightMap0, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base0, lod).r - _LayerCenterOffset0) * _LayerHeightAmplitude0;
-    float height1 = (SAMPLE_LAYER_TEXTURE2D_LOD(_HeightMap1, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base1, lod).r - _LayerCenterOffset1) * _LayerHeightAmplitude1;
-    float height2 = (SAMPLE_LAYER_TEXTURE2D_LOD(_HeightMap2, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base2, lod).r - _LayerCenterOffset2) * _LayerHeightAmplitude2;
-    float height3 = (SAMPLE_LAYER_TEXTURE2D_LOD(_HeightMap3, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base3, lod).r - _LayerCenterOffset3) * _LayerHeightAmplitude3;
+    float height0 = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap0, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base0, lod).r - _LayerCenterOffset0) * _LayerHeightAmplitude0;
+    float height1 = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap1, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base1, lod).r - _LayerCenterOffset1) * _LayerHeightAmplitude1;
+    float height2 = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap2, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base2, lod).r - _LayerCenterOffset2) * _LayerHeightAmplitude2;
+    float height3 = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap3, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base3, lod).r - _LayerCenterOffset3) * _LayerHeightAmplitude3;
     SetEnabledHeightByLayer(height0, height1, height2, height3);
     float heightResult = BlendLayeredScalar(height0, height1, height2, height3, weights);
 
 #if defined(_HEIGHT_BASED_BLEND)
 
 #if defined(_HEIGHTMAP0) || defined(_HEIGHTMAP1) || defined(_HEIGHTMAP2) || defined(_HEIGHTMAP3)
-    float height0 = (SAMPLE_LAYER_TEXTURE2D(_HeightMap0, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base0).r - _LayerCenterOffset0) * _LayerHeightAmplitude0;
-    float height1 = (SAMPLE_LAYER_TEXTURE2D(_HeightMap1, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base1).r - _LayerCenterOffset1) * _LayerHeightAmplitude1;
-    float height2 = (SAMPLE_LAYER_TEXTURE2D(_HeightMap2, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base2).r - _LayerCenterOffset2) * _LayerHeightAmplitude2;
-    float height3 = (SAMPLE_LAYER_TEXTURE2D(_HeightMap3, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base3).r - _LayerCenterOffset3) * _LayerHeightAmplitude3;
+    float height0 = (SAMPLE_UVMAPPING_TEXTURE2D(_HeightMap0, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base0).r - _LayerCenterOffset0) * _LayerHeightAmplitude0;
+    float height1 = (SAMPLE_UVMAPPING_TEXTURE2D(_HeightMap1, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base1).r - _LayerCenterOffset1) * _LayerHeightAmplitude1;
+    float height2 = (SAMPLE_UVMAPPING_TEXTURE2D(_HeightMap2, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base2).r - _LayerCenterOffset2) * _LayerHeightAmplitude2;
+    float height3 = (SAMPLE_UVMAPPING_TEXTURE2D(_HeightMap3, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base3).r - _LayerCenterOffset3) * _LayerHeightAmplitude3;
     SetEnabledHeightByLayer(height0, height1, height2, height3);
     float4 heights = float4(height0, height1, height2, height3);
 
     float3 mainNormalTS = GetNormalTS0(input, layerTexCoord, float3(0.0, 0.0, 1.0), 0.0, true, maxMipBias * (1.0 - influenceFactor));
 
     // Add on our regular normal a bit of Main Layer normal base on influence factor. Note that this affect only the "visible" normal.
+    #ifdef SURFACE_GRADIENT
+    return normalTS + influenceFactor * mainNormalTS;
+    #else
+    #endif
 }
 
 float3 ComputeMainBaseColorInfluence(float3 baseColor0, float3 baseColor1, float3 baseColor2, float3 baseColor3, float compoMask, LayerTexCoord layerTexCoord, float weights[_MAX_LAYER])
 
     // We want to calculate the mean color of the texture. For this we will sample a low mipmap
     float textureBias = 15.0; // Use maximum bias
-    float3 baseMeanColor0 = SAMPLE_LAYER_TEXTURE2D_BIAS(_BaseColorMap0, sampler_BaseColorMap0, layerTexCoord.base0, textureBias).rgb *_BaseColor0.rgb;
-    float3 baseMeanColor1 = SAMPLE_LAYER_TEXTURE2D_BIAS(_BaseColorMap1, sampler_BaseColorMap0, layerTexCoord.base1, textureBias).rgb *_BaseColor1.rgb;
-    float3 baseMeanColor2 = SAMPLE_LAYER_TEXTURE2D_BIAS(_BaseColorMap2, sampler_BaseColorMap0, layerTexCoord.base2, textureBias).rgb *_BaseColor2.rgb;
-    float3 baseMeanColor3 = SAMPLE_LAYER_TEXTURE2D_BIAS(_BaseColorMap3, sampler_BaseColorMap0, layerTexCoord.base3, textureBias).rgb *_BaseColor3.rgb;
+    float3 baseMeanColor0 = SAMPLE_UVMAPPING_TEXTURE2D_BIAS(_BaseColorMap0, sampler_BaseColorMap0, layerTexCoord.base0, textureBias).rgb *_BaseColor0.rgb;
+    float3 baseMeanColor1 = SAMPLE_UVMAPPING_TEXTURE2D_BIAS(_BaseColorMap1, sampler_BaseColorMap0, layerTexCoord.base1, textureBias).rgb *_BaseColor1.rgb;
+    float3 baseMeanColor2 = SAMPLE_UVMAPPING_TEXTURE2D_BIAS(_BaseColorMap2, sampler_BaseColorMap0, layerTexCoord.base2, textureBias).rgb *_BaseColor2.rgb;
+    float3 baseMeanColor3 = SAMPLE_UVMAPPING_TEXTURE2D_BIAS(_BaseColorMap3, sampler_BaseColorMap0, layerTexCoord.base3, textureBias).rgb *_BaseColor3.rgb;
 
     float3 meanColor = BlendLayeredVector3(baseMeanColor0, baseMeanColor1, baseMeanColor2, baseMeanColor3, weights);
 
 
 void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
 {
+    ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal
+
-    GetLayerTexCoord(input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
-                     input.positionWS, input.tangentToWorld[2].xyz, layerTexCoord);
+    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
+    GetLayerTexCoord(input, layerTexCoord);
 
     ApplyPerPixelDisplacement(input, V, layerTexCoord);
 
     surfaceData.perceptualSmoothness = SURFACEDATA_BLEND_SCALAR(surfaceData, perceptualSmoothness, weights);
     surfaceData.ambientOcclusion = SURFACEDATA_BLEND_SCALAR(surfaceData, ambientOcclusion, weights);
     surfaceData.metallic = SURFACEDATA_BLEND_SCALAR(surfaceData, metallic, weights);
-
-    // Init other unused parameter
-    surfaceData.tangentWS = input.tangentToWorld[0].xyz;
+#ifdef SURFACE_GRADIENT
+    surfaceData.tangentWS = normalize(input.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent when using surface gradient
+#else
+    surfaceData.tangentWS = input.worldToTangent[0].xyz;
+#endif
+    // Init other parameters
     surfaceData.materialId = 0;
     surfaceData.anisotropy = 0;
     surfaceData.specular = 0.04;
     GetNormalAndTangentWS(input, V, normalTS, surfaceData.normalWS, surfaceData.tangentWS);
     // Done one time for all layered - cumulate with spec occ alpha for now
     surfaceData.specularOcclusion = SURFACEDATA_BLEND_SCALAR(surfaceData, specularOcclusion, weights);
-    surfaceData.specularOcclusion *= GetHorizonOcclusion(V, surfaceData.normalWS, input.tangentToWorld[2].xyz, _HorizonFade);
+    surfaceData.specularOcclusion *= GetHorizonOcclusion(V, surfaceData.normalWS, input.worldToTangent[2].xyz, _HorizonFade);
 
     GetBuiltinData(input, surfaceData, alpha, depthOffset, builtinData);
 }

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

 void ADD_IDX(ComputeLayerTexCoord)( float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3,
-                                    float3 positionWS, float3 vertexNormalWS, bool isPlanar, bool isTriplanar, float worldScale, inout LayerTexCoord layerTexCoord, float additionalTiling = 1.0)
+                                    float3 positionWS, int mappingType, float worldScale, inout LayerTexCoord layerTexCoord, float additionalTiling = 1.0)
 {
     // Handle uv0, uv1, uv2, uv3 based on _UVMappingMask weight (exclusif 0..1)
     float2 uvBase = ADD_IDX(_UVMappingMask).x * texCoord0 +
                         ADD_IDX(_UVDetailsMappingMask).w * texCoord3;
 
     // If base is planar/triplanar then detail map is forced to be planar/triplanar
-    ADD_IDX(layerTexCoord.base).isPlanar = isPlanar;
-    ADD_IDX(layerTexCoord.base).isTriplanar = isTriplanar;
-    ADD_IDX(layerTexCoord.details).isPlanar = isPlanar;
-    ADD_IDX(layerTexCoord.details).isTriplanar = isTriplanar;
+    ADD_IDX(layerTexCoord.details).mappingType = ADD_IDX(layerTexCoord.base).mappingType = mappingType;
+    ADD_IDX(layerTexCoord.details).normalWS = ADD_IDX(layerTexCoord.base).normalWS = layerTexCoord.vertexNormalWS;
+    // Copy data for the uvmapping
+    ADD_IDX(layerTexCoord.details).triplanarWeights = ADD_IDX(layerTexCoord.base).triplanarWeights = layerTexCoord.triplanarWeights;
 
     // TODO: Currently we only handle world planar/triplanar but we may want local planar/triplanar.
     // In this case both position and normal need to be convert to object space.
     float2 uvXY;
     float2 uvZY;
-    GetTriplanarCoordinate(positionWS * worldScale, vertexNormalWS, uvXZ, uvXY, uvZY);
+    GetTriplanarCoordinate(positionWS * worldScale, uvXZ, uvXY, uvZY);
-    if (isPlanar)
+    // Planar is just XZ of triplanar
+    if (mappingType == UV_MAPPING_PLANAR)
     {
         uvBase = uvDetails = uvXZ;
     }
     ADD_IDX(layerTexCoord.details).uvXZ = TRANSFORM_TEX(uvXZ, ADD_IDX(_DetailMap));
     ADD_IDX(layerTexCoord.details).uvXY = TRANSFORM_TEX(uvXY, ADD_IDX(_DetailMap));
     ADD_IDX(layerTexCoord.details).uvZY = TRANSFORM_TEX(uvZY, ADD_IDX(_DetailMap));
+
+    #ifdef SURFACE_GRADIENT
+    // This part is only relevant for normal mapping with UV_MAPPING_UVSET
+    // Note: This code work only in pixel shader (as we rely on ddx), it should not be use in other context
+    ADD_IDX(layerTexCoord.base).tangentWS = ADD_IDX(_UVMappingMask).x * layerTexCoord.vertexTangentWS0 +
+                                            ADD_IDX(_UVMappingMask).y * layerTexCoord.vertexTangentWS1 +
+                                            ADD_IDX(_UVMappingMask).z * layerTexCoord.vertexTangentWS2 +
+                                            ADD_IDX(_UVMappingMask).w * layerTexCoord.vertexTangentWS3;
+
+    ADD_IDX(layerTexCoord.base).bitangentWS =   ADD_IDX(_UVMappingMask).x * layerTexCoord.vertexBitangentWS0 +
+                                                ADD_IDX(_UVMappingMask).y * layerTexCoord.vertexBitangentWS1 +
+                                                ADD_IDX(_UVMappingMask).z * layerTexCoord.vertexBitangentWS2 +
+                                                ADD_IDX(_UVMappingMask).w * layerTexCoord.vertexBitangentWS3;
+
+    ADD_IDX(layerTexCoord.details).tangentWS =  ADD_IDX(_UVDetailsMappingMask).x * layerTexCoord.vertexTangentWS0 +
+                                                ADD_IDX(_UVDetailsMappingMask).y * layerTexCoord.vertexTangentWS1 +
+                                                ADD_IDX(_UVDetailsMappingMask).z * layerTexCoord.vertexTangentWS2 +
+                                                ADD_IDX(_UVDetailsMappingMask).w * layerTexCoord.vertexTangentWS3;
+
+    ADD_IDX(layerTexCoord.details).bitangentWS =    ADD_IDX(_UVDetailsMappingMask).x * layerTexCoord.vertexBitangentWS0 +
+                                                    ADD_IDX(_UVDetailsMappingMask).y * layerTexCoord.vertexBitangentWS1 +
+                                                    ADD_IDX(_UVDetailsMappingMask).z * layerTexCoord.vertexBitangentWS2 +
+                                                    ADD_IDX(_UVDetailsMappingMask).w * layerTexCoord.vertexBitangentWS3;
+    #endif
 }
 
 float3 ADD_IDX(GetNormalTS)(FragInputs input, LayerTexCoord layerTexCoord, float3 detailNormalTS, float detailMask, bool useBias, float bias)
     #ifdef _NORMALMAP_TANGENT_SPACE_IDX
     if (useBias)
     {
-        normalTS = SAMPLE_LAYER_NORMALMAP_BIAS(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base), ADD_IDX(_NormalScale), bias);
+        normalTS = SAMPLE_UVMAPPING_NORMALMAP_BIAS(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base), ADD_IDX(_NormalScale), bias);
-        normalTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base), ADD_IDX(_NormalScale));
+        normalTS = SAMPLE_UVMAPPING_NORMALMAP(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base), ADD_IDX(_NormalScale));
-    // to be able to combine object space normal with detail map we transform it to tangent space (object space normal composition is complex operation).
+    // to be able to combine object space normal with detail map or to apply a "scale" we transform it to tangent space (object space normal composition is complex operation).
+    // Note: There is no such a thing like triplanar with object space normal, so we call directly 2D function
-        float3 normalOS = SAMPLE_LAYER_NORMALMAP_RGB_BIAS(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base), ADD_IDX(_NormalScale), bias).rgb;
-        normalTS = TransformObjectToTangent(normalOS, input.tangentToWorld);
+        #ifdef SURFACE_GRADIENT
+        // /We need to decompress the normal ourselve here as UnpackNormalRGB will return a surface gradient
+        float3 normalOS = SAMPLE_TEXTURE2D_BIAS(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base).uv, bias).xyz * 2.0 - 1.0;
+        // normalize(normalOS) // TO CHECK: SurfaceGradientFromPerturbedNormal doesn't require normalOS to be normalize, to check
+        normalTS = SurfaceGradientFromPerturbedNormal(input.worldToTangent[2], normalOS);
+        normalTS *= ADD_IDX(_NormalScale);
+        #else
+        float3 normalOS = UnpackNormalRGB(SAMPLE_TEXTURE2D_BIAS(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base).uv, bias), 1.0);
+        normalTS = TransformObjectToTangent(normalOS, input.worldToTangent);
+        normalTS.xy *= ADD_IDX(_NormalScale);  // Scale in tangent space
+        normalTS = (normalTS);
+        #endif
-        float3 normalOS = SAMPLE_LAYER_NORMALMAP_RGB(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base), ADD_IDX(_NormalScale)).rgb;
-        normalTS = TransformObjectToTangent(normalOS, input.tangentToWorld);
+        #ifdef SURFACE_GRADIENT
+        // /We need to decompress the normal ourselve here as UnpackNormalRGB will return a surface gradient
+        float3 normalOS = SAMPLE_TEXTURE2D(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base).uv).xyz * 2.0 - 1.0;
+        // normalize(normalOS) // TO CHECK: SurfaceGradientFromPerturbedNormal doesn't require normalOS to be normalize, to check
+        normalTS = SurfaceGradientFromPerturbedNormal(input.worldToTangent[2], normalOS);
+        normalTS *= ADD_IDX(_NormalScale);
+        #else
+        float3 normalOS = UnpackNormalRGB(SAMPLE_TEXTURE2D(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base).uv), 1.0);
+        normalTS = TransformObjectToTangent(normalOS, input.worldToTangent);
+        normalTS.xy *= ADD_IDX(_NormalScale); // Scale in tangent space
+        normalTS = (normalTS);
+        #endif        
-    normalTS = lerp(normalTS, BlendNormalRNM(normalTS, detailNormalTS), detailMask);
+        #ifdef SURFACE_GRADIENT
+        normalTS += detailNormalTS;
+        #else
+        normalTS = lerp(normalTS, BlendNormalRNM(normalTS, detailNormalTS), detailMask);
+        #endif
-    normalTS = float3(0.0, 0.0, 1.0);
-#endif
-
-#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
-    #ifdef _DOUBLESIDED_LIGHTING_FLIP
-    float3 oppositeNormalTS = -normalTS;
+    #ifdef SURFACE_GRADIENT
+    normalTS = float3(0.0, 0.0, 0.0); // No gradient
-    // Mirror the normal with the plane define by vertex normal
-    float3 oppositeNormalTS = reflect(normalTS, float3(0.0, 0.0, 1.0)); // Reflect around vertex normal (in tangent space this is z)
+    normalTS = float3(0.0, 0.0, 1.0);
-    // TODO : Test if GetOddNegativeScale() is necessary here in case of normal map, as GetOddNegativeScale is take into account in CreateTangentToWorld();
-    normalTS = input.isFrontFace ?
-                    (GetOddNegativeScale() >= 0.0 ? normalTS : oppositeNormalTS) :
-                    (-GetOddNegativeScale() >= 0.0 ? normalTS : oppositeNormalTS);
 #endif
 
     return normalTS;
 float ADD_IDX(GetSurfaceData)(FragInputs input, LayerTexCoord layerTexCoord, out SurfaceData surfaceData, out float3 normalTS)
 {
-    float alpha = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_BaseColorMap), ADD_ZERO_IDX(sampler_BaseColorMap), ADD_IDX(layerTexCoord.base)).a * ADD_IDX(_BaseColor).a;
+    float alpha = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_BaseColorMap), ADD_ZERO_IDX(sampler_BaseColorMap), ADD_IDX(layerTexCoord.base)).a * ADD_IDX(_BaseColor).a;
 
     // Perform alha test very early to save performance (a killed pixel will not sample textures)
 #if defined(_ALPHATEST_ON) && !defined(LAYERED_LIT_SHADER)
     float3 detailNormalTS = float3(0.0, 0.0, 0.0);
     float detailMask = 0.0;
 #ifdef _DETAIL_MAP_IDX
-    detailMask = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_DetailMask), SAMPLER_DETAILMASK_IDX, ADD_IDX(layerTexCoord.base)).g;
-    float2 detailAlbedoAndSmoothness = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_DetailMap), SAMPLER_DETAILMAP_IDX, ADD_IDX(layerTexCoord.details)).rb;
+    detailMask = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_DetailMask), SAMPLER_DETAILMASK_IDX, ADD_IDX(layerTexCoord.base)).g;
+    float2 detailAlbedoAndSmoothness = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_DetailMap), SAMPLER_DETAILMAP_IDX, ADD_IDX(layerTexCoord.details)).rb;
-    detailNormalTS = SAMPLE_LAYER_NORMALMAP_AG(ADD_IDX(_DetailMap), SAMPLER_DETAILMAP_IDX, ADD_IDX(layerTexCoord.details), ADD_ZERO_IDX(_DetailNormalScale));
+    detailNormalTS = SAMPLE_UVMAPPING_NORMALMAP_AG(ADD_IDX(_DetailMap), SAMPLER_DETAILMAP_IDX, ADD_IDX(layerTexCoord.details), ADD_ZERO_IDX(_DetailNormalScale));
-    surfaceData.baseColor = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_BaseColorMap), ADD_ZERO_IDX(sampler_BaseColorMap), ADD_IDX(layerTexCoord.base)).rgb * ADD_IDX(_BaseColor).rgb;
+    surfaceData.baseColor = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_BaseColorMap), ADD_ZERO_IDX(sampler_BaseColorMap), ADD_IDX(layerTexCoord.base)).rgb * ADD_IDX(_BaseColor).rgb;
 #ifdef _DETAIL_MAP_IDX
     surfaceData.baseColor *= LerpWhiteTo(2.0 * saturate(detailAlbedo * ADD_IDX(_DetailAlbedoScale)), detailMask);
 #endif
-    surfaceData.specularOcclusion = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_SpecularOcclusionMap), SAMPLER_SPECULAROCCLUSIONMAP_IDX, ADD_IDX(layerTexCoord.base)).a;
+    surfaceData.specularOcclusion = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_SpecularOcclusionMap), SAMPLER_SPECULAROCCLUSIONMAP_IDX, ADD_IDX(layerTexCoord.base)).a;
 #else
     // The specular occlusion will be perform outside the internal loop
     surfaceData.specularOcclusion = 1.0;
     normalTS = ADD_IDX(GetNormalTS)(input, layerTexCoord, detailNormalTS, detailMask, false, 0.0);
 
 #if defined(_MASKMAP_IDX)
-    surfaceData.perceptualSmoothness = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).a;
+    surfaceData.perceptualSmoothness = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).a;
 #else
     surfaceData.perceptualSmoothness = 1.0;
 #endif
 
     // MaskMap is RGBA: Metallic, Ambient Occlusion (Optional), emissive Mask (Optional), Smoothness
 #ifdef _MASKMAP_IDX
-    surfaceData.metallic = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).r;
-    surfaceData.ambientOcclusion = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).g;
+    surfaceData.metallic = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).r;
+    surfaceData.ambientOcclusion = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).g;
 #else
     surfaceData.metallic = 1.0;
     surfaceData.ambientOcclusion = 1.0;
     // This part of the code is not used in case of layered shader but we keep the same macro system for simplicity
 #if !defined(LAYERED_LIT_SHADER)
 
+#ifdef _SUBSURFACE_SCATTERING
+#else
+    surfaceData.materialId = (_MaterialID == MATERIALID_LIT_SSS) ? 0 : _MaterialID;
+#endif
-#ifdef _NORMALMAP_TANGENT_SPACE_IDX // Normal and tangent use same space
-    float3 tangentTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base), 1.0);
-    surfaceData.tangentWS = TransformTangentToWorld(tangentTS, input.tangentToWorld);
-#else // Object space
-    float3 tangentOS = SAMPLE_LAYER_NORMALMAP_RGB(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base), 1.0).rgb;
+    #ifdef _NORMALMAP_TANGENT_SPACE_IDX // Normal and tangent use same space
+    float3 tangentTS = SAMPLE_UVMAPPING_NORMALMAP(_TangentMap, sampler_TangentMap, layerTexCoord.base, 1.0);
+    surfaceData.tangentWS = TransformTangentToWorld(tangentTS, input.worldToTangent);
+    #else // Object space
+    // Note: There is no such a thing like triplanar with object space normal, so we call directly 2D function
+    float3 tangentOS = UnpackNormalRGB(SAMPLE_TEXTURE2D(_TangentMap, sampler_TangentMap,  layerTexCoord.base.uv), 1.0);
-#endif
+    #endif
-    surfaceData.tangentWS = input.tangentToWorld[0].xyz;
+    #ifdef SURFACE_GRADIENT
+    surfaceData.tangentWS = normalize(input.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent when using surface gradient
+    #else
+    surfaceData.tangentWS = input.worldToTangent[0].xyz;
+    #endif
-    // TODO: Is there anything todo regarding flip normal but for the tangent ?
-    surfaceData.anisotropy = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_AnisotropyMap), ADD_ZERO_IDX(sampler_AnisotropyMap), ADD_IDX(layerTexCoord.base)).b;
+    surfaceData.anisotropy = SAMPLE_UVMAPPING_TEXTURE2D(_AnisotropyMap, sampler_AnisotropyMap, layerTexCoord.base).b;
 #else
     surfaceData.anisotropy = 1.0;
 #endif
 
     surfaceData.subsurfaceProfile = _SubsurfaceProfile;
 #ifdef _SUBSURFACE_RADIUS_MAP
-	surfaceData.subsurfaceRadius = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_SubsurfaceRadiusMap), ADD_ZERO_IDX(sampler_SubsurfaceRadiusMap), ADD_IDX(layerTexCoord.base)).r * _SubsurfaceRadius;
+	surfaceData.subsurfaceRadius = SAMPLE_UVMAPPING_TEXTURE2D(_SubsurfaceRadiusMap, sampler_SubsurfaceRadiusMap, layerTexCoord.base).r * _SubsurfaceRadius;
-    surfaceData.subsurfaceProfile = 0;
-	surfaceData.thickness = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_ThicknessMap), ADD_ZERO_IDX(sampler_ThicknessMap), ADD_IDX(layerTexCoord.base)).r;
+	surfaceData.thickness = SAMPLE_UVMAPPING_TEXTURE2D(_ThicknessMap, sampler_ThicknessMap, layerTexCoord.base).r;
 #else
     surfaceData.thickness = _Thickness;
 #endif
     // Layered shader only support materialId 0
     surfaceData.materialId = 0;
 
-    surfaceData.tangentWS = input.tangentToWorld[0].xyz;
-    surfaceData.anisotropy = 0;
-    surfaceData.specular = 0.04;
+    // 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.anisotropy = 0.0;
+    surfaceData.specular = 0.0;
-    surfaceData.subsurfaceRadius = 1.0;
+    surfaceData.subsurfaceRadius = 0.0;
-    surfaceData.coatPerceptualSmoothness = 1.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

+// shared constant between lit and layered lit
+float _AlphaCutoff;
+float4 _DoubleSidedConstants;
+
+float _HorizonFade;
+
+float _PPDMaxSamples;
+float _PPDMinSamples;
+float _PPDLodThreshold;
+
+TEXTURE2D(_DiffuseLightingMap);
+SAMPLER2D(sampler_DiffuseLightingMap);
+
+TEXTURE2D(_DistortionVectorMap);
+SAMPLER2D(sampler_DistortionVectorMap);
+
+float3 _EmissiveColor;
+TEXTURE2D(_EmissiveColorMap);
+SAMPLER2D(sampler_EmissiveColorMap);
+float _EmissiveIntensity;
+
+// Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
+// value that exist to identify if the GI emission need to be enabled.
+// In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
+// TODO: Fix the code in legacy unity so we can customize the beahvior for GI
+float3 _EmissionColor;
+
 #ifndef LAYERED_LIT_SHADER
 
 // Set of users variables
 //TEXTURE2D(_CoatRoughnessMap);
 //SAMPLER2D(sampler_CoatRoughnessMap);
 
-TEXTURE2D(_DiffuseLightingMap);
-SAMPLER2D(sampler_DiffuseLightingMap);
-
-TEXTURE2D(_DistortionVectorMap);
-SAMPLER2D(sampler_DistortionVectorMap);
-
-float3 _EmissiveColor;
-TEXTURE2D(_EmissiveColorMap);
-SAMPLER2D(sampler_EmissiveColorMap);
-float _EmissiveIntensity;
-
-float _AlphaCutoff;
-
-float _HorizonFade;
-
-float _UVMappingPlanar;
-
-float _PPDMaxSamples;
-float _PPDMinSamples;
-float _PPDLodThreshold;
 
 #else // LAYERED_LIT_SHADER
 
 PROP_DECL(float, _HeightAmplitude);
 PROP_DECL(float, _HeightCenter);
 
-TEXTURE2D(_DiffuseLightingMap);
-SAMPLER2D(sampler_DiffuseLightingMap);
-
-TEXTURE2D(_DistortionVectorMap);
-SAMPLER2D(sampler_DistortionVectorMap);
-
 TEXTURE2D(_LayerMaskMap);
 SAMPLER2D(sampler_LayerMaskMap);
 
 float _LayerTilingBlendMask;
 PROP_DECL(float, _LayerTiling);
 
-float3 _EmissiveColor;
-TEXTURE2D(_EmissiveColorMap);
-SAMPLER2D(sampler_EmissiveColorMap);
-float _EmissiveIntensity;
-
-float _UVMappingPlanarBlendMask;
-PROP_DECL(float, _UVMappingPlanar);  
-
-float _AlphaCutoff;
-
-float _HorizonFade;
-
-float _PPDMaxSamples;
-float _PPDMinSamples;
-float _PPDLodThreshold;
 
 #endif // LAYERED_LIT_SHADER
 

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

     bool frustumCulled = WorldViewFrustumCull(p0, p1, p2, maxDisplacement, (float4[4])unity_CameraWorldClipPlanes);
 
     bool faceCull = false;
-#if !(defined(_DOUBLESIDED) || defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR))
+#ifndef _DOUBLESIDED_ON
     // TODO: Handle inverse culling (for mirror)!
     if (_TessellationBackFaceCullEpsilon > -0.99) // Is backface culling enabled ?
     {
 {
     // This call will work for both LayeredLit and Lit shader
     LayerTexCoord layerTexCoord;
+    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
     GetLayerTexCoord(
 #ifdef VARYINGS_DS_NEED_TEXCOORD0
         input.texCoord0,

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

         _Anisotropy("Anisotropy", Range(0.0, 1.0)) = 0
         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 
-        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2, Specular Color, 3)] _MaterialID("MaterialId", Int) = 0
-        _Thickness("Thickness", Range(0.004, 1.0)) = 0.5
+        _Thickness("Thickness", Range(0.004, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
         //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
         _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
 
         // Stencil state
-        [HideInInspector] _StencilRef("_StencilRef", Int) = 0
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 1
 
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _CullMode("__cullmode", Float) = 2.0
         [HideInInspector] _ZTestMode("_ZTestMode", Int) = 8
 
-        // Material Id
-        [HideInInspector] _MaterialId("_MaterialId", FLoat) = 0
-
-        [Enum(None, 0, DoubleSided, 1, DoubleSidedLigthingFlip, 2, DoubleSidedLigthingMirror, 3)] _DoubleSidedMode("Double sided mode", Float) = 0
+        [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
+        [ToggleOff] _DoubleSidedMirrorEnable("Double sided mirror enable", Float) = 1.0
+        [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
-        [HideInInspector] _UVMappingPlanar("_UVMappingPlanar", Float) = 0
+
+        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2, Specular Color, 3)] _MaterialID("MaterialId", Int) = 0
+
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
         _PPDMaxSamples("Max sample for POM", Range(1.0, 64.0)) = 15
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
 
+        // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
+        // value that exist to identify if the GI emission need to be enabled.
+        // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
+        // TODO: Fix the code in legacy unity so we can customize the beahvior for GI
+        _EmissionColor("Color", Color) = (1, 1, 1)
+
         // Tessellation specific
         [Enum(Phong, 0, Displacement, 1, DisplacementPhong, 2)] _TessellationMode("Tessellation mode", Float) = 0
         _TessellationFactor("Tessellation Factor", Range(0.0, 15.0)) = 4.0
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
-    #pragma shader_feature _ _DOUBLESIDED _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
+    #pragma shader_feature _DOUBLESIDED_ON
+    #pragma shader_feature _PER_PIXEL_DISPLACEMENT
-    #pragma shader_feature _MAPPING_TRIPLANAR
+    #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR
-    #pragma shader_feature _PER_PIXEL_DISPLACEMENT
     #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3
     #pragma shader_feature _EMISSIVE_COLOR
 
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
     #pragma shader_feature _THICKNESS_MAP
+    #pragma shader_feature _SUBSURFACE_SCATTERING
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
 
     #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
     #define TESSELLATION_ON
+    // Use surface gradient normal mapping as it handle correctly triplanar normal mapping and multiple UVSet
+    #define SURFACE_GRADIENT
 
     //-------------------------------------------------------------------------------------
     // Include
             Name "GBuffer"  // Name is not used
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
-            Cull  [_CullMode]
+            Cull [_CullMode]
 
             Stencil
             {
             Name "GBufferDebugLighting"  // Name is not used
             Tags{ "LightMode" = "GBufferDebugLighting" } // This will be only for opaque object based on the RenderQueue index
 
-            Cull[_CullMode]
+            Cull [_CullMode]
-                Stencil
+            Stencil
-                Ref[_StencilRef]
+                Ref  [_StencilRef]
                 Comp Always
                 Pass Replace
             }
 
             ENDHLSL
         }
-
     }
 
     CustomEditor "Experimental.Rendering.HDPipeline.LitGUI"

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

             #define N_PROFILES 8
             #define N_SAMPLES  7
 
-            float4   _FilterKernels[N_PROFILES][N_SAMPLES + 1]; // RGB = weights, A = radial distance
+            float4   _FilterKernels[N_PROFILES][N_SAMPLES]; // RGB = weights, A = radial distance
+            float4   _HalfRcpWeightedVariances[N_PROFILES]; // RGB for chromatic, A for achromatic
             float4x4 _InvProjMatrix;
 
             TEXTURE2D_FLOAT(_CameraDepthTexture);
             #endif
                 float2 scaledDirection = distScale * stepSize * unitDirection;
 
-                // Load (1 / (2 * Variance)) for bilateral weighting.
+                // Load (1 / (2 * WeightedVariance)) for bilateral weighting.
-                float3 halfRcpVariance = _FilterKernels[profileID][N_SAMPLES].rgb;
+                float3 halfRcpVariance = _HalfRcpWeightedVariances[profileID].rgb;
-                float  halfRcpVariance = _FilterKernels[profileID][N_SAMPLES].a;
+                float  halfRcpVariance = _HalfRcpWeightedVariances[profileID].a;
             #endif
                 // Take the first (central) sample.
                 float2 samplePosition   = posInput.unPositionSS;

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

 // Varying - Use for pixel shader
 // This second set of define allow to say which varyings will be output in the vertex (no more tesselation)
 #if REQUIRE_TANGENT_TO_WORLD
+#define VARYINGS_NEED_POSITION_WS // Required to get view vector
 #define VARYINGS_NEED_TANGENT_TO_WORLD
 #endif
 

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

 // Varying - Use for pixel shader
 // This second set of define allow to say which varyings will be output in the vertex (no more tesselation)
 #if REQUIRE_TANGENT_TO_WORLD
+#define VARYINGS_NEED_POSITION_WS // Required to get view vector
 #define VARYINGS_NEED_TANGENT_TO_WORLD
 #endif
 

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

 #endif
 #define VARYINGS_NEED_COLOR
 
-#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
+#ifdef _DOUBLESIDED_ON
 #define VARYINGS_NEED_CULLFACE
 #endif
 

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

 #define VARYINGS_NEED_POSITION_WS
 
 #if REQUIRE_TANGENT_TO_WORLD
+#define VARYINGS_NEED_POSITION_WS // Required to get view vector
 #define VARYINGS_NEED_TANGENT_TO_WORLD
 #endif
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/MaterialUtilities.hlsl

 #endif
 }
 
+// Flipping or mirroring a normal can be done directly on the tangent space. This has the benefit to apply to the whole process either in surface gradient or not.
+// This function will modify FragInputs and this is not propagate outside of GetSurfaceAndBuiltinData(). This is ok as tangent space is not use outside of GetSurfaceAndBuiltinData().
+void ApplyDoubleSidedFlipOrMirror(inout FragInputs input)
+{
+#ifdef _DOUBLESIDED_ON
+    // _DoubleSidedConstants is float3(-1, -1, -1) in flip mode and float3(1, 1, -1) in mirror mode
+    // To get a flipped normal with the tangent space, we must flip bitangent (because it is construct from the normal) and normal
+    // To get a mirror normal with the tangent space, we only need to flip the normal and not the tangent
+    float2 flipSign = input.isFrontFace ? float2(1.0, 1.0) : _DoubleSidedConstants.yz; // TOCHECK :  GetOddNegativeScale() is not necessary here as it is apply for tangent space creation.
+    input.worldToTangent[1] = flipSign.x * input.worldToTangent[1]; // bitangent    
+    input.worldToTangent[2] = flipSign.y * input.worldToTangent[2]; // normal
+
+    #ifdef SURFACE_GRADIENT
+    // TOCHECK: seems that we don't need to invert any genBasisTB(), sign cancel. Which is expected as we deal with surface gradient.
+    #endif
+#endif
+}
+
-void GetNormalAndTangentWS(FragInputs input, float3 V, float3 normalTS, inout float3 normalWS, inout float3 tangentWS, bool twoSided = false)
+void GetNormalAndTangentWS(FragInputs input, float3 V, float3 normalTS, inout float3 normalWS, inout float3 tangentWS, bool wantNegativeNormal = false)
-    normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
+    #ifdef SURFACE_GRADIENT
+    normalWS = SurfaceGradientResolveNormal(input.worldToTangent[2], normalTS);
+    #else
+    normalWS = TransformTangentToWorld(normalTS, input.worldToTangent);
+    #endif
-    // NdotV should not be negative for visible pixels, but it can happen due to the
-    // perspective projection and the normal mapping + decals. In that case, the normal
-    // should be modified to become valid (i.e facing the camera) to avoid weird artifacts.
-    // Note: certain applications (e.g. SpeedTree) require to still have negative normal to perform their own two sided lighting
-    // This will  potentially reduce the length of the normal at edges of geometry.
-    GetShiftedNdotV(normalWS, V, twoSided);
+    GetShiftedNdotV(normalWS, V, wantNegativeNormal);
+    // This is use with anisotropic material
     tangentWS = normalize(tangentWS - dot(tangentWS, normalWS));
 }

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

 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
+    // A Material can be authored from the shader graph or by hand. When written by hand we need to provide an inspector.
+    // Such a Material will share some properties between it various variant (shader graph variant or hand authored variant).
+    // This is the purpose of BaseLitGUI. It contain all properties that are common to all Material based on Lit template.
+    // For the default hand written Lit material see LitUI.cs that contain specific properties for our default implementation.
-        protected static class Styles
+        protected static class StylesBaseUnlit
-            public static string optionText = "Options";
+            public static string optionText = "Surface options";
+            public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
+            public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
+
-            public static GUIContent doubleSidedModeText = new GUIContent("Double Sided", "This will render the two face of the objects (disable backface culling)");
+            public static GUIContent doubleSidedEnableText = new GUIContent("Double Sided", "This will render the two face of the objects (disable backface culling) and flip/mirror normal");
-
-            public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
-            public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
-
-            public static string InputsText = "Inputs";
-
-            public static string InputsMapText = "";
-
-            public static GUIContent colorText = new GUIContent("Color + Opacity", "Albedo (RGB) and Opacity (A)");
-
-            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
-            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
-
-            public static GUIContent emissiveWarning = new GUIContent("Emissive value is animated but the material has not been configured to support emissive. Please make sure the material itself has some amount of emissive.");
-            public static GUIContent emissiveColorWarning = new GUIContent("Ensure emissive color is non-black for emission to have effect.");
-
         }
 
         public enum SurfaceType
         }
+
         public enum BlendMode
         {
             Lerp,
             Premultiply
         }
 
-        public enum DoubleSidedMode
+        protected MaterialEditor m_MaterialEditor;
+
+        // Properties
+        protected MaterialProperty surfaceType = null;
+        protected const string kSurfaceType = "_SurfaceType";
+        protected MaterialProperty alphaCutoffEnable = null;
+        protected const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
+        protected MaterialProperty alphaCutoff = null;
+        protected const string kAlphaCutoff = "_AlphaCutoff";
+        protected MaterialProperty doubleSidedEnable = null;
+        protected const string kDoubleSidedEnable = "_DoubleSidedEnable";
+        protected MaterialProperty blendMode = null;
+        protected const string kBlendMode = "_BlendMode";
+        protected MaterialProperty distortionEnable = null;
+        protected const string kDistortionEnable = "_DistortionEnable";
+        protected MaterialProperty distortionOnly = null;
+        protected const string kDistortionOnly = "_DistortionOnly";
+        protected MaterialProperty distortionDepthTest = null;
+        protected const string kDistortionDepthTest = "_DistortionDepthTest";
+
+        // See comment in LitProperties.hlsl
+        const string kEmissionColor = "_EmissionColor";
+
+        // The following set of functions are call by the ShaderGraph
+        // It will allow to display our common parameters + setup keyword correctly for them
+        protected abstract void FindMaterialProperties(MaterialProperty[] props);
+        protected abstract void SetupMaterialKeywordsAndPassInternal(Material material);
+        protected abstract void MaterialPropertiesGUI();
+        // This function will said if emissive is use or not regarding enlighten/PVR
+        protected abstract bool ShouldEmissionBeEnabled(Material material);
+
+        protected virtual void FindBaseMaterialProperties(MaterialProperty[] props)
-            None,
-            DoubleSided
+            surfaceType = FindProperty(kSurfaceType, props);
+            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
+            alphaCutoff = FindProperty(kAlphaCutoff, props);
+            doubleSidedEnable = FindProperty(kDoubleSidedEnable, props);            
+            blendMode = FindProperty(kBlendMode, props);
+            distortionEnable = FindProperty(kDistortionEnable, props);
+            distortionOnly = FindProperty(kDistortionOnly, props);
+            distortionDepthTest = FindProperty(kDistortionDepthTest, props);
-       void SurfaceTypePopup()
+        void SurfaceTypePopup()
-            mode = (SurfaceType)EditorGUILayout.Popup(Styles.surfaceTypeText, (int)mode, Styles.surfaceTypeNames);
+            mode = (SurfaceType)EditorGUILayout.Popup(StylesBaseUnlit.surfaceTypeText, (int)mode, StylesBaseUnlit.surfaceTypeNames);
             if (EditorGUI.EndChangeCheck())
             {
                 m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
             EditorGUI.showMixedValue = false;
         }
 
-        void BlendModePopup()
+        private void BlendModePopup()
-            mode = (BlendMode)EditorGUILayout.Popup(Styles.blendModeText, (int)mode, Styles.blendModeNames);
+            mode = (BlendMode)EditorGUILayout.Popup(StylesBaseUnlit.blendModeText, (int)mode, StylesBaseUnlit.blendModeNames);
             if (EditorGUI.EndChangeCheck())
             {
                 m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
             EditorGUI.showMixedValue = false;
         }
 
-        protected void ShaderOptionsGUI()
+        protected virtual void BaseMaterialPropertiesGUI()
-            GUILayout.Label(Styles.optionText, EditorStyles.boldLabel);
+            GUILayout.Label(StylesBaseUnlit.optionText, EditorStyles.boldLabel);
-                m_MaterialEditor.ShaderProperty(distortionEnable, Styles.distortionEnableText.text);
+                m_MaterialEditor.ShaderProperty(distortionEnable, StylesBaseUnlit.distortionEnableText);
-                if (distortionEnable.floatValue == 1.0)
+                if (distortionEnable.floatValue == 1.0f)
-                    m_MaterialEditor.ShaderProperty(distortionOnly, Styles.distortionOnlyText.text);
-                    m_MaterialEditor.ShaderProperty(distortionDepthTest, Styles.distortionDepthTestText.text);
+                    m_MaterialEditor.ShaderProperty(distortionOnly, StylesBaseUnlit.distortionOnlyText);
+                    m_MaterialEditor.ShaderProperty(distortionDepthTest, StylesBaseUnlit.distortionDepthTestText);
-            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, Styles.alphaCutoffEnableText.text);
-            if (alphaCutoffEnable.floatValue == 1.0)
+            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, StylesBaseUnlit.alphaCutoffEnableText);
+            if (alphaCutoffEnable.floatValue == 1.0f)
-                m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
+                m_MaterialEditor.ShaderProperty(alphaCutoff, StylesBaseUnlit.alphaCutoffText);
-            m_MaterialEditor.ShaderProperty(doubleSidedMode, Styles.doubleSidedModeText.text);
-
-            EditorGUI.indentLevel--;
+            // This function must finish with double sided option (see LitUI.cs)
+            m_MaterialEditor.ShaderProperty(doubleSidedEnable, StylesBaseUnlit.doubleSidedEnableText);
-        public void FindCommonOptionProperties(MaterialProperty[] props)
+        static public void SetKeyword(Material m, string keyword, bool state)
-            surfaceType = FindProperty(kSurfaceType, props);
-            blendMode = FindProperty(kBlendMode, props);
-            alphaCutoff = FindProperty(kAlphaCutoff, props);
-            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
-            doubleSidedMode = FindProperty(kDoubleSidedMode, props);
-            distortionEnable = FindProperty(kDistortionEnable, props);
-            distortionOnly = FindProperty(kDistortionOnly, props);
-            distortionDepthTest = FindProperty(kDistortionDepthTest, props);
+            if (state)
+                m.EnableKeyword(keyword);
+            else
+                m.DisableKeyword(keyword);
-		protected void SetupCommonOptionsKeywords(Material material)
-		{
-			// Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation
-            // (MaterialProperty value might come from renderer material property block)
-
-            bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
+        // All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if ocde change
+        static public void SetupBaseUnlitKeywords(Material material)
+        {
+            bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) > 0.0f;
-            DoubleSidedMode doubleSidedMode = (DoubleSidedMode)material.GetFloat(kDoubleSidedMode);
 
             if (surfaceType == SurfaceType.Opaque)
             {
                 }
             }
 
-            if (doubleSidedMode == DoubleSidedMode.None)
+            bool doubleSidedEnable = material.GetFloat(kDoubleSidedEnable) > 0.0f;
+            if (doubleSidedEnable)
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back);
+                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Off);
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Off);
+                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back);
+            SetKeyword(material, "_DOUBLESIDED_ON", doubleSidedEnable);
-            bool distortionEnable = material.GetFloat(kDistortionEnable) == 1.0;
-            bool distortionOnly = material.GetFloat(kDistortionOnly) == 1.0;
-            bool distortionDepthTest = material.GetFloat(kDistortionDepthTest) == 1.0;
-
+            bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
             if (distortionEnable)
             {
                 material.SetShaderPassEnabled("DistortionVectors", true);
                 material.SetShaderPassEnabled("DistortionVectors", false);
             }
 
+            bool distortionDepthTest = material.GetFloat(kDistortionDepthTest) > 0.0f;
+            if (distortionDepthTest)
+            {
+                material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.LessEqual);
+            }
+            else
+            {
+                material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.Always);
+            }
+
+            SetKeyword(material, "_DISTORTION_ON", distortionEnable);
+
+            // A material's GI flag internally keeps track of whether emission is enabled at all, it's enabled but has no effect
+            // or is enabled and may be modified at runtime. This state depends on the values of the current flag and emissive color.
+            // The fixup routine makes sure that the material is in the correct state if/when changes are made to the mode or color.
+            MaterialEditor.FixupEmissiveFlag(material);
+        }
+
+        static public void SetupBaseUnlitMaterialPass(Material material)
+        {
+            bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f;
+            bool distortionOnly = material.GetFloat(kDistortionOnly) > 0.0f;
+
-                // Disable all passes except dbug material
+                // Disable all passes except debug material
+                material.SetShaderPassEnabled("GBuffer", false);
+                material.SetShaderPassEnabled("ShadowCaster", false);
+                material.SetShaderPassEnabled("DepthOnly", false);
+                material.SetShaderPassEnabled("MotionVectors", false);
-                material.SetShaderPassEnabled("ForwardOnlyOpaque", false);
+                material.SetShaderPassEnabled("GBuffer", true);
+                material.SetShaderPassEnabled("ShadowCaster", true);
+                material.SetShaderPassEnabled("DepthOnly", true);
+                material.SetShaderPassEnabled("MotionVectors", true);
-                material.SetShaderPassEnabled("ForwardOnlyOpaque", true);
+        }
-            if (distortionDepthTest)
-            {
-                material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.LessEqual);
-            }
-            else
+        // Dedicated to emissive - for emissive Enlighten/PVR
+        protected void DoEmissionArea(Material material)
+        {
+            // Emission for GI?
+            if (ShouldEmissionBeEnabled(material))
-                material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.Always);
+                if (m_MaterialEditor.EmissionEnabledProperty())
+                {
+                    // change the GI flag and fix it up with emissive as black if necessary
+                    m_MaterialEditor.LightmapEmissionFlagsProperty(MaterialEditor.kMiniTextureFieldLabelIndentLevel, true);
+                }
-
-            SetKeyword(material, "_DISTORTION_ON", distortionEnable);
-
-            SetupEmissionGIFlags(material);
-		}
-
-        protected void SetKeyword(Material m, string keyword, bool state)
-        {
-            if (state)
-                m.EnableKeyword(keyword);
-            else
-                m.DisableKeyword(keyword);
         }
 
         public void ShaderPropertiesGUI(Material material)
             // Detect any changes to the material
             EditorGUI.BeginChangeCheck();
             {
-                ShaderOptionsGUI();
+                BaseMaterialPropertiesGUI();
-                ShaderInputGUI();
+                MaterialPropertiesGUI();
+
+                DoEmissionArea(material);
+                m_MaterialEditor.EnableInstancingField();
-                    SetupMaterialKeywords((Material)obj);
+                    SetupMaterialKeywordsAndPassInternal((Material)obj);
+        // This is call by the inspector
-            FindCommonOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
+            m_MaterialEditor = materialEditor;
+            // We should always do this call at the beginning
+            m_MaterialEditor.serializedObject.Update();
+
+            // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
+            FindBaseMaterialProperties(props);
-            m_MaterialEditor = materialEditor;
-        }
-        // TODO: ? or remove
-        bool HasValidEmissiveKeyword(Material material)
-        {
-            /*
-            // Material animation might be out of sync with the material keyword.
-            // So if the emission support is disabled on the material, but the property blocks have a value that requires it, then we need to show a warning.
-            // (note: (Renderer MaterialPropertyBlock applies its values to emissionColorForRendering))
-            bool hasEmissionKeyword = material.IsKeywordEnabled ("_EMISSION");
-            if (!hasEmissionKeyword && ShouldEmissionBeEnabled (material, emissionColorForRendering.colorValue))
-                return false;
-            else
-                return true;
-            */
-
-            return true;
+            // We should always do this call at the end
+            m_MaterialEditor.serializedObject.ApplyModifiedProperties();
-
-        protected virtual void SetupEmissionGIFlags(Material material)
-        {
-            // Setup lightmap emissive flags
-            MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
-            if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
-            {
-                if (ShouldEmissionBeEnabled(material))
-                    flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
-                else
-                    flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
-
-                material.globalIlluminationFlags = flags;
-            }
-        }
-
-        protected MaterialEditor m_MaterialEditor;
-
-        MaterialProperty surfaceType = null;
-        protected const string kSurfaceType = "_SurfaceType";
-        MaterialProperty blendMode = null;
-        protected const string kBlendMode = "_BlendMode";
-        MaterialProperty alphaCutoff = null;
-        protected const string kAlphaCutoff = "_AlphaCutoff";
-        MaterialProperty alphaCutoffEnable = null;
-        protected const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
-        MaterialProperty doubleSidedMode = null;
-        protected const string kDoubleSidedMode = "_DoubleSidedMode";
-        MaterialProperty distortionEnable = null;
-        const string kDistortionEnable = "_DistortionEnable";
-        MaterialProperty distortionOnly = null;
-        const string kDistortionOnly = "_DistortionOnly";
-        MaterialProperty distortionDepthTest = null;
-        const string kDistortionDepthTest = "_DistortionDepthTest";
-
-        protected static string[] reservedProperties = new string[] { kSurfaceType, kBlendMode, kAlphaCutoff, kAlphaCutoffEnabled, kDoubleSidedMode };
-
-        protected abstract void FindMaterialProperties(MaterialProperty[] props);
-        protected abstract void ShaderInputGUI();
-		protected abstract void SetupMaterialKeywords(Material material);
-        protected abstract bool ShouldEmissionBeEnabled(Material material);
-
 }

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

 {
     class UnlitGUI : BaseUnlitGUI
     {
-        MaterialProperty color = null;
-        MaterialProperty colorMap = null;
-        MaterialProperty emissiveColor = null;
-        MaterialProperty emissiveColorMap = null;
-        MaterialProperty emissiveIntensity = null;
+        protected static class Styles
+        {
+            public static string InputsText = "Inputs";
+
+            public static GUIContent colorText = new GUIContent("Color", "Color");
+
+            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
+            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
+            public static GUIContent emissiveColorModeText = new GUIContent("Emissive Color Usage", "Use emissive color or emissive mask");
+        }
+        protected MaterialProperty color = null;
+        protected const string kColor = "_Color";
+        protected MaterialProperty colorMap = null;
+        protected const string kColorMap = "_ColorMap";
+        protected MaterialProperty emissiveColor = null;
+        protected const string kEmissiveColor = "_EmissiveColor";
+        protected MaterialProperty emissiveColorMap = null;
+        protected MaterialProperty emissiveIntensity = null;
-            color = FindProperty("_Color", props);
-            colorMap = FindProperty("_ColorMap", props);
-            emissiveColor = FindProperty("_EmissiveColor", props);
+            color = FindProperty(kColor, props);
+            colorMap = FindProperty(kColorMap, props);
+
+            emissiveColor = FindProperty(kEmissiveColor, props);
-            emissiveIntensity = FindProperty("_EmissiveIntensity", props);
+            emissiveIntensity = FindProperty(kEmissiveIntensity, props);
-        override protected void ShaderInputGUI()
+        protected override void MaterialPropertiesGUI()
-            EditorGUI.indentLevel++;
-
             GUILayout.Label(Styles.InputsText, EditorStyles.boldLabel);
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.colorText, colorMap, color);
-            m_MaterialEditor.LightmapEmissionProperty(MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
+        }
-            EditorGUI.indentLevel--;
+        protected override bool ShouldEmissionBeEnabled(Material mat)
+        {
+            return mat.GetFloat(kEmissiveIntensity) > 0.0f;
-        protected override void SetupMaterialKeywords(Material material)
+        protected override void SetupMaterialKeywordsAndPassInternal(Material material)
-			SetupCommonOptionsKeywords(material);
-            SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
+            SetupMaterialKeywordsAndPass(material);
-        protected override bool ShouldEmissionBeEnabled(Material mat)
+        // All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if code change
+        static public void SetupMaterialKeywordsAndPass(Material material)
-            float emissiveIntensity = mat.GetFloat(kEmissiveIntensity);
-            var realtimeEmission = (mat.globalIlluminationFlags & MaterialGlobalIlluminationFlags.RealtimeEmissive) > 0;
-            return emissiveIntensity > 0.0f || realtimeEmission;
+            SetupBaseUnlitKeywords(material);
+            SetupBaseUnlitMaterialPass(material);
+
+            SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
-
     }
 
 } // namespace UnityEditor

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

         [HideInInspector] _CullMode("__cullmode", Float) = 2.0
         [HideInInspector] _ZTestMode("_ZTestMode", Int) = 8
 
-        [Enum(None, 0, DoubleSided, 1)] _DoubleSidedMode("Double sided mode", Float) = 0
+        [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
+
+        // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
+        // value that exist to identify if the GI emission need to be enabled.
+        // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
+        // TODO: Fix the code in legacy unity so we can customize the beahvior for GI
+        _EmissionColor("Color", Color) = (1, 1, 1)
     }
 
     HLSLINCLUDE
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON
-    #pragma shader_feature _ _DOUBLESIDED
+    // #pragma shader_feature _DOUBLESIDED_ON - We have no lighting, so no need to have this combination for shader, the option will just disable backface culling
 
     #pragma shader_feature _EMISSIVE_COLOR_MAP
 

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

 float _EmissiveIntensity;
 
 float _AlphaCutoff;
+
+// Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
+// value that exist to identify if the GI emission need to be enabled.
+// In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
+// TODO: Fix the code in legacy unity so we can customize the beahvior for GI
+float3 _EmissionColor;

Assets/ScriptableRenderPipeline/HDRenderPipeline/PostProcess/Editor/PostProcessingEditor.cs

             public SerializedProperty intensity;
             public SerializedProperty smoothness;
         }
-
-        public class BloomSettings
-        {
-            public SerializedProperty enabled;
-            public SerializedProperty intensity;
-            public SerializedProperty threshold;
-            public SerializedProperty softKnee;
-            public SerializedProperty radius;
-            public SerializedProperty lensTexture;
-            public SerializedProperty lensIntensity;
-        }
         #endregion
 
         public ColorGradingSettings colorGrading;
-        public BloomSettings bloomSettings;
         public SerializedProperty globalDithering;
 
         SerializedProperty FindProperty<TValue>(Expression<Func<PostProcessing, TValue>> expr)
                 smoothness = FindProperty(x => x.vignetteSettings.smoothness)
             };
 
-            bloomSettings = new BloomSettings
-            {
-                enabled = FindProperty(x => x.bloomSettings.enabled),
-
-                intensity = FindProperty(x => x.bloomSettings.intensity),
-                threshold = FindProperty(x => x.bloomSettings.threshold),
-
-                softKnee = FindProperty(x => x.bloomSettings.softKnee),
-                radius = FindProperty(x => x.bloomSettings.radius),
-
-                lensTexture = FindProperty(x => x.bloomSettings.lensTexture),
-                lensIntensity = FindProperty(x => x.bloomSettings.lensIntensity)
-            };
-
             globalDithering = FindProperty(x => x.globalDithering);
         }
 
 
             Do("Color Grading", ColorGradingUI);
             Do("Eye Adaptation", EyeAdaptationUI);
-            Do("Bloom", BloomUI);
             Do("Chromatic Aberration", ChromaticAberrationUI);
             Do("Vignette", VignetteUI);
 
                     EditorGUILayout.PropertyField(eyeAdaptation.speedDown);
                     EditorGUI.indentLevel--;
                 }
-            }
-        }
-
-        void BloomUI()
-        {
-            EditorGUILayout.PropertyField(bloomSettings.enabled);
-
-            if (bloomSettings.enabled.boolValue)
-            {
-                EditorGUILayout.PropertyField(bloomSettings.intensity);
-                EditorGUILayout.PropertyField(bloomSettings.threshold);
-
-                EditorGUILayout.PropertyField(bloomSettings.softKnee);
-                EditorGUILayout.PropertyField(bloomSettings.radius);
-
-                EditorGUILayout.PropertyField(bloomSettings.lensTexture);
-                EditorGUILayout.PropertyField(bloomSettings.lensIntensity);
-
-                bloomSettings.intensity.floatValue = Mathf.Max(0f, bloomSettings.intensity.floatValue);
-                bloomSettings.threshold.floatValue = Mathf.Max(0f, bloomSettings.threshold.floatValue);
-                bloomSettings.lensIntensity.floatValue = Mathf.Max(0f, bloomSettings.lensIntensity.floatValue);
             }
         }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/PostProcess/PostProcessing.Settings.cs

-using System;
+using System;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
 
             [Range(0f, 1f)] public float intensity = 0.3f;
             [Range(0f, 1f)] public float smoothness = 0.3f;
-        }
-
-        [Serializable]
-        public sealed class BloomSettings
-        {
-            public bool enabled = false;
-
-            public float intensity = 0.5f;
-            public float threshold = 1.1f;
-
-            [Range(0f, 1f)] public float softKnee = 0.5f;
-            [Range(1f, 7f)] public float radius = 5f;
-
-            public Texture lensTexture;
-            public float lensIntensity = 3f;
         }
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/PostProcess/PostProcessing.cs

     [RequireComponent(typeof(Camera))]
     public sealed partial class PostProcessing : MonoBehaviour
     {
-        // Quick & very dirty temporary wrapper used for bloom (easy porting from old school render
-        // texture blitting to command buffers)
-        struct RenderTextureWrapper
-        {
-            static int s_Counter = 0;
-
-            public int id;
-            public RenderTargetIdentifier identifier;
-            public int width;
-            public int height;
-            public int depth;
-            public FilterMode filter;
-            public RenderTextureFormat format;
-
-            internal void Release(CommandBuffer cmd)
-            {
-                cmd.ReleaseTemporaryRT(id);
-                id = 0;
-            }
-
-            internal static RenderTextureWrapper Create(CommandBuffer cmd, int width, int height, int depth = 0, FilterMode filter = FilterMode.Bilinear, RenderTextureFormat format = RenderTextureFormat.DefaultHDR)
-            {
-                s_Counter++;
-
-                int id = Shader.PropertyToID("_TempRenderTexture_" + s_Counter);
-                cmd.GetTemporaryRT(id, width, height, depth, filter, format);
-
-                return new RenderTextureWrapper
-                {
-                    id = id,
-                    identifier = new RenderTargetIdentifier(id),
-                    width = width,
-                    height = height,
-                    depth = depth,
-                    filter = filter,
-                    format = format
-                };
-            }
-        }
-
-        public BloomSettings bloomSettings = new BloomSettings();
-        Material m_BloomMaterial;
         Material m_FinalPassMaterial;
 
         ComputeShader m_EyeCompute;
 
         static uint[] s_EmptyHistogramBuffer = new uint[k_HistogramBins];
 
-        const int k_MaxPyramidBlurLevel = 16;
-        readonly RenderTextureWrapper[] m_BlurBuffer1 = new RenderTextureWrapper[k_MaxPyramidBlurLevel];
-        readonly RenderTextureWrapper[] m_BlurBuffer2 = new RenderTextureWrapper[k_MaxPyramidBlurLevel];
-        RenderTextureWrapper m_BloomTex;
-
         bool m_FirstFrame = true;
 
         // Don't forget to update 'EyeAdaptation.cginc' if you change these values !
         void OnEnable()
         {
             m_EyeAdaptationMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/EyeAdaptation");
-            m_BloomMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Bloom");
             m_FinalPassMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/FinalPass");
 
             m_EyeCompute = Resources.Load<ComputeShader>("EyeHistogram");
         void OnDisable()
         {
             Utilities.Destroy(m_EyeAdaptationMaterial);
-            Utilities.Destroy(m_BloomMaterial);
             Utilities.Destroy(m_FinalPassMaterial);
 
             foreach (var rt in m_AutoExposurePool)
             Utilities.SafeRelease(m_HistogramBuffer);
 
             m_EyeAdaptationMaterial = null;
-            m_BloomMaterial = null;
             m_FinalPassMaterial = null;
         }
 
             if (eyeAdaptation.enabled)
                 DoEyeAdaptation(camera, cmd, source);
 
-            if (bloomSettings.enabled)
-                DoBloom(camera, cmd, source);
-
             if (chromaSettings.enabled)
                 DoChromaticAberration();
 
             DoColorGrading();
 
             cmd.Blit(source, destination, m_FinalPassMaterial, 0);
-
-            if (bloomSettings.enabled)
-                m_BloomTex.Release(cmd);
 
             context.ExecuteCommandBuffer(cmd);
             cmd.Dispose();
             m_FirstFrame = false;
         }
 
-        void DoBloom(Camera camera, CommandBuffer cmd, RenderTargetIdentifier source)
-        {
-            m_BloomMaterial.shaderKeywords = null;
-
-            // Apply auto exposure before the prefiltering pass if needed
-            if (eyeAdaptation.enabled)
-            {
-                m_BloomMaterial.EnableKeyword("EYE_ADAPTATION");
-                m_BloomMaterial.SetTexture(Uniforms._AutoExposure, m_CurrentAutoExposure);
-            }
-
-            // Do bloom on a half-res buffer, full-res doesn't bring much and kills performances on
-            // fillrate limited platforms
-            int tw = camera.pixelWidth / 2;
-            int th = camera.pixelHeight / 2;
-
-            // Determine the iteration count
-            float logh = Mathf.Log(th, 2f) + bloomSettings.radius - 8f;
-            int logh_i = (int)logh;
-            int iterations = Mathf.Clamp(logh_i, 1, k_MaxPyramidBlurLevel);
-
-            // Uupdate the shader properties
-            float lthresh = Mathf.GammaToLinearSpace(bloomSettings.threshold);;
-            m_BloomMaterial.SetFloat(Uniforms._Threshold, lthresh);
-
-            float knee = lthresh * bloomSettings.softKnee + 1e-5f;
-            var curve = new Vector3(lthresh - knee, knee * 2f, 0.25f / knee);
-            m_BloomMaterial.SetVector(Uniforms._Curve, curve);
-
-            float sampleScale = 0.5f + logh - logh_i;
-            m_BloomMaterial.SetFloat(Uniforms._SampleScale, sampleScale);
-
-            // Prefilter pass
-            var prefiltered = RenderTextureWrapper.Create(cmd, tw, th, 0, FilterMode.Point);
-            cmd.Blit(source, prefiltered.identifier, m_BloomMaterial, 0);
-
-            var last = prefiltered;
-
-            // Construct a mip pyramid
-            for (int level = 0; level < iterations; level++)
-            {
-                m_BlurBuffer1[level] = RenderTextureWrapper.Create(cmd, last.width / 2, last.height / 2);
-                cmd.Blit(last.identifier, m_BlurBuffer1[level].identifier, m_BloomMaterial, level == 0 ? 1 : 2);
-                last = m_BlurBuffer1[level];
-            }
-
-            // Upsample and combine loop
-            for (int level = iterations - 2; level >= 0; level--)
-            {
-                var baseTex = m_BlurBuffer1[level];
-                cmd.SetGlobalTexture(Uniforms._BaseTex, baseTex.identifier); // Boooo
-
-                m_BlurBuffer2[level] = RenderTextureWrapper.Create(cmd, baseTex.width, baseTex.height);
-
-                cmd.Blit(last.identifier, m_BlurBuffer2[level].identifier, m_BloomMaterial, 3);
-                last = m_BlurBuffer2[level];
-            }
-
-            m_BloomTex = last;
-
-            // Release the temporary buffers
-            for (int i = 0; i < k_MaxPyramidBlurLevel; i++)
-            {
-                if (m_BlurBuffer1[i].id != 0)
-                    m_BlurBuffer1[i].Release(cmd);
-
-                if (m_BlurBuffer2[i].id != 0 && m_BlurBuffer2[i].id != m_BloomTex.id)
-                    m_BlurBuffer2[i].Release(cmd);
-            }
-
-            prefiltered.Release(cmd);
-
-            // Push everything to the uber material
-            m_FinalPassMaterial.EnableKeyword("BLOOM");
-
-            cmd.SetGlobalTexture(Uniforms._BloomTex, m_BloomTex.identifier);
-            cmd.SetGlobalVector(Uniforms._Bloom_Settings, new Vector2(sampleScale, bloomSettings.intensity));
-
-            if (bloomSettings.lensIntensity > 0f && bloomSettings.lensTexture != null)
-            {
-                m_FinalPassMaterial.EnableKeyword("BLOOM_LENS_DIRT");
-                cmd.SetGlobalTexture(Uniforms._Bloom_DirtTex, bloomSettings.lensTexture);
-                cmd.SetGlobalFloat(Uniforms._Bloom_DirtIntensity, bloomSettings.lensIntensity);
-            }
-        }
-
         void DoChromaticAberration()
         {
             var spectralLut = chromaSettings.spectralTexture == null
             internal static readonly int _AutoExposure               = Shader.PropertyToID("_AutoExposure");
 
             internal static readonly int _DebugWidth                 = Shader.PropertyToID("_DebugWidth");
-
-            internal static readonly int _Threshold                  = Shader.PropertyToID("_Threshold");
-            internal static readonly int _Curve                      = Shader.PropertyToID("_Curve");
-            internal static readonly int _SampleScale                = Shader.PropertyToID("_SampleScale");
-            internal static readonly int _BaseTex                    = Shader.PropertyToID("_BaseTex");
-            internal static readonly int _BloomTex                   = Shader.PropertyToID("_BloomTex");
-            internal static readonly int _Bloom_Settings             = Shader.PropertyToID("_Bloom_Settings");
-            internal static readonly int _Bloom_DirtTex              = Shader.PropertyToID("_Bloom_DirtTex");
-            internal static readonly int _Bloom_DirtIntensity        = Shader.PropertyToID("_Bloom_DirtIntensity");
 
             internal static readonly int _ChromaticAberration_Amount = Shader.PropertyToID("_ChromaticAberration_Amount");
             internal static readonly int _ChromaticAberration_Lut    = Shader.PropertyToID("_ChromaticAberration_Lut");

Assets/ScriptableRenderPipeline/HDRenderPipeline/PostProcess/Resources/FinalPass.shader

         #include "ShaderLibrary/Common.hlsl"
         #include "HDRenderPipeline/ShaderVariables.hlsl"
         #include "ColorGrading.hlsl"
-        #include "Bloom.hlsl"
 
         TEXTURE2D(_MainTex);
         SAMPLER2D(sampler_MainTex);
         float4 _LogLut_Params;
 
         float _Exposure;
-
-        TEXTURE2D(_BloomTex);
-        SAMPLER2D(sampler_BloomTex);
-        float4 _BloomTex_TexelSize;
-        float2 _Bloom_Settings; // x: sampleScale, y: bloom.intensity
-
-        TEXTURE2D(_Bloom_DirtTex);
-        SAMPLER2D(sampler_Bloom_DirtTex);
-        float _Bloom_DirtIntensity;
 
         float4 _NeutralTonemapperParams1;
         float4 _NeutralTonemapperParams2;
             }
             #endif
 
-            #if BLOOM
-            {
-                float3 bloom = UpsampleFilter(TEXTURE2D_PARAM(_BloomTex, sampler_BloomTex), uv, _BloomTex_TexelSize.xy, _Bloom_Settings.x) * _Bloom_Settings.y; // Flipped
-                color += bloom;
-
-                #if BLOOM_LENS_DIRT
-                {
-                    float3 dirt = SAMPLE_TEXTURE2D(_Bloom_DirtTex, sampler_Bloom_DirtTex, uv).rgb * _Bloom_DirtIntensity; // Flipped
-                    color += bloom * dirt;
-                }
-                #endif
-            }
-            #endif
-
             #if VIGNETTE
             {
                 float2 d = abs(uv - _Vignette_Settings.zw) * _Vignette_Settings.x;
                 #pragma fragment Frag
                 #pragma multi_compile __ NEUTRAL_GRADING CUSTOM_GRADING
                 #pragma multi_compile __ EYE_ADAPTATION
-                #pragma multi_compile __ BLOOM
-                #pragma multi_compile __ BLOOM_LENS_DIRT
                 #pragma multi_compile __ CHROMATIC_ABERRATION
                 #pragma multi_compile __ VIGNETTE
                 #pragma multi_compile __ DITHERING

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/SubsurfaceScatteringParameters.cs

 using System;
+using UnityEngine.Rendering;
 #if UNITY_EDITOR
     using UnityEditor;
 #endif
     public class SubsurfaceScatteringProfile
     {
         public const int numSamples = 7; // Must be an odd number
-        public const int numVectors = 8; // numSamples + 1 for (1 / (2 * WeightedVariance))
-        
+
-        Color       m_StdDev1;
+        public Color   stdDev1;
-        Color       m_StdDev2;
+        public Color   stdDev2;
-        float       m_LerpWeight;
+        public float   lerpWeight;
-        Vector4[]   m_FilterKernel;
+        public bool    enableTransmission;
-        public bool m_KernelNeedsUpdate;
+        public Vector2 thicknessRemap;
+        [SerializeField] [HideInInspector]
+        Vector4[]      m_FilterKernel;
+        [SerializeField] [HideInInspector]
+        Vector3[]      m_HalfRcpVariances;
+        [SerializeField] [HideInInspector]
+        Vector4        m_HalfRcpWeightedVariances;
-            m_StdDev1    = new Color(0.3f, 0.3f, 0.3f, 0.0f);
-            m_StdDev2    = new Color(1.0f, 1.0f, 1.0f, 0.0f);
-            m_LerpWeight = 0.5f;
-            ComputeKernel();
-        }
+            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;
+            enableTransmission = false;
+            thicknessRemap     = new Vector2(0, 3);
-        public Color stdDev1
-        {
-            get { return m_StdDev1; }
-            set { if (m_StdDev1 != value) { m_StdDev1 = value; m_KernelNeedsUpdate = true; } }
-        }
-
-        public Color stdDev2
-        {
-            get { return m_StdDev2; }
-            set { if (m_StdDev2 != value) { m_StdDev2 = value; m_KernelNeedsUpdate = true; } }
-        }
-
-        public float lerpWeight
-        {
-            get { return m_LerpWeight; }
-            set { if (m_LerpWeight != value) { m_LerpWeight = value; m_KernelNeedsUpdate = true; } }
+            UpdateKernelAndVarianceData();
-            get { if (m_KernelNeedsUpdate) ComputeKernel(); return m_FilterKernel; }
-        }
-
-        public void SetDirtyFlag()
-        {
-            m_KernelNeedsUpdate = true;
+            // Set via UpdateKernelAndVarianceData().
+            get { return m_FilterKernel; }
-        // --- Private Methods ---
-
-        static float Gaussian(float x, float stdDev)
+        public Vector3[] halfRcpVariances
-            float variance = stdDev * stdDev;
-            return Mathf.Exp(-x * x / (2 * variance)) / Mathf.Sqrt(2 * Mathf.PI * variance);
+            // Set via UpdateKernelAndVarianceData().
+            get { return m_HalfRcpVariances; }
-        static float GaussianCombination(float x, float stdDev1, float stdDev2, float lerpWeight)
+        public Vector4 halfRcpWeightedVariances
-            return Mathf.Lerp(Gaussian(x, stdDev1), Gaussian(x, stdDev2), lerpWeight);
+            // Set via UpdateKernelAndVarianceData().
+            get { return m_HalfRcpWeightedVariances; }
-        static float RationalApproximation(float t)
-        {
-            // Abramowitz and Stegun formula 26.2.23.
-            // The absolute value of the error should be less than 4.5 e-4.
-            float[] c = {2.515517f, 0.802853f, 0.010328f};
-            float[] d = {1.432788f, 0.189269f, 0.001308f};
-            return t - ((c[2] * t + c[1]) * t + c[0]) / (((d[2] * t + d[1]) * t + d[0]) * t + 1.0f);
-        }
- 
-        // Ref: https://www.johndcook.com/blog/csharp_phi_inverse/
-        static float NormalCdfInverse(float p, float stdDev)
+        public void UpdateKernelAndVarianceData()
-            float x;
-
-            if (p < 0.5)
+            if (m_FilterKernel == null)
-                // F^-1(p) = - G^-1(p)
-                x = -RationalApproximation(Mathf.Sqrt(-2.0f * Mathf.Log(p)));
-            }
-            else
-            {
-                // F^-1(p) = G^-1(1-p)
-                x = RationalApproximation(Mathf.Sqrt(-2.0f * Mathf.Log(1.0f - p)));
+                m_FilterKernel = new Vector4[numSamples];
-            return x * stdDev;
-        }
-
-        static float GaussianCombinationCdfInverse(float p, float stdDev1, float stdDev2, float lerpWeight)
-        {
-            return Mathf.Lerp(NormalCdfInverse(p, stdDev1), NormalCdfInverse(p, stdDev2), lerpWeight);
-        }
-
-        void ComputeKernel()
-        {
-            if (m_FilterKernel == null || m_FilterKernel.Length != numVectors)
+            if (m_HalfRcpVariances == null)
-                m_FilterKernel = new Vector4[numVectors];
+                m_HalfRcpVariances = new Vector3[2];
             }
 
             // Our goal is to blur the image using a filter which is represented
             // It is separable by design, but generally not radially symmetric.
 
             // Find the widest Gaussian across 3 color channels.
-            float maxStdDev1 = Mathf.Max(m_StdDev1.r, m_StdDev1.g, m_StdDev1.b);
-            float maxStdDev2 = Mathf.Max(m_StdDev2.r, m_StdDev2.g, m_StdDev2.b);
+            float maxStdDev1 = Mathf.Max(stdDev1.r, stdDev1.g, stdDev1.b);
+            float maxStdDev2 = Mathf.Max(stdDev2.r, stdDev2.g, stdDev2.b);
-            Vector3 weightSum = new Vector3(0, 0, 0); 
+            Vector3 weightSum = new Vector3(0, 0, 0);
-                float pos = GaussianCombinationCdfInverse(u, maxStdDev1, maxStdDev2, m_LerpWeight);
-                float pdf = GaussianCombination(pos, maxStdDev1, maxStdDev2, m_LerpWeight);
+                float pos = GaussianCombinationCdfInverse(u, maxStdDev1, maxStdDev2, lerpWeight);
+                float pdf = GaussianCombination(pos, maxStdDev1, maxStdDev2, lerpWeight);
-                val.x = GaussianCombination(pos, m_StdDev1.r, m_StdDev2.r, m_LerpWeight);
-                val.y = GaussianCombination(pos, m_StdDev1.g, m_StdDev2.g, m_LerpWeight);
-                val.z = GaussianCombination(pos, m_StdDev1.b, m_StdDev2.b, m_LerpWeight);
+                val.x = GaussianCombination(pos, stdDev1.r, stdDev2.r, lerpWeight);
+                val.y = GaussianCombination(pos, stdDev1.g, stdDev2.g, lerpWeight);
+                val.z = GaussianCombination(pos, stdDev1.b, stdDev2.b, lerpWeight);
 
                 // We do not divide by 'numSamples' since we will renormalize, anyway.
                 m_FilterKernel[i].x = val.x * (1 / pdf);
                 m_FilterKernel[i].z *= 1 / weightSum.z;
             }
 
+            // Store (1 / (2 * Variance)) per color channel per Gaussian.
+            m_HalfRcpVariances[0].x = 0.5f / (stdDev1.r * stdDev1.r);
+            m_HalfRcpVariances[0].y = 0.5f / (stdDev1.g * stdDev1.g);
+            m_HalfRcpVariances[0].z = 0.5f / (stdDev1.b * stdDev1.b);
+            m_HalfRcpVariances[1].x = 0.5f / (stdDev2.r * stdDev2.r);
+            m_HalfRcpVariances[1].y = 0.5f / (stdDev2.g * stdDev2.g);
+            m_HalfRcpVariances[1].z = 0.5f / (stdDev2.b * stdDev2.b);
+
-            weightedStdDev.x = Mathf.Lerp(m_StdDev1.r, m_StdDev2.r, m_LerpWeight);
-            weightedStdDev.y = Mathf.Lerp(m_StdDev1.g, m_StdDev2.g, m_LerpWeight);
-            weightedStdDev.z = Mathf.Lerp(m_StdDev1.b, m_StdDev2.b, m_LerpWeight);
-            weightedStdDev.w = Mathf.Lerp(maxStdDev1,  maxStdDev2,  m_LerpWeight);
+            weightedStdDev.x = Mathf.Lerp(stdDev1.r,  stdDev2.r,  lerpWeight);
+            weightedStdDev.y = Mathf.Lerp(stdDev1.g,  stdDev2.g,  lerpWeight);
+            weightedStdDev.z = Mathf.Lerp(stdDev1.b,  stdDev2.b,  lerpWeight);
+            weightedStdDev.w = Mathf.Lerp(maxStdDev1, maxStdDev2, lerpWeight);
+
+            // Store (1 / (2 * WeightedVariance)) per color channel.
+            m_HalfRcpWeightedVariances.x = 0.5f / (weightedStdDev.x * weightedStdDev.x);
+            m_HalfRcpWeightedVariances.y = 0.5f / (weightedStdDev.y * weightedStdDev.y);
+            m_HalfRcpWeightedVariances.z = 0.5f / (weightedStdDev.z * weightedStdDev.z);
+            m_HalfRcpWeightedVariances.w = 0.5f / (weightedStdDev.w * weightedStdDev.w);
+        }
+
+        // --- Private Methods ---
+
+        static float Gaussian(float x, float stdDev)
+        {
+            float variance = stdDev * stdDev;
+            return Mathf.Exp(-x * x / (2 * variance)) / Mathf.Sqrt(2 * Mathf.PI * variance);
+        }
+
+        static float GaussianCombination(float x, float stdDev1, float stdDev2, float lerpWeight)
+        {
+            return Mathf.Lerp(Gaussian(x, stdDev1), Gaussian(x, stdDev2), lerpWeight);
+        }
+
+        static float RationalApproximation(float t)
+        {
+            // Abramowitz and Stegun formula 26.2.23.
+            // The absolute value of the error should be less than 4.5 e-4.
+            float[] c = {2.515517f, 0.802853f, 0.010328f};
+            float[] d = {1.432788f, 0.189269f, 0.001308f};
+            return t - ((c[2] * t + c[1]) * t + c[0]) / (((d[2] * t + d[1]) * t + d[0]) * t + 1.0f);
+        }
+
+        // Ref: https://www.johndcook.com/blog/csharp_phi_inverse/
+        static float NormalCdfInverse(float p, float stdDev)
+        {
+            float x;
+
+            if (p < 0.5)
+            {
+                // F^-1(p) = - G^-1(p)
+                x = -RationalApproximation(Mathf.Sqrt(-2.0f * Mathf.Log(p)));
+            }
+            else
+            {
+                // F^-1(p) = G^-1(1-p)
+                x = RationalApproximation(Mathf.Sqrt(-2.0f * Mathf.Log(1.0f - p)));
+            }
-            // Store (1 / (2 * Variance)) per color channel.
-            m_FilterKernel[numSamples].x = 0.5f / (weightedStdDev.x * weightedStdDev.x);
-            m_FilterKernel[numSamples].y = 0.5f / (weightedStdDev.y * weightedStdDev.y);
-            m_FilterKernel[numSamples].z = 0.5f / (weightedStdDev.z * weightedStdDev.z);
-            m_FilterKernel[numSamples].w = 0.5f / (weightedStdDev.w * weightedStdDev.w);
+            return x * stdDev;
+        }
+
+        static float GaussianCombinationCdfInverse(float p, float stdDev1, float stdDev2, float lerpWeight)
+        {
+            return Mathf.Lerp(NormalCdfInverse(p, stdDev1), NormalCdfInverse(p, stdDev2), lerpWeight);
         }
     }
 
+
-        int m_NumProfiles;
+        bool                          m_EnableSSS;
+        [SerializeField]
+        int                           m_NumProfiles;
+        [SerializeField]
+        int                           m_TransmissionFlags;
+        [SerializeField]
+        float[]                       m_ThicknessRemaps;
+        [SerializeField]
+        Vector4[]                     m_HalfRcpVariancesAndLerpWeights;
+        [SerializeField]
+        Vector4[]                     m_HalfRcpWeightedVariances;
+        [SerializeField]
+        Vector4[]                     m_FilterKernels;
+            m_EnableSSS   = true;
             m_NumProfiles = 1;
             m_Profiles    = new SubsurfaceScatteringProfile[m_NumProfiles];
 
             }
+
+            OnValidate();
-        public SubsurfaceScatteringProfile[] profiles { set { m_Profiles = value; OnValidate(); } get { return m_Profiles; } }
+        public bool enableSSS {
+            // Set via serialization.
+            get { return m_EnableSSS; }
+        }
-        public void SetDirtyFlag()
+        public SubsurfaceScatteringProfile[] profiles {
+            // Set via serialization.
+            get { return m_Profiles; }
+        }
+
+        // Returns a bit mask s.t. the i-th bit indicates whether the i-th profile requires transmittance evaluation.
+        // Supplies '_TransmissionFlags' to Lit.hlsl.
+        public int transmissionFlags {
+            // Set during OnValidate().
+            get { return m_TransmissionFlags; }
+        }
+
+        // Supplies '_ThicknessRemaps' to Lit.hlsl.
+        public float[] thicknessRemaps
-            for (int i = 0; i < m_Profiles.Length; i++)
-            {
-                m_Profiles[i].SetDirtyFlag();
-            }
+            // Set during OnValidate().
+            get { return m_ThicknessRemaps; }
+        }
+
+        // Supplies '_HalfRcpVariancesAndLerpWeights' to Lit.hlsl.
+        public Vector4[] halfRcpVariancesAndLerpWeights {
+            // Set during OnValidate().
+            get { return m_HalfRcpVariancesAndLerpWeights; }
+        }
+
+        // Supplies '_HalfRcpWeightedVariances' to CombineSubsurfaceScattering.shader.
+        public Vector4[] halfRcpWeightedVariances {
+            // Set during OnValidate().
+            get { return m_HalfRcpWeightedVariances; }
-        // --- Private Methods ---
+        // Supplies '_FilterKernels' to CombineSubsurfaceScattering.shader.
+        public Vector4[] filterKernels
+        {
+            // Set during OnValidate().
+            get { return m_FilterKernels; }
+        }
-        void OnValidate()
+        public void OnValidate()
         {
             if (m_Profiles.Length > maxNumProfiles)
             {
-            m_NumProfiles = m_Profiles.Length;
+            m_NumProfiles       = m_Profiles.Length;
+            m_TransmissionFlags = 0;
+
+            if (m_ThicknessRemaps == null)
+            {
+                m_ThicknessRemaps = new float[maxNumProfiles * 2];
+            }
+
+            if (m_HalfRcpVariancesAndLerpWeights == null)
+            {
+                m_HalfRcpVariancesAndLerpWeights = new Vector4[maxNumProfiles * 2];
+            }
+
+            if (m_HalfRcpWeightedVariances == null)
+            {
+                m_HalfRcpWeightedVariances = new Vector4[maxNumProfiles];
+            }
+
+            if (m_FilterKernels == null)
+            {
+                m_FilterKernels = new Vector4[maxNumProfiles * SubsurfaceScatteringProfile.numSamples];
+            }
+                m_TransmissionFlags |= (m_Profiles[i].enableTransmission ? 1 : 0) << i;
+
                 c.r = Mathf.Clamp(m_Profiles[i].stdDev1.r, 0.05f, 2.0f);
                 c.g = Mathf.Clamp(m_Profiles[i].stdDev1.g, 0.05f, 2.0f);
                 c.b = Mathf.Clamp(m_Profiles[i].stdDev1.b, 0.05f, 2.0f);
                 m_Profiles[i].stdDev2 = c;
 
                 m_Profiles[i].lerpWeight = Mathf.Clamp01(m_Profiles[i].lerpWeight);
+
+                m_Profiles[i].thicknessRemap.x = Mathf.Clamp(m_Profiles[i].thicknessRemap.x, 0, m_Profiles[i].thicknessRemap.y);
+                m_Profiles[i].thicknessRemap.y = Mathf.Max(m_Profiles[i].thicknessRemap.x, m_Profiles[i].thicknessRemap.y);
+
+                m_Profiles[i].UpdateKernelAndVarianceData();
+            }
+
+            // Use the updated data to fill the cache.
+            for (int i = 0; i < m_NumProfiles; i++)
+            {
+                m_ThicknessRemaps[2 * i]                      = m_Profiles[i].thicknessRemap.x;
+                m_ThicknessRemaps[2 * i + 1]                  = m_Profiles[i].thicknessRemap.y - m_Profiles[i].thicknessRemap.x;
+                m_HalfRcpVariancesAndLerpWeights[2 * i]       = m_Profiles[i].halfRcpVariances[0];
+                m_HalfRcpVariancesAndLerpWeights[2 * i].w     = 1.0f - m_Profiles[i].lerpWeight;
+                m_HalfRcpVariancesAndLerpWeights[2 * i + 1]   = m_Profiles[i].halfRcpVariances[1];
+                m_HalfRcpVariancesAndLerpWeights[2 * i + 1].w = m_Profiles[i].lerpWeight;
+                m_HalfRcpWeightedVariances[i]                 = m_Profiles[i].halfRcpWeightedVariances;
+
+                for (int j = 0, n = SubsurfaceScatteringProfile.numSamples; j < n; j++)
+                {
+                    m_FilterKernels[n * i + j] = m_Profiles[i].filterKernel[j];
+                }
             }
         }
     }
     {
         private class Styles
         {
-            public readonly GUIContent sssCategory          = new GUIContent("Subsurface scattering");
-            public readonly GUIContent sssProfileStdDev1    = new GUIContent("SSS profile 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("SSS profile 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("SSS profile filter interpolation", "Controls linear interpolation between the two Gaussian filters.");
+            public readonly GUIContent category              = new GUIContent("Subsurface scattering parameters");
+            public readonly GUIContent[] profiles            = new GUIContent[SubsurfaceScatteringParameters.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 profilePreview0       = new GUIContent("Profile preview");
+            public readonly GUIContent profilePreview1       = new GUIContent("Shows the fraction of light scattered from the source as radius increases to 1.");
+            public readonly GUIContent profilePreview2       = new GUIContent("Note that the intensity of the region in the center may be clamped.");
+            public readonly GUIContent transmittancePreview0 = new GUIContent("Transmittance preview");
+            public readonly GUIContent transmittancePreview1 = new GUIContent("Shows the fraction of light passing through the object as thickness increases to 1.");
+            public readonly GUIContent numProfiles           = new GUIContent("Number of profiles");
+            public readonly GUIContent profileStdDev1        = 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 profileStdDev2        = 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 profileLerpWeight     = new GUIContent("Filter interpolation",  "Controls linear interpolation between the two Gaussian filters.");
+            public readonly GUIContent profileTransmission   = new GUIContent("Enable transmission",   "Toggles simulation of light passing through thin objects. Depends on the thickness of the material.");
+            public readonly GUIContent profileThicknessRemap = new GUIContent("Thickness remap",       "Remaps the thickness parameter from [0, 1] to the desired range.");
+
+            public readonly GUIStyle   centeredMiniBoldLabel = new GUIStyle (GUI.skin.label);
-        private static Styles s_Styles;
-
-        private SerializedProperty m_Profiles;
+        private static Styles      s_Styles;
+        private SerializedProperty m_EnableSSS, m_Profiles, m_NumProfiles;
+        private Material           m_ProfileMaterial, m_TransmittanceMaterial;
+        private RenderTexture[]    m_ProfileImages, m_TransmittanceImages;
 
         // --- Public Methods ---
 
                 if (s_Styles == null)
                 {
                     s_Styles = new Styles();
+
+                    s_Styles.centeredMiniBoldLabel.alignment = TextAnchor.MiddleCenter;
+                    s_Styles.centeredMiniBoldLabel.fontSize  = 10;
+                    s_Styles.centeredMiniBoldLabel.fontStyle = FontStyle.Bold;
+
+        void OnEnable()
+        {
+            m_EnableSSS             = serializedObject.FindProperty("m_EnableSSS");
+            m_Profiles              = serializedObject.FindProperty("m_Profiles");
+            m_NumProfiles           = m_Profiles.FindPropertyRelative("Array.size");
+            m_ProfileMaterial       = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawGaussianProfile");
+            m_TransmittanceMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawTransmittanceGraph");
+            m_ProfileImages         = new RenderTexture[SubsurfaceScatteringParameters.maxNumProfiles];
+            m_TransmittanceImages   = new RenderTexture[SubsurfaceScatteringParameters.maxNumProfiles];
+
+            for (int i = 0; i < SubsurfaceScatteringParameters.maxNumProfiles; i++)
+            {
+                m_ProfileImages[i]       = new RenderTexture(256, 256, 0, RenderTextureFormat.DefaultHDR);
+                m_TransmittanceImages[i] = new RenderTexture(16,  256, 0, RenderTextureFormat.DefaultHDR);
+            }
+        }
+
-            EditorGUILayout.PropertyField(m_Profiles, true);
+
+            // Validate the data before displaying it.
+            ((SubsurfaceScatteringParameters)serializedObject.targetObject).OnValidate();
+
+            EditorGUILayout.LabelField(styles.category, EditorStyles.boldLabel);
+
+            EditorGUILayout.PropertyField(m_EnableSSS);
+            EditorGUILayout.PropertyField(m_NumProfiles, styles.numProfiles);
+            EditorGUILayout.PropertyField(m_Profiles);
+
+            if (m_Profiles.isExpanded)
+            {
+                EditorGUI.indentLevel++;
+
+                for (int i = 0, n = Math.Min(m_Profiles.arraySize, SubsurfaceScatteringParameters.maxNumProfiles); i < n; i++)
+                {
+                    SerializedProperty profile = m_Profiles.GetArrayElementAtIndex(i);
+			        EditorGUILayout.PropertyField(profile, styles.profiles[i]);
+
+                    if (profile.isExpanded)
+                    {
+                        EditorGUI.indentLevel++;
+
+                        SerializedProperty profileStdDev1        = profile.FindPropertyRelative("stdDev1");
+                        SerializedProperty profileStdDev2        = profile.FindPropertyRelative("stdDev2");
+                        SerializedProperty profileLerpWeight     = profile.FindPropertyRelative("lerpWeight");
+                        SerializedProperty profileTransmission   = profile.FindPropertyRelative("enableTransmission");
+                        SerializedProperty profileThicknessRemap = profile.FindPropertyRelative("thicknessRemap");
+
+                        EditorGUILayout.PropertyField(profileStdDev1,      styles.profileStdDev1);
+                        EditorGUILayout.PropertyField(profileStdDev2,      styles.profileStdDev2);
+                        EditorGUILayout.PropertyField(profileLerpWeight,   styles.profileLerpWeight);
+                        EditorGUILayout.PropertyField(profileTransmission, styles.profileTransmission);
+
+                        Vector2 thicknessRemap = profileThicknessRemap.vector2Value;
+                        EditorGUILayout.LabelField("Min thickness: ", thicknessRemap.x.ToString());
+                        EditorGUILayout.LabelField("Max thickness: ", thicknessRemap.y.ToString());
+                        EditorGUILayout.MinMaxSlider(styles.profileThicknessRemap, ref thicknessRemap.x, ref thicknessRemap.y, 0, 10);
+                        profileThicknessRemap.vector2Value = thicknessRemap;
+
+                        EditorGUILayout.Space();
+                        EditorGUILayout.LabelField(styles.profilePreview0, styles.centeredMiniBoldLabel);
+                        EditorGUILayout.LabelField(styles.profilePreview1, EditorStyles.centeredGreyMiniLabel);
+                        EditorGUILayout.LabelField(styles.profilePreview2, EditorStyles.centeredGreyMiniLabel);
+                        EditorGUILayout.Space();
+
+                        // Draw the profile.
+                        m_ProfileMaterial.SetColor("_StdDev1",    profileStdDev1.colorValue);
+                        m_ProfileMaterial.SetColor("_StdDev2",    profileStdDev2.colorValue);
+                        m_ProfileMaterial.SetFloat("_LerpWeight", profileLerpWeight.floatValue);
+                        EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(256, 256), m_ProfileImages[i], m_ProfileMaterial, ScaleMode.ScaleToFit, 1.0f);
+
+                        EditorGUILayout.Space();
+                        EditorGUILayout.LabelField(styles.transmittancePreview0, styles.centeredMiniBoldLabel);
+                        EditorGUILayout.LabelField(styles.transmittancePreview1, EditorStyles.centeredGreyMiniLabel);
+                        EditorGUILayout.Space();
+
+                        // Draw the transmittance graph.
+                        m_TransmittanceMaterial.SetColor("_StdDev1",         profileStdDev1.colorValue);
+                        m_TransmittanceMaterial.SetColor("_StdDev2",         profileStdDev2.colorValue);
+                        m_TransmittanceMaterial.SetFloat("_LerpWeight",      profileLerpWeight.floatValue);
+                        m_TransmittanceMaterial.SetVector("_ThicknessRemap", profileThicknessRemap.vector2Value);
+                        EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(16, 16), m_TransmittanceImages[i], m_TransmittanceMaterial, ScaleMode.ScaleToFit, 16.0f);
+
+                        EditorGUILayout.Space();
+
+                        EditorGUI.indentLevel--;
+                    }
+		        }
+
+                EditorGUI.indentLevel--;
+            }
+
+                // Serialization does not invoke setters, but does call OnValidate().
-                // Serialization ignores setters.
-                ((SubsurfaceScatteringParameters)target).SetDirtyFlag();
-        }
-
-        // --- Private Methods ---
-
-        void OnEnable()
-        {
-            m_Profiles = serializedObject.FindProperty("m_Profiles");
         }
     }
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass.meta

 fileFormatVersion: 2
-guid: e3b3ad4462341ec4b86566ec1fd82c7c
+guid: 057d8506536500045b3047320a4d6122
 folderAsset: yes
 timeCreated: 1476885561
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/FragInputs.hlsl

     float2 texCoord1;
     float2 texCoord2;
     float2 texCoord3;
-    float3 tangentToWorld[3]; // These 3 vectors are normalized (no need for the material to normalize) and these are only for UVSet 0
+
+    // TODO: confirm with Morten following statement
+    // Our TBN is orthogonal but is maybe not orthonormal in order to be compliant with external bakers (Like xnormal that use mikktspace).
+    // (xnormal for example take into account the interpolation when baking the normal and normalizing the tangent basis could cause distortion).
+    // When using worldToTangent with surface gradient, it doesn't normalize the tangent/bitangent vector (We instead use exact same scale as applied to interpolated vertex normal to avoid breaking compliance).
+    // this mean that any usage of worldToTangent[1] or worldToTangent[2] outside of the context of normal map (like for POM) must normalize the TBN (TCHECK if this make any difference ?)
+    // When not using surface gradient, each vector of worldToTangent are normalize (TODO: Maybe they should not even in case of no surface gradient ? Ask Morten) 
+    float3x3 worldToTangent;
 
     // For two sided lighting
     bool isFrontFace;
     FragInputs output;
     ZERO_INITIALIZE(FragInputs, output);
 
-    output.tangentToWorld[0] = float3(0.0, 0.0, 1.0);
-    output.tangentToWorld[2] = float3(0.0, 0.0, 1.0);
+    // Init to some default value to make the computer quiet (else it output "divide by zero" warning even if value is not used).
+    output.worldToTangent[0] = float3(0.0, 0.0, 1.0);
+    output.worldToTangent[2] = float3(0.0, 0.0, 1.0);
 
     return output;
 }
         result = float3(input.texCoord3, 0.0);
         break;
     case DEBUGVIEWVARYING_VERTEX_TANGENT_WS:
-        result = input.tangentToWorld[0].xyz * 0.5 + 0.5;
+        result = input.worldToTangent[0].xyz * 0.5 + 0.5;
-        result = input.tangentToWorld[1].xyz * 0.5 + 0.5;
+        result = input.worldToTangent[1].xyz * 0.5 + 0.5;
-        result = input.tangentToWorld[2].xyz * 0.5 + 0.5;
+        result = input.worldToTangent[2].xyz * 0.5 + 0.5;
         break;
     case DEBUGVIEWVARYING_VERTEX_COLOR:
         result = input.color.rgb; needLinearToSRGB = true;

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/VaryingMesh.hlsl

 #endif
 
 #ifdef VARYINGS_NEED_TANGENT_TO_WORLD
-    // Normalize the normal/tangent after interpolation
+    float4 tangentWS = float4(input.interpolators2.xyz, input.interpolators2.w > 0.0 ? 1.0 : -1.0);
+    // TODO: We should be able to not make distinction between the two path, but it mean material need to be aware to normalize the TBN when required, like for example for POM.
+    // For now do some test by keeping code consistent with previous visual.
+#ifdef SURFACE_GRADIENT
+    // Normalize normalWS vector but keep the renormFactor to apply it to bitangent and tangent
+    float renormFactor = 1.0 / length(input.interpolators1);
+    float3 normalWS = renormFactor * input.interpolators1;
+
+    // no normalizes is mandatory for tangentWS
+ 
+    // bitangent on the fly option in xnormal to reduce vertex shader outputs.
+    float3x3 worldToTangent = CreateWorldToTangent(normalWS, tangentWS.xyz, tangentWS.w);
+    output.worldToTangent[0] = worldToTangent[0];
+    // prepare for surfgrad formulation without breaking compliance (use exact same scale as applied to interpolated vertex normal to avoid breaking compliance).
+    output.worldToTangent[1] = worldToTangent[1] * renormFactor;
+    output.worldToTangent[2] = worldToTangent[2] * renormFactor;
+#else
+    // TODO: Check if we must do like for surface gradient (i.e not normalize ?) For now, for consistency with previous code we normalize
+    // Normalize after the interpolation
-    float4 tangentWS = float4(normalize(input.interpolators2.xyz), input.interpolators2.w);
-    float3x3 tangentToWorld = CreateTangentToWorld(normalWS, tangentWS.xyz, tangentWS.w);
-    output.tangentToWorld[0] = tangentToWorld[0];
-    output.tangentToWorld[1] = tangentToWorld[1];
-    output.tangentToWorld[2] = tangentToWorld[2];
+    tangentWS.xyz = normalize(tangentWS.xyz);
+
+    // bitangent on the fly option in xnormal to reduce vertex shader outputs.
+    float3x3 worldToTangent = CreateWorldToTangent(normalWS, tangentWS.xyz, tangentWS.w);
+    output.worldToTangent[0] = worldToTangent[0];
+    output.worldToTangent[1] = worldToTangent[1];
+    output.worldToTangent[2] = worldToTangent[2];
+
+#endif // VARYINGS_NEED_TANGENT_TO_WORLD
 
 #ifdef VARYINGS_NEED_TEXCOORD0 
     output.texCoord0 = input.interpolators3.xy;

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

     return mul(GetWorldToHClipMatrix(), float4(positionWS, 1.0));
 }
 
-float3x3 CreateTangentToWorld(float3 normal, float3 tangent, float tangentSign)
-{
-    // For odd-negative scale transforms we need to flip the sign
-    float sgn = tangentSign * GetOddNegativeScale();
-    float3 bitangent = cross(normal, tangent) * sgn;
-
-    return float3x3(tangent, bitangent, normal);
-}
-
 // Computes world space view direction, from object space position
 float3 GetWorldSpaceNormalizeViewDir(float3 positionWS)
 {
     return normalize(V);
 }
 
-float3 TransformTangentToWorld(float3 dirTS, float3 tangentToWorld[3])
+float3x3 CreateWorldToTangent(float3 normal, float3 tangent, float flipSign)
-    // TODO check: do we need to normalize ?
-    return normalize(mul(dirTS, float3x3(tangentToWorld[0].xyz, tangentToWorld[1].xyz, tangentToWorld[2].xyz)));
+    // For odd-negative scale transforms we need to flip the sign
+    float sgn = flipSign * GetOddNegativeScale();
+    float3 bitangent = cross(normal, tangent) * sgn;
+
+    return float3x3(tangent, bitangent, normal);
-// Assume TBN is orthonormal.
-float3 TransformWorldToTangent(float3 dirWS, float3 tangentToWorld[3])
+float3 TransformTangentToWorld(float3 dirTS, float3x3 worldToTangent)
-    // TODO check: do we need to normalize ?
-    return normalize(mul(float3x3(tangentToWorld[0].xyz, tangentToWorld[1].xyz, tangentToWorld[2].xyz), dirWS));
+    // Use transpose transformation to go from tangent to world as the matrix is orthogonal
+    return mul(dirTS, worldToTangent);
-float3 TransformTangentToObject(float3 dirTS, float3 worldToTangent[3])
+float3 TransformWorldToTangent(float3 dirWS, float3x3 worldToTangent)
-    // TODO check: do we need to normalize ?
-    // worldToTangent is orthonormal so inverse <==> transpose
-    float3x3 mWorldToTangent = float3x3(worldToTangent[0].xyz, worldToTangent[1].xyz, worldToTangent[2].xyz);
-    float3 normalWS = mul(dirTS, mWorldToTangent);
-    return normalize(mul((float3x3)unity_WorldToObject, normalWS));
+    return mul(worldToTangent, dirWS);
+}
+
+float3 TransformTangentToObject(float3 dirTS, float3x3 worldToTangent)
+{
+    // Use transpose transformation to go from tangent to world as the matrix is orthogonal
+    float3 normalWS = mul(dirTS, worldToTangent);
+    return mul((float3x3)unity_WorldToObject, normalWS);
-// Assume TBN is orthonormal.
-float3 TransformObjectToTangent(float3 dirOS, float3 worldToTangent[3])
+float3 TransformObjectToTangent(float3 dirOS, float3x3 worldToTangent)
-    // TODO check: do we need to normalize ?
-    return normalize(mul(float3x3(worldToTangent[0].xyz, worldToTangent[1].xyz, worldToTangent[2].xyz), mul((float3x3)unity_ObjectToWorld, dirOS)));
+    return mul(worldToTangent, mul((float3x3)unity_ObjectToWorld, dirOS));
 }
 #endif // UNITY_SHADER_VARIABLES_INCLUDED

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow.meta

 fileFormatVersion: 2
-guid: 74dbe7f252951f340bb1038a738db89e
+guid: f4cebcdbc19874c46ab4194e5ce59c67
 folderAsset: yes
 timeCreated: 1477395055
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow/Shadow.hlsl

-// TODO: 
-// - How to support a Gather sampling with such abstraction ?
-// - What's belong to shadow and what's belong to renderloop ? (shadowmap size depends on the usage of atlas or not)
-// - Is PunctualShadowData fixed or customizable ? Who is the owner ? Should it be pass to GetPunctualShadowAttenuation ? Sure it should...
-// - Could be return by GetShadowTextureCoordinate() and pass to GetPunctualShadowAttenuation(). But in this case, who control the atlas application ? 
-// TODO: 
-// Caution: formula doesn't work as we are texture atlas...
-// if (max3(abs(NDC.x), abs(NDC.y), 1.0 - texCoordXYZ.z) <= 1.0) return 1.0;
+#ifndef SHADOW_HLSL
+#define SHADOW_HLSL
+//
+// Shadow master include header.
+//
+// There are four relevant files for shadows.
+// First ShadowContext.hlsl must declare the specific ShadowContext struct and the loader that goes along with it.
+// ShadowContext loading and resource setup from C# must be in sync.
+//
+// Second there are two headers for shadow algorithms, whose signatures must match any of the Get...Attenuation function prototypes.
+// The first header contains engine defaults, whereas the second header is empty by default. All project specific custom shadow algorithms should go in there or leave empty.
+//
+// Last there's a dispatcher include. By default the Get...Attenuation functions are rerouted to their default implementations. This can be overridden for each
+// shadow type in the dispatcher source. For each overridden shadow type a specific define must be defined to prevent falling back to the default functions.
+//
+
+
+//#define SHADOWS_USE_SHADOWCTXT
+
+#ifdef  SHADOWS_USE_SHADOWCTXT
+#define SHADOW_SUPPORTS_DYNAMIC_INDEXING 0 // only on >= sm 5.1
+
+// TODO: Remove this once we've moved over to the new system. Also delete the undef at the bottom again.
+#define ShadowData ShadowDataExp
+
+#include "ShadowBase.cs.hlsl"	// ShadowData definition, auto generated (don't modify)
+#include "ShadowTexFetch.hlsl"	// Resource sampling definitions (don't modify)
+
+#define SHADOWCONTEXT_DECLARE( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )	\
+																										\
+	struct ShadowContext																				\
+	{																									\
+		StructuredBuffer<ShadowData>	shadowDatas;													\
+		StructuredBuffer<int4>			payloads;														\
+		Texture2DArray					tex2DArray[_Tex2DArraySlots];									\
+		TextureCubeArray				texCubeArray[_TexCubeArraySlots];								\
+		SamplerComparisonState			compSamplers[_SamplerCompSlots];								\
+		SamplerState					samplers[_SamplerSlots];										\
+	};																									\
+																										\
+	SHADOW_DEFINE_SAMPLING_FUNCS( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )
+
+// Shadow context definition and initialization, i.e. resource binding (project header, must be kept in sync with C# runtime)
+#include "ShadowContext.hlsl"
+
+// helper function to extract shadowmap data from the ShadowData struct
+void unpackShadowmapId( uint shadowmapId, out uint texIdx, out uint sampIdx, out float slice )
+{
+	texIdx  = (shadowmapId >> 24) & 0xff;
+	sampIdx = (shadowmapId >> 16) & 0xff;
+	slice   = (float)(shadowmapId & 0xffff);
+}
+void unpackShadowmapId( uint shadowmapId, out uint texIdx, out uint sampIdx )
+{
+	texIdx  = (shadowmapId >> 24) & 0xff;
+	sampIdx = (shadowmapId >> 16) & 0xff;
+}
+void unpackShadowmapId( uint shadowmapId, out float slice )
+{
+	slice = (float)(shadowmapId & 0xffff);
+}
+
+
+
+// shadow sampling prototypes
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L );
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L, float2 unPositionSS );
+// shadow sampling prototypes with screenspace info
+float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L );
+float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L, float2 unPositionSS );
+
+
+// wedge in the actual shadow sampling algorithms
+#include "ShadowSampling.hlsl"			// sampling patterns
+#include "ShadowAlgorithms.hlsl"		// engine default algorithms (don't modify)
+#include "ShadowAlgorithmsCustom.hlsl"	// project specific custom algorithms (project can modify this)
+
+
+// default dispatchers for the individual shadow types (with and without screenspace support)
+// point/spot light shadows
+float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L )
+{
+	return EvalShadow_PunctualDepth(shadowContext, positionWS, shadowDataIndex, L);
+}
+float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+{
+	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, shadowDataIndex, L );
+}
+// directional light shadows
+float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L )
+{
+	return EvalShadow_CascadedDepth( shadowContext, positionWS, shadowDataIndex, L );
+}
+float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+{
+	return GetDirectionalShadowAttenuationDefault( shadowContext, positionWS, shadowDataIndex, L );
+}
+
+// include project specific shadow dispatcher. If this file is not empty, it MUST define which default shadows it's overriding
+#include "ShadowDispatch.hlsl"
+
+// if shadow dispatch is empty we'll fall back to default shadow sampling implementations
+#ifndef SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L )
+{
+	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, shadowDataIndex, L );
+}
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+{
+	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, shadowDataIndex, L, unPositionSS );
+}
+#endif
+#ifndef SHADOW_DISPATCH_USE_CUSTOM_DIRECTIONAL
+float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L )
+{
+	return GetDirectionalShadowAttenuationDefault( shadowContext, positionWS, shadowDataIndex, L );
+}
+float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+{
+	return GetDirectionalShadowAttenuationDefault( shadowContext, positionWS, shadowDataIndex, L, unPositionSS );
+}
+#endif
+#undef ShadowData // TODO: Remove this once we've moved over to the new system. Also delete the define at the top again.
+
+#endif // SHADOWS_USE_SHADOWCTXT
+
+#endif // SHADOW_HLSL

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky.meta

 fileFormatVersion: 2
-guid: 066ab4d03bd03384f81c9d82b479f8dd
+guid: 99e8d5bd81663624399d10e3fc27571c
 folderAsset: yes
 timeCreated: 1479239906
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/Editor/HDRISkyEditor.cs

 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [CanEditMultipleObjects]
-    [CustomEditor(typeof(HDRISkyParameters))]
+    [CustomEditor(typeof(HDRISkySettings))]
     public class HDRISkyParametersEditor
         : Editor
     {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/HDRISkyRenderer.cs

     public class HDRISkyRenderer : SkyRenderer
     {
         Material m_SkyHDRIMaterial; // Renders a cubemap into a render texture (can be cube or 2D)
-        private HDRISkyParameters m_HdriSkyParams;
+        private HDRISkySettings m_HdriSkyParams;
-        public HDRISkyRenderer(HDRISkyParameters hdriSkyParams)
+        public HDRISkyRenderer(HDRISkySettings hdriSkyParams)
         {
             m_HdriSkyParams = hdriSkyParams;
         }
             }
         }
 
-        public override void RenderSky(BuiltinSkyParameters builtinParams, SkyParameters skyParameters, bool renderForCubemap)
+        public override void RenderSky(BuiltinSkyParameters builtinParams, SkySettings skyParameters, bool renderForCubemap)
         {
             m_SkyHDRIMaterial.SetTexture("_Cubemap", m_HdriSkyParams.skyHDRI);
             m_SkyHDRIMaterial.SetVector("_SkyParam", new Vector4(m_HdriSkyParams.exposure, m_HdriSkyParams.multiplier, m_HdriSkyParams.rotation, 0.0f));

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/Resources/SkyHDRI.shader

             ZWrite Off
             ZTest Always
             Blend One Zero
+            Cull Off
 
             HLSLPROGRAM
             ENDHLSL
             ZWrite Off
             ZTest LEqual
             Blend One Zero
+            Cull Off
 
             HLSLPROGRAM
             ENDHLSL

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

     public class ProceduralSkyRenderer : SkyRenderer
     {
         Material m_ProceduralSkyMaterial = null; // Renders a cubemap into a render texture (can be cube or 2D)
-        private ProceduralSkyParameters m_ProceduralSkyParameters;
+        private ProceduralSkySettings m_ProceduralSkySettings;
-        public ProceduralSkyRenderer(ProceduralSkyParameters proceduralSkyParameters)
+        public ProceduralSkyRenderer(ProceduralSkySettings proceduralSkySettings)
-            m_ProceduralSkyParameters = proceduralSkyParameters;
+            m_ProceduralSkySettings = proceduralSkySettings;
         }
 
         public override void Build()
 
         public override bool IsSkyValid()
         {
-            if (m_ProceduralSkyMaterial == null || m_ProceduralSkyParameters == null)
+            if (m_ProceduralSkyMaterial == null || m_ProceduralSkySettings == null)
-            return m_ProceduralSkyParameters.skyHDRI != null &&
-                   m_ProceduralSkyParameters.worldMieColorRamp != null &&
-                   m_ProceduralSkyParameters.worldRayleighColorRamp != null;
+            return m_ProceduralSkySettings.skyHDRI != null &&
+                   m_ProceduralSkySettings.worldMieColorRamp != null &&
+                   m_ProceduralSkySettings.worldRayleighColorRamp != null;
         }
 
         public override void SetRenderTargets(BuiltinSkyParameters builtinParams)
             Utilities.SetRenderTarget(builtinParams.renderContext, builtinParams.colorBuffer);
         }
 
-        void SetKeywords(BuiltinSkyParameters builtinParams, ProceduralSkyParameters param, bool renderForCubemap)
+        void SetKeywords(BuiltinSkyParameters builtinParams, ProceduralSkySettings param, bool renderForCubemap)
         {
             // Ensure that all preprocessor symbols are initially undefined.
             m_ProceduralSkyMaterial.DisableKeyword("ATMOSPHERICS");
                 m_ProceduralSkyMaterial.EnableKeyword("PERFORM_SKY_OCCLUSION_TEST");
             }
 
-            if (param.debugMode != ProceduralSkyParameters.ScatterDebugMode.None)
+            if (param.debugMode != ProceduralSkySettings.ScatterDebugMode.None)
-        void SetUniforms(BuiltinSkyParameters builtinParams, ProceduralSkyParameters param, bool renderForCubemap, ref MaterialPropertyBlock properties)
+        void SetUniforms(BuiltinSkyParameters builtinParams, ProceduralSkySettings param, bool renderForCubemap, ref MaterialPropertyBlock properties)
         {
             properties.SetTexture("_Cubemap", param.skyHDRI);
             properties.SetVector("_SkyParam", new Vector4(param.exposure, param.multiplier, param.rotation, 0.0f));
             properties.SetFloat("_HeightMieDensity",        renderForCubemap ? -0.0f : -param.heightMieDensity / 100000f);
         }
 
-        override public void RenderSky(BuiltinSkyParameters builtinParams, SkyParameters skyParameters, bool renderForCubemap)
+        override public void RenderSky(BuiltinSkyParameters builtinParams, SkySettings skyParameters, bool renderForCubemap)
-            SetKeywords(builtinParams, m_ProceduralSkyParameters, renderForCubemap);
+            SetKeywords(builtinParams, m_ProceduralSkySettings, renderForCubemap);
-            SetUniforms(builtinParams, m_ProceduralSkyParameters, renderForCubemap, ref properties);
+            SetUniforms(builtinParams, m_ProceduralSkySettings, renderForCubemap, ref properties);
 
             var cmd = new CommandBuffer { name = "" };
 

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

             ZWrite Off
             ZTest Always
             Blend One OneMinusSrcAlpha, Zero One
+            Cull Off
 
             HLSLPROGRAM
             #pragma target 4.5

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

 {
     [ExecuteInEditMode]
     [DisallowMultipleComponent]
-    public class ProceduralSkyParameters : SkyParameters
+    public class ProceduralSkySettings : SkySettings
     {
         public enum OcclusionDownscale { x1 = 1, x2 = 2, x4 = 4 }
         public enum OcclusionSamples   { x64 = 0, x164 = 1, x244 = 2 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/Resources.meta

 fileFormatVersion: 2
-guid: 4cdc45a9a65126a42aca158413a5b089
+guid: 920208451db81a846ae1c2d55f7b50b4
 folderAsset: yes
 timeCreated: 1479239906
 licenseType: Pro

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

         bool                    m_useMIS = false;
 
 
-        private SkyParameters m_SkyParameters;
-        public SkyParameters skyParameters
+        private SkySettings m_SkySettings;
+        public SkySettings skySettings
-                if (m_SkyParameters == value)
+                if (m_SkySettings == value)
                     return;
 
                 if (m_Renderer != null)
                 }
 
                 m_SkyParametersHash = 0;
-                m_SkyParameters = value;
+                m_SkySettings = value;
+                {
+                    m_Renderer.Build();
+                }
-            get { return m_SkyParameters; }
+            get { return m_SkySettings; }
         }
 
         protected Mesh BuildSkyMesh(Vector3 cameraPosition, Matrix4x4 cameraInvViewProjectionMatrix, bool forceUVBottom)
             };
         }
 
-        void RebuildTextures(SkyParameters skyParameters)
+        void RebuildTextures(SkySettings skySettings)
-            if (skyParameters != null)
-                resolution = (int)skyParameters.resolution;
+            if (skySettings != null)
+                resolution = (int)skySettings.resolution;
 
             if ((m_SkyboxCubemapRT != null) && (m_SkyboxCubemapRT.width != resolution))
             {
         public void Resize(float nearPlane, float farPlane)
         {
             // When loading RenderDoc, RenderTextures will go null
-            RebuildTextures(skyParameters);
+            RebuildTextures(skySettings);
-            if (m_Renderer != null)
-                m_Renderer.Build();
-
             // Create unititialized. Lazy initialization is performed later.
             m_iblFilterGgx = new IBLFilterGGX();
 
             return m_Renderer != null && m_Renderer.IsSkyValid();
         }
 
-        private void RenderSkyToCubemap(BuiltinSkyParameters builtinParams, SkyParameters skyParameters, RenderTexture target)
+        private void RenderSkyToCubemap(BuiltinSkyParameters builtinParams, SkySettings skySettings, RenderTexture target)
         {
             for (int i = 0; i < 6; ++i)
             {
                 builtinParams.depthBuffer = BuiltinSkyParameters.nullRT;
 
                 Utilities.SetRenderTarget(builtinParams.renderContext, target, ClearFlag.ClearNone, 0, (CubemapFace)i);
-                m_Renderer.RenderSky(builtinParams, skyParameters, true);
+                m_Renderer.RenderSky(builtinParams, skySettings, true);
-        private void RenderCubemapGGXConvolution(ScriptableRenderContext renderContext, BuiltinSkyParameters builtinParams, SkyParameters skyParams, Texture input, RenderTexture target)
+        private void RenderCubemapGGXConvolution(ScriptableRenderContext renderContext, BuiltinSkyParameters builtinParams, SkySettings skyParams, Texture input, RenderTexture target)
         {
             using (new Utilities.ProfilingSample("Sky Pass: GGX Convolution", renderContext))
             {
                     }
 
                     if (
-                        (skyParameters.updateMode == EnvironementUpdateMode.OnDemand && m_UpdateRequired) ||
-                        (skyParameters.updateMode == EnvironementUpdateMode.OnChanged && skyParameters.GetHash() != m_SkyParametersHash) ||
-                        (skyParameters.updateMode == EnvironementUpdateMode.Realtime && m_CurrentUpdateTime > skyParameters.updatePeriod)
+                        (skySettings.updateMode == EnvironementUpdateMode.OnDemand && m_UpdateRequired) ||
+                        (skySettings.updateMode == EnvironementUpdateMode.OnChanged && skySettings.GetHash() != m_SkyParametersHash) ||
+                        (skySettings.updateMode == EnvironementUpdateMode.Realtime && m_CurrentUpdateTime > skySettings.updatePeriod)
-                        RenderSkyToCubemap(m_BuiltinParameters, skyParameters, m_SkyboxCubemapRT);
+                        RenderSkyToCubemap(m_BuiltinParameters, skySettings, m_SkyboxCubemapRT);
-                        RenderCubemapGGXConvolution(renderContext, m_BuiltinParameters, skyParameters, m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT);
+                        RenderCubemapGGXConvolution(renderContext, m_BuiltinParameters, skySettings, m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT);
-                        m_SkyParametersHash = skyParameters.GetHash();
+                        m_SkyParametersHash = skySettings.GetHash();
                         m_CurrentUpdateTime = 0.0f;
                     }
                 }
                     m_BuiltinParameters.depthBuffer = depthBuffer;
 
                     m_Renderer.SetRenderTargets(m_BuiltinParameters);
-                    m_Renderer.RenderSky(m_BuiltinParameters, skyParameters, false);
+                    m_Renderer.RenderSky(m_BuiltinParameters, skySettings, false);
                 }
             }
         }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyRenderer.cs

         public abstract void Cleanup();
         public abstract void SetRenderTargets(BuiltinSkyParameters builtinParams);
         // renderForCubemap: When rendering into a cube map, no depth buffer is available so user has to make sure not to use depth testing or the depth texture.
-        public abstract void RenderSky(BuiltinSkyParameters builtinParams, SkyParameters skyParameters, bool renderForCubemap);
+        public abstract void RenderSky(BuiltinSkyParameters builtinParams, SkySettings skyParameters, bool renderForCubemap);
         public abstract bool IsSkyValid();
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkySettings.cs

 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [ExecuteInEditMode]
-    public abstract class SkyParameters : ScriptableObject
+    public abstract class SkySettings : ScriptableObject
     {
         protected class Unhashed : System.Attribute {}
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

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

Assets/ScriptableRenderPipeline/ShaderLibrary/API/D3D11.hlsl

 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
+#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D

Assets/ScriptableRenderPipeline/ShaderLibrary/API/Metal.hlsl

 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
+#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D

Assets/ScriptableRenderPipeline/ShaderLibrary/API/PSSL.hlsl

 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
+#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D

Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl

 #endif
 #include "API/Validate.hlsl"
 
+// Some shader compiler don't support to do multiple ## for concatenation inside the same macro, it require an indirection.
+// This is the purpose of this macro
+#define MERGE_NAME(X, Y) X##Y
+
 // ----------------------------------------------------------------------------
 // Common intrinsic (general implementation of intrinsic available on some platform)
 // ----------------------------------------------------------------------------

Assets/ScriptableRenderPipeline/ShaderLibrary/CommonLighting.hlsl

 // NdotV should not be negative for visible pixels, but it can happen due to the
 // perspective projection and the normal mapping + decals. In that case, the normal
 // should be modified to become valid (i.e facing the camera) to avoid weird artifacts.
-// Note: certain applications (e.g. SpeedTree) require to still have negative normal to perform their own two sided lighting
-// This will  potentially reduce the length of the normal at edges of geometry.
-float GetShiftedNdotV(inout float3 N, float3 V, bool twoSided)
+// Note: certain applications (e.g. SpeedTree) require to still have negative normal to perform their own two sided lighting, they can use wantNegativeNormal
+// This will potentially reduce the length of the normal at edges of geometry.
+float GetShiftedNdotV(inout float3 N, float3 V, bool wantNegativeNormal)
-    if (!twoSided && NdotV < limit)
+    if (!wantNegativeNormal && NdotV < limit)
     {
         // We do not renormalize the normal because { abs(length(N) - 1.0) < limit }.
         N    += (-NdotV + limit) * V;

Assets/ScriptableRenderPipeline/ShaderLibrary/CommonMaterial.hlsl

 // Parallax mapping
 // ----------------------------------------------------------------------------
 
-float2 ParallaxOffset(float3 viewDirTS, float height)
-{
-    // Parallax mapping with offset limiting to reduce weird artifcat (i.e do not divide by z), also save performance
-    return viewDirTS.xy * height;
-}
-
 // ref https://www.gamedev.net/topic/678043-how-to-blend-world-space-normals/#entry5287707
 // assume compositing in world space
 // Note: Using vtxNormal = float3(0, 0, 1) give the BlendNormalRNM formulation.
     return normalize(float3(n1.xy * n2.z + n2.xy * n1.z, n1.z * n2.z));
 }
 
-// Ref: http://http.developer.nvidia.com/GPUGems3/gpugems3_ch01.html
+// Ref: http://http.developer.nvidia.com/GPUGems3/gpugems3_ch01.html / http://www.slideshare.net/icastano/cascades-demo-secrets
 float3 ComputeTriplanarWeights(float3 normal)
 { 
     // Determine the blend weights for the 3 planar projections.  
+    blendWeights = blendWeights * blendWeights * blendWeights; // pow(blendWeights, 3);
     // Force weights to sum to 1.0 (very important!)  
     blendWeights = max(blendWeights, float3(0.0, 0.0, 0.0));
     blendWeights /= dot(blendWeights, 1.0);
 
-// Planar/Triplanar convention for Unity
-// position and vertex normal must be in the same space
-void GetTriplanarCoordinate(float3 position, float3 vertexNormal, out float2 uvXZ, out float2 uvXY, out float2 uvZY)
-{
-    float3 direction = sign(vertexNormal);
-
-    // In triplanar, if we are facing away from the world axis, a different axis will be flipped for each direction.
-    // This is particularly problematic for tangent space normal maps which need to be in the right direction.
-    // So we multiplying the offending coordinate by the sign of the normal.
-    uvXZ = -float2(position.x, direction.y * position.z);
-    uvXY = float2(-position.x, direction.z * position.y);
-    uvZY = float2(direction.x * position.z, position.y);
+// Planar/Triplanar convention for Unity in world space
+void GetTriplanarCoordinate(float3 position, out float2 uvXZ, out float2 uvXY, out float2 uvZY)
+{ 
+    // Caution: This must follow the same rule as what is use for SurfaceGradient triplanar
+    // TODO: Currently the normal mapping looks wrong without SURFACE_GRADIENT option because we don't handle corretly the tangent space
+    uvXZ = float2(position.z, position.x);
+    uvXY = float2(position.x, position.y);
+    uvZY = float2(position.z, position.y);    
 }
 
 float LerpWhiteTo(float b, float t)

Assets/ScriptableRenderPipeline/fptl/FptlLighting.cs

 
             // 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);
+            if(k_UseAsyncCompute) 
+            {
+                RenderShadowMaps(cullResults, loop);
+                loop.SetupCameraProperties(camera);
+            }
 
             // Push all global params
             var numDirLights = UpdateDirectionalLights(camera, cullResults.visibleLights);

Assets/TestScenes/FPTL/Materials/Custom_NewSurfaceShader.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Custom_NewSurfaceShader
-  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_Shader: {fileID: 0}
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses: []
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BumpMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailMask:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissionMap
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MainTex
-      second:
+    - _MainTex:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _OcclusionMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _ParallaxMap:
-    - first:
-        name: _SpecGlossMap
-      second:
+    - _SpecGlossMap:
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.258
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _Metallic
-      second: 0
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.258
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _SpecColor
-      second: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Assets/TestScenes/FPTL/Materials/gray.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: gray
-  m_Shader: {fileID: 45, guid: 0000000000000000f000000000000000, type: 0}
+  m_Shader: {fileID: 0}
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses: []
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _AlternateLightMap
-      second:
+    - _AlternateLightMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailMask:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissionMap
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MainTex
-      second:
+    - _MainTex:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _OcclusionMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _ParallaxMap:
-    - first:
-        name: _SpecGlossMap
-      second:
+    - _SpecGlossMap:
-    - first:
-        name: g_tOverrideLightmap
-      second:
+    - g_tOverrideLightmap:
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.825
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _Metallic
-      second: 0
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _OcclusionStrengthDirectDiffuse
-      second: 1
-    - first:
-        name: _OcclusionStrengthDirectSpecular
-      second: 1
-    - first:
-        name: _OcclusionStrengthIndirectDiffuse
-      second: 1
-    - first:
-        name: _OcclusionStrengthIndirectSpecular
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SpecularMode
-      second: 2
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
-    - first:
-        name: g_bEnableMetallic
-      second: 0
-    - first:
-        name: g_bReceiveShadows
-      second: 1
-    - first:
-        name: g_bUnlit
-      second: 0
-    - first:
-        name: g_bWorldAlignedTexture
-      second: 0
-    - first:
-        name: g_flCubeMapScalar
-      second: 1
-    - first:
-        name: g_flReflectanceBias
-      second: 0
-    - first:
-        name: g_flReflectanceMax
-      second: 1
-    - first:
-        name: g_flReflectanceMin
-      second: 0
-    - first:
-        name: g_flReflectanceScale
-      second: 1
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.825
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _OcclusionStrengthDirectDiffuse: 1
+    - _OcclusionStrengthDirectSpecular: 1
+    - _OcclusionStrengthIndirectDiffuse: 1
+    - _OcclusionStrengthIndirectSpecular: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SpecularMode: 2
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    - g_bEnableMetallic: 0
+    - g_bReceiveShadows: 1
+    - g_bUnlit: 0
+    - g_bWorldAlignedTexture: 0
+    - g_flCubeMapScalar: 1
+    - g_flReflectanceBias: 0
+    - g_flReflectanceMax: 1
+    - g_flReflectanceMin: 0
+    - g_flReflectanceScale: 1
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _SpecColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: g_vWorldAlignedNormalTangentU
-      second: {r: -1, g: 0, b: 0, a: 0}
-    - first:
-        name: g_vWorldAlignedNormalTangentV
-      second: {r: 0, g: 0, b: 1, a: 0}
-    - first:
-        name: g_vWorldAlignedTextureNormal
-      second: {r: 0, g: 1, b: 0, a: 0}
-    - first:
-        name: g_vWorldAlignedTexturePosition
-      second: {r: 0, g: 0, b: 0, a: 0}
-    - first:
-        name: g_vWorldAlignedTextureSize
-      second: {r: 1, g: 1, b: 1, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}
+    - g_vWorldAlignedNormalTangentU: {r: -1, g: 0, b: 0, a: 0}
+    - g_vWorldAlignedNormalTangentV: {r: 0, g: 0, b: 1, a: 0}
+    - g_vWorldAlignedTextureNormal: {r: 0, g: 1, b: 0, a: 0}
+    - g_vWorldAlignedTexturePosition: {r: 0, g: 0, b: 0, a: 0}
+    - g_vWorldAlignedTextureSize: {r: 1, g: 1, b: 1, a: 0}

Assets/TestScenes/HDTest/CascadedShadowsTest.unity

     m_EnableBakedLightmaps: 0
     m_EnableRealtimeLightmaps: 0
   m_LightmapEditorSettings:
-    serializedVersion: 6
+    serializedVersion: 8
     m_Resolution: 2
     m_BakeResolution: 40
     m_TextureWidth: 1024
     m_FinalGatherFiltering: 1
     m_FinalGatherRayCount: 256
     m_ReflectionCompression: 2
-    m_StationaryBakeMode: 3
+    m_MixedBakeMode: 3
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFiltering: 0
+    m_PVRFilteringMode: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousColorSigma: 1
+    m_PVRFilteringAtrousNormalSigma: 1
+    m_PVRFilteringAtrousPositionSigma: 1
-  m_RuntimeCPUUsage: 25
   m_ShadowMaskMode: 2
 --- !u!196 &4
 NavMeshSettings:
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_CCT: 6500
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &1612942797
   m_Name: 
   m_EditorClassIdentifier: 
   shadowResolution: 1024
+  m_innerSpotPercent: 0
   shadowDimmer: 1
   affectDiffuse: 1
   affectSpecular: 1
   m_Script: {fileID: 11500000, guid: bc357c46587fc9d4cb8f311794d7d2f3, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_SkyRendererTypeName: UnityEngine.Experimental.ScriptableRenderLoop.HDRISkyRenderer
-  m_ShadowMaxDistance: 1000
-  m_ShadowCascadeCount: 4
-  m_ShadowCascadeSplit0: 0.015
-  m_ShadowCascadeSplit1: 0.05
-  m_ShadowCascadeSplit2: 0.15
+  m_Settings:
+    m_ShadowMaxDistance: 1000
+    m_ShadowCascadeCount: 4
+    m_ShadowCascadeSplit0: 0.05
+    m_ShadowCascadeSplit1: 0.2
+    m_ShadowCascadeSplit2: 0.3
+    m_ShadowNearPlaneOffset: 5
 --- !u!4 &2100643540
 Transform:
   m_ObjectHideFlags: 0

Assets/TestScenes/HDTest/CascadedShadowsTest/Lit_Gray.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+        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
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _GlossyReflections: 1
     - _HeightAmplitude: 0.01
     - _HeightCenter: 0.5
-    - _MaterialId: 0
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _PPDLodThreshold: 5
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _SrcBlend: 1
-    - _SubSurfaceRadius: 0
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 1
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 0.49803922, g: 0.49803922, b: 0.49803922, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GlobalIlluminationTest/Material/Chrome.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: Chrome
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DEPTHOFFSETENABLE_OFF _DETAIL_MAP_WITH_NORMAL
-    _DISTORTIONDEPTHTEST_OFF _DISTORTIONENABLE_OFF _DISTORTIONONLY_OFF _ENABLEPERPIXELDISPLACEMENT_OFF
-    _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+        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
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _GlossyReflections: 1
     - _HeightAmplitude: 0.01
     - _HeightCenter: 0.5
-    - _MaterialId: 0
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
-    - _SubSurfaceRadius: 0
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 1
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GlobalIlluminationTest/Material/Lit_Green.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: Lit_Green
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
-  disabledShaderPasses: []
+  disabledShaderPasses:
+  - DistortionVectors
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+        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}
     - _DistortionEnable: 0
     - _DistortionOnly: 0
     - _DoubleSided: 1
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _HeightCenter: 0.5
     - _HeightMapMode: 0
     - _HeightScale: 1
+    - _HorizonFade: 1
-    - _MaterialId: 0
     - _Metalic: 0
     - _Metallic: 0
     - _Mettalic: 0
     - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 0.5
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 0, g: 1, b: 0, a: 1}
     - _Color: {r: 0, g: 1, b: 0, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GlobalIlluminationTest/Material/Lit_Grey.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: Lit_Grey
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DEPTHOFFSETENABLE_OFF _DISTORTIONDEPTHTEST_OFF
-    _DISTORTIONENABLE_OFF _DISTORTIONONLY_OFF _ENABLEPERPIXELDISPLACEMENT_OFF
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
-  disabledShaderPasses: []
+  disabledShaderPasses:
+  - DistortionVectors
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     m_Floats:
     - _AlphaCutoff: 0.5
     - _AlphaCutoffEnable: 0
     - _DistortionDepthTest: 0
     - _DistortionEnable: 0
     - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _GlossyReflections: 1
     - _HeightAmplitude: 0.01
     - _HeightCenter: 0.5
-    - _MaterialId: 0
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _PPDLodThreshold: 5
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 0.5
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GlobalIlluminationTest/Material/Lit_Red.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: Lit_Red
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
-    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
   m_CustomRenderQueue: -1
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+        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}
     - _DistortionEnable: 0
     - _DistortionOnly: 0
     - _DoubleSided: 1
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _HeightCenter: 0.5
     - _HeightMapMode: 0
     - _HeightScale: 1
+    - _HorizonFade: 1
-    - _MaterialId: 0
-    - _Mettalic: 0
+    - _PPDLodThreshold: 5
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _SrcBlend: 1
-    - _SubSurfaceRadius: 0
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 1
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 1, g: 0, b: 0, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GlobalIlluminationTest/TestRealtime.cs

 	void Update () {
         if (m_SceneSettings != null)
         {
-            HDRISkyParameters skyParams = m_SceneSettings.GetComponent<HDRISkyParameters>();
+            HDRISkySettings skyParams = m_SceneSettings.GetComponent<HDRISkySettings>();
             if (skyParams)
                 skyParams.rotation = (skyParams.rotation + Time.deltaTime * m_RotationSpeed) % 360.0f;
         }

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

     - _HeightAmplitude: 0
     - _HeightCenter: 0
     - _HorizonFade: 1
-    - _MaterialId: 0
+    - _MaterialID: 0
+    - _StencilRef: 1
     - _Metallic: 0
     - _Mode: 0
     - _NormalDetailMul: 0.347
     - _SmoothnessVar: 0.491
     - _SpecularHighlights: 1
     - _SrcBlend: 1
-    - _SubSurfaceRadius: 0
     - _SurfaceType: 0
     - _Tess: 8
     - _TessFar: 1

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Lit_Blue
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
-    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
-  disabledShaderPasses: []
+  disabledShaderPasses:
+  - DistortionVectors
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     m_Floats:
     - _AlphaCutoff: 0.5
     - _AlphaCutoffEnable: 0
     - _DistortionDepthTest: 0
     - _DistortionEnable: 0
     - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _HeightCenter: 0.5
     - _HeightMapMode: 0
     - _HeightScale: 1
-    - _MaterialId: 0
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _PPDLodThreshold: 5
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 0.5
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 0, g: 0, b: 1, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Lit_Green
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
-    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
-  disabledShaderPasses: []
+  disabledShaderPasses:
+  - DistortionVectors
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     m_Floats:
     - _AlphaCutoff: 0.5
     - _AlphaCutoffEnable: 0
     - _DistortionDepthTest: 0
     - _DistortionEnable: 0
     - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _HeightCenter: 0.5
     - _HeightMapMode: 0
     - _HeightScale: 1
-    - _MaterialId: 0
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _PPDLodThreshold: 5
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 0.5
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 0, g: 1, b: 0, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Lit_Red
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
-    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE _SPECULAROCCLUSIONMAP
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE _SPECULAROCCLUSIONMAP
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
   m_CustomRenderQueue: -1
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+        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
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _HeightCenter: 0.5
     - _HeightMapMode: 0
     - _HeightScale: 1
-    - _MaterialId: 0
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _PPDLodThreshold: 5
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _SrcBlend: 1
-    - _SubSurfaceRadius: 0
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 1
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 1, g: 0, b: 0, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Lit_White
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
-    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
   m_CustomRenderQueue: -1
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+        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
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _HeightCenter: 0.5
     - _HeightMapMode: 0
     - _HeightScale: 1
-    - _MaterialId: 0
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _PPDLodThreshold: 5
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _SrcBlend: 1
-    - _SubSurfaceRadius: 0
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 1
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_0
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMap:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _DistortionVectorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _HeightMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MainTex:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _ThicknessMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 1
-    - first:
-        name: _Metallic
-      second: 1
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _Metalic: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_1
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMap:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _DistortionVectorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _HeightMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MainTex:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _ThicknessMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.1
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 1
-    - first:
-        name: _Metallic
-      second: 1
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0.1
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.1
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _Metalic: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.1
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_2
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMap:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _DistortionVectorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _HeightMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MainTex:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _ThicknessMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.2
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 1
-    - first:
-        name: _Metallic
-      second: 1
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0.2
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.2
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _Metalic: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.2
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_3
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMap:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _DistortionVectorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _HeightMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MainTex:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _ThicknessMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.3
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 1
-    - first:
-        name: _Metallic
-      second: 1
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0.3
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.3
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _Metalic: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.3
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_4
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMap:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _DistortionVectorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _HeightMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MainTex:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _ThicknessMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.4
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 1
-    - first:
-        name: _Metallic
-      second: 1
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0.4
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.4
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _Metalic: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.4
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_5
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMap:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _DistortionVectorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _HeightMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MainTex:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _ThicknessMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.5
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 1
-    - first:
-        name: _Metallic
-      second: 1
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0.5
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _Metalic: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_6
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMap:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _DistortionVectorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _HeightMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MainTex:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _ThicknessMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.6
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 1
-    - first:
-        name: _Metallic
-      second: 1
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0.6
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.6
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _Metalic: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.6
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_7
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMap:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _DistortionVectorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _HeightMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MainTex:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _ThicknessMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.7
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 1
-    - first:
-        name: _Metallic
-      second: 1
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0.7
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.7
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _Metalic: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.7
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_8
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMap:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _DistortionVectorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _EmissionMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _HeightMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MainTex:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _ThicknessMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.8
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 1
-    - first:
-        name: _Metallic
-      second: 1
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0.8
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.8
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _MaterialID: 0
+    - _Metalic: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.8
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _Thickness: 0.5
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _Color
-      second: {r: 1, g: 1, b: 1, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}