Merge branch 'master' into refactor-hdloop

Conflicts:
	Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.cs
	Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.cs
	Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyRenderer.cs
	Assets/ScriptableRenderLoop/HDRenderPipeline/Utilities.cs

Assets/BasicRenderLoopTutorial/BasicRenderLoop.cs

             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("BasicPass"));
             settings.sorting.flags = SortFlags.CommonOpaque;
             settings.inputFilter.SetQueuesOpaque();
-            context.DrawRenderers(ref settings);
+            context.DrawRenderers(settings);
 
             // Draw skybox
             context.DrawSkybox(camera);
             settings.inputFilter.SetQueuesTransparent();
-            context.DrawRenderers(ref settings);
+            context.DrawRenderers(settings);
 
             context.Submit();
         }

Assets/Editor/Tests/RenderloopTests/RenderloopTestFixture.cs

         var sceneCamera = Camera.main;
         var camObject = sceneCamera.gameObject;
 
-        GraphicsSettings.renderPipeline = m_Instance;
+        GraphicsSettings.renderPipelineAsset = m_Instance;
         s_Callback = renderCallback;
         Transform t = camObject.transform;
 
         SceneView.lastActiveSceneView.LookAtDirect(t.position + t.forward * camDist, t.rotation, size);
 
         sceneCamera.Render();
-        GraphicsSettings.renderPipeline = null;
+        GraphicsSettings.renderPipelineAsset = null;
     }
 }

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

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #define LIGHTLOOP_TILE_PASS 1            
-            #define LIGHTLOOP_TILE_ALL	1
+            #define LIGHTLOOP_TILE_PASS           
+            #define LIGHTLOOP_TILE_ALL
 
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.cs

     public class HDRenderPipeline : RenderPipelineAsset
     {
         const string k_HDRenderPipelinePath = "Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.asset";
-        
+
 #if UNITY_EDITOR
         [MenuItem("RenderPipeline/CreateHDRenderPipeline")]
         static void CreateHDRenderPipeline()
 
             instance.m_Setup = AssetDatabase.LoadAssetAtPath<HDRenderPipelineSetup>("Assets/HDRenderPipelineSetup.asset");
         }
-        
+
         [UnityEditor.MenuItem("RenderPipeline/UpdateHDLoop")]
         static void UpdateHDLoop()
         {
         public SkyParameters skyParametersToUse
         {
             get
-            {
+        {
                 if (SkyParametersSingleton.overrideSettings)
                     return SkyParametersSingleton.overrideSettings;
 
             m_ShadowSettings.directionalLightCascades = new Vector3(commonSettings.shadowCascadeSplit0, commonSettings.shadowCascadeSplit1, commonSettings.shadowCascadeSplit2);
             m_ShadowSettings.maxShadowDistance = commonSettings.shadowMaxDistance;
         }
-    }
+        }
-    {
+        {
         public bool enableDrawLightBoundsDebug = false;
         public bool disableTileAndCluster = true; // For debug / test
         public bool disableDeferredShadingInCompute = true;
         public Vector4 screenSize;
         public Matrix4x4 viewProjectionMatrix;
         public Matrix4x4 invViewProjectionMatrix;
-    }
+        }
-    public class DebugParameters
-    {
-        // Material Debugging
-        public int debugViewMaterial = 0;
+        public class DebugParameters
+        {
+            // Material Debugging
+            public int debugViewMaterial = 0;
-        // Rendering debugging
-        public bool displayOpaqueObjects = true;
-        public bool displayTransparentObjects = true;
+            // Rendering debugging
+            public bool displayOpaqueObjects = true;
+            public bool displayTransparentObjects = true;
-        public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
-        public bool useDepthPrepass = false;
-        public bool useDistortion = true;
+            public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
+            public bool useDepthPrepass = false;
+            public bool useDistortion = true;
-        // we have to fallback to forward-only rendering when scene view is using wireframe rendering mode --
-        // as rendering everything in wireframe + deferred do not play well together
-        public bool ShouldUseForwardRenderingOnly() { return useForwardRenderingOnly || GL.wireframe; }
-    }
+            // we have to fallback to forward-only rendering when scene view is using wireframe rendering mode --
+            // as rendering everything in wireframe + deferred do not play well together
+            public bool ShouldUseForwardRenderingOnly () { return useForwardRenderingOnly || GL.wireframe; }
+        }
-    public class GBufferManager
-    {
-        public const int MaxGbuffer = 8;
+        public class GBufferManager
+        {
+            public const int MaxGbuffer = 8;
-        public void SetBufferDescription(int index, string stringId, RenderTextureFormat inFormat, RenderTextureReadWrite inSRGBWrite)
-        {
-            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)
+            {
+                IDs[index] = Shader.PropertyToID(stringId);
+                RTIDs[index] = new RenderTargetIdentifier(IDs[index]);
+                formats[index] = inFormat;
+                sRGBWrites[index] = inSRGBWrite;
+            }
-        public void InitGBuffers(int width, int height, CommandBuffer cmd)
-        {
-            for (int index = 0; index < gbufferCount; index++)
+            public void InitGBuffers(int width, int height, CommandBuffer cmd)
+                for (int index = 0; index < gbufferCount; index++)
+                {
+                }
-        }
-        public RenderTargetIdentifier[] GetGBuffers()
-        {
-            var colorMRTs = new RenderTargetIdentifier[gbufferCount];
-            for (int index = 0; index < gbufferCount; index++)
+            public RenderTargetIdentifier[] GetGBuffers()
-                colorMRTs[index] = RTIDs[index];
+                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)
-        {
-            for (int index = 0; index < gbufferCount; index++)
+            /*
+            public void BindBuffers(Material mat)
-                mat.SetTexture(IDs[index], RTs[index]);
+                for (int index = 0; index < gbufferCount; 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
         {
             get { return m_Owner.debugParameters; }
         }
-        
+
-            m_CameraDepthBuffer = Shader.PropertyToID("_CameraDepthTexture");
+            m_CameraDepthBuffer  = Shader.PropertyToID("_CameraDepthTexture");
 
             m_CameraColorBufferRT = new RenderTargetIdentifier(m_CameraColorBuffer);
             m_CameraDepthBufferRT = new RenderTargetIdentifier(m_CameraDepthBuffer);
                 Shader.SetGlobalInt("_EnvLightSkyEnabled", 1);
             }
             else
-            {
+                    {
-            }
+                    }
 
             var cmd = new CommandBuffer { name = "Push Global Parameters" };
 
 
-            renderContext.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+                    renderContext.ExecuteCommandBuffer(cmd);
+                    cmd.Dispose();
-        }
+                }
 
         public override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
         {
 #endif
 
             GraphicsSettings.lightsUseLinearIntensity = true;
-            GraphicsSettings.lightsUseCCT = true;
+            GraphicsSettings.lightsUseColorTemperature = true;
 
             m_SkyManager.Build();
 
 
             ShadowOutput shadows;
             using (new Utilities.ProfilingSample("Shadow Pass", renderContext))
-            {
+                {
-            }
+                }
-            {
+                {
                 m_lightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera, ref shadows);
                 m_lightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthBufferRT); // TODO: Use async compute here to run light culling during shadow
             }
 
             // bind depth surface for editor grid/gizmo/selection rendering
             if (camera.cameraType == CameraType.SceneView)
-            {
+                    {
                 var cmd = new CommandBuffer();
                 cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, m_CameraDepthBufferRT);
                 renderContext.ExecuteCommandBuffer(cmd);
                 sorting = { flags = SortFlags.CommonOpaque }
             };
             settings.inputFilter.SetQueuesOpaque();
-            renderContext.DrawRenderers(ref settings);
+            renderContext.DrawRenderers(settings);
         }
 
         void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, string passName, RendererConfiguration rendererConfiguration = 0)
                 sorting = { flags = SortFlags.CommonTransparent }
             };
             settings.inputFilter.SetQueuesTransparent();
-            renderContext.DrawRenderers(ref settings);
+            renderContext.DrawRenderers(settings);
         }
 
         void RenderDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderContext)
         {
             if (debugParameters.ShouldUseForwardRenderingOnly())
             {
-                return;
+                return ;
             }
 
             using (new Utilities.ProfilingSample("GBuffer Pass", renderContext))
         {
             if (debugParameters.ShouldUseForwardRenderingOnly())
             {
-                return;
+                return ;
-            
+
             m_lightLoop.RenderDeferredLighting(hdCamera, renderContext, m_CameraColorBuffer);
         }
 
         {
             m_SkyManager.RenderSky(hdCamera, m_lightLoop.GetCurrentSunLight(), m_CameraColorBufferRT, m_CameraDepthBufferRT, renderContext);
         }
-
+        
         void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
         {
             // TODO: Currently we can't render opaque object forward when deferred is enabled
             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 == 0) || debugParameters.ShouldUseForwardRenderingOnly())
-                    return;
+                if ((ShaderConfig.s_VelocityInGbuffer == 1) || debugParameters.ShouldUseForwardRenderingOnly())
+                    return ;
 
                 int w = camera.pixelWidth;
                 int h = camera.pixelHeight;
         void RenderDistortion(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext)
         {
             if (!debugParameters.useDistortion)
-                return;
+                return ;
 
             using (new Utilities.ProfilingSample("Distortion Pass", renderContext))
             {
                     cmd.GetTemporaryRT(m_CameraColorBuffer, w, h, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear, 1, true);   // Enable UAV
                     cmd.GetTemporaryRT(m_CameraDepthBuffer, w, h, 24, FilterMode.Point, RenderTextureFormat.Depth);
                     if (!m_Owner.debugParameters.ShouldUseForwardRenderingOnly())
-                    {
+        {
-                    }
-                    renderContext.ExecuteCommandBuffer(cmd);
-                    cmd.Dispose();
+            }
+            renderContext.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
-                }
+        }
-                {
+        {
-                }
+            }
-                {
+            {
-                    {
+                {
-                    }
+                    }
                 // END TEMP
             }
         }

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/Forward.hlsl

 
 // Must match name in GetKeyword() method of forward lighting architecture .cs file
 // #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS -> can't use a pragma from include... (for now)
-// #pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF  -> can't use a pragma from include... (for now)
+
+// No USE_FPTL_LIGHTLIST as we are in forward and this use the cluster path (but cluster path can use the tile light list for opaque)
+#define USE_CLUSTERED_LIGHTLIST
+#define LIGHTLOOP_TILE_ALL

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

 
             // Chose supported lighting architecture in case of deferred rendering
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-            //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF 
 
             // TODO: Workflow problem here, I would like to only generate variant for the LIGHTLOOP_TILE_PASS case, not the LIGHTLOOP_SINGLE_PASS case. This must be on lightloop side and include here.... (Can we codition
             #pragma multi_compile LIGHTLOOP_TILE_DIRECT LIGHTLOOP_TILE_INDIRECT LIGHTLOOP_TILE_ALL

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

             public static float VIEWPORT_SCALE_Z = 1.0f;
 
             // enable unity's original left-hand shader camera space (right-hand internally in unity).
-            public static int USE_LEFTHAND_CAMERASPACE = 0;
+            public static int USE_LEFTHAND_CAMERASPACE = 1;
 
             // flags
             public static int IS_CIRCULAR_SPOT_SHAPE = 1;
 
                     SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
                     SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlKernel : s_shadeOpaqueClusteredKernel, cmd);
-                    SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
-
 
                     // In case of bUseClusteredForDeferred disable toggle option since we're using m_perVoxelLightLists as opposed to lightList
                     if (bUseClusteredForDeferred)
 
                     if (tileSettings.disableTileAndCluster)
                     {
+                        // This is a debug brute force renderer to debug tile/cluster which render all the lights
                         Utilities.SetupMaterialHDCamera(hdCamera, m_SingleDeferredMaterial);
                         m_SingleDeferredMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                         m_SingleDeferredMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
 
             public override void RenderForward(Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
             {
-                // Note: if we use render opaque with deferred tiling we need to render a opque depth pass for these opaque objects
+                // Note: if we use render opaque with deferred tiling we need to render a opaque depth pass for these opaque objects
                 bool useFptl = renderOpaque && usingFptl;
 
                 var cmd = new CommandBuffer();
                 else
                 {
                     cmd.name = useFptl ? "Forward Tiled pass" : "Forward Clustered pass";
+                    // say that we want to use tile of single loop
-                    cmd.SetGlobalFloat("g_isOpaquesOnlyEnabled", useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
+                    cmd.SetGlobalFloat("_UseTileLightList", useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
                     cmd.SetGlobalBuffer("g_vLightListGlobal", useFptl ? s_LightList : s_PerVoxelLightLists);
                 }
 

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

 #define MAX_NR_LIGHTS_PER_CAMERA (1024)
 #define MAX_NR_BIGTILE_LIGHTS_PLUSONE (512)
 #define VIEWPORT_SCALE_Z (1)
-#define USE_LEFTHAND_CAMERASPACE (0)
+#define USE_LEFTHAND_CAMERASPACE (1)
 #define IS_CIRCULAR_SPOT_SHAPE (1)
 #define HAS_COOKIE_TEXTURE (2)
 #define IS_BOX_PROJECTED (4)

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

     return FetchIndexTile(tileOffset, lightIndex);
 }
 
-#else
+#elif defined(USE_CLUSTERED_LIGHTLIST)
 
 #include "ClusteredUtils.hlsl"
 

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

             Triplanar,
         }
 
+        public enum VertexColorMode
+        {
+            None,
+            Multiply,
+            Add
+        }
+
-                new GUIContent("Base Layer"),
+                new GUIContent("Main layer"),
-
 
             public readonly GUIStyle[] layerLabelColors = 
             {
             public readonly GUIContent layersText = new GUIContent("Layers");
             public readonly GUIContent emissiveText = new GUIContent("Emissive");
             public readonly GUIContent layerMapMaskText = new GUIContent("Layer Mask", "Layer mask (multiplied by vertex color if enabled)");
-            public readonly GUIContent layerMapVertexColorText = new GUIContent("Use Vertex Color", "If no layer mask is set, vertex color values between 0 and 1.0 are used as final mask.\nIf a layer mask is set, vertex color values are remapped between -1 and 1 and added to the mask (neutral at 0.5 vertex color).");
+            public readonly GUIContent vertexColorModeText = new GUIContent("Vertex Color Mode", "Mode multiply: vertex color is multiply with the mask. Mode additive: vertex color values are remapped between -1 and 1 and added to the mask (neutral at 0.5 vertex color).");
+            public readonly GUIContent MainLayerInfluenceText = new GUIContent("Main layer influence", "Main layer influence.");
+            public readonly GUIContent DensityOpacityInfluenceText = new GUIContent("Density / Opacity", "Density / Opacity");
+            public readonly GUIContent useMainLayerInfluenceModeText = new GUIContent("Main Layer Influence", "Switch between regular layers mode and base/layers mode");            
-            public readonly GUIContent inheritBaseLayerText = new GUIContent("Inherit Base Layer Normal", "Inherit the normal from the base layer.");
+            public readonly GUIContent heightControlText = new GUIContent("Height control");
-            public readonly GUIContent useHeightBasedBlendV2Text = new GUIContent("Use Height Based Blend V2", "Layer will be blended with the underlying layer based on the height.");
+            public readonly GUIContent useHeightBasedBlendV2Text = new GUIContent("Use V2", "Layer will be blended with the underlying layer based on the height.");
-            public readonly GUIContent inheritBaseNormalText = new GUIContent("Inherit Base Layer Normal", "Inherit the normal from the base layer.");
-            public readonly GUIContent inheritBaseHeightText = new GUIContent("Inherit Base Layer Height", "Inherit the height from the base layer.");
-            public readonly GUIContent inheritBaseColorText = new GUIContent("Inherit Base Layer Color", "Inherit the base color from the base layer.");
+            public readonly GUIContent inheritBaseNormalText = new GUIContent("Normal influence", "Inherit the normal from the base layer.");
+            public readonly GUIContent inheritBaseHeightText = new GUIContent("Heightmap influence", "Inherit the height from the base layer.");
+            public readonly GUIContent inheritBaseColorText = new GUIContent("BaseColor influence", "Inherit the base color from the base layer.");
+                layerLabelColors[0].normal.textColor = Color.white;
                 layerLabelColors[1].normal.textColor = Color.red;
                 layerLabelColors[2].normal.textColor = Color.green;
                 layerLabelColors[3].normal.textColor = Color.blue;
 
         MaterialProperty layerMaskMap = null;
         const string kLayerMaskMap = "_LayerMaskMap";
-        MaterialProperty layerMaskVertexColor = null;
-        const string kLayerMaskVertexColor = "_LayerMaskVertexColor";
+        MaterialProperty vertexColorMode = null;
+        const string kVertexColorMode = "_VertexColorMode";
         MaterialProperty layerCount = null;
         const string kLayerCount = "_LayerCount";
         MaterialProperty[] layerTexWorldScale = new MaterialProperty[kMaxLayerCount];
         MaterialProperty[] layerUVDetail = new MaterialProperty[kMaxLayerCount];
         MaterialProperty[] layerUVDetailsMappingMask = new MaterialProperty[kMaxLayerCount];
 
+
+        const string kkUseMainLayerInfluence = "_UseMainLayerInfluence";
+        MaterialProperty useMainLayerInfluence = null;
         const string kUseHeightBasedBlend = "_UseHeightBasedBlend";
         MaterialProperty useHeightBasedBlend = null;
         const string kUseHeightBasedBlendV2 = "_UseHeightBasedBlendV2";
         const string kHeightOffset = "_HeightOffset";
         MaterialProperty[] heightOffset = new MaterialProperty[kMaxLayerCount-1];
-        const string kInheritBaseLayer = "_InheritBaseLayer";
-        MaterialProperty[] inheritBaseLayer = new MaterialProperty[kMaxLayerCount - 1];
         const string kHeightFactor = "_HeightFactor";
         MaterialProperty[] heightFactor = new MaterialProperty[kMaxLayerCount-1];
         const string kHeightCenterOffset = "_HeightCenterOffset";
             FindMaterialOptionProperties(props);
 
             layerMaskMap = FindProperty(kLayerMaskMap, props);
-            layerMaskVertexColor = FindProperty(kLayerMaskVertexColor, props);
+            vertexColorMode = FindProperty(kVertexColorMode, props);
+
+            useMainLayerInfluence = FindProperty(kkUseMainLayerInfluence, props);
             useHeightBasedBlend = FindProperty(kUseHeightBasedBlend, props);
             useHeightBasedBlendV2 = FindProperty(kUseHeightBasedBlendV2, props);
             
 
                 if(i != 0)
                 {
-                    inheritBaseLayer[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseLayer, i), props);
                     heightOffset[i-1] = FindProperty(string.Format("{0}{1}", kHeightOffset, i), props);
                     heightFactor[i-1] = FindProperty(string.Format("{0}{1}", kHeightFactor, i), props);
                     blendSize[i-1] = FindProperty(string.Format("{0}{1}", kBlendSize, i), props);
 
             Material material = m_MaterialEditor.target as Material;
 
+            bool baseLayerModeEnable = useMainLayerInfluence.floatValue > 0.0f;
+
             EditorGUILayout.LabelField(styles.layerLabels[layerIndex], styles.layerLabelColors[layerIndex]);
 
             EditorGUI.indentLevel++;
 
             if(layerIndex > 0)
             {
-                if (!useHeightBasedBlend.hasMixedValue && useHeightBasedBlend.floatValue != 0.0f)
+                bool heightBasedBlendEnable = useHeightBasedBlend.floatValue != 0.0f;
+                bool heightBasedBlendV2Enable = useHeightBasedBlendV2.floatValue != 0.0f;
+ 
+                int paramIndex = layerIndex - 1;
+
+                EditorGUILayout.LabelField(styles.DensityOpacityInfluenceText, EditorStyles.boldLabel);
+
+                EditorGUI.indentLevel++;
+
+                m_MaterialEditor.ShaderProperty(opacityAsDensity[paramIndex], styles.opacityAsDensityText);
+                m_MaterialEditor.ShaderProperty(minimumOpacity[paramIndex], styles.minimumOpacityText);
+
+                EditorGUI.indentLevel--;
+
+                if (baseLayerModeEnable)
+                {
+                    EditorGUILayout.LabelField(styles.MainLayerInfluenceText, EditorStyles.boldLabel);
+
+                    EditorGUI.indentLevel++;
+
+                    m_MaterialEditor.ShaderProperty(inheritBaseColor[paramIndex], styles.inheritBaseColorText);
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.ShaderProperty(inheritBaseColorThreshold[paramIndex], styles.inheritBaseColorThresholdText);
+                    EditorGUI.indentLevel--;
+                    m_MaterialEditor.ShaderProperty(inheritBaseNormal[paramIndex], styles.inheritBaseNormalText);
+                    // Main height influence is only available if the shader use the heightmap for displacement (per vertex or per level)
+                    // We always display it as it can be tricky to know when per pixel displacement is enabled or not
+                    m_MaterialEditor.ShaderProperty(inheritBaseHeight[paramIndex], styles.inheritBaseHeightText);
+
+                    EditorGUI.indentLevel--;
+                }
+
+                if (!useHeightBasedBlend.hasMixedValue && heightBasedBlendEnable)
-                    int heightParamIndex = layerIndex - 1;
+                    EditorGUILayout.LabelField(styles.heightControlText, EditorStyles.boldLabel);
+
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.ShaderProperty(heightFactor[paramIndex], styles.heightFactorText);
-                    if(useHeightBasedBlendV2.floatValue != 1.0f)
+                    if (!heightBasedBlendV2Enable)
-                        //m_MaterialEditor.ShaderProperty(inheritBaseLayer[heightParamIndex], styles.inheritBaseLayerText);
-                        m_MaterialEditor.ShaderProperty(heightOffset[heightParamIndex], styles.heightOffsetText);
-                        m_MaterialEditor.ShaderProperty(heightFactor[heightParamIndex], styles.heightFactorText);
-                        m_MaterialEditor.ShaderProperty(blendSize[heightParamIndex], styles.blendSizeText);
-                        m_MaterialEditor.ShaderProperty(inheritBaseColor[heightParamIndex], styles.inheritBaseColorText);
-                        EditorGUI.indentLevel++;
-                        m_MaterialEditor.ShaderProperty(inheritBaseColorThreshold[heightParamIndex], styles.inheritBaseColorThresholdText);
-                        EditorGUI.indentLevel--;
-                        m_MaterialEditor.ShaderProperty(inheritBaseNormal[heightParamIndex], styles.inheritBaseNormalText);
+                        m_MaterialEditor.ShaderProperty(heightOffset[paramIndex], styles.heightOffsetText);
+                        m_MaterialEditor.ShaderProperty(blendSize[paramIndex], styles.blendSizeText);
-                        m_MaterialEditor.ShaderProperty(heightFactor[heightParamIndex], styles.heightFactorText);
-                        m_MaterialEditor.ShaderProperty(heightCenterOffset[heightParamIndex], styles.heightCenterOffsetText);
-                        m_MaterialEditor.ShaderProperty(blendUsingHeight[heightParamIndex], styles.blendUsingHeight);
-                        m_MaterialEditor.ShaderProperty(inheritBaseColor[heightParamIndex], styles.inheritBaseColorText);
-                        EditorGUI.indentLevel++;
-                        m_MaterialEditor.ShaderProperty(inheritBaseColorThreshold[heightParamIndex], styles.inheritBaseColorThresholdText);
-                        EditorGUI.indentLevel--;
-                        m_MaterialEditor.ShaderProperty(inheritBaseNormal[heightParamIndex], styles.inheritBaseNormalText);
-                        m_MaterialEditor.ShaderProperty(inheritBaseHeight[heightParamIndex], styles.inheritBaseHeightText);
-                        m_MaterialEditor.ShaderProperty(opacityAsDensity[heightParamIndex], styles.opacityAsDensityText);
-                        m_MaterialEditor.ShaderProperty(minimumOpacity[heightParamIndex], styles.minimumOpacityText);
+                        m_MaterialEditor.ShaderProperty(heightCenterOffset[paramIndex], styles.heightCenterOffsetText);
+                        m_MaterialEditor.ShaderProperty(blendUsingHeight[paramIndex], styles.blendUsingHeight);
+                    EditorGUI.indentLevel--;
                 }
             }
 
             m_MaterialEditor.TexturePropertySingleLine(styles.layerMapMaskText, layerMaskMap);
 
             EditorGUI.BeginChangeCheck();
+            EditorGUI.showMixedValue = useMainLayerInfluence.hasMixedValue;
+            bool mainLayerModeInfluenceEnable = EditorGUILayout.Toggle(styles.useMainLayerInfluenceModeText, useMainLayerInfluence.floatValue > 0.0f);
+            if (EditorGUI.EndChangeCheck())
+            {
+                useMainLayerInfluence.floatValue = mainLayerModeInfluenceEnable ? 1.0f : 0.0f;
+            }
+
+            m_MaterialEditor.ShaderProperty(vertexColorMode, styles.vertexColorModeText);
+
+            EditorGUI.BeginChangeCheck();
             EditorGUI.showMixedValue = useHeightBasedBlend.hasMixedValue;
             bool enabled = EditorGUILayout.Toggle(styles.useHeightBasedBlendText, useHeightBasedBlend.floatValue > 0.0f);
             if (EditorGUI.EndChangeCheck())
             if (enabled)
             {
                 EditorGUI.BeginChangeCheck();
-                bool enabledV2 = EditorGUILayout.Toggle(styles.useHeightBasedBlendV2Text, useHeightBasedBlendV2.floatValue > 0.0f);
+                EditorGUI.indentLevel++;
+                bool enabledV2 = EditorGUILayout.Toggle(styles.useHeightBasedBlendV2Text, useHeightBasedBlendV2.floatValue > 0.0f);                
                 if (EditorGUI.EndChangeCheck())
                 {
                     useHeightBasedBlendV2.floatValue = enabledV2 ? 1.0f : 0.0f;
-            }
-            else
-            {
-                m_MaterialEditor.ShaderProperty(layerMaskVertexColor, styles.layerMapVertexColorText);
+                EditorGUI.indentLevel--;
-
 
             EditorGUILayout.Space();
 
             }
 
             SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
-            bool useHeightBasedBlend = material.GetFloat(kUseHeightBasedBlend) != 0.0f;
-            if(useHeightBasedBlend)
+
+            SetKeyword(material, "_MAIN_LAYER_INFLUENCE_MODE", material.GetFloat(kkUseMainLayerInfluence) != 0.0f);
+
+            VertexColorMode VCMode = (VertexColorMode)vertexColorMode.floatValue;
+            if (VCMode == VertexColorMode.Multiply)
-                bool useHeightBasedBlendV2 = material.GetFloat(kUseHeightBasedBlendV2) != 0.0f;
-
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", true);
+            }
+            else if (VCMode == VertexColorMode.Add)
+            {
-                SetKeyword(material, "_HEIGHT_BASED_BLEND", true);
-                SetKeyword(material, "_HEIGHT_BASED_BLEND_V2", useHeightBasedBlendV2);
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", true);
-                if (material.GetTexture(kLayerMaskMap) != null)
-                {
-                    SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", material.GetFloat(kLayerMaskVertexColor) != 0.0f);
-                    SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", false);
-                }
-                else
-                {
-                    SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", material.GetFloat(kLayerMaskVertexColor) != 0.0f);
-                    SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", false);
-                }
-                SetKeyword(material, "_HEIGHT_BASED_BLEND", false);
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", false);
+                SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", false);
+
+            bool useHeightBasedBlend = material.GetFloat(kUseHeightBasedBlend) != 0.0f;
+            bool useHeightBasedBlendV2 = material.GetFloat(kUseHeightBasedBlendV2) != 0.0f;
+            SetKeyword(material, "_HEIGHT_BASED_BLEND", useHeightBasedBlend);
+            SetKeyword(material, "_HEIGHT_BASED_BLEND_V2", useHeightBasedBlend && useHeightBasedBlendV2);
 
             // We have to check for each layer if the UV2 or UV3 is needed.
             bool needUV3 = false;

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

 
         // Layer blending options
         _LayerMaskMap("LayerMaskMap", 2D) = "white" {}
-        [ToggleOff]  _LayerMaskVertexColor("Use Vertex Color Mask", Float) = 0.0
+        // Layer blending options V2
+        [ToggleOff] _UseHeightBasedBlendV2("Use Height Blend V2", Float) = 0.0
+        [ToggleOff] _UseMainLayerInfluence("UseMainLayerInfluence", Float) = 0.0
 
         _HeightOffset1("_HeightOffset1", Range(-0.3, 0.3)) = 0.0
         _HeightOffset2("_HeightOffset2", Range(-0.3, 0.3)) = 0.0
         _BlendSize2("_BlendSize2", Range(0, 0.30)) = 0.0
         _BlendSize3("_BlendSize3", Range(0, 0.30)) = 0.0
 
-        _InheritBaseLayer1("_InheritBaseLayer1", Range(0, 1.0)) = 0.0
-        _InheritBaseLayer2("_InheritBaseLayer2", Range(0, 1.0)) = 0.0
-        _InheritBaseLayer3("_InheritBaseLayer3", Range(0, 1.0)) = 0.0
-
-
-        // Layer blending options V2
-        [ToggleOff] _UseHeightBasedBlendV2("Use Height Blend V2", Float) = 0.0
 
         _HeightCenterOffset1("_HeightCenterOffset1", Float) = 0.0
         _HeightCenterOffset2("_HeightCenterOffset2", Float) = 0.0
 
         [HideInInspector] _LayerCount("_LayerCount", Float) = 2.0
 
+        [Enum(None, 0, Multiply, 1, Add, 2)] _VertexColorMode("Vertex color mode", Float) = 0
+
         // 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.
     #pragma shader_feature _HEIGHTMAP
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _ _LAYER_MASK_VERTEX_COLOR_MUL _LAYER_MASK_VERTEX_COLOR_ADD
+    #pragma shader_feature _MAIN_LAYER_INFLUENCE_MODE
     #pragma shader_feature _HEIGHT_BASED_BLEND
     #pragma shader_feature _HEIGHT_BASED_BLEND_V2
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../Lighting/Forward.hlsl"
-            // #include "../../Lighting/Forward.hlsl"
-            //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF
 
             #include "../../Lighting/Lighting.hlsl"            
             #include "../Lit/ShaderPass/LitSharePass.hlsl"

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

 
         // Layer blending options
         _LayerMaskMap("LayerMaskMap", 2D) = "white" {}
-        [ToggleOff]  _LayerMaskVertexColor("Use Vertex Color Mask", Float) = 0.0
+        // Layer blending options V2
+        [ToggleOff] _UseHeightBasedBlendV2("Use Height Blend V2", Float) = 0.0
+        [ToggleOff] _UseMainLayerInfluence("UseMainLayerInfluence", Float) = 0.0
 
         _HeightOffset1("_HeightOffset1", Range(-0.3, 0.3)) = 0.0
         _HeightOffset2("_HeightOffset2", Range(-0.3, 0.3)) = 0.0
         _BlendSize2("_BlendSize2", Range(0, 0.30)) = 0.0
         _BlendSize3("_BlendSize3", Range(0, 0.30)) = 0.0
 
-        _InheritBaseLayer1("_InheritBaseLayer1", Range(0, 1.0)) = 0.0
-        _InheritBaseLayer2("_InheritBaseLayer2", Range(0, 1.0)) = 0.0
-        _InheritBaseLayer3("_InheritBaseLayer3", Range(0, 1.0)) = 0.0
-
-
-        // Layer blending options V2
-        [ToggleOff] _UseHeightBasedBlendV2("Use Height Blend V2", Float) = 0.0
 
         _HeightCenterOffset1("_HeightCenterOffset1", Float) = 0.0
         _HeightCenterOffset2("_HeightCenterOffset2", Float) = 0.0
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
 
         [HideInInspector] _LayerCount("_LayerCount", Float) = 2.0
+
+        [Enum(None, 0, Multiply, 1, Add, 2)] _VertexColorMode("Vertex color mode", Float) = 0
 
         // WARNING
         // All the following properties that concern the UV mapping are the same as in the Lit shader.
     #pragma shader_feature _HEIGHTMAP
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _ _LAYER_MASK_VERTEX_COLOR_MUL _LAYER_MASK_VERTEX_COLOR_ADD
+    #pragma shader_feature _MAIN_LAYER_INFLUENCE_MODE
     #pragma shader_feature _HEIGHT_BASED_BLEND
     #pragma shader_feature _HEIGHT_BASED_BLEND_V2
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../Lighting/Forward.hlsl"
-            // #include "../../Lighting/Forward.hlsl"
-            //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF
 
             #include "../../Lighting/Lighting.hlsl"            
             #include "../Lit/ShaderPass/LitSharePass.hlsl"

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

             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 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 (G)", "Anisotropy");
+            public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map (B)", "Anisotropy");
-            public static GUIContent detailMaskText = new GUIContent("Detail Mask (B)", "Mask for detailMap");
+            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");
         const string kDepthOffsetEnable = "_DepthOffsetEnable";
 
         // tessellation params
-        MaterialProperty tessellationMode = null;
+        protected MaterialProperty tessellationMode = null;
         const string kTessellationMode = "_TessellationMode";
         MaterialProperty tessellationFactor = null;
         const string kTessellationFactor = "_TessellationFactor";

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

             
             m_MaterialEditor.TexturePropertySingleLine(Styles.anisotropyMapText, anisotropyMap);
 
+            EditorGUILayout.Space();
+            GUILayout.Label(Styles.textureControlText, EditorStyles.label);
             m_MaterialEditor.TextureScaleOffsetProperty(baseColorMap);
 
             EditorGUILayout.Space();

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

     }
     else if (surfaceData.materialId == MATERIALID_LIT_SSS)
     {
-        outGBuffer2 = float4(surfaceData.subSurfaceRadius, surfaceData.thickness, 0.0, surfaceData.subSurfaceProfile / 8.0f); // Number of profile not define yet
+        outGBuffer2 = float4(surfaceData.subSurfaceRadius, surfaceData.thickness, 0.0, surfaceData.subSurfaceProfile / 8.0); // Number of profile not define yet
     }
     else if (surfaceData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
         bsdfData.fresnel0 = 0.028; // TODO take from subSurfaceProfile
         bsdfData.subSurfaceRadius = inGBuffer2.r;
         bsdfData.thickness = inGBuffer2.g;
-        bsdfData.subSurfaceProfile = inGBuffer2.a * 8.0f;
+        bsdfData.subSurfaceProfile = inGBuffer2.a * 8.0;
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
     specularLighting   = float3(0.0, 0.0, 0.0);
     float3 cookieColor = float3(1.0, 1.0, 1.0);
 
-    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0f)
+    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
     {
         float shadowAttenuation = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
 
         illuminance *= cookie.a;
     }
 
-    [branch] if (illuminance > 0.0f)
+    [branch] if (illuminance > 0.0)
     {
         BSDF(V, L, positionWS, preLightData, bsdfData, diffuseLighting, specularLighting);
         diffuseLighting  *= (cookieColor * lightData.color) * (illuminance * lightData.diffuseScale);

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.shader

             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../Lighting/Forward.hlsl"
-            // #include "../../Lighting/Forward.hlsl"
-            //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF
 
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"

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

 // Fill SurfaceData/Builtin data function
 //-------------------------------------------------------------------------------------
 #include "../MaterialUtilities.hlsl"
+#include "../SampleLayer.hlsl"
 
 void GetBuiltinData(FragInputs input, SurfaceData surfaceData, float alpha, float depthOffset, out BuiltinData builtinData)
 {
     builtinData.depthOffset = depthOffset;
 }
 
-// Gather all kind of mapping in one struct, allow to improve code readability
-struct LayerUV
-{
-    float2 uv;
-    // triplanar
-    bool isTriplanar;
-    float2 uvYZ;
-    float2 uvZX;
-    float2 uvXY;
-};
-
 struct LayerTexCoord
 {
 #ifndef LAYERED_LIT_SHADER
     float3 weights;
 };
 
-float4 SampleLayer(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights)
-{
-    if (layerUV.isTriplanar)
-    {
-        float4 val = float4(0.0, 0.0, 0.0, 0.0);
-
-        if (weights.x > 0.0)
-            val += weights.x * SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ);
-        if (weights.y > 0.0)
-            val += weights.y * SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX);
-        if (weights.z > 0.0)
-            val += weights.z * SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY);
-
-        return val;
-    }
-    else
-    {
-        return SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv);
-    }
-}
-
-float4 SampleLayerLod(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float lod)
-{
-    if (layerUV.isTriplanar)
-    {
-        float4 val = float4(0.0, 0.0, 0.0, 0.0);
-
-        if (weights.x > 0.0)
-            val += weights.x * SAMPLE_TEXTURE2D_LOD(layerTex, layerSampler, layerUV.uvYZ, lod);
-        if (weights.y > 0.0)
-            val += weights.y * SAMPLE_TEXTURE2D_LOD(layerTex, layerSampler, layerUV.uvZX, lod);
-        if (weights.z > 0.0)
-            val += weights.z * SAMPLE_TEXTURE2D_LOD(layerTex, layerSampler, layerUV.uvXY, lod);
-
-        return val;
-    }
-    else
-    {
-        return SAMPLE_TEXTURE2D_LOD(layerTex, layerSampler, layerUV.uv, lod);
-    }
-}
-
-#define ADD_FUNC_SUFFIX(Name) Name
-#define NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV, bias) SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV)
-#include "LayeredLitNormalSampling.hlsl"
-#undef ADD_FUNC_SUFFIX
-#undef NORMAL_SAMPLE_FUNC
-
-#define ADD_FUNC_SUFFIX(Name) Name##_Bias
-#define NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV, bias) SAMPLE_TEXTURE2D_BIAS(layerTex, layerSampler, layerUV, bias)
-#include "LayeredLitNormalSampling.hlsl"
-#undef ADD_FUNC_SUFFIX
-#undef NORMAL_SAMPLE_FUNC
-
-// Macro to improve readibility of surface data
-#define SAMPLE_LAYER_TEXTURE2D(textureName, samplerName, coord) SampleLayer(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights)
-#define SAMPLE_LAYER_TEXTURE2D_LOD(textureName, samplerName, coord, lod) SampleLayerLod(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, lod)
-#define SAMPLE_LAYER_NORMALMAP(textureName, samplerName, coord, scale, useBias, bias) useBias ? SampleLayerNormal_Bias(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, bias) : SampleLayerNormal(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, bias)
-#define SAMPLE_LAYER_NORMALMAP_AG(textureName, samplerName, coord, scale, useBias, bias) useBias ? SampleLayerNormalAG_Bias(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, bias) : SampleLayerNormalAG(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, bias)
-#define SAMPLE_LAYER_NORMALMAP_RGB(textureName, samplerName, coord, scale, useBias, bias) useBias ? SampleLayerNormalRGB_Bias(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, bias) : SampleLayerNormalRGB(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, bias)
-
-
+// include LitDataInternal to define GetSurfaceData
 #define LAYER_INDEX 0
 #define ADD_IDX(Name) Name
 #define ADD_ZERO_IDX(Name) Name
 #endif
 }
 
+// Calculate displacement for per vertex displacement mapping
+float ComputePerVertexDisplacement(LayerTexCoord layerTexCoord, float4 vertexColor, float lod)
+{
+    return SampleHeightmapLod(layerTexCoord, lod);
+}
+
 void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
 {
     LayerTexCoord layerTexCoord;
     // so it allow us to correctly deal with detail normal map and optimize the code for the layered shaders
     float3 normalTS;
     float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS);
-    surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
-    surfaceData.tangentWS = input.tangentToWorld[0].xyz;
-
-    // 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) make use of double-sided lighting.
-    // This will  potentially reduce the length of the normal at edges of geometry.
-    bool twoSided = false;
-    GetShiftedNdotV(surfaceData.normalWS, V, twoSided);
-
-    // Orthonormalize the basis vectors using the Gram-Schmidt process.
-    // We assume that the length of the surface normal is sufficiently close to 1.
-    surfaceData.tangentWS = normalize(surfaceData.tangentWS - dot(surfaceData.tangentWS, surfaceData.normalWS));
+    GetNormalAndTangentWS(input, V, normalTS, surfaceData.normalWS, surfaceData.tangentWS);
 
     // Caution: surfaceData must be fully initialize before calling GetBuiltinData
     GetBuiltinData(input, surfaceData, alpha, depthOffset, builtinData);
 
 #define ADD_ZERO_IDX(Name) Name##0
 
-// Generate function for all layer
+// include LitDataInternal multiple time to define the variation of GetSurfaceData for each layer
 #define LAYER_INDEX 0
 #define ADD_IDX(Name) Name##0
 #include "LitDataInternal.hlsl"
 void ComputeMaskWeights(float3 inputMasks, out float outWeights[_MAX_LAYER])
 {
     float masks[_MAX_LAYER];
-    masks[0] = 1.0f; // Layer 0 is always full
+    masks[0] = 1.0; // Layer 0 is always full
-    float left = 1.0f;
+    // Algorithm is like this:
+    // Top layer have priority on others layers
+    // If a top layer doesn't use the full weight, the remaining can be use by the following layer.
+    float weightsSum = 0.0;
-    for (int i = _LAYER_COUNT - 1; i > 0; --i)
+    for (int i = _LAYER_COUNT - 1; i >= 0; --i)
-        outWeights[i] = masks[i] * left;
-        left -= outWeights[i];
+        outWeights[i] = min(masks[i], (1.0 - weightsSum));
+        weightsSum = saturate(weightsSum + masks[i]);
-    outWeights[0] = left;
-float3 BlendLayeredFloat3(float3 x0, float3 x1, float3 x2, float3 x3, float weight[4])
+float3 BlendLayeredVector3(float3 x0, float3 x1, float3 x2, float3 x3, float weight[4])
 {
     float3 result = float3(0.0, 0.0, 0.0);
 
     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 PROP_BLEND_SCALAR(name, mask) BlendLayeredScalar(name##0, name##1, name##2, name##3, mask);
+
 float ApplyHeightBasedBlend(inout float inputFactor, float previousLayerHeight, float layerHeight, float heightOffset, float heightFactor, float edgeBlendStrength, float vertexColor)
 {
     float finalLayerHeight = heightFactor * layerHeight + heightOffset + _VertexColorHeightFactor * (vertexColor * 2.0 - 1.0);
     return saturate(lerp(inputMask * inputHeight * blendUsingHeight * 100, 1, inputMask * inputMask)); // 100 arbitrary scale to limit blendUsingHeight values.
 }
 
-
-#define SURFACEDATA_BLEND_COLOR(surfaceData, name, mask) BlendLayeredFloat3(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 PROP_BLEND_SCALAR(name, mask) BlendLayeredScalar(name##0, name##1, name##2, name##3, mask);
-
 void GetLayerTexCoord(float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3,
                       float3 positionWS, float3 normalWS, out LayerTexCoord layerTexCoord)
 {
 float3 ComputeInheritedNormalTS(FragInputs input, float3 normalTS0, float3 normalTS1, float3 normalTS2, float3 normalTS3, LayerTexCoord layerTexCoord, float weights[_MAX_LAYER])
 {
     float3 normalTS;
-//#if !defined(_HEIGHT_BASED_BLEND_V2)
-//    float _InheritBaseLayer0 = 1.0f; // Default value for lerp when all weights but base layer are zero.
-//
-//    // Compute the combined inheritance factor of layers 1,2 and 3
-//    float inheritFactor = PROP_BLEND_SCALAR(_InheritBaseLayer, weights);
-//    float3 vertexNormalTS = float3(0.0, 0.0, 1.0);
-//    // The idea here is to lerp toward vertex normal. This way when we don't want to inherit, we will combine layer 1/2/3 normal with a vertex normal which is neutral.
-//    float3 baseLayerNormalTS = normalize(lerp(vertexNormalTS, normalTS0, inheritFactor));
-//    // Blend layer 1/2/3 normals before combining to the base layer. Again we need to have a neutral value for base layer (vertex normal) in case all weights are zero.
-//    float3 layersNormalTS = BlendLayeredFloat3(vertexNormalTS, normalTS1, normalTS2, normalTS3, weights);
-//    normalTS = BlendNormalRNM(baseLayerNormalTS, layersNormalTS);
-//#else
-    float inheritBaseNormal = BlendLayeredScalar(1.0f, _InheritBaseNormal1, _InheritBaseNormal2, _InheritBaseNormal3, weights);
+    float inheritBaseNormal = BlendLayeredScalar(1.0, _InheritBaseNormal1, _InheritBaseNormal2, _InheritBaseNormal3, weights);
-    float maxMipBias = 12.0f; // We arbitrarly choose the max bias for a 2048 texture. Smaller texture will bias toward vertex normal faster.
-    float3 inheritedBaseNormalTS = GetNormalTS0(input, layerTexCoord, float3(0.0, 0.0, 0.0), 0.0f, true, maxMipBias * (1.0 - inheritBaseNormal));
+    float maxMipBias = log2(max(_NormalMap0_TexelSize.x, _NormalMap0_TexelSize.y)) + 1.0; // TODO: Use hardware instruction here (GetDimensions) that can retunr mipmaps num ? will this be faster
+    float3 inheritedBaseNormalTS = GetNormalTS0(input, layerTexCoord, float3(0.0, 0.0, 0.0), 0.0, true, maxMipBias * (1.0 - inheritBaseNormal));
-    float3 layersNormalTS = BlendLayeredFloat3(float3(0.0, 0.0, 1.0), normalTS1, normalTS2, normalTS3, weights);
+    float3 layersNormalTS = BlendLayeredVector3(float3(0.0, 0.0, 1.0), normalTS1, normalTS2, normalTS3, weights);
-//#endif
 
     return normalTS;
 }
-    //return BlendLayeredFloat3(baseColor0, baseColor1, baseColor2, baseColor3, weights);
+    float inheritBaseColor = BlendLayeredScalar(1.0, _InheritBaseColor1, _InheritBaseColor2, _InheritBaseColor3, weights);
+    float inheritBaseColorThreshold = BlendLayeredScalar(1.0, _InheritBaseColorThreshold1, _InheritBaseColorThreshold2, _InheritBaseColorThreshold3, weights);
+
+    inheritBaseColor = inheritBaseColor * (1.0 - saturate(compoMask / inheritBaseColorThreshold));
+
+    // We want to calculate the mean color of the texture. For this we will sample a low mipmap
+    float textureBias = 15.0; // Force a high number to be sure we get the lowest mip
+    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 meanColor = BlendLayeredVector3(baseMeanColor0, baseMeanColor1, baseMeanColor2, baseMeanColor3, weights);
+    float3 baseColor = BlendLayeredVector3(baseColor0, baseColor1, baseColor2, baseColor3, weights);
-    float inheritBaseColor = BlendLayeredScalar(1.0f, _InheritBaseColor1, _InheritBaseColor2, _InheritBaseColor3, weights);
-    float inheritBaseColorThreshold = BlendLayeredScalar(1.0f, _InheritBaseColorThreshold1, _InheritBaseColorThreshold2, _InheritBaseColorThreshold3, weights);
+    // If we inherit from base layer, we will add a bit of it
+    return inheritBaseColor * (baseColor0 - meanColor) + baseColor;
+}
-    inheritBaseColor = inheritBaseColor * (1.0 - saturate(compoMask / inheritBaseColorThreshold));
+// Calculate displacement for per vertex displacement mapping
+float ComputePerVertexDisplacement(LayerTexCoord layerTexCoord, float4 vertexColor, float lod)
+{
+    // Mask Values : Layer 1, 2, 3 are r, g, b. Always use layer0 parametrization for the mask
+    float3 inputMaskValues = SAMPLE_LAYER_TEXTURE2D_LOD(_LayerMaskMap, sampler_LayerMaskMap, layerTexCoord.base0, lod).rgb;
-    float textureBias = 12.0f;
-    float3 baseMeanColor0 = SAMPLE_TEXTURE2D_BIAS(_BaseColorMap0, sampler_BaseColorMap0, layerTexCoord.base0.uv, textureBias).rgb * _BaseColor0.rgb;
-    float3 baseMeanColor1 = SAMPLE_TEXTURE2D_BIAS(_BaseColorMap1, sampler_BaseColorMap0, layerTexCoord.base1.uv, textureBias).rgb * _BaseColor1.rgb;
-    float3 baseMeanColor2 = SAMPLE_TEXTURE2D_BIAS(_BaseColorMap2, sampler_BaseColorMap0, layerTexCoord.base2.uv, textureBias).rgb * _BaseColor2.rgb;
-    float3 baseMeanColor3 = SAMPLE_TEXTURE2D_BIAS(_BaseColorMap3, sampler_BaseColorMap0, layerTexCoord.base3.uv, textureBias).rgb * _BaseColor3.rgb;
+#if defined(_LAYER_MASK_VERTEX_COLOR_MUL)
+    inputMaskValues *= vertexColor.rgb;
+#elif defined(_LAYER_MASK_VERTEX_COLOR_ADD)
+    inputMaskValues = saturate(inputMaskValues + vertexColor.rgb * 2.0 - 1.0);
+#endif
-    //float3 toto1 = lerp(baseMeanColor1, baseMeanColor0, _InheritBaseColor1) + baseColor1 - baseMeanColor1;
-    //float3 toto2 = lerp(baseMeanColor2, baseMeanColor0, _InheritBaseColor2) + baseColor2 - baseMeanColor2;
-    //float3 toto3 = lerp(baseMeanColor3, baseMeanColor0, _InheritBaseColor3) + baseColor3 - baseMeanColor3;
+    float weights[_MAX_LAYER];
+    ComputeMaskWeights(inputMaskValues, weights);
-    //return BlendLayeredFloat3(baseColor0, toto1, toto3, toto3, weights);
+    float height0 = SampleHeightmapLod0(layerTexCoord, lod);
+    float height1 = SampleHeightmapLod1(layerTexCoord, lod, _HeightCenterOffset1, _HeightFactor1);
+    float height2 = SampleHeightmapLod2(layerTexCoord, lod, _HeightCenterOffset2, _HeightFactor2);
+    float height3 = SampleHeightmapLod3(layerTexCoord, lod, _HeightCenterOffset3, _HeightFactor3);
+    float heightResult = BlendLayeredScalar(height0, height1, height2, height3, weights);
-    float3 meanColor = BlendLayeredFloat3(baseMeanColor0, baseMeanColor1, baseMeanColor2, baseMeanColor3, weights);
-    float3 baseColor = BlendLayeredFloat3(baseColor0, baseColor1, baseColor2, baseColor3, weights);
+#if defined(_MAIN_LAYER_INFLUENCE_MODE)
+    // Think that inheritbasedheight will be 0 if height0 is fully visible in weights. So there is no double contribution of height0
+    float inheritBaseHeight = BlendLayeredScalar(0.0, _InheritBaseHeight1, _InheritBaseHeight2, _InheritBaseHeight3, weights);
+    return heightResult + height0 * inheritBaseHeight;
+#endif
-    //return lerp(baseMeanColor1, baseColor0, _InheritBaseColor1) + (baseColor1 - baseMeanColor1);
-    return lerp(meanColor, baseColor0, inheritBaseColor) + (baseColor - meanColor);
+    return heightResult;
+// Calculate weights to apply to each layer
+// Caution: This function must not be use for per vertex of per pixel displacement, there is a dedicated function for them.
+// this function handle triplanar
+    // Mask Values : Layer 1, 2, 3 are r, g, b. Always use layer0 parametrization for the mask
+    float3 inputMaskValues = SAMPLE_LAYER_TEXTURE2D(_LayerMaskMap, sampler_LayerMaskMap, layerTexCoord.base0).rgb;
+
+#if defined(_LAYER_MASK_VERTEX_COLOR_MUL)
+    inputMaskValues *= input.color.rgb;
+#elif defined(_LAYER_MASK_VERTEX_COLOR_ADD)
+    inputMaskValues = saturate(inputMaskValues + input.color.rgb * 2.0 - 1.0);
+#endif
+
+    float3 minOpaParam = float3(_MinimumOpacity1, _MinimumOpacity2, _MinimumOpacity3);
+    float3 remapedOpacity = lerp(minOpaParam, float3(1.0, 1.0, 1.0), inputAlphaMask.yzw); // Remap opacity mask from [0..1] to [minOpa..1]
+    float3 opacityAsDensity = saturate((inputAlphaMask.yzw - (float3(1.0, 1.0, 1.0) - inputMaskValues)) * 20.0);
+
+    float3 useOpacityAsDensityParam = float3(_OpacityAsDensity1, _OpacityAsDensity2, _OpacityAsDensity3);
+    inputMaskValues = lerp(inputMaskValues * remapedOpacity, opacityAsDensity, useOpacityAsDensityParam);
+
+#if defined(_HEIGHT_BASED_BLEND)
     float height0 = SampleHeightmap0(layerTexCoord);
     float height1 = SampleHeightmap1(layerTexCoord, _HeightCenterOffset1, _HeightFactor1);
     float height2 = SampleHeightmap2(layerTexCoord, _HeightCenterOffset2, _HeightFactor2);
-    // Mask Values : Layer 1, 2, 3 are r, g, b
-    float3 inputMaskValues = SAMPLE_TEXTURE2D(_LayerMaskMap, sampler_LayerMaskMap, input.texCoord0).rgb;
-    // Mutually exclusive with _HEIGHT_BASED_BLEND
-#if defined(_LAYER_MASK_VERTEX_COLOR_MUL) // Used when no layer mask is set
-    inputMaskValues *= input.color.rgb;
-#elif defined(_LAYER_MASK_VERTEX_COLOR_ADD) || defined(_HEIGHT_BASED_BLEND_V2) // When layer mask is set, color is additive to enable user to override it.
-    inputMaskValues = saturate(inputMaskValues + input.color.rgb * 2.0 - 1.0);
-#endif
-
-#if defined(_HEIGHT_BASED_BLEND)
     #if !defined(_HEIGHT_BASED_BLEND_V2)
         float baseLayerHeight = heights.x;
         baseLayerHeight = ApplyHeightBasedBlend(inputMaskValues.r, baseLayerHeight, heights.y, _HeightOffset1, _HeightFactor1, _BlendSize1, input.color.r);
 
-        float3 minOpaParam = float3(_MinimumOpacity1, _MinimumOpacity2, _MinimumOpacity3);
-        float3 remapedOpacity = (float3(1.0, 1.0, 1.0) - minOpaParam) * inputAlphaMask.yzw + minOpaParam; // Remap opacity mask from [0..1] to [minOpa..1]
-        float3 opacityAsDensity = saturate((inputAlphaMask.yzw - (float3(1.0, 1.0, 1.0) - inputMaskValues))*20.0);
-
-        float3 useOpacityAsDensityParam = float3(_OpacityAsDensity1, _OpacityAsDensity2, _OpacityAsDensity3);
-        inputMaskValues = lerp(inputMaskValues * remapedOpacity, opacityAsDensity, useOpacityAsDensityParam);
-
         // HACK, use height0 to avoid compiler error for unused sampler
         // To remove once we have POM
         heights.y += (heights.x * 0.0001);
 #endif
 
     ComputeMaskWeights(inputMaskValues, outWeights);
-
-//#if defined(_HEIGHT_BASED_BLEND_V2)
-//    float inheritBaseHeight = BlendLayeredScalar(0.0f, _InheritBaseHeight1, _InheritBaseHeight2, _InheritBaseHeight3, weights);
-//    float blendedLayerHeight = BlendLayeredScalar(heights.x, heights.y, heights.z, heights.w, weights);
-//    float finalHeight = heights.x * inheritBaseHeight + blendedLayerHeight;
-//    // Use this for POM/Tesselation
-//#endif
 }
 
 void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
     // For layered shader, alpha of base color is used as either an opacity mask, a composition mask for inheritance parameters or a density mask.
     float alpha = PROP_BLEND_SCALAR(alpha, weights);
 
-#if defined(_HEIGHT_BASED_BLEND)
+#if defined(_MAIN_LAYER_INFLUENCE_MODE)
+    float3 normalTS = ComputeInheritedNormalTS(input, normalTS0, normalTS1, normalTS2, normalTS3, layerTexCoord, weights);
-    surfaceData.baseColor = SURFACEDATA_BLEND_COLOR(surfaceData, baseColor, weights);
+    surfaceData.baseColor = SURFACEDATA_BLEND_VECTOR3(surfaceData, baseColor, weights);
+    float3 normalTS = BlendLayeredVector3(normalTS0, normalTS1, normalTS2, normalTS3, weights);
+
-    float3 normalTS;
-#if defined(_HEIGHT_BASED_BLEND)
-    normalTS = ComputeInheritedNormalTS(input, normalTS0, normalTS1, normalTS2, normalTS3, layerTexCoord, weights);
-#else
-    normalTS = BlendLayeredFloat3(normalTS0, normalTS1, normalTS2, normalTS3, weights);
-#endif
-
-    surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
-    surfaceData.tangentWS = input.tangentToWorld[0].xyz;
-
-    // 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) make use of double-sided lighting.
-    // This will  potentially reduce the length of the normal at edges of geometry.
-    bool twoSided = false;    
-    GetShiftedNdotV(surfaceData.normalWS, V, twoSided);
-
-    // Orthonormalize the basis vectors using the Gram-Schmidt process.
-    // We assume that the length of the surface normal is sufficiently close to 1.
-    surfaceData.tangentWS = normalize(surfaceData.tangentWS - dot(surfaceData.tangentWS, surfaceData.normalWS));
-
+    surfaceData.tangentWS = normalize(input.tangentToWorld[0].xyz);
     surfaceData.materialId = 0;
     surfaceData.anisotropy = 0;
     surfaceData.specular = 0.04;
     surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
     surfaceData.coatPerceptualSmoothness = 1.0;
     surfaceData.specularColor = float3(0.0, 0.0, 0.0);
+
+    GetNormalAndTangentWS(input, V, normalTS, surfaceData.normalWS, surfaceData.tangentWS);
 
     GetBuiltinData(input, surfaceData, alpha, depthOffset, builtinData);
 }

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

     ADD_IDX(layerTexCoord.details).uvXY = TRANSFORM_TEX(uvXY, ADD_IDX(_DetailMap));
 }
 
-float ADD_IDX(SampleHeightmap)(LayerTexCoord layerTexCoord, float centerOffset = 0.0f, float multiplier = 1.0f)
+float ADD_IDX(SampleHeightmap)(LayerTexCoord layerTexCoord, float centerOffset = 0.0, float multiplier = 1.0)
+{
+#ifdef _HEIGHTMAP
+    return (SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), ADD_IDX(layerTexCoord.base)).r - ADD_IDX(_HeightCenter) - centerOffset) * ADD_IDX(_HeightAmplitude) * multiplier;
+#else
+    return 0.0;
+#endif
+}
+
+float ADD_IDX(SampleHeightmapLod)(LayerTexCoord layerTexCoord, float lod, float centerOffset = 0.0, float multiplier = 1.0)
-    return (SAMPLE_TEXTURE2D(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), ADD_IDX(layerTexCoord.base).uv).r - ADD_IDX(_HeightCenter) - centerOffset) * ADD_IDX(_HeightAmplitude) * multiplier;
+    return (SAMPLE_LAYER_TEXTURE2D_LOD(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), ADD_IDX(layerTexCoord.base), lod).r - ADD_IDX(_HeightCenter) - centerOffset) * ADD_IDX(_HeightAmplitude) * multiplier;
+// Note: The sampling of heightmap inside POM don't use sampling abstraction (with triplanar) as 
+// POM must be apply separately for each uv set (so 3 time for triplanar)
 void ADD_IDX(ParallaxOcclusionMappingLayer)(inout LayerTexCoord layerTexCoord, int numSteps, float3 viewDirTS)
 {
     // Convention: 1.0 is top, 0.0 is bottom - POM is always inward, no extrusion
 
     #ifdef _NORMALMAP
         #ifdef _NORMALMAP_TANGENT_SPACE
-            normalTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base), ADD_ZERO_IDX(_NormalScale), useBias, bias);
+            if (useBias)
+            {
+                normalTS = SAMPLE_LAYER_NORMALMAP_BIAS(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base), ADD_ZERO_IDX(_NormalScale), bias);
+            }
+            else
+            {
+                normalTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base), ADD_ZERO_IDX(_NormalScale));
+            }            
-            float3 normalOS = SAMPLE_LAYER_NORMALMAP_RGB(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base), ADD_ZERO_IDX(_NormalScale), useBias, bias).rgb;
-            normalTS = TransformObjectToTangent(normalOS, input.tangentToWorld);
+            // to be able to combine object space normal with detail map we transform it to tangent space (object space normal composition is not simple).
+            // then later we will re-transform it to world space.
+            if (useBias)
+            {
+                float3 normalOS = SAMPLE_LAYER_NORMALMAP_RGB_BIAS(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base), ADD_ZERO_IDX(_NormalScale), bias).rgb;
+                normalTS = TransformObjectToTangent(normalOS, input.tangentToWorld);
+            }
+            else
+            {
+                float3 normalOS = SAMPLE_LAYER_NORMALMAP_RGB(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base), ADD_ZERO_IDX(_NormalScale)).rgb;
+                normalTS = TransformObjectToTangent(normalOS, input.tangentToWorld);
+            }
         #endif
 
         #ifdef _DETAIL_MAP
         #endif
         // 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);
+                        (GetOddNegativeScale() >= 0.0 ? normalTS : oppositeNormalTS) :
+                        (-GetOddNegativeScale() >= 0.0 ? normalTS : oppositeNormalTS);
     #endif
 
     return normalTS;
     float3 detailNormalTS = float3(0.0, 0.0, 0.0);
     float detailMask = 0.0;
 #ifdef _DETAIL_MAP
-    detailMask = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_DetailMask), ADD_ZERO_IDX(sampler_DetailMask), ADD_IDX(layerTexCoord.base)).b;
+    detailMask = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_DetailMask), ADD_ZERO_IDX(sampler_DetailMask), ADD_IDX(layerTexCoord.base)).g;
     float2 detailAlbedoAndSmoothness = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_DetailMap), ADD_ZERO_IDX(sampler_DetailMap), ADD_IDX(layerTexCoord.details)).rb;
     float detailAlbedo = detailAlbedoAndSmoothness.r;
     float detailSmoothness = detailAlbedoAndSmoothness.g;
-    detailNormalTS = SAMPLE_LAYER_NORMALMAP_AG(ADD_IDX(_DetailMap), ADD_ZERO_IDX(sampler_DetailMap), ADD_IDX(layerTexCoord.details), ADD_ZERO_IDX(_DetailNormalScale), false, 0.0f);
+    detailNormalTS = SAMPLE_LAYER_NORMALMAP_AG(ADD_IDX(_DetailMap), ADD_ZERO_IDX(sampler_DetailMap), ADD_IDX(layerTexCoord.details), ADD_ZERO_IDX(_DetailNormalScale));
     //float detailAO = 0.0;
     #else
     // TODO: Use heightmap as a derivative with Morten Mikklesen approach, how this work with our abstraction and triplanar ?
     surfaceData.normalWS = float3(0.0, 0.0, 0.0); // Need to init this so that the compiler leaves us alone.
 
     // TODO: think about using BC5
-    normalTS = ADD_IDX(GetNormalTS)(input, layerTexCoord, detailNormalTS, detailMask, false, 0.0f);
+    normalTS = ADD_IDX(GetNormalTS)(input, layerTexCoord, detailNormalTS, detailMask, false, 0.0);
 
 #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     surfaceData.perceptualSmoothness = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_BaseColorMap), ADD_ZERO_IDX(sampler_BaseColorMap), ADD_IDX(layerTexCoord.base)).a;
     // TODO: Is there anything todo regarding flip normal but for the tangent ?
 
 #ifdef _ANISOTROPYMAP
-    surfaceData.anisotropy = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_AnisotropyMap), ADD_ZERO_IDX(sampler_AnisotropyMap), ADD_IDX(layerTexCoord.base)).g;
+    surfaceData.anisotropy = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_AnisotropyMap), ADD_ZERO_IDX(sampler_AnisotropyMap), ADD_IDX(layerTexCoord.base)).b;
 #else
     surfaceData.anisotropy = 1.0;
 #endif

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

 
 PROP_DECL_TEX2D(_NormalMap);
 PROP_DECL(float, _NormalScale);
+float4 _NormalMap0_TexelSize; // Unity facility. This will provide the size of the base normal to the shader
 
 PROP_DECL_TEX2D(_HeightMap);
 float4 _HeightMap0_TexelSize;
 float _BlendSize2;
 float _BlendSize3;
 float _VertexColorHeightFactor;
-float _InheritBaseLayer1;
-float _InheritBaseLayer2;
-float _InheritBaseLayer3;
 
 // Blend Properties V2
 float _UseHeightBasedBlendV2;

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

         input.normalWS,
         layerTexCoord);
 
-    // TODO: For now just use Layer0, but we are suppose to apply the same heightmap blending than in the pixel shader
-#ifdef _HEIGHTMAP
-    // TODO test mip lod to reduce texture cache miss
-    //float dist = distance(input.positionWS, cameraPosWS);
-    // No ddx/ddy to calculate LOD, use camera distance instead
-    //float fadeDist = _TessellationFactorMaxDistance - _TessellationFactorMinDistance;
-    //float heightMapLod = saturate((dist - _TessellationFactorMinDistance) / min(fadeDist, 0.01)) * 6; // 6 is an arbitrary number here
-    float heightMapLod = 0.0;
-
-    float height = (SAMPLE_LAYER_TEXTURE2D_LOD(ADD_ZERO_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), ADD_ZERO_IDX(layerTexCoord.base), heightMapLod).r - ADD_ZERO_IDX(_HeightCenter)) * ADD_ZERO_IDX(_HeightAmplitude);
-#else
-    float height = 0.0;
+    float lod = 0.0;
+    float4 vertexColor = float4(0.0, 0.0, 0.0, 0.0);
+#ifdef VARYINGS_DS_NEED_COLOR
+    vertexColor = input.color;
-
+    float height = ComputePerVertexDisplacement(layerTexCoord, vertexColor, lod);
     float3 displ = height * input.normalWS;
 
         // Applying scaling of the object if requested

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

             #pragma hull Hull
             #pragma domain Domain
 
-            #define SHADERPASS SHADERPASS_FORWARD
+            #define SHADERPASS SHADERPASS_FORWARD            
+            #include "../../Lighting/Forward.hlsl"
-            // #include "../../Lighting/Forward.hlsl"
-            //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF
 
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"

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

 
 // Attributes
 #define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELLATION_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
+#define REQUIRE_VERTEX_COLOR_FOR_TESSELATION REQUIRE_UV_FOR_TESSELATION
 #define REQUIRE_TANGENT_TO_WORLD (defined(_HEIGHTMAP) && defined(_PER_PIXEL_DISPLACEMENT))
 
 // This first set of define allow to say which attributes will be use by the mesh in the vertex and domain shader (for tesselation)
         #define ATTRIBUTES_NEED_TEXCOORD3
         #endif
     #endif
+#endif
+
+#if REQUIRE_VERTEX_COLOR_FOR_TESSELATION
+#define ATTRIBUTES_NEED_COLOR
 #endif
 
 // Varying - Use for pixel shader

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

 
 // Attributes
 #define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELLATION_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
+#define REQUIRE_VERTEX_COLOR_FOR_TESSELATION REQUIRE_UV_FOR_TESSELATION
 #define REQUIRE_TANGENT_TO_WORLD (defined(_HEIGHTMAP) && defined(_PER_PIXEL_DISPLACEMENT))
 
 // This first set of define allow to say which attributes will be use by the mesh in the vertex and domain shader (for tesselation)
         #define ATTRIBUTES_NEED_TEXCOORD3
         #endif
     #endif
+#endif
+
+#if REQUIRE_VERTEX_COLOR_FOR_TESSELATION
+#define ATTRIBUTES_NEED_COLOR
 #endif
 
 // Varying - Use for pixel shader

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

 
 // Attributes
 #define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELLATION_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
+#define REQUIRE_VERTEX_COLOR_FOR_TESSELATION REQUIRE_UV_FOR_TESSELATION
 #define REQUIRE_TANGENT_TO_WORLD 0 /* (defined(_HEIGHTMAP) && defined(_PER_PIXEL_DISPLACEMENT)) */
 
 // This first set of define allow to say which attributes will be use by the mesh in the vertex and domain shader (for tesselation)
         #endif
     #endif
 #endif
+
+#if REQUIRE_VERTEX_COLOR_FOR_TESSELATION
+#define ATTRIBUTES_NEED_COLOR
+#endif
+
 
 // Varying - Use for pixel shader
 // This second set of define allow to say which varyings will be output in the vertex (no more tesselation)

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/MaterialUtilities.hlsl

         // TODO: Move all this to C++!
         float4x4 identity = 0;
         identity._m00_m11_m22_m33 = 1.0;
-        float4x4 WorldToTexture = (unity_ProbeVolumeParams.y == 1.0f) ? unity_ProbeVolumeWorldToObject : identity;
+        float4x4 WorldToTexture = (unity_ProbeVolumeParams.y == 1.0) ? unity_ProbeVolumeWorldToObject : identity;
 
         float4x4 translation = identity;
         translation._m30_m31_m32 = -unity_ProbeVolumeMin.xyz;
 #else
     return float2(0.0, 0.0);
 #endif
-}
+}
+
+// This function convert the tangent space normal/tangent to world space and orthonormalize it + apply a correction of the normal if it is not pointing towards the near plane
+void GetNormalAndTangentWS(FragInputs input, float3 V, float3 normalTS, inout float3 normalWS, inout float3 tangentWS, bool twoSided = false)
+{
+    normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
+
+    // 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);
+
+    // Orthonormalize the basis vectors using the Gram-Schmidt process.
+    // We assume that the length of the surface normal is sufficiently close to 1.
+    tangentWS = normalize(tangentWS - dot(tangentWS, normalWS));
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Unlit/Unlit.shader

 
             ENDHLSL
         }
-        
-        // ------------------------------------------------------------------
-        //  forward opaque pass
-        // Material opaque that are always forward (i.e can't render in deferred) need to implement ForwardOnlyOpaque pass
-        // (Code is exactly the same as "Forward", it simply allow our system to filter objects correctly
-        // TODO: can we do this another way ? Like relying on QueueIndex ? But it will be require anyway for material with two forward pass like hair
-        Pass
-        {
-            Name "ForwardUnlit"
-            Tags { "LightMode" = "ForwardOnlyOpaque" }
-
-            Blend [_SrcBlend] [_DstBlend]
-            ZWrite [_ZWrite]
-            Cull [_CullMode]
-
-            HLSLPROGRAM
-
-            #define SHADERPASS SHADERPASS_FORWARD_UNLIT
-            #include "../../Material/Material.hlsl"            
-            #include "ShaderPass/UnlitSharePass.hlsl"
-            #include "UnlitData.hlsl"
-            #include "../../ShaderPass/ShaderPassForwardUnlit.hlsl"
-
-            ENDHLSL
-        }
 
         // ------------------------------------------------------------------
         //  forward pass

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl

         inputMesh.positionOS.xy = inputMesh.uv1 * unity_LightmapST.xy + unity_LightmapST.zw;
         // OpenGL right now needs to actually use incoming vertex position,
         // so use it in a very dummy way
-        //v.positionOS.z = vertex.z > 0 ? 1.0e-4f : 0.0f;
+        //v.positionOS.z = vertex.z > 0 ? 1.0e-4 : 0.0;
     }
     if (unity_MetaVertexControl.y)
     {
-        //v.positionOS.z = vertex.z > 0 ? 1.0e-4f : 0.0f;
+        //v.positionOS.z = vertex.z > 0 ? 1.0e-4 : 0.0;
     }
 
     float3 positionWS = TransformObjectToWorld(inputMesh.positionOS);

Assets/ScriptableRenderLoop/HDRenderPipeline/Shadow/Shadow.hlsl

 // - 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.0f - texCoordXYZ.z) <= 1.0f) return 1.0;
+// if (max3(abs(NDC.x), abs(NDC.y), 1.0 - texCoordXYZ.z) <= 1.0) return 1.0;
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyParameters.cs

         public Gradient worldMieColorRamp             = null;
         public float    worldMieDensity               = 15f;
         public float    worldMieExtinctionFactor      = 0f;
+        public float    worldMieNearScatterPush       = 0f;
-        public float    worldNearScatterPush          = 0f;
         public float    worldNormalDistance           = 1000f;
         public float    worldRayleighColorIntensity   = 1f;
         public Gradient worldRayleighColorRamp        = null;
+        public float    worldRayleighNearScatterPush  = 0f;
-        public float    heightNearScatterPush         = 0f;
+        public float    heightMieNearScatterPush      = 0f;
+        public float    heightRayleighNearScatterPush = 0f;
         public float    heightSeaLevel                = 0f;
 
         /*
 
         public void OnValidate()
         {
-            worldMieDensity              = Mathf.Clamp(worldMieDensity, 0f, 1000f);
-            worldMiePhaseAnisotropy      = Mathf.Clamp01(worldMiePhaseAnisotropy);
-            worldNearScatterPush         = Mathf.Clamp(worldNearScatterPush, -200f, 300f);
-            worldNormalDistance          = Mathf.Clamp(worldNormalDistance, 1f, 10000f);
-            worldRayleighDensity         = Mathf.Clamp(worldRayleighDensity, 0, 1000f);
-            worldRayleighIndirectScatter = Mathf.Clamp(worldRayleighIndirectScatter, 0f, 1f);
+            worldMieDensity               = Mathf.Clamp(worldMieDensity, 0f, 1000f);
+            worldMiePhaseAnisotropy       = Mathf.Clamp01(worldMiePhaseAnisotropy);
+            worldMieNearScatterPush       = Mathf.Clamp(worldMieNearScatterPush, -200f, 300f);
+            worldNormalDistance           = Mathf.Clamp(worldNormalDistance, 1f, 10000f);
+            worldRayleighDensity          = Mathf.Clamp(worldRayleighDensity, 0, 1000f);
+            worldRayleighIndirectScatter  = Mathf.Clamp(worldRayleighIndirectScatter, 0f, 1f);
+            worldRayleighNearScatterPush  = Mathf.Clamp(worldRayleighNearScatterPush, -200f, 300f);
-            heightMieDensity             = Mathf.Clamp(heightMieDensity, 0, 1000f);
-            heightNearScatterPush        = Mathf.Clamp(heightNearScatterPush, -200f, 300f);
-            heightNormalDistance         = Mathf.Clamp(heightNormalDistance, 1f, 10000f);
-            heightRayleighDensity        = Mathf.Clamp(heightRayleighDensity, 0, 1000f);
+            heightMieDensity              = Mathf.Clamp(heightMieDensity, 0, 1000f);
+            heightMieNearScatterPush      = Mathf.Clamp(heightMieNearScatterPush, -200f, 300f);
+            heightNormalDistance          = Mathf.Clamp(heightNormalDistance, 1f, 10000f);
+            heightRayleighDensity         = Mathf.Clamp(heightRayleighDensity, 0, 1000f);
+            heightRayleighNearScatterPush = Mathf.Clamp(heightRayleighNearScatterPush, -200f, 300f);
-            worldScaleExponent           = Mathf.Clamp(worldScaleExponent, 1f, 2f);
+            worldScaleExponent            = Mathf.Clamp(worldScaleExponent, 1f, 2f);
 
             /*
             occlusionBias                = Mathf.Clamp01(occlusionBias);

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

             Utilities.SetRenderTarget(builtinParams.renderContext, builtinParams.colorBuffer);
         }
 
-        void SetKeywords(BuiltinSkyParameters builtinParams, ProceduralSkyParameters param)
+        void SetKeywords(BuiltinSkyParameters builtinParams, ProceduralSkyParameters param, bool renderForCubemap)
         {
             // Ensure that all preprocessor symbols are initially undefined.
             m_ProceduralSkyMaterial.DisableKeyword("ATMOSPHERICS");
             */
 
             // Expected to be valid for the sky pass, and invalid for the cube map generation pass.
-            if (builtinParams.depthBuffer != BuiltinSkyParameters.nullRT)
+            if (!renderForCubemap)
             {
                 m_ProceduralSkyMaterial.EnableKeyword("PERFORM_SKY_OCCLUSION_TEST");
             }
             }
         }
 
-        void SetUniforms(BuiltinSkyParameters builtinParams, ProceduralSkyParameters param, ref MaterialPropertyBlock properties)
+        void SetUniforms(BuiltinSkyParameters builtinParams, ProceduralSkyParameters param, bool renderForCubemap, ref MaterialPropertyBlock properties)
         {
             properties.SetTexture("_Cubemap", param.skyHDRI);
             properties.SetVector("_SkyParam", new Vector4(param.exposure, param.multiplier, param.rotation, 0.0f));
 
             m_ProceduralSkyMaterial.SetFloat("_WorldScaleExponent", param.worldScaleExponent);
             m_ProceduralSkyMaterial.SetFloat("_WorldNormalDistanceRcp", 1f / param.worldNormalDistance);
-            m_ProceduralSkyMaterial.SetFloat("_WorldNearScatterPush", -Mathf.Pow(Mathf.Abs(param.worldNearScatterPush), param.worldScaleExponent) * Mathf.Sign(param.worldNearScatterPush));
+            m_ProceduralSkyMaterial.SetFloat("_WorldMieNearScatterPush", -Mathf.Pow(Mathf.Abs(param.worldMieNearScatterPush), param.worldScaleExponent) * Mathf.Sign(param.worldMieNearScatterPush));
+            m_ProceduralSkyMaterial.SetFloat("_WorldRayleighNearScatterPush", -Mathf.Pow(Mathf.Abs(param.worldRayleighNearScatterPush), param.worldScaleExponent) * Mathf.Sign(param.worldRayleighNearScatterPush));
             m_ProceduralSkyMaterial.SetFloat("_WorldRayleighDensity", -param.worldRayleighDensity / 100000f);
             m_ProceduralSkyMaterial.SetFloat("_WorldMieDensity", -param.worldMieDensity / 100000f);
 
             m_ProceduralSkyMaterial.SetVector("_MieColorP20", (Vector4)mieColorP20 * param.worldMieColorIntensity);
 
             m_ProceduralSkyMaterial.SetFloat("_HeightNormalDistanceRcp", 1f / param.heightNormalDistance);
-            m_ProceduralSkyMaterial.SetFloat("_HeightNearScatterPush", -Mathf.Pow(Mathf.Abs(param.heightNearScatterPush), param.worldScaleExponent) * Mathf.Sign(param.heightNearScatterPush));
-            m_ProceduralSkyMaterial.SetFloat("_HeightRayleighDensity", -param.heightRayleighDensity / 100000f);
-            m_ProceduralSkyMaterial.SetFloat("_HeightMieDensity", -param.heightMieDensity / 100000f);
+            m_ProceduralSkyMaterial.SetFloat("_HeightMieNearScatterPush", -Mathf.Pow(Mathf.Abs(param.heightMieNearScatterPush), param.worldScaleExponent) * Mathf.Sign(param.heightMieNearScatterPush));
+            m_ProceduralSkyMaterial.SetFloat("_HeightRayleighNearScatterPush", -Mathf.Pow(Mathf.Abs(param.heightRayleighNearScatterPush), param.worldScaleExponent) * Mathf.Sign(param.heightRayleighNearScatterPush));
+            // m_ProceduralSkyMaterial.SetFloat("_HeightRayleighDensity", -param.heightRayleighDensity / 100000f);
+            // m_ProceduralSkyMaterial.SetFloat("_HeightMieDensity", -param.heightMieDensity / 100000f);
             m_ProceduralSkyMaterial.SetFloat("_HeightSeaLevel", param.heightSeaLevel);
             m_ProceduralSkyMaterial.SetVector("_HeightPlaneShift", param.heightPlaneShift);
             m_ProceduralSkyMaterial.SetFloat("_HeightDistanceRcp", 1f / param.heightDistance);
             m_ProceduralSkyMaterial.SetFloat("_MiePhaseAnisotropy", param.worldMiePhaseAnisotropy);
             m_ProceduralSkyMaterial.SetFloat("_MieExtinctionFactor", param.worldMieExtinctionFactor);
 
+            // Since we use the material for rendering the sky both into the cubemap, and
+            // during the fullscreen pass, setting the 'PERFORM_SKY_OCCLUSION_TEST' keyword has no effect.
+            properties.SetFloat("_DisableSkyOcclusionTest", renderForCubemap ? 1.0f : 0.0f);
+            // We flip the screens-space Y axis in case we follow the D3D convention.
+            properties.SetFloat("_FlipY",                   renderForCubemap ? 1.0f : 0.0f);
+            // We do not render the height fog into the sky IBL cubemap.
+            properties.SetFloat("_HeightRayleighDensity",   renderForCubemap ? -0.0f : -param.heightRayleighDensity / 100000f);
+            properties.SetFloat("_HeightMieDensity",        renderForCubemap ? -0.0f : -param.heightMieDensity / 100000f);
         }
 
         override public void RenderSky(BuiltinSkyParameters builtinParams, SkyParameters skyParameters, bool renderForCubemap)
 
             // Define select preprocessor symbols.
-            SetKeywords(builtinParams, m_ProceduralSkyParameters);
+            SetKeywords(builtinParams, m_ProceduralSkyParameters, renderForCubemap);
-            SetUniforms(builtinParams, m_ProceduralSkyParameters, ref properties);
+            SetUniforms(builtinParams, m_ProceduralSkyParameters, renderForCubemap, ref properties);
-            // Since we use the material for rendering the sky both into the cubemap, and
-            // during the fullscreen pass, setting the 'PERFORM_SKY_OCCLUSION_TEST' keyword has no effect.
-            if (builtinParams.depthBuffer != BuiltinSkyParameters.nullRT)
+            if (!renderForCubemap)
-                properties.SetFloat("_DisableSkyOcclusionTest", 0.0f);
-            }
-            else
-            {
-                properties.SetFloat("_DisableSkyOcclusionTest", 1.0f);
             }
 
             cmd.DrawMesh(builtinParams.skyMesh, Matrix4x4.identity, m_ProceduralSkyMaterial, 0, 0, properties);

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/Resources/AtmosphericScattering.hlsl

 
 uniform float       _WorldScaleExponent;
 uniform float       _WorldNormalDistanceRcp;
-uniform float       _WorldNearScatterPush;
+uniform float       _WorldRayleighNearScatterPush;
+uniform float       _WorldMieNearScatterPush;
 uniform float       _WorldRayleighDensity;
 uniform float       _WorldMieDensity;
 
 uniform float3      _MieColorP45;
 
 uniform float       _HeightNormalDistanceRcp;
-uniform float       _HeightNearScatterPush;
+uniform float       _HeightMieNearScatterPush;
+uniform float       _HeightRayleighNearScatterPush;
 uniform float       _HeightRayleighDensity;
 uniform float       _HeightMieDensity;
 uniform float       _HeightSeaLevel;
     if(angleY >= 0.f) mieColor = lerp(_MieColorO00, _MieColorP20, saturate(angleY / angle20));
     else mieColor = lerp(_MieColorM20, _MieColorO00, saturate((angleY + angle20) / angle20));
 
-    const float pushedDistance = max(0.f, worldVecLen + _WorldNearScatterPush);
-    const float pushedDensity = /*HeightDensity **/ pushedDistance /** exp(-scaledWorldPos.y / 8000.f)*/;
-    const float rayleighScatter = (1.f - exp(_WorldRayleighDensity * pushedDensity)) * rayleighPh;
+    const float pushedMieDistance      = max(0.f, worldVecLen + _WorldMieNearScatterPush);
+    const float pushedRayleighDistance = max(0.f, worldVecLen + _WorldRayleighNearScatterPush);
+    const float pushedMieDensity       = /*HeightDensity **/ pushedMieDistance      /** exp(-scaledWorldPos.y / 8000.f)*/;
+    const float pushedRayleighDensity  = /*HeightDensity **/ pushedRayleighDistance /** exp(-scaledWorldPos.y / 8000.f)*/;
+    const float rayleighScatter = (1.f - exp(_WorldRayleighDensity * pushedRayleighDensity)) * rayleighPh;
-    const float mieScatter = (1.f - exp(_WorldMieDensity * pushedDensity));
+    const float mieScatter = (1.f - exp(_WorldMieDensity * pushedMieDensity));
-    const float mieScatter = (1.f - exp(_WorldMieDensity * pushedDensity)) * miePh;
+    const float mieScatter = (1.f - exp(_WorldMieDensity * pushedMieDensity)) * miePh;
-    const float pushedHeightDistance = max(0.f, worldVecLen + _HeightNearScatterPush);
-    const float heightScatter = (1.f - exp(_HeightRayleighDensity * pushedHeightDistance)) * HeightDensity;
+    const float pushedRayleighHeightDistance = max(0.f, worldVecLen + _HeightRayleighNearScatterPush);
+    const float pushedMieHeightDistance      = max(0.f, worldVecLen + _HeightMieNearScatterPush);
+    const float heightRayleighScatter = (1.f - exp(_HeightRayleighDensity * pushedRayleighHeightDistance)) * HeightDensity;
-    const float heightMieScatter = (1.f - exp(_HeightMieDensity * pushedHeightDistance)) * HeightDensity;
+    const float heightMieScatter = (1.f - exp(_HeightMieDensity * pushedMieHeightDistance)) * HeightDensity;
-    const float heightMieScatter = (1.f - exp(_HeightMieDensity * pushedHeightDistance)) * HeightDensity * miePh;
+    const float heightMieScatter = (1.f - exp(_HeightMieDensity * pushedMieHeightDistance)) * HeightDensity * miePh;
-    rayleighColor = lerp(Luminance(rayleighColor).rrr, rayleighColor, saturate(pushedDistance * _WorldNormalDistanceRcp));
-    float3 heightRayleighColor = lerp(Luminance(_HeightRayleighColor.xyz).rrr, _HeightRayleighColor.xyz, saturate(pushedHeightDistance * _HeightNormalDistanceRcp));
+    rayleighColor = lerp(Luminance(rayleighColor).rrr, rayleighColor, saturate(pushedRayleighDistance * _WorldNormalDistanceRcp));
+    float3 heightRayleighColor = lerp(Luminance(_HeightRayleighColor.xyz).rrr, _HeightRayleighColor.xyz, saturate(pushedRayleighHeightDistance * _HeightNormalDistanceRcp));
-    coords3.rgb = saturate(heightScatter) * heightRayleighColor;
-    coords3.a = heightScatter;
+    coords3.rgb = saturate(heightRayleighScatter) * heightRayleighColor;
+    coords3.a = heightRayleighScatter;
 
     coords2.rgb = mieScatter * mieColor + saturate(heightMieScatter) * mieColor;
     coords2.a = mieScatter;

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

 
             float _DisableSkyOcclusionTest;
 
+            float _FlipY;
+
             #define IS_RENDERING_SKY
             #include "AtmosphericScattering.hlsl"
 
                 sincos(phi, sinPhi, cosPhi);
                 float3 rotDirX = float3(cosPhi, 0, -sinPhi);
                 float3 rotDirY = float3(sinPhi, 0, cosPhi);
-                dir = float3(dot(rotDirX, dir), dir.y, dot(rotDirY, dir));
+                float3 rotatedDir = float3(dot(rotDirX, dir), dir.y, dot(rotDirY, dir));
 
                 // input.positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
                 }
 
                 // Since we only need the world space position, so we don't pass the view-projection matrix.
-                UpdatePositionInput(depthRaw, _InvViewProjMatrix, k_identity4x4, posInput);
+                UpdatePositionInput(depthRaw, _InvViewProjMatrix, k_identity4x4, posInput, _FlipY != 0);
 
                 float4 c1, c2, c3;
                 VolundTransferScatter(posInput.positionWS, c1, c2, c3);
 
                 if (skyTexWeight == 1.0)
                 {
-                    skyColor  = SAMPLE_TEXTURECUBE_LOD(_Cubemap, sampler_Cubemap, dir, 0).rgb;
+                    skyColor  = SAMPLE_TEXTURECUBE_LOD(_Cubemap, sampler_Cubemap, rotatedDir, 0).rgb;
                     skyColor *= exp2(_SkyParam.x) * _SkyParam.y;
                     opacity   = 1.0; // Fully overwrite unoccluded scene regions.
                 }

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/SkyManager.cs

                 Vector3[] lookAtList = {
                             new Vector3(1.0f, 0.0f, 0.0f),
                             new Vector3(-1.0f, 0.0f, 0.0f),
-                            new Vector3(0.0f, -1.0f, 0.0f),
+                            new Vector3(0.0f, -1.0f, 0.0f),
-                            new Vector3(0.0f, -1.0f, 0.0f),
-                            new Vector3(0.0f, -1.0f, 0.0f),
+                            new Vector3(0.0f, 1.0f, 0.0f),
+                            new Vector3(0.0f, 1.0f, 0.0f),
-                            new Vector3(0.0f, -1.0f, 0.0f),
-                            new Vector3(0.0f, -1.0f, 0.0f),
+                            new Vector3(0.0f, 1.0f, 0.0f),
+                            new Vector3(0.0f, 1.0f, 0.0f),
                         };
 
                 for (int i = 0; i < 6; ++i)
                     m_faceCameraInvViewProjectionMatrix[i] = m_faceCameraViewProjectionMatrix[i].inverse;
 
-                    m_CubemapFaceMesh[i] = BuildSkyMesh(Vector3.zero, m_faceCameraInvViewProjectionMatrix[i], false);
+                    m_CubemapFaceMesh[i] = BuildSkyMesh(Vector3.zero, m_faceCameraInvViewProjectionMatrix[i], true);
                 }
             }
         }
                     m_iblFilterGgx.Initialize(renderContext);
                 }
 
-                // Copy the first mip.
-
-                // WARNING:
-                // Since we can't instanciate the parameters anymore (we don't know the final type here)
-                // we can't make sure that exposure/multiplier etc are at neutral values
-                // This will be solved with proper CopyTexture
-
-                // TEMP code until CopyTexture is implemented for command buffer
-                // All parameters are neutral because exposure/multiplier have already been applied in the first copy.
-                //SkyParameters skyParams = new SkyParameters();
-                //skyParams.exposure = 0.0f;
-                //skyParams.multiplier = 1.0f;
-                //skyParams.rotation = 0.0f;
-                //skyParams.skyHDRI = input;
-                RenderSkyToCubemap(builtinParams, skyParams, target);
-                // End temp
-
-                //for (int f = 0; f < 6; f++)
-                //    Graphics.CopyTexture(input, f, 0, target, f, 0);
+                // Copy the first mip
+                var cmd = new CommandBuffer { name = "" };
+                for (int f = 0; f < 6; f++)
+                {
+                    cmd.CopyTexture(input, f, 0, target, f, 0);
+                }
+                renderContext.ExecuteCommandBuffer(cmd);
+                cmd.Dispose();
 
                 if (m_useMIS)
                 {

Assets/ScriptableRenderLoop/HDRenderPipeline/Utilities.cs

 
         public static HDRenderPipeline GetHDRenderPipeline()
         {
-            HDRenderPipeline renderContext = GraphicsSettings.renderPipeline as HDRenderPipeline;
+            HDRenderPipeline renderContext = GraphicsSettings.renderPipelineAsset as HDRenderPipeline;
             if (renderContext == null)
             {
                 Debug.LogWarning("SkyParameters component can only be used with HDRenderPipeline custom RenderPipeline.");

Assets/ScriptableRenderLoop/RenderPasses/ShadowRenderPass.cs

             commandBuffer.Dispose();
 
             // Render
-            loop.DrawShadows(ref settings);
+            loop.DrawShadows(settings);
         }
     }
 }

Assets/ScriptableRenderLoop/ShaderLibrary/AreaLighting.hlsl

     // Clamp to avoid artifacts. This particular constant gives the best results.
     cosTheta    = Clamp(cosTheta, -0.9999, 0.9999);
     float theta = FastACos(cosTheta);
-    float res = cross(v1, v2).z * theta * rsqrt(1.0f - cosTheta * cosTheta); // optimization from * 1 / sin(theta)
+    float res = cross(v1, v2).z * theta * rsqrt(1.0 - cosTheta * cosTheta); // optimization from * 1 / sin(theta)
 
     return res;
 }

Assets/ScriptableRenderLoop/ShaderLibrary/BSDF.hlsl

     float lambdaV = NdotL * sqrt((-NdotV * a2 + NdotV) * NdotV + a2);
     float lambdaL = NdotV * sqrt((-NdotL * a2 + NdotL) * NdotL + a2);
 
-    // Simplify visibility term: (2.0f * NdotL * NdotV) /  ((4.0f * NdotL * NdotV) * (lambda_v + lambda_l));
+    // Simplify visibility term: (2.0 * NdotL * NdotV) /  ((4.0 * NdotL * NdotV) * (lambda_v + lambda_l));
     return 0.5 / (lambdaV + lambdaL);
 }
 
     lambdaV *= NdotL;
     float lambdaL = NdotV * sqrt((-NdotL * a2 + NdotL) * NdotL + a2);
 
-    // Simplify visibility term: (2.0f * NdotL * NdotV) /  ((4.0f * NdotL * NdotV) * (lambda_v + lambda_l));
+    // Simplify visibility term: (2.0 * NdotL * NdotV) /  ((4.0 * NdotL * NdotV) * (lambda_v + lambda_l));
     return 0.5 / (lambdaV + lambdaL);
 }
 

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

     float3 adir = abs(dir);
 
     // +Z -Z
-    faceIndex = dir.z > 0.0f ? CUBEMAPFACE_NEGATIVE_Z : CUBEMAPFACE_POSITIVE_Z;
+    faceIndex = dir.z > 0.0 ? CUBEMAPFACE_NEGATIVE_Z : CUBEMAPFACE_POSITIVE_Z;
 
     // +X -X
     if (adir.x > adir.y && adir.x > adir.z)
 {
     float x = abs(inX);
     float res = (0.0468878 * x + -0.203471) * x + 1.570796; // p(x)
-    res *= sqrt(1.0f - x);
+    res *= sqrt(1.0 - x);
 
     return (inX >= 0) ? res : PI - res; // Undo range reduction
 }
 // From deferred or compute shader
 // depth must be the depth from the raw depth buffer. This allow to handle all kind of depth automatically with the inverse view projection matrix.
 // For information. In Unity Depth is always in range 0..1 (even on OpenGL) but can be reversed.
-void UpdatePositionInput(float depth, float4x4 invViewProjectionMatrix, float4x4 ViewProjectionMatrix, inout PositionInputs posInput)
+// It may be necessary to flip the Y axis as the origin of the screen-space coordinate system
+// of Direct3D is at the top left corner of the screen, with the Y axis pointing downwards.
+void UpdatePositionInput(float depth, float4x4 invViewProjectionMatrix, float4x4 ViewProjectionMatrix,
+                         inout PositionInputs posInput, bool flipY = false)
-    // TODO: Do we need to flip Y axis here on OGL ?
-    posInput.positionCS = float4(posInput.positionSS.xy * 2.0 - 1.0, depth, 1.0);
-    float4 hpositionWS = mul(invViewProjectionMatrix, posInput.positionCS);
+    float2 screenSpacePos;
+    screenSpacePos.x = posInput.positionSS.x;
+    screenSpacePos.y = flipY ? 1.0 - posInput.positionSS.y : posInput.positionSS.y;
+
+    posInput.positionCS = float4(screenSpacePos * 2.0 - 1.0, depth, 1.0);
+    float4 hpositionWS  = mul(invViewProjectionMatrix, posInput.positionCS);
     posInput.positionWS = hpositionWS.xyz / hpositionWS.w;
 
     // The compiler should optimize this (less expensive than reconstruct depth VS from depth buffer)

Assets/ScriptableRenderLoop/ShaderLibrary/CommonLighting.hlsl

 float SmoothDistanceAttenuation(float squaredDistance, float invSqrAttenuationRadius)
 {
     float factor = squaredDistance * invSqrAttenuationRadius;
-    float smoothFactor = saturate(1.0f - factor * factor);
+    float smoothFactor = saturate(1.0 - factor * factor);
     return smoothFactor * smoothFactor;
 }
 
 {
     float sqrDist = dot(unL, unL);
-    float attenuation = 1.0f / (max(PUNCTUAL_LIGHT_THRESHOLD * PUNCTUAL_LIGHT_THRESHOLD, sqrDist));
+    float attenuation = 1.0 / (max(PUNCTUAL_LIGHT_THRESHOLD * PUNCTUAL_LIGHT_THRESHOLD, sqrDist));
     // Non physically based hack to limit light influence to attenuationRadius.
     attenuation *= SmoothDistanceAttenuation(sqrDist, invSqrAttenuationRadius);
 
 // 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) make use of double-sided lighting.
+// 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)
 {
 
     float a     = 1.0 / (1.0 + N.z);
     float b     = -N.x * N.y * a;
-    tangentX    = float3(1.0f - N.x * N.x * a , b, -N.x);
-    tangentY    = float3(b, 1.0f - N.y * N.y * a, -N.y);
+    tangentX    = float3(1.0 - N.x * N.x * a , b, -N.x);
+    tangentY    = float3(b, 1.0 - N.y * N.y * a, -N.y);
 }
 */
 

Assets/ScriptableRenderLoop/ShaderLibrary/ImageBasedLighting.hlsl

             }
 
             // invOmegaP is precomputed on CPU and provide as a parameter of the function
-            // float omegaP = FOUR_PI / (6.0f * cubemapWidth * cubemapWidth);
+            // float omegaP = FOUR_PI / (6.0 * cubemapWidth * cubemapWidth);
             mipLevel        = 0.5 * log2(omegaS * invOmegaP);
         }
 
             // This will blur the reflection.
             // TODO: find a more accurate MIP bias function.
             mipLevel = lerp(mipLevel, lastMipLevel, bias);
-
-            // TODO: There is a bug currently where autogenerate mipmap for the cubemap seems to
-            // clamp the mipLevel to 6. correct it! Then remove this clamp
-            // All MIP map levels beyond UNITY_SPECCUBE_LOD_STEPS contain invalid data.
-            mipLevel = min(mipLevel, UNITY_SPECCUBE_LOD_STEPS);
 
             // TODO: use a Gaussian-like filter to generate the MIP pyramid.
             float3 val = SAMPLE_TEXTURECUBE_LOD(tex, sampl, L, mipLevel).rgb;

Assets/ScriptableRenderLoop/ShaderLibrary/Packing.hlsl

     vResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;
     float Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;
     vResult.w = frac(Le);
-    vResult.z = (Le - (floor(vResult.w*255.0f)) / 255.0f) / 255.0f;
+    vResult.z = (Le - (floor(vResult.w * 255.0)) / 255.0) / 255.0;
     return vResult;
 }
 

Assets/ScriptableRenderLoop/ShaderLibrary/Tessellation.hlsl

 // TODO: Move in geomtry.hlsl
 float DistanceFromPlane(float3 pos, float4 plane)
 {
-    float d = dot(float4(pos, 1.0f), plane);
+    float d = dot(float4(pos, 1.0), plane);
     return d;
 }
 
     float4 planeTest;
 
     // left
-    planeTest.x =   ((DistanceFromPlane(p0, cameraWorldClipPlanes[0]) > -cullEps) ? 1.0f : 0.0f) +
-                    ((DistanceFromPlane(p1, cameraWorldClipPlanes[0]) > -cullEps) ? 1.0f : 0.0f) +
-                    ((DistanceFromPlane(p2, cameraWorldClipPlanes[0]) > -cullEps) ? 1.0f : 0.0f);
+    planeTest.x =   ((DistanceFromPlane(p0, cameraWorldClipPlanes[0]) > -cullEps) ? 1.0 : 0.0) +
+                    ((DistanceFromPlane(p1, cameraWorldClipPlanes[0]) > -cullEps) ? 1.0 : 0.0) +
+                    ((DistanceFromPlane(p2, cameraWorldClipPlanes[0]) > -cullEps) ? 1.0 : 0.0);
-    planeTest.y =   ((DistanceFromPlane(p0, cameraWorldClipPlanes[1]) > -cullEps) ? 1.0f : 0.0f) +
-                    ((DistanceFromPlane(p1, cameraWorldClipPlanes[1]) > -cullEps) ? 1.0f : 0.0f) +
-                    ((DistanceFromPlane(p2, cameraWorldClipPlanes[1]) > -cullEps) ? 1.0f : 0.0f);
+    planeTest.y =   ((DistanceFromPlane(p0, cameraWorldClipPlanes[1]) > -cullEps) ? 1.0 : 0.0) +
+                    ((DistanceFromPlane(p1, cameraWorldClipPlanes[1]) > -cullEps) ? 1.0 : 0.0) +
+                    ((DistanceFromPlane(p2, cameraWorldClipPlanes[1]) > -cullEps) ? 1.0 : 0.0);
-    planeTest.z =   ((DistanceFromPlane(p0, cameraWorldClipPlanes[2]) > -cullEps) ? 1.0f : 0.0f) +
-                    ((DistanceFromPlane(p1, cameraWorldClipPlanes[2]) > -cullEps) ? 1.0f : 0.0f) +
-                    ((DistanceFromPlane(p2, cameraWorldClipPlanes[2]) > -cullEps) ? 1.0f : 0.0f);
+    planeTest.z =   ((DistanceFromPlane(p0, cameraWorldClipPlanes[2]) > -cullEps) ? 1.0 : 0.0) +
+                    ((DistanceFromPlane(p1, cameraWorldClipPlanes[2]) > -cullEps) ? 1.0 : 0.0) +
+                    ((DistanceFromPlane(p2, cameraWorldClipPlanes[2]) > -cullEps) ? 1.0 : 0.0);
-    planeTest.w =   ((DistanceFromPlane(p0, cameraWorldClipPlanes[3]) > -cullEps) ? 1.0f : 0.0f) +
-                    ((DistanceFromPlane(p1, cameraWorldClipPlanes[3]) > -cullEps) ? 1.0f : 0.0f) +
-                    ((DistanceFromPlane(p2, cameraWorldClipPlanes[3]) > -cullEps) ? 1.0f : 0.0f);
+    planeTest.w =   ((DistanceFromPlane(p0, cameraWorldClipPlanes[3]) > -cullEps) ? 1.0 : 0.0) +
+                    ((DistanceFromPlane(p1, cameraWorldClipPlanes[3]) > -cullEps) ? 1.0 : 0.0) +
+                    ((DistanceFromPlane(p2, cameraWorldClipPlanes[3]) > -cullEps) ? 1.0 : 0.0);
 
     // has to pass all 4 plane tests to be visible
     return !all(planeTest);

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

             //@TODO: need to get light probes + LPPV too?
             settings.inputFilter.SetQueuesOpaque();
             settings.rendererConfiguration = RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
-            loop.DrawRenderers(ref settings);
+            loop.DrawRenderers(settings);
         }
 
         void RenderForward(CullResults cull, Camera camera, ScriptableRenderContext loop, bool opaquesOnly)
             if (opaquesOnly) settings.inputFilter.SetQueuesOpaque();
             else settings.inputFilter.SetQueuesTransparent();
 
-            loop.DrawRenderers(ref settings);
+            loop.DrawRenderers(settings);
         }
 
         static void DepthOnlyForForwardOpaques(CullResults cull, Camera camera, ScriptableRenderContext loop)
                 sorting = { flags = SortFlags.CommonOpaque }
             };
             settings.inputFilter.SetQueuesOpaque();
-            loop.DrawRenderers(ref settings);
+            loop.DrawRenderers(settings);
         }
 
         bool usingFptl

Assets/TestScenes/HDTest/GlobalIlluminationTest.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.5456157, g: 0.39781958, b: 0.24038762, a: 1}
+  m_IndirectSpecularColor: {r: 0.3199737, g: 0.28755516, b: 0.26444194, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
   m_CCT: 6570
+  m_UseCCT: 0
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!114 &565152817
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
   m_CCT: 6570
+  m_UseCCT: 0
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!114 &1108908834
   resolution: 256
   updateMode: 1
   updatePeriod: 0
-  skyHDRI: {fileID: 8900000, guid: 9b513842339ef704ca63ef696691bc34, type: 3}
+  skyHDRI: {fileID: 8900000, guid: de78f930088fc194290da7400c89bfb5, type: 3}
 --- !u!114 &1944423447
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_Script: {fileID: 11500000, guid: bc357c46587fc9d4cb8f311794d7d2f3, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_SkyRendererTypeName: UnityEngine.Experimental.ScriptableRenderLoop.HDRISkyRenderer
+  m_SkyRendererTypeName: UnityEngine.Experimental.Rendering.HDPipeline.HDRISkyRenderer
+  m_ShadowMaxDistance: 1000
+  m_ShadowCascadeCount: 4
+  m_ShadowCascadeSplit0: 0.05
+  m_ShadowCascadeSplit1: 0.2
+  m_ShadowCascadeSplit2: 0.3
 --- !u!4 &1944423448
 Transform:
   m_ObjectHideFlags: 0

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_BlendColor.mat

   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
     _DISTORTIONONLY_OFF _EMISSION _EMISSIVE_COLOR _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS
     _LAYERMASKMAP _LAYER_MAPPING_PLANAR0 _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_PLANAR_1
-    _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_PLANAR_3 _LAYER_MASK_VERTEX_COLOR _NORMALMAP_TANGENT_SPACE
+    _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_PLANAR_3 _LAYER_MASK_VERTEX_COLOR _LAYER_MASK_VERTEX_COLOR_MUL
+    _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
     - _BlendSize1: 0
     - _BlendSize2: 0
     - _BlendSize3: 0
+    - _BlendUsingHeight1: 0
+    - _BlendUsingHeight2: 0
+    - _BlendUsingHeight3: 0
     - _BumpScale: 1
     - _CullMode: 2
     - _Cutoff: 0.5
     - _EmissiveIntensity1: 0
     - _EmissiveIntensity2: 0
     - _EmissiveIntensity3: 0
+    - _EnablePerPixelDisplacement: 0
+    - _HeightAmplitude0: 1
+    - _HeightAmplitude1: 1
+    - _HeightAmplitude2: 1
+    - _HeightAmplitude3: 1
+    - _HeightCenter0: 0
+    - _HeightCenter1: 0
+    - _HeightCenter2: 0
+    - _HeightCenter3: 0
+    - _HeightCenterOffset1: 0
+    - _HeightCenterOffset2: 0
+    - _HeightCenterOffset3: 0
     - _HeightFactor1: 1
     - _HeightFactor2: 1
     - _HeightFactor3: 1
     - _HeightScale1: 1
     - _HeightScale2: 1
     - _HeightScale3: 1
+    - _InheritBaseColor1: 0
+    - _InheritBaseColor2: 0
+    - _InheritBaseColor3: 0
+    - _InheritBaseColorThreshold1: 1
+    - _InheritBaseColorThreshold2: 1
+    - _InheritBaseColorThreshold3: 1
+    - _InheritBaseHeight1: 0
+    - _InheritBaseHeight2: 0
+    - _InheritBaseHeight3: 0
+    - _InheritBaseLayer1: 0
+    - _InheritBaseLayer2: 0
+    - _InheritBaseLayer3: 0
+    - _InheritBaseNormal1: 0
+    - _InheritBaseNormal2: 0
+    - _InheritBaseNormal3: 0
     - _LayerCount: 4
     - _LayerMapping0: 2
     - _LayerMapping1: 2
     - _Metallic1: 0
     - _Metallic2: 0
     - _Metallic3: 0
+    - _MinimumOpacity1: 1
+    - _MinimumOpacity2: 1
+    - _MinimumOpacity3: 1
+    - _NormalScale0: 1
+    - _NormalScale1: 1
+    - _NormalScale2: 1
+    - _NormalScale3: 1
+    - _OpacityAsDensity1: 0
+    - _OpacityAsDensity2: 0
+    - _OpacityAsDensity3: 0
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _Smoothness: 0.5
     - _Smoothness0: 0.5
     - _UVMappingPlanar2: 0
     - _UVMappingPlanar3: 0
     - _UVSec: 0
+    - _UseBaseLayerMode: 0
+    - _UseHeightBasedBlendV2: 0
+    - _VertexColorMode: 1
     - _ZTestMode: 8
     - _ZWrite: 1
     m_Colors:

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_BlendColor.mat.meta

 timeCreated: 1480943223
 licenseType: Pro
 NativeFormatImporter:
+  mainObjectFileID: -1
   userData: '{"GUIDArray":["fbea672215bd9944f8d9f98d5437e3cb","b91619c97bb14b64b82c0cdeaac0cc68","be6f395f0458348419faf76aca4cf856","000d0f1d5b188ed43a674de93e854997"]}'
   assetBundleName: 
   assetBundleVariant: 

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

   m_PrefabInternal: {fileID: 0}
   m_Name: CubeTransparent
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _BaseColorMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _DetailMask:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _DiffuseLightingMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _Anisotropy: 0
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionEnable: 0
+    - _EnablePerPixelDisplacement: 0
+    - _HeightAmplitude: 0.01
+    - _HeightCenter: 0.5
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _MaterialId: 0
     - _Mode: 0
     - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _Smoothness: 0.5
     - _SmoothnessTextureChannel: 0
     - _SurfaceType: 1
+    - _TexWorldScale: 1
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
     - _BaseColor: {r: 0.9117647, g: 0.1273789, b: 0.1273789, a: 0.566}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/test-transparent.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: test-transparent
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _NORMALMAP _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP _NORMALMAP_TANGENT_SPACE
+  m_EnableInstancingVariants: 0
+  disabledShaderPasses:
+  - DistortionVectors
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _AnisotropyMap:
         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}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _DetailMask:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _DiffuseMap:
         m_Texture: {fileID: 2800000, guid: d734753529ca78148a43944515a64bc5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _EmissionMap:
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     m_Floats:
     - _AlphaCutoff: 0.5
     - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
     - _BlendMode: 0
     - _BumpScale: 1
     - _CoatCoverage: 0
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionEnable: 0
     - _DistortionOnly: 0
     - _DoubleSided: 1
     - _DoubleSidedLigthing: 1
     - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _HeightAmplitude: 0.01
+    - _HeightCenter: 0.5
     - _HeightMapMode: 0
     - _HeightScale: 1
     - _MaterialID: 0
     - _Mettalic: 0
     - _Mode: 0
     - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _Smoothness: 0.524
     - _SmoothnessTextureChannel: 0
     - _SubSurfaceRadius: 0
     - _SurfaceType: 1
+    - _TexWorldScale: 1
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
     - _BaseColor: {r: 1, g: 1, b: 1, a: 0.397}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _SpecColor: {r: 0.04, g: 0.04, b: 0.04, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

ProjectSettings/GraphicsSettings.asset

   m_FogKeepExp2: 1
   m_AlbedoSwatchInfos: []
   m_LightsUseLinearIntensity: 1
-  m_LightsUseCCT: 1
+  m_LightsUseColorTemperature: 1

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

+
+// These functions are use to hide the handling of triplanar mapping
+// Normal need a specific treatment as they use special encoding for both base and detail map
+// Also we use multiple inclusion to handle the various variation for lod and bias
+
+// param can be unused, lod or bias
+float4 ADD_FUNC_SUFFIX(SampleLayer)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 triplanarWeights, float param)
+{
+    if (layerUV.isTriplanar)
+    {
+        float4 val = float4(0.0, 0.0, 0.0, 0.0);
+
+        if (triplanarWeights.x > 0.0)
+            val += triplanarWeights.x * SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvYZ, param);
+        if (triplanarWeights.y > 0.0)
+            val += triplanarWeights.y * SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvZX, param);
+        if (triplanarWeights.z > 0.0)
+            val += triplanarWeights.z * SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvXY, param);
+
+        return val;
+    }
+    else
+    {
+        return SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uv, param);
+    }
+}
+
+// TODO: Handle BC5 format, currently this code is for DXT5nm - After the change, rename this function UnpackNormalmapRGorAG
+// This version is use for the base normal map
+float3 ADD_FUNC_SUFFIX(SampleLayerNormal)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 triplanarWeights, float scale, float param)
+{
+    if (layerUV.isTriplanar)
+    {
+        float3 val = float3(0.0, 0.0, 0.0);
+
+        if (triplanarWeights.x > 0.0)
+            val += triplanarWeights.x * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvYZ, param), scale);
+        if (triplanarWeights.y > 0.0)
+            val += triplanarWeights.y * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvZX, param), scale);
+        if (triplanarWeights.z > 0.0)
+            val += triplanarWeights.z * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvXY, param), scale);
+
+        return normalize(val);
+    }
+    else
+    {
+        return UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uv, param), scale);
+    }
+}
+
+// This version is for normalmap with AG encoding only. Mainly use with details map.
+float3 ADD_FUNC_SUFFIX(SampleLayerNormalAG)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 triplanarWeights, float scale, float param)
+{
+    if (layerUV.isTriplanar)
+    {
+        float3 val = float3(0.0, 0.0, 0.0);
+
+        if (triplanarWeights.x > 0.0)
+            val += triplanarWeights.x * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvYZ, param), scale);
+        if (triplanarWeights.y > 0.0)
+            val += triplanarWeights.y * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvZX, param), scale);
+        if (triplanarWeights.z > 0.0)
+            val += triplanarWeights.z * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvXY, param), scale);
+
+        return normalize(val);
+    }
+    else
+    {
+        return UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uv, param), scale);
+    }
+}
+
+// This version is for normalmap with RGB encoding only, i.e uncompress or BC7. Mainly used for object space normal.
+float3 ADD_FUNC_SUFFIX(SampleLayerNormalRGB)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 triplanarWeights, float scale, float param)
+{
+    if (layerUV.isTriplanar)
+    {
+        float3 val = float3(0.0, 0.0, 0.0);
+
+        if (triplanarWeights.x > 0.0)
+            val += triplanarWeights.x * UnpackNormalRGB(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvYZ, param), scale);
+        if (triplanarWeights.y > 0.0)
+            val += triplanarWeights.y * UnpackNormalRGB(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvZX, param), scale);
+        if (triplanarWeights.z > 0.0)
+            val += triplanarWeights.z * UnpackNormalRGB(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvXY, param), scale);
+
+        return normalize(val);
+    }
+    else
+    {
+        return UnpackNormalRGB(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uv, param), scale);
+    }
+}

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

+fileFormatVersion: 2
+guid: 6bcabcbfab3a70c45891987f8557e2e0
+timeCreated: 1485260584
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/SampleLayer.hlsl

+// Gather all kind of mapping in one struct, allow to improve code readability
+struct LayerUV
+{
+    float2 uv;
+    // triplanar
+    bool isTriplanar;
+    float2 uvYZ;
+    float2 uvZX;
+    float2 uvXY;
+};
+
+// Multiple includes of the file to handle all variations of textures sampling for regular, lod and bias
+
+// Regular sampling functions
+#define ADD_FUNC_SUFFIX(Name) Name
+#define SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV, unused) SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV)
+#include "SampleLayerInternal.hlsl"
+#undef ADD_FUNC_SUFFIX
+#undef SAMPLE_TEXTURE_FUNC
+
+// Lod sampling functions
+#define ADD_FUNC_SUFFIX(Name) Name##Lod
+#define SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV, lod) SAMPLE_TEXTURE2D_LOD(layerTex, layerSampler, layerUV, lod)
+#include "SampleLayerInternal.hlsl"
+#undef ADD_FUNC_SUFFIX
+#undef SAMPLE_TEXTURE_FUNC
+
+// Bias sampling functions
+#define ADD_FUNC_SUFFIX(Name) Name##Bias
+#define SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV, bias) SAMPLE_TEXTURE2D_BIAS(layerTex, layerSampler, layerUV, bias)
+#include "SampleLayerInternal.hlsl"
+#undef ADD_FUNC_SUFFIX
+#undef SAMPLE_TEXTURE_FUNC
+
+// Macro to improve readibility of surface data
+#define SAMPLE_LAYER_TEXTURE2D(textureName, samplerName, coord)             SampleLayer(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, 0.0) // Last 0.0 is unused
+#define SAMPLE_LAYER_TEXTURE2D_LOD(textureName, samplerName, coord, lod)    SampleLayerLod(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, lod)
+#define SAMPLE_LAYER_TEXTURE2D_BIAS(textureName, samplerName, coord, bias)  SampleLayerBias(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, bias)
+
+#define SAMPLE_LAYER_NORMALMAP(textureName, samplerName, coord, scale)              SampleLayerNormal(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, 0.0)
+#define SAMPLE_LAYER_NORMALMAP_LOD(textureName, samplerName, coord, scale, lod)     SampleLayerNormalLod(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, lod)
+#define SAMPLE_LAYER_NORMALMAP_BIAS(textureName, samplerName, coord, scale, bias)   SampleLayerNormalBias(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, bias)
+
+#define SAMPLE_LAYER_NORMALMAP_AG(textureName, samplerName, coord, scale)              SampleLayerNormalAG(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, 0.0)
+#define SAMPLE_LAYER_NORMALMAP_AG_LOD(textureName, samplerName, coord, scale, lod)     SampleLayerNormalAGLod(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, lod)
+#define SAMPLE_LAYER_NORMALMAP_AG_BIAS(textureName, samplerName, coord, scale, bias)   SampleLayerNormalAGBias(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, bias)
+
+#define SAMPLE_LAYER_NORMALMAP_RGB(textureName, samplerName, coord, scale)              SampleLayerNormalRGB(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, 0.0)
+#define SAMPLE_LAYER_NORMALMAP_RGB_LOD(textureName, samplerName, coord, scale, lod)     SampleLayerNormalRGBLod(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, lod)
+#define SAMPLE_LAYER_NORMALMAP_RGB_BIAS(textureName, samplerName, coord, scale, bias)   SampleLayerNormalRGBBias(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale, bias)

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/SampleLayer.hlsl.meta

+fileFormatVersion: 2
+guid: f3e4d64dcf820e040a738f576d8d1f79
+timeCreated: 1485260584
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/SampleLayerInternal.hlsl

+
+// These functions are use to hide the handling of triplanar mapping
+// Normal need a specific treatment as they use special encoding for both base and detail map
+// Also we use multiple inclusion to handle the various variation for lod and bias
+
+// param can be unused, lod or bias
+float4 ADD_FUNC_SUFFIX(SampleLayer)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float param)
+{
+    if (layerUV.isTriplanar)
+    {
+        float4 val = float4(0.0, 0.0, 0.0, 0.0);
+
+        if (weights.x > 0.0)
+            val += weights.x * SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvYZ, param);
+        if (weights.y > 0.0)
+            val += weights.y * SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvZX, param);
+        if (weights.z > 0.0)
+            val += weights.z * SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvXY, param);
+
+        return val;
+    }
+    else
+    {
+        return SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uv, param);
+    }
+}
+
+// TODO: Handle BC5 format, currently this code is for DXT5nm - After the change, rename this function UnpackNormalmapRGorAG
+// This version is use for the base normal map
+float3 ADD_FUNC_SUFFIX(SampleLayerNormal)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale, float param)
+{
+    if (layerUV.isTriplanar)
+    {
+        float3 val = float3(0.0, 0.0, 0.0);
+
+        if (weights.x > 0.0)
+            val += weights.x * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvYZ, param), scale);
+        if (weights.y > 0.0)
+            val += weights.y * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvZX, param), scale);
+        if (weights.z > 0.0)
+            val += weights.z * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvXY, param), scale);
+
+        return normalize(val);
+    }
+    else
+    {
+        return UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uv, param), scale);
+    }
+}
+
+// This version is for normalmap with AG encoding only. Mainly use with details map.
+float3 ADD_FUNC_SUFFIX(SampleLayerNormalAG)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale, float param)
+{
+    if (layerUV.isTriplanar)
+    {
+        float3 val = float3(0.0, 0.0, 0.0);
+
+        if (weights.x > 0.0)
+            val += weights.x * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvYZ, param), scale);
+        if (weights.y > 0.0)
+            val += weights.y * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvZX, param), scale);
+        if (weights.z > 0.0)
+            val += weights.z * UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvXY, param), scale);
+
+        return normalize(val);
+    }
+    else
+    {
+        return UnpackNormalAG(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uv, param), scale);
+    }
+}
+
+// This version is for normalmap with RGB encoding only, i.e uncompress or BC7. Mainly used for object space normal.
+float3 ADD_FUNC_SUFFIX(SampleLayerNormalRGB)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale, float param)
+{
+    if (layerUV.isTriplanar)
+    {
+        float3 val = float3(0.0, 0.0, 0.0);
+
+        if (weights.x > 0.0)
+            val += weights.x * UnpackNormalRGB(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvYZ, param), scale);
+        if (weights.y > 0.0)
+            val += weights.y * UnpackNormalRGB(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvZX, param), scale);
+        if (weights.z > 0.0)
+            val += weights.z * UnpackNormalRGB(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uvXY, param), scale);
+
+        return normalize(val);
+    }
+    else
+    {
+        return UnpackNormalRGB(SAMPLE_TEXTURE_FUNC(layerTex, layerSampler, layerUV.uv, param), scale);
+    }
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/SampleLayerInternal.hlsl.meta

+fileFormatVersion: 2
+guid: 01b8f0e33ff01164da19412b5fbdc7d4
+timeCreated: 1485250177
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: 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_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _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
+    - _MaterialId: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.4
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _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/Lit_Blue.mat.meta

+fileFormatVersion: 2
+guid: 5fca900cf1782bc40858cab3a67624c4
+timeCreated: 1480089588
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: 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_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _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
+    - _MaterialId: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0, g: 1, b: 0, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _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/Lit_Green.mat.meta

+fileFormatVersion: 2
+guid: c0b044e8d3bb04947bd559a0964cff2b
+timeCreated: 1480089588
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: 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_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses:
+  - DistortionVectors
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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: 2800000, guid: b24f69ff4ace9194fb0d9eee4f5cf1a4, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _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
+    - _MaterialId: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 1
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 0, b: 0, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _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/Lit_Red.mat.meta

+fileFormatVersion: 2
+guid: 2cd5a13366cb5a646a6f3881edeb0d38
+timeCreated: 1480089588
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: 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_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses:
+  - DistortionVectors
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _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
+    - _MaterialId: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _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/Lit_White.mat.meta

+fileFormatVersion: 2
+guid: 4709cba96526aa041abe1fb27397b28e
+timeCreated: 1480089588
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/LayeredTessellation.meta

+fileFormatVersion: 2
+guid: a3942f1f17206ea47b331d0bcefa96c9
+folderAsset: yes
+timeCreated: 1485267469
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+fileFormatVersion: 2
+guid: fb2257d1d25c6ed46893dd1f61c1cf9f
+folderAsset: yes
+timeCreated: 1485365645
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Common/Textures/LayerMask.tga.meta

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

Assets/TestScenes/HDTest/GraphicTest/LayeredTessellation/Layer-2-woord-rock.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Layer-2-woord-rock
+  m_Shader: {fileID: 4800000, guid: eab0538d9d5746246806a9611c04ac4d, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DEPTHOFFSETENABLE_OFF _DETAIL_MAP_WITH_NORMAL
+    _DISTORTIONDEPTHTEST_OFF _DISTORTIONENABLE_OFF _DISTORTIONONLY_OFF _ENABLEPERPIXELDISPLACEMENT_OFF
+    _HEIGHTMAP _LAYERMASKVERTEXCOLOR_OFF _NORMALMAP _NORMALMAP_TANGENT_SPACE _TESSELLATIONOBJECTSCALE_OFF
+    _TESSELLATION_DISPLACEMENT _USEHEIGHTBASEDBLENDV2_OFF _USEHEIGHTBASEDBLEND_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses:
+  - DistortionVectors
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 2800000, guid: 37411c7405e8c1a42ac0a0f50983bd46, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 2800000, guid: 0353c00d9bc99f14780836a6a51a6d97, type: 3}
+        m_Scale: {x: 2, y: 2}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap0:
+        m_Texture: {fileID: 2800000, guid: a3f1edea0cb01de42968bf3e4317f387, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 2800000, guid: db7b513b0c2406e40be832dc28133281, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        m_Texture: {fileID: 2800000, guid: 01dda0caaf1cdcb4a821d7c0a8cfb018, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap0:
+        m_Texture: {fileID: 2800000, guid: bbc15758a54df6f43a834cbf4e150d45, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 2800000, guid: ccbd506f77c77e04eaa274a3d3d417e3, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BlendSize1: 0
+    - _BlendSize2: 0
+    - _BlendSize3: 0
+    - _BlendUsingHeight1: 0
+    - _BlendUsingHeight2: 0
+    - _BlendUsingHeight3: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightAmplitude0: 0.8
+    - _HeightAmplitude1: 1.27
+    - _HeightAmplitude2: 1
+    - _HeightAmplitude3: 1
+    - _HeightCenter0: 0.5
+    - _HeightCenter1: 0.5
+    - _HeightCenter2: 0
+    - _HeightCenter3: 0
+    - _HeightCenterOffset1: 0
+    - _HeightCenterOffset2: 0
+    - _HeightCenterOffset3: 0
+    - _HeightFactor1: 1
+    - _HeightFactor2: 1
+    - _HeightFactor3: 1
+    - _HeightOffset1: 0
+    - _HeightOffset2: 0
+    - _HeightOffset3: 0
+    - _InheritBaseColor1: 0
+    - _InheritBaseColor2: 0
+    - _InheritBaseColor3: 0
+    - _InheritBaseColorThreshold1: 1
+    - _InheritBaseColorThreshold2: 1
+    - _InheritBaseColorThreshold3: 1
+    - _InheritBaseHeight1: 0.06
+    - _InheritBaseHeight2: 0
+    - _InheritBaseHeight3: 0
+    - _InheritBaseLayer1: 0
+    - _InheritBaseLayer2: 0
+    - _InheritBaseLayer3: 0
+    - _InheritBaseNormal1: 0
+    - _InheritBaseNormal2: 0
+    - _InheritBaseNormal3: 0
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 0
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _MinimumOpacity1: 1
+    - _MinimumOpacity2: 1
+    - _MinimumOpacity3: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale0: 1
+    - _NormalScale1: 1
+    - _NormalScale2: 1
+    - _NormalScale3: 1
+    - _OcclusionStrength: 1
+    - _OpacityAsDensity1: 0
+    - _OpacityAsDensity2: 0
+    - _OpacityAsDensity3: 0
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TessellationBackFaceCullEpsilon: -0.25
+    - _TessellationFactor: 4
+    - _TessellationFactorMaxDistance: 50
+    - _TessellationFactorMinDistance: 20
+    - _TessellationFactorTriangleSize: 100
+    - _TessellationMode: 1
+    - _TessellationObjectScale: 0
+    - _TessellationShapeFactor: 0.75
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVMappingPlanar0: 0
+    - _UVMappingPlanar1: 0
+    - _UVMappingPlanar2: 0
+    - _UVMappingPlanar3: 0
+    - _UVSec: 0
+    - _UseHeightBasedBlend: 0
+    - _UseHeightBasedBlendV2: 0
+    - _VertexColorHeightFactor: 0.3
+    - _ZTestMode: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {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}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask3: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/GraphicTest/LayeredTessellation/Layer-2-woord-rock.mat.meta

+fileFormatVersion: 2
+guid: 2ebfc83bd8b60ca479682b22f411906a
+timeCreated: 1485267495
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: '{"GUIDArray":["e6f68673cc8e7c347a989ffe33cb21b4","f6dfdaa6d241dc94bb8816edbe111721","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

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

-
-
-
-// TODO: Handle BC5 format, currently this code is for DXT5nm
-// THis function below must call UnpackNormalmapRGorAG
-float3 ADD_FUNC_SUFFIX(SampleLayerNormal)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale, float bias)
-{
-    if (layerUV.isTriplanar)
-    {
-        float3 val = float3(0.0, 0.0, 0.0);
-
-        if (weights.x > 0.0)
-            val += weights.x * UnpackNormalAG(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uvYZ, bias), scale);
-        if (weights.y > 0.0)
-            val += weights.y * UnpackNormalAG(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uvZX, bias), scale);
-        if (weights.z > 0.0)
-            val += weights.z * UnpackNormalAG(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uvXY, bias), scale);
-
-        return normalize(val);
-    }
-    else
-    {
-        return UnpackNormalAG(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uv, bias), scale);
-    }
-}
-
-// This version is for normalmap with AG encoding only (use with details map)
-float3 ADD_FUNC_SUFFIX(SampleLayerNormalAG)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale, float bias)
-{
-    if (layerUV.isTriplanar)
-    {
-        float3 val = float3(0.0, 0.0, 0.0);
-
-        if (weights.x > 0.0)
-            val += weights.x * UnpackNormalAG(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uvYZ, bias), scale);
-        if (weights.y > 0.0)
-            val += weights.y * UnpackNormalAG(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uvZX, bias), scale);
-        if (weights.z > 0.0)
-            val += weights.z * UnpackNormalAG(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uvXY, bias), scale);
-
-        return normalize(val);
-    }
-    else
-    {
-        return UnpackNormalAG(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uv, bias), scale);
-    }
-}
-
-// This version is for normalmap with RGB encoding only, i.e non encoding. It is necessary to use this abstraction to handle correctly triplanar
-// plus consistent with the normal scale parameter
-float3 ADD_FUNC_SUFFIX(SampleLayerNormalRGB)(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale, float bias)
-{
-    if (layerUV.isTriplanar)
-    {
-        float3 val = float3(0.0, 0.0, 0.0);
-
-        if (weights.x > 0.0)
-            val += weights.x * UnpackNormalRGB(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uvYZ, bias), scale);
-        if (weights.y > 0.0)
-            val += weights.y * UnpackNormalRGB(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uvZX, bias), scale);
-        if (weights.z > 0.0)
-            val += weights.z * UnpackNormalRGB(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uvXY, bias), scale);
-
-        return normalize(val);
-    }
-    else
-    {
-        return UnpackNormalRGB(NORMAL_SAMPLE_FUNC(layerTex, layerSampler, layerUV.uv, bias), scale);
-    }
-}

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

-fileFormatVersion: 2
-guid: 541d9773d4d9b4c4f92e026284359f50
-timeCreated: 1485010820
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/TestScenes/HDTest/Leaf.meta

-fileFormatVersion: 2
-guid: 01cfa4863006ad6499396fb0d4802c7e
-folderAsset: yes
-timeCreated: 1475755141
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/TestScenes/HDTest/HDRenderLoopTest.meta

-fileFormatVersion: 2
-guid: bb067c1f82e9d8648b8909e905f6607b
-folderAsset: yes
-timeCreated: 1484331444
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: