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

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugViewMaterial.cs

         public enum DebugViewGbuffer
         {
             Depth = DebugViewVarying.VertexColorAlpha + 1,
-            BakeDiffuseLighting,
+            BakeDiffuseLightingWithAlbedoPlusEmissive,
         }
     }
 }

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

 // UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewGbuffer:  static fields
 //
 #define DEBUGVIEWGBUFFER_DEPTH (10)
-#define DEBUGVIEWGBUFFER_BAKE_DIFFUSE_LIGHTING (11)
+#define DEBUGVIEWGBUFFER_BAKE_DIFFUSE_LIGHTING_WITH_ALBEDO_PLUS_EMISSIVE (11)
 
 
 #endif

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

             Blend SrcAlpha OneMinusSrcAlpha // We will lerp only the values that are valid
 
             HLSLPROGRAM
-            #pragma target 5.0
-            #pragma only_renderers d3d11 ps4// TEMP: unitl we go futher in dev
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
 
             #pragma vertex Vert
             #pragma fragment Frag
                     float linearDepth = frac(posInput.depthVS * 0.1);
                     result = linearDepth.xxx;
                 }
-                else if (_DebugViewMaterial == DEBUGVIEWGBUFFER_BAKE_DIFFUSE_LIGHTING)
+                // Caution: This value is not the same than the builtin data bakeDiffuseLighting. It also include emissive and multiply by the albedo
+                else if (_DebugViewMaterial == DEBUGVIEWGBUFFER_BAKE_DIFFUSE_LIGHTING_WITH_ALBEDO_PLUS_EMISSIVE)
-                    result = bakeDiffuseLighting;
+                    // TODO: require a remap
+                    // TODO: we should not gamma correct, but easier to debug for now without correct high range value
+                    result = bakeDiffuseLighting; needLinearToSRGB = true;
                 }
 
                 GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB);

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

             Blend SrcAlpha OneMinusSrcAlpha
 
             HLSLPROGRAM
-            #pragma target 5.0
-            #pragma only_renderers d3d11 ps4// TEMP: unitl we go futher in dev
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
 
             #pragma vertex Vert
             #pragma fragment Frag

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.cs

 
 
                 // Clear GBuffers
-                using (new Utilities.ProfilingSample("Clear GBuffer", renderContext))
+                if (!debugParameters.ShouldUseForwardRenderingOnly())
-                    Utilities.SetRenderTarget(renderContext, m_gbufferManager.GetGBuffers(), m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black);
+                    using (new Utilities.ProfilingSample("Clear GBuffer", renderContext))
+                    {
+                        Utilities.SetRenderTarget(renderContext, m_gbufferManager.GetGBuffers(), m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black);
+                    }
-
                 // END TEMP
             }
         }
 
                 Shader.SetGlobalInt("_DebugViewMaterial", (int)debugParameters.debugViewMaterial);
 
-                RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, "DebugViewMaterial");
+                RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, "DebugViewMaterial", Utilities.kRendererConfigurationBakedLighting);
             }
 
             // Render GBuffer opaque
 
             // Render forward transparent
             {
-                RenderTransparentRenderList(cull, hdCamera.camera, renderContext, "DebugViewMaterial");
+                RenderTransparentRenderList(cull, hdCamera.camera, renderContext, "DebugViewMaterial", Utilities.kRendererConfigurationBakedLighting);
             }
 
             // Last blit
                 return ;
             }
 
-            // Bind material data
-            m_LitRenderLoop.Bind();
             m_lightLoop.RenderDeferredLighting(hdCamera, renderContext, m_CameraColorBuffer);
         }
 
 
             using (new Utilities.ProfilingSample("Forward Pass", renderContext))
             {
-                // Bind material data
-                m_LitRenderLoop.Bind();
-
                 Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthBufferRT);
 
                 m_lightLoop.RenderForward(camera, renderContext, renderOpaque);
-                    RenderOpaqueRenderList(cullResults, camera, renderContext, "Forward");
+                    RenderOpaqueRenderList(cullResults, camera, renderContext, "Forward", Utilities.kRendererConfigurationBakedLighting);
                 }
                 else
                 {
         {
             using (new Utilities.ProfilingSample("Forward Only Pass", renderContext))
             {
-                // Bind material data
-                m_LitRenderLoop.Bind();
-
-                RenderOpaqueRenderList(cullResults, camera, renderContext, "ForwardOnlyOpaque");
+                RenderOpaqueRenderList(cullResults, camera, renderContext, "ForwardOnlyOpaque", Utilities.kRendererConfigurationBakedLighting);
             }
         }
 
 
                 InitAndClearBuffer(camera, renderContext);
 
+                // TODO: Find a correct place to bind these material textures
+                // We have to bind the material specific global parameters in this mode
+                m_LitRenderLoop.Bind();
+
                 RenderDepthPrepass(cullResults, camera, renderContext);
 
                 // Forward opaque with deferred/cluster tile require that we fill the depth buffer
                     using (new Utilities.ProfilingSample("Build Light list", renderContext))
                     {
                         m_lightLoop.PrepareLightsForGPU(m_ShadowSettings, cullResults, camera, ref shadows);
-                        m_lightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthBufferRT); // TODO: Use async compute here to run light culling during shadow
-
-                        PushGlobalParams(hdCamera, renderContext);
+                        m_lightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthBufferRT); // TODO: Use async compute here to run light culling during shadow                        
+
+                    PushGlobalParams(hdCamera, renderContext);
 
                     // Caution: We require sun light here as some sky use the sun light to render, mean UpdateSkyEnvironment
                     // must be call after BuildGPULightLists. 

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

             Blend[_SrcBlend][_DstBlend]
 
             HLSLPROGRAM
-            #pragma target 5.0
-            #pragma only_renderers d3d11 ps4// TEMP: unitl we go futher in dev
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
 
             #pragma vertex Vert
             #pragma fragment Frag

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/Resources/lightlistbuild-bigtile.compute

 	for(int l=0; l<iNrCoarseLights; l++)
 	{
 		const uint idxCoarse = lightsListLDS[l];
-        [branch]if (idxCoarse<(uint)g_iNrVisibLights && _LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+
+		bool canEnter = idxCoarse<(uint)g_iNrVisibLights;
+		if(canEnter) canEnter = _LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE;		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+    [branch]if(canEnter)
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
 	

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

 // Note: These parameters can be store in GBuffer if the writer wants
 //-----------------------------------------------------------------------------
 
-#include "BuiltinData.cs.hlsl"
+//TODO: return this original relative path include after fixing a bug in Unity side
+//#include "BuiltinData.cs.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Builtin/BuiltinData.cs.hlsl"
 
 //-----------------------------------------------------------------------------
 // common Encode/Decode functions
         break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
         // TODO: require a remap
-        result = builtinData.bakeDiffuseLighting;
+        // TODO: we should not gamma correct, but easier to debug for now without correct high range value
+        result = builtinData.bakeDiffuseLighting; needLinearToSRGB = true;
         break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR:
         // emissiveColor is premultiply by emissive intensity

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

             public readonly GUIContent heightFactorText = new GUIContent("Height Multiplier", "Scale applied to the height of the layer.");
             public readonly GUIContent blendSizeText = new GUIContent("Blend Size", "Thickness over which the layer will be blended with the previous one.");
 
-
+            public readonly GUIContent heightCenterOffsetText = new GUIContent("Height Center Offset", "Offset applied to the center of the height of the layer.");
+            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 blendUsingHeight = new GUIContent("Blend Using Height", "Blend Layers using 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 inheritBaseColorThresholdText = new GUIContent("Threshold", "Inherit the base color from the base layer.");
+            public readonly GUIContent minimumOpacityText = new GUIContent("Minimum Opacity", "Minimum Opacity.");
+            public readonly GUIContent opacityAsDensityText = new GUIContent("Use Opacity as Density", "Use Opacity as Density.");
             public StylesLayer()
             {
                 layerLabelColors[1].normal.textColor = Color.red;
 
         const string kUseHeightBasedBlend = "_UseHeightBasedBlend";
         MaterialProperty useHeightBasedBlend = null;
+        const string kUseHeightBasedBlendV2 = "_UseHeightBasedBlendV2";
+        MaterialProperty useHeightBasedBlendV2 = null;
+        const string kBlendUsingHeight = "_BlendUsingHeight";
+        MaterialProperty[] blendUsingHeight = new MaterialProperty[kMaxLayerCount - 1];
         const string kHeightOffset = "_HeightOffset";
         MaterialProperty[] heightOffset = new MaterialProperty[kMaxLayerCount-1];
         const string kInheritBaseLayer = "_InheritBaseLayer";
+        const string kHeightCenterOffset = "_HeightCenterOffset";
+        MaterialProperty[] heightCenterOffset = new MaterialProperty[kMaxLayerCount - 1];
+        // Height blend V2
+        const string kInheritBaseNormal = "_InheritBaseNormal";
+        MaterialProperty[] inheritBaseNormal = new MaterialProperty[kMaxLayerCount - 1];
+        const string kInheritBaseHeight = "_InheritBaseHeight";
+        MaterialProperty[] inheritBaseHeight = new MaterialProperty[kMaxLayerCount - 1];
+        const string kInheritBaseColor = "_InheritBaseColor";
+        MaterialProperty[] inheritBaseColor = new MaterialProperty[kMaxLayerCount - 1];
+        const string kInheritBaseColorThreshold = "_InheritBaseColorThreshold";
+        MaterialProperty[] inheritBaseColorThreshold = new MaterialProperty[kMaxLayerCount - 1];
+        const string kOpacityAsDensity = "_OpacityAsDensity";
+        MaterialProperty[] opacityAsDensity = new MaterialProperty[kMaxLayerCount - 1];
+        const string kMinimumOpacity = "_MinimumOpacity";
+        MaterialProperty[] minimumOpacity = new MaterialProperty[kMaxLayerCount - 1];
+
         MaterialProperty layerEmissiveColor = null;
         MaterialProperty layerEmissiveColorMap = null;
         MaterialProperty layerEmissiveIntensity = null;
             vertexColorHeightFactor = FindProperty(kVertexColorHeightFactor, props);
             layerCount = FindProperty(kLayerCount, props);
             useHeightBasedBlend = FindProperty(kUseHeightBasedBlend, props);
+            useHeightBasedBlendV2 = FindProperty(kUseHeightBasedBlendV2, props);
             
             for (int i = 0; i < kMaxLayerCount; ++i)
             {
                     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);
+
+                    heightCenterOffset[i - 1] = FindProperty(string.Format("{0}{1}", kHeightCenterOffset, i), props);
+                    blendUsingHeight[i - 1] = FindProperty(string.Format("{0}{1}", kBlendUsingHeight, i), props);
+                    inheritBaseNormal[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseNormal, i), props);
+                    inheritBaseHeight[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseHeight, i), props);
+                    inheritBaseColor[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseColor, i), props);
+                    inheritBaseColorThreshold[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseColorThreshold, i), props);
+                    minimumOpacity[i - 1] = FindProperty(string.Format("{0}{1}", kMinimumOpacity, i), props);
+                    opacityAsDensity[i - 1] = FindProperty(string.Format("{0}{1}", kOpacityAsDensity, i), props);
                 }
             }
 
                 {
                     int heightParamIndex = layerIndex - 1;
 
-                    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);
+                    if(useHeightBasedBlendV2.floatValue != 1.0f)
+                    {
+                        //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);
+                    }
+                    else
+                    {
+                        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);
+                    }
                 }
             }
 
             }
             if (enabled)
             {
-                m_MaterialEditor.ShaderProperty(vertexColorHeightFactor, styles.vertexColorHeightMultiplierText);
+                EditorGUI.BeginChangeCheck();
+                bool enabledV2 = EditorGUILayout.Toggle(styles.useHeightBasedBlendV2Text, useHeightBasedBlendV2.floatValue > 0.0f);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    useHeightBasedBlendV2.floatValue = enabledV2 ? 1.0f : 0.0f;
+                }
+                if(!enabledV2)
+                    m_MaterialEditor.ShaderProperty(vertexColorHeightFactor, styles.vertexColorHeightMultiplierText);
             }
             else
             {
             bool useHeightBasedBlend = material.GetFloat(kUseHeightBasedBlend) != 0.0f;
             if(useHeightBasedBlend)
             {
+                bool useHeightBasedBlendV2 = material.GetFloat(kUseHeightBasedBlendV2) != 0.0f;
+
+                SetKeyword(material, "_HEIGHT_BASED_BLEND_V2", useHeightBasedBlendV2);
             }
             else
             {

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

         _HeightOffset2("_HeightOffset2", Range(-0.3, 0.3)) = 0.0
         _HeightOffset3("_HeightOffset3", Range(-0.3, 0.3)) = 0.0
 
-        _HeightFactor1("_HeightFactor1", Range(0, 5)) = 1
-        _HeightFactor2("_HeightFactor2", Range(0, 5)) = 1
-        _HeightFactor3("_HeightFactor3", Range(0, 5)) = 1
+        _HeightFactor1("_HeightFactor1", Float) = 1
+        _HeightFactor2("_HeightFactor2", Float) = 1
+        _HeightFactor3("_HeightFactor3", Float) = 1
 
         _BlendSize1("_BlendSize1", Range(0, 0.30)) = 0.0
         _BlendSize2("_BlendSize2", Range(0, 0.30)) = 0.0
 
         _VertexColorHeightFactor("_VertexColorHeightFactor", Float) = 0.3
 
+        // Layer blending options V2
+        [ToggleOff] _UseHeightBasedBlendV2("Use Height Blend V2", Float) = 0.0
+
+        _HeightCenterOffset1("_HeightCenterOffset1", Float) = 0.0
+        _HeightCenterOffset2("_HeightCenterOffset2", Float) = 0.0
+        _HeightCenterOffset3("_HeightCenterOffset3", Float) = 0.0
+
+        _BlendUsingHeight1("_BlendUsingHeight1", Float) = 0.0
+        _BlendUsingHeight2("_BlendUsingHeight2", Float) = 0.0
+        _BlendUsingHeight3("_BlendUsingHeight3", Float) = 0.0
+
+        _InheritBaseNormal1("_InheritBaseNormal1", Range(0, 1.0)) = 0.0
+        _InheritBaseNormal2("_InheritBaseNormal2", Range(0, 1.0)) = 0.0
+        _InheritBaseNormal3("_InheritBaseNormal3", Range(0, 1.0)) = 0.0
+
+        _InheritBaseHeight1("_InheritBaseHeight1", Range(0, 1.0)) = 0.0
+        _InheritBaseHeight2("_InheritBaseHeight2", Range(0, 1.0)) = 0.0
+        _InheritBaseHeight3("_InheritBaseHeight3", Range(0, 1.0)) = 0.0
+
+        _InheritBaseColor1("_InheritBaseColor1", Range(0, 1.0)) = 0.0
+        _InheritBaseColor2("_InheritBaseColor2", Range(0, 1.0)) = 0.0
+        _InheritBaseColor3("_InheritBaseColor3", Range(0, 1.0)) = 0.0
+
+        _InheritBaseColorThreshold1("_InheritBaseColorThreshold1", Range(0, 1.0)) = 1.0
+        _InheritBaseColorThreshold2("_InheritBaseColorThreshold2", Range(0, 1.0)) = 1.0
+        _InheritBaseColorThreshold3("_InheritBaseColorThreshold3", Range(0, 1.0)) = 1.0
+
+        _MinimumOpacity1("_MinimumOpacity1", Range(0, 1.0)) = 1.0
+        _MinimumOpacity2("_MinimumOpacity2", Range(0, 1.0)) = 1.0
+        _MinimumOpacity3("_MinimumOpacity3", Range(0, 1.0)) = 1.0
+
+        _OpacityAsDensity1("_OpacityAsDensity1", Range(0, 1.0)) = 0.0
+        _OpacityAsDensity2("_OpacityAsDensity2", Range(0, 1.0)) = 0.0
+        _OpacityAsDensity3("_OpacityAsDensity3", Range(0, 1.0)) = 0.0
+
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
         _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
 
     HLSLINCLUDE
 
-    #pragma target 5.0
-    #pragma only_renderers d3d11 ps4// TEMP: unitl we go futher in dev
+    #pragma target 4.5
+    #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _ _LAYER_MASK_VERTEX_COLOR_MUL _LAYER_MASK_VERTEX_COLOR_ADD
     #pragma shader_feature _HEIGHT_BASED_BLEND
+    #pragma shader_feature _HEIGHT_BASED_BLEND_V2
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

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

 
     HLSLINCLUDE
 
-    #pragma target 5.0
-    #pragma only_renderers d3d11 ps4// TEMP: unitl we go futher in dev
+    #pragma target 4.5
+    #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _ _TESSELLATION_DISPLACEMENT _TESSELLATION_DISPLACEMENT_PHONG
+    #pragma shader_feature _TESSELLATION_OBJECT_SCALE
 
     #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_0
             // Lightmap memo
             // DYNAMICLIGHTMAP_ON is used when we have an "enlighten lightmap" ie a lightmap updated at runtime by enlighten.This lightmap contain indirect lighting from realtime lights and realtime emissive material.Offline baked lighting(from baked material / light, 
             // both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON.
+
+            // No tessellation for Meta pass
+            #undef TESSELLATION_ON
 
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../Material/Material.hlsl"            

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

             public static GUIContent tessellationFactorTriangleSizeText = new GUIContent("Triangle size", "Desired screen space sized of triangle (in pixel). Smaller value mean smaller triangle.");
             public static GUIContent tessellationShapeFactorText = new GUIContent("Shape factor", "Strength of Phong tessellation shape (lerp factor)");
             public static GUIContent tessellationBackFaceCullEpsilonText = new GUIContent("Triangle culling Epsilon", "If -1.0 back face culling is enabled for tessellation, higher number mean more aggressive culling and better performance");
-            //public static GUIContent tessellationObjectScaleText = new GUIContent("Enable object scale", "Scale displacement taking into account the object scale");
+            public static GUIContent tessellationObjectScaleText = new GUIContent("Enable object scale", "Tesselation displacement will take into account the object scale - Only work with uniform positive scale");
         }
 
         public enum SurfaceType
                 if ((DoubleSidedMode)doubleSidedMode.floatValue == DoubleSidedMode.None)
                 {
                     m_MaterialEditor.ShaderProperty(tessellationBackFaceCullEpsilon, Styles.tessellationBackFaceCullEpsilonText);
-                }  
-                // TODO: Implement
-                // m_MaterialEditor.ShaderProperty(tessellationObjectScale, Styles.tessellationObjectScaleText);
+                }
+                m_MaterialEditor.ShaderProperty(tessellationObjectScale, Styles.tessellationObjectScaleText);
                 EditorGUI.indentLevel--;
             }
         }
             tessellationFactorTriangleSize = FindProperty(kTessellationFactorTriangleSize, props, false);
             tessellationShapeFactor = FindProperty(kTessellationShapeFactor, props, false);
             tessellationBackFaceCullEpsilon = FindProperty(kTessellationBackFaceCullEpsilon, props, false);
-            //tessellationObjectScale = FindProperty(kTessellationObjectScale, props, false);
+            tessellationObjectScale = FindProperty(kTessellationObjectScale, props, false);
         }
 
         protected void SetupCommonOptionsKeywords(Material material)
                     material.DisableKeyword("_TESSELLATION_DISPLACEMENT");
                     material.EnableKeyword("_TESSELLATION_DISPLACEMENT_PHONG");
                 }
+
+                bool tessellationObjectScaleEnable = material.GetFloat(kTessellationObjectScale) == 1.0;
+                SetKeyword(material, "_TESSELLATION_OBJECT_SCALE", tessellationObjectScaleEnable);
             }
         }
 
         const string kTessellationShapeFactor = "_TessellationShapeFactor";
         MaterialProperty tessellationBackFaceCullEpsilon = null;
         const string kTessellationBackFaceCullEpsilon = "_TessellationBackFaceCullEpsilon";
-        //MaterialProperty tessellationObjectScale = null;
-        //const string kTessellationObjectScale = "_TessellationObjectScale";
+        MaterialProperty tessellationObjectScale = null;
+        const string kTessellationObjectScale = "_TessellationObjectScale";
 
         protected static string[] reservedProperties = new string[] { kSurfaceType, kBlendMode, kAlphaCutoff, kAlphaCutoffEnabled, kDoubleSidedMode };
 

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

             private Material      m_InitPreFGD;
             private RenderTexture m_PreIntegratedFGD;
 
-            // For area lighting
-            private Texture2D m_LtcGGXMatrix;                    // RGBA
-            private Texture2D m_LtcDisneyDiffuseMatrix;          // RGBA
-            private Texture2D m_LtcMultiGGXFresnelDisneyDiffuse; // RGB, A unused
+            // For area lighting - We pack all texture inside a texture array to reduce the number of resource required
+            private Texture2DArray m_LtcData; // 0: m_LtcGGXMatrix - RGBA, 2: m_LtcDisneyDiffuseMatrix - RGBA, 3: m_LtcMultiGGXFresnelDisneyDiffuse - RGB, A unused
-            Material CreateEngineMaterial(string shaderPath)
-            {
-                Material mat = new Material(Shader.Find(shaderPath) as Shader);
-                mat.hideFlags = HideFlags.HideAndDontSave;
-                return mat;
-            }
-
-            Texture2D CreateLUT(int width, int height, TextureFormat format, Color[] pixels)
-            {
-                Texture2D tex = new Texture2D(width, height, format, false /*mipmap*/, true /*linear*/);
-                tex.hideFlags = HideFlags.HideAndDontSave;
-                tex.wrapMode = TextureWrapMode.Clamp;
-                tex.filterMode = FilterMode.Bilinear;
-                tex.SetPixels(pixels);
-                tex.Apply();
-                return tex;
-            }
-            Texture2D LoadLUT(TextureFormat format, float[] LUTScalar)
+            void LoadLUT(Texture2DArray tex, int arrayElement, TextureFormat format, float[] LUTScalar)
             {
                 const int count = k_LtcLUTResolution * k_LtcLUTResolution;
                 Color[] pixels = new Color[count];
                     pixels[i] = new Color(0, 0, 0, LUTScalar[i]);
                 }
 
-                return CreateLUT(k_LtcLUTResolution, k_LtcLUTResolution, format, pixels);
+                tex.SetPixels(pixels, arrayElement);
-            Texture2D LoadLUT(TextureFormat format, double[,] LUTTransformInv)
+            void LoadLUT(Texture2DArray tex, int arrayElement, TextureFormat format, double[,] LUTTransformInv)
             {
                 const int count = k_LtcLUTResolution * k_LtcLUTResolution;
                 Color[] pixels = new Color[count];
                                           (float)LUTTransformInv[i, 6]);
                 }
 
-                return CreateLUT(k_LtcLUTResolution, k_LtcLUTResolution, format, pixels);
+                tex.SetPixels(pixels, arrayElement);
-            Texture2D LoadLUT(TextureFormat format, float[] LtcGGXMagnitudeData,
-                                                    float[] LtcGGXFresnelData,
-                                                    float[] LtcDisneyDiffuseMagnitudeData)
+            void LoadLUT(Texture2DArray tex, int arrayElement, TextureFormat format,   float[] LtcGGXMagnitudeData,
+                                                                                        float[] LtcGGXFresnelData,
+                                                                                        float[] LtcDisneyDiffuseMagnitudeData)
             {
                 const int count = k_LtcLUTResolution * k_LtcLUTResolution;
                 Color[] pixels = new Color[count];
                                           LtcGGXFresnelData[i], LtcDisneyDiffuseMagnitudeData[i], 1);
                 }
 
-                return CreateLUT(k_LtcLUTResolution, k_LtcLUTResolution, format, pixels);
+                tex.SetPixels(pixels, arrayElement);
-                m_InitPreFGD = CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
+                m_InitPreFGD = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
 
                 // TODO: switch to RGBA64 when it becomes available.
                 m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
 
-                m_LtcGGXMatrix                    = LoadLUT(TextureFormat.RGBAHalf, s_LtcGGXMatrixData);
-                m_LtcDisneyDiffuseMatrix          = LoadLUT(TextureFormat.RGBAHalf, s_LtcDisneyDiffuseMatrixData);
+                m_LtcData = new Texture2DArray(k_LtcLUTResolution, k_LtcLUTResolution, 3, TextureFormat.RGBAHalf, false /*mipmap*/, true /* linear */)
+                {
+                    hideFlags = HideFlags.HideAndDontSave,
+                    wrapMode = TextureWrapMode.Clamp,
+                    filterMode = FilterMode.Bilinear
+                };
+
+                LoadLUT(m_LtcData, 0, TextureFormat.RGBAHalf,   s_LtcGGXMatrixData);
+                LoadLUT(m_LtcData, 1, TextureFormat.RGBAHalf,   s_LtcDisneyDiffuseMatrixData);
-                m_LtcMultiGGXFresnelDisneyDiffuse = LoadLUT(TextureFormat.RGBAHalf, s_LtcGGXMagnitudeData,
-                                                                                    s_LtcGGXFresnelData,
-                                                                                    s_LtcDisneyDiffuseMagnitudeData);
+                LoadLUT(m_LtcData, 2, TextureFormat.RGBAHalf,   s_LtcGGXMagnitudeData, s_LtcGGXFresnelData, s_LtcDisneyDiffuseMagnitudeData);
+
+                m_LtcData.Apply();
 
                 isInit = false;
             }
 
             public void Bind()
             {
-                Shader.SetGlobalTexture("_PreIntegratedFGD",                m_PreIntegratedFGD);
-                Shader.SetGlobalTexture("_LtcGGXMatrix",                    m_LtcGGXMatrix);
-                Shader.SetGlobalTexture("_LtcDisneyDiffuseMatrix",          m_LtcDisneyDiffuseMatrix);
-                Shader.SetGlobalTexture("_LtcMultiGGXFresnelDisneyDiffuse", m_LtcMultiGGXFresnelDisneyDiffuse);
+                Shader.SetGlobalTexture("_PreIntegratedFGD", m_PreIntegratedFGD);
+                Shader.SetGlobalTexture("_LtcData", m_LtcData);
             }
         }
     }

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

 //-----------------------------------------------------------------------------
 
 // SurfaceData is define in Lit.cs which generate Lit.cs.hlsl
-#include "Lit.cs.hlsl"
+//TODO: return this original relative path include after fixing a bug in Unity side
+//#include "Lit.cs.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.cs.hlsl"
 
 // In case we pack data uint16 buffer we need to change the output render target format to uint16
 // TODO: Is there a way to automate these output type based on the format declare in lit.cs ?
 // TODO: Check if anisotropy with a dynamic if on anisotropy > 0 is performant. Because it may mean we always calculate both isotropy and anisotropy case.
 // Maybe we should always calculate anisotropy in case of standard ? Don't think the compile can optimize correctly.
 
-// TODO: I haven't configure this sampler in the code, we should be able to do it (but Unity don't allow it for now...)
-// By default Unity provide MIG_MAG_LINEAR_POINT sampler, so it fit with our need.
-// TODO: to avoid the message Fragment program 'Frag' : sampler 'sampler_PreIntegratedFGD' has no matching texture and will be undefined.
-// We need to test this define LIGHTLOOP_TILE_DIRECT, this is a bad workaround but no alternative until we can setup sampler correctly...
-#if defined(LIT_DISPLAY_REFERENCE_IBL) || defined(LIGHTLOOP_TILE_DIRECT)
-// When reference mode is enabled, then we need to chose another sampler not related to cubemap code...
-SAMPLER2D(sampler_LtcGGXMatrix);
-#define SRL_BilinearSampler sampler_LtcGGXMatrix // Used for all textures
-#else
-SAMPLER2D(sampler_PreIntegratedFGD);
-#define SRL_BilinearSampler sampler_PreIntegratedFGD // Used for all textures
-#endif
-
+// TODO: we can share the sampler here and name it SRL_BilinearSampler. However Unity currently doesn't support to set sampler in C#
+// + to avoid the message Fragment program 'Frag' : sampler 'sampler_PreIntegratedFGD' has no matching texture and will be undefined.
-TEXTURE2D(_LtcGGXMatrix);                    // RGBA
-TEXTURE2D(_LtcDisneyDiffuseMatrix);          // RGBA
-TEXTURE2D(_LtcMultiGGXFresnelDisneyDiffuse); // RGB, A unused
+SAMPLER2D(sampler_PreIntegratedFGD);
+TEXTURE2D_ARRAY(_LtcData); // We pack the 3 Ltc data inside a texture array
+SAMPLER2D(sampler_LtcData);
+#define LTC_GGX_MATRIX_INDEX 0 // RGBA
+#define LTC_DISNEY_DIFFUSE_MATRIX_INDEX 1 // RGBA
+#define LTC_MULTI_GGX_FRESNEL_DISNEY_DIFFUSE_INDEX 2 // RGB, A unused
 
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
     //  _PreIntegratedFGD.y = Gv * Fc
     // Pre integrate DisneyDiffuse FGD:
     // _PreIntegratedFGD.z = DisneyDiffuse
-    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD, SRL_BilinearSampler, float2(NdotV, perceptualRoughness), 0).xyz;
+    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD, sampler_PreIntegratedFGD, float2(NdotV, perceptualRoughness), 0).xyz;
 
     // f0 * Gv * (1 - Fc) + Gv * Fc
     specularFGD = fresnel0 * preFGD.x + preFGD.y;
     // Note we load the matrix transpose (avoid to have to transpose it in shader)
     preLightData.ltcXformGGX      = 0.0;
     preLightData.ltcXformGGX._m22 = 1.0;
-    preLightData.ltcXformGGX._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_LOD(_LtcGGXMatrix, SRL_BilinearSampler, uv, 0);
+    preLightData.ltcXformGGX._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, sampler_LtcData, uv, LTC_GGX_MATRIX_INDEX, 0);
-    preLightData.ltcXformDisneyDiffuse._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_LOD(_LtcDisneyDiffuseMatrix, SRL_BilinearSampler, uv, 0);
+    preLightData.ltcXformDisneyDiffuse._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, sampler_LtcData, uv, LTC_DISNEY_DIFFUSE_MATRIX_INDEX, 0);
-    float3 ltcMagnitude = SAMPLE_TEXTURE2D_LOD(_LtcMultiGGXFresnelDisneyDiffuse, SRL_BilinearSampler, uv, 0).r;
+    float3 ltcMagnitude = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, sampler_LtcData, uv, LTC_MULTI_GGX_FRESNEL_DISNEY_DIFFUSE_INDEX, 0).rgb;
     preLightData.ltcGGXFresnelMagnitudeDiff = ltcMagnitude.r;
     preLightData.ltcGGXFresnelMagnitude     = ltcMagnitude.g;
     preLightData.ltcDisneyDiffuseMagnitude  = ltcMagnitude.b;

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

 
     HLSLINCLUDE
 
-    #pragma target 5.0
-    #pragma only_renderers d3d11 ps4// TEMP: until we go futher in dev
+    #pragma target 4.5
+    #pragma only_renderers d3d11 ps4 metal // TEMP: until we go futher in dev
 
     //-------------------------------------------------------------------------------------
     // Variant

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

     }
 }
 
-// TODO: Handle BC5 format, currently this code is for DXT5nm
-// THis function below must call UnpackNormalmapRGorAG
-float3 SampleLayerNormal(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale)
-{
-    if (layerUV.isTriplanar)
-    {
-        float3 val = float3(0.0, 0.0, 0.0);
-
-        if (weights.x > 0.0)
-            val += weights.x * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ), scale);
-        if (weights.y > 0.0)
-            val += weights.y * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX), scale);
-        if (weights.z > 0.0)
-            val += weights.z * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY), scale);
-
-        return normalize(val);
-    }
-    else
-    {
-        return UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv), scale);
-    }
-}
+#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
-// This version is for normalmap with AG encoding only (use with details map)
-float3 SampleLayerNormalAG(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale)
-{
-    if (layerUV.isTriplanar)
-    {
-        float3 val = float3(0.0, 0.0, 0.0);
-
-        if (weights.x > 0.0)
-            val += weights.x * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ), scale);
-        if (weights.y > 0.0)
-            val += weights.y * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX), scale);
-        if (weights.z > 0.0)
-            val += weights.z * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY), scale);
-
-        return normalize(val);
-    }
-    else
-    {
-        return UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv), 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 SampleLayerNormalRGB(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale)
-{
-    if (layerUV.isTriplanar)
-    {
-        float3 val = float3(0.0, 0.0, 0.0);
-
-        if (weights.x > 0.0)
-            val += weights.x * UnpackNormalRGB(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ), scale);
-        if (weights.y > 0.0)
-            val += weights.y * UnpackNormalRGB(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX), scale);
-        if (weights.z > 0.0)
-            val += weights.z * UnpackNormalRGB(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY), scale);
-
-        return normalize(val);
-    }
-    else
-    {
-        return UnpackNormalRGB(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv), scale);
-    }
-}
+#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
-#define SAMPLE_LAYER_NORMALMAP(textureName, samplerName, coord, scale) SampleLayerNormal(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale)
-#define SAMPLE_LAYER_NORMALMAP_AG(textureName, samplerName, coord, scale) SampleLayerNormalAG(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale)
-#define SAMPLE_LAYER_NORMALMAP_RGB(textureName, samplerName, coord, scale) SampleLayerNormalRGB(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale)
+#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)
+
 
 #ifndef LAYERED_LIT_SHADER
 
     return max(finalLayerHeight, previousLayerHeight);
 }
 
+float3 ApplyHeightBasedBlendV2(float3 inputMask, float3 inputHeight, float3 blendUsingHeight)
+{
+    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);
 #endif
 }
 
+float3 ComputeInheritedNormalTS(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
+
+    // Compute how much we want to inherit from base layer normal base on the mask. Base layer always fully inherit from "itself" if it's the visible layer.
+    float inheritBaseNormal = BlendLayeredScalar(1.0f, _InheritBaseNormal1, _InheritBaseNormal2, _InheritBaseNormal3, weights);
+    // Based on this inheritance parameters, fetch a lower level of the base layer normal map so that the less we inherit the more this tends to be "vertex normal"
+    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(layerTexCoord, float3(0.0, 0.0, 0.0), 0.0f, true, maxMipBias * (1.0 - inheritBaseNormal));
+
+    // Blend all layers but the base one. This will then be added to the "inherited" normal of base layer (that's why base layer here is tangent space vertex normal so that if it's the visible layer we add nothing in term of normal map).
+    float3 layersNormalTS = BlendLayeredFloat3(float3(0.0, 0.0, 1.0), normalTS1, normalTS2, normalTS3, weights);
+    // Add the inherited normal to the blended top layers.
+    normalTS = BlendNormalRNM(inheritedBaseNormalTS, layersNormalTS);
+//#endif
+
+    return normalTS;
+}
+
+float3 ComputeInheritedColor(float3 baseColor0, float3 baseColor1, float3 baseColor2, float3 baseColor3, float compoMask, LayerTexCoord layerTexCoord, float weights[_MAX_LAYER])
+{
+    //return BlendLayeredFloat3(baseColor0, baseColor1, baseColor2, baseColor3, weights);
+
+    float inheritBaseColor = BlendLayeredScalar(1.0f, _InheritBaseColor1, _InheritBaseColor2, _InheritBaseColor3, weights);
+    float inheritBaseColorThreshold = BlendLayeredScalar(1.0f, _InheritBaseColorThreshold1, _InheritBaseColorThreshold2, _InheritBaseColorThreshold3, weights);
+
+    inheritBaseColor = inheritBaseColor * (1.0 - saturate(compoMask / inheritBaseColorThreshold));
+
+    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;
+
+    //float3 toto1 = lerp(baseMeanColor1, baseMeanColor0, _InheritBaseColor1) + baseColor1 - baseMeanColor1;
+    //float3 toto2 = lerp(baseMeanColor2, baseMeanColor0, _InheritBaseColor2) + baseColor2 - baseMeanColor2;
+    //float3 toto3 = lerp(baseMeanColor3, baseMeanColor0, _InheritBaseColor3) + baseColor3 - baseMeanColor3;
+
+    //return BlendLayeredFloat3(baseColor0, toto1, toto3, toto3, weights);
+
+    float3 meanColor = BlendLayeredFloat3(baseMeanColor0, baseMeanColor1, baseMeanColor2, baseMeanColor3, weights);
+    float3 baseColor = BlendLayeredFloat3(baseColor0, baseColor1, baseColor2, baseColor3, weights);
+
+    //return lerp(baseMeanColor1, baseColor0, _InheritBaseColor1) + (baseColor1 - baseMeanColor1);
+    return lerp(meanColor, baseColor0, inheritBaseColor) + (baseColor - meanColor);
+}
+
+void ComputeLayerWeights(FragInputs input, LayerTexCoord layerTexCoord, float4 inputAlphaMask, out float outWeights[_MAX_LAYER])
+{
+    float height0 = SampleHeightmap0(layerTexCoord);
+    float height1 = SampleHeightmap1(layerTexCoord, _HeightCenterOffset1, _HeightFactor1);
+    float height2 = SampleHeightmap2(layerTexCoord, _HeightCenterOffset2, _HeightFactor2);
+    float height3 = SampleHeightmap3(layerTexCoord, _HeightCenterOffset3, _HeightFactor3);
+
+    float4 heights = float4(height0, height1, height2, height3);
+    // 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);
+        baseLayerHeight = ApplyHeightBasedBlend(inputMaskValues.g, baseLayerHeight, heights.z, _HeightOffset2 + _HeightOffset1, _HeightFactor2, _BlendSize2, input.color.g);
+        ApplyHeightBasedBlend(inputMaskValues.b, baseLayerHeight, heights.w, _HeightOffset3 + _HeightOffset2 + _HeightOffset1, _HeightFactor3, _BlendSize3, input.color.b);
+    #else
+
+        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);
+
+        inputMaskValues = ApplyHeightBasedBlendV2(inputMaskValues, heights.yzw, float3(_BlendUsingHeight1, _BlendUsingHeight2, _BlendUsingHeight3));
+    #endif
+#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)
 {
     LayerTexCoord layerTexCoord;
     ApplyPerPixelDisplacement(input, V, layerTexCoord);
 
-    float height0 = SampleHeightmap0(layerTexCoord);
-    float height1 = SampleHeightmap1(layerTexCoord);
-    float height2 = SampleHeightmap2(layerTexCoord);
-    float height3 = SampleHeightmap3(layerTexCoord);
-
-    SurfaceData surfaceData0;
-    SurfaceData surfaceData1;
-    SurfaceData surfaceData2;
-    SurfaceData surfaceData3;
-    float3 normalTS0;
-    float3 normalTS1;
-    float3 normalTS2;
-    float3 normalTS3;
+    SurfaceData surfaceData0, surfaceData1, surfaceData2, surfaceData3;
+    float3 normalTS0, normalTS1, normalTS2, normalTS3;
-    // Mask Values : Layer 1, 2, 3 are r, g, b
-    float3 maskValues = SAMPLE_TEXTURE2D(_LayerMaskMap, sampler_LayerMaskMap, input.texCoord0).rgb;
+    float weights[_MAX_LAYER];
+    ComputeLayerWeights(input, layerTexCoord, float4(alpha0, alpha1, alpha2, alpha3), weights);
-    // Mutually exclusive with _HEIGHT_BASED_BLEND
-#if defined(_LAYER_MASK_VERTEX_COLOR_MUL) // Used when no layer mask is set
-    maskValues *= input.color.rgb;
-#elif defined(_LAYER_MASK_VERTEX_COLOR_ADD) // When layer mask is set, color is additive to enable user to override it.
-    maskValues = saturate(maskValues + input.color.rgb * 2.0 - 1.0);
-#endif
+    // 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);
-    float baseLayerHeight = height0;
-    baseLayerHeight = ApplyHeightBasedBlend(maskValues.r, baseLayerHeight, height1, _HeightOffset1, _HeightFactor1, _BlendSize1, input.color.r);
-    baseLayerHeight = ApplyHeightBasedBlend(maskValues.g, baseLayerHeight, height2, _HeightOffset2 + _HeightOffset1, _HeightFactor2, _BlendSize2, input.color.g);
-    ApplyHeightBasedBlend(maskValues.b, baseLayerHeight, height3, _HeightOffset3 + _HeightOffset2 + _HeightOffset1, _HeightFactor3, _BlendSize3, input.color.b);
+    surfaceData.baseColor = ComputeInheritedColor(surfaceData0.baseColor, surfaceData1.baseColor, surfaceData2.baseColor, surfaceData3.baseColor, alpha, layerTexCoord, weights);
+#else
+    surfaceData.baseColor = SURFACEDATA_BLEND_COLOR(surfaceData, baseColor, weights);
-
-    float weights[_MAX_LAYER];
-    ComputeMaskWeights(maskValues, weights);
-
-    surfaceData.baseColor = SURFACEDATA_BLEND_COLOR(surfaceData, baseColor, weights);
     surfaceData.specularOcclusion = SURFACEDATA_BLEND_SCALAR(surfaceData, specularOcclusion, weights);
     surfaceData.perceptualSmoothness = SURFACEDATA_BLEND_SCALAR(surfaceData, perceptualSmoothness, weights);
     surfaceData.ambientOcclusion = SURFACEDATA_BLEND_SCALAR(surfaceData, ambientOcclusion, weights);
 #if defined(_HEIGHT_BASED_BLEND)
-    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);
+    normalTS = ComputeInheritedNormalTS(normalTS0, normalTS1, normalTS2, normalTS3, layerTexCoord, weights);
+
     surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
     surfaceData.tangentWS = input.tangentToWorld[0].xyz;
 
     surfaceData.coatPerceptualSmoothness = 1.0;
     surfaceData.specularColor = float3(0.0, 0.0, 0.0);
 
-    float alpha = PROP_BLEND_SCALAR(alpha, weights);
     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 ADD_IDX(SampleHeightmap)(LayerTexCoord layerTexCoord, float centerOffset = 0.0f, float multiplier = 1.0f)
-    return (SAMPLE_TEXTURE2D(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), ADD_IDX(layerTexCoord.base).uv).r - ADD_IDX(_HeightCenter)) * ADD_IDX(_HeightAmplitude);
+    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;
 #else
     return 0.0;
 #endif
     float2 uv = ADD_IDX(layerTexCoord.base).uv;
 
     // Compute lod as we will sample inside a loop (so can't use regular sampling)
-    float lod = CALCULATE_TEXTURE2D_LOD(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), uv);
+    // It appear that CALCULATE_TEXTURE2D_LOD only return interger lod. We want to use float lod to have smoother transition and fading
+    // float lod = CALCULATE_TEXTURE2D_LOD(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), uv);
+    float lod = ComputeTextureLOD(uv, GET_TEXELSIZE_NAME(ADD_IDX(_HeightMap))); 
-    float2 texOffsetCurrent = uv;
+    float2 texOffsetCurrent = 0;
     float prevHeight = SAMPLE_TEXTURE2D_LOD(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), uv + texOffsetCurrent, lod).r;
     texOffsetCurrent += texOffsetPerStep;
     float currHeight = SAMPLE_TEXTURE2D_LOD(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), uv + texOffsetCurrent, lod).r;
 
     // Found below and above points, now perform line interesection (ray) with piecewise linear heightfield approximation
 
+    // Refine the search by adding few extra intersection
+#define POM_REFINE 1
+#if POM_REFINE
+
+    float pt0 = rayHeight + stepSize;
+    float pt1 = rayHeight;
+    float delta0 = pt0 - prevHeight;
+    float delta1 = pt1 - currHeight;
-#define POM_REFINE 0
-#if POM_REFINE
+    float2 offset = float2(0.0, 0.0);
+
+    float threshold = 1.0;
+
+    for (int i = 0; i < 5; ++i)
+    {
+        float t = (pt0 * delta1 - pt1 * delta0) / (delta1 - delta0);
+        offset = (1 - t) * texOffsetPerStep * numSteps;
+
+        currHeight = SAMPLE_TEXTURE2D_LOD(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), uv + offset, lod).r;
+
+        threshold = t - currHeight;
+
+        if (abs(threshold) <= 0.01)
+            break;
+
+        if (threshold < 0.0)
+        {
+            delta1 = threshold;
+            pt1 = t;
+        }
+        else
+        {
+            delta0 = threshold;
+            pt0 = t;
+        }
+    }
-    /*
-    float t0 = rayHeight + stepSize;
-    float t1 = rayHeight; 
-    float delta0 = t0 - prevHeight;
-    float delta1 = t1 - currHeight;
-    float t = (t0 * delta1 - t1 * delta0) / (delta1 - delta0);
-    float2 offset = uv + (1 - t) * texOffsetPerStep * numSteps;
-    */
-        
+    
+    //float pt0 = rayHeight + stepSize;
+    //float pt1 = rayHeight; 
+    //float delta0 = pt0 - prevHeight;
+    //float delta1 = pt1 - currHeight;
+    //float t = (pt0 * delta1 - pt1 * delta0) / (delta1 - delta0);
+    //float2 offset = (1 - t) * texOffsetPerStep * numSteps;
+
+    // A bit more optimize
-    float2 offset = (ratio) * (texOffsetCurrent - texOffsetPerStep) + (1.0 - ratio) * texOffsetCurrent; 
+    float2 offset = texOffsetCurrent - ratio * texOffsetPerStep;
+
+    // TODO: expose LOD fading
+    //float lodThreshold = 0.0;
+    //offset *= (1.0 - saturate(lod - lodThreshold));
 
     // Apply offset only on base. Details could use another mapping and will not be consistant...
     // Don't know if this will still ok.
 
+float3 ADD_IDX(GetNormalTS)(FragInputs input, LayerTexCoord layerTexCoord, float3 detailNormalTS, float detailMask, bool useBias, float bias)
+{
+    float3 normalTS;
+
+    #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);
+        #else // Object space
+            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);
+        #endif
+
+        #ifdef _DETAIL_MAP
+            normalTS = lerp(normalTS, BlendNormalRNM(normalTS, detailNormalTS), detailMask);
+        #endif
+    #else
+        normalTS = float3(0.0, 0.0, 1.0);
+    #endif
+
+    #if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
+        #ifdef _DOUBLESIDED_LIGHTING_FLIP
+            float3 oppositeNormalTS = -normalTS;
+        #else
+            // Mirror the normal with the plane define by vertex normal
+            float3 oppositeNormalTS = reflect(normalTS, float3(0.0, 0.0, 1.0)); // Reflect around vertex normal (in tangent space this is z)
+        #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);
+    #endif
+
+    return normalTS;
+}
+
 // Return opacity
 float ADD_IDX(GetSurfaceData)(FragInputs input, LayerTexCoord layerTexCoord, out SurfaceData surfaceData, out float3 normalTS)
 {
     clip(alpha - _AlphaCutoff);
 #endif
 
+    float3 detailNormalTS = float3(0.0, 0.0, 0.0);
+    float detailMask = 0.0;
-    float 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)).b;
     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;
-    float3 detailNormalTS = SAMPLE_LAYER_NORMALMAP_AG(ADD_IDX(_DetailMap), ADD_ZERO_IDX(sampler_DetailMap), ADD_IDX(layerTexCoord.details), ADD_ZERO_IDX(_DetailNormalScale));
+    detailNormalTS = SAMPLE_LAYER_NORMALMAP_AG(ADD_IDX(_DetailMap), ADD_ZERO_IDX(sampler_DetailMap), ADD_IDX(layerTexCoord.details), ADD_ZERO_IDX(_DetailNormalScale), false, 0.0f);
-    float3 detailNormalTS = float3(0.0, 0.0, 1.0);
+    detailNormalTS = float3(0.0, 0.0, 1.0);
     //float detailAO = detail.b;
     #endif
 #endif
     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
-#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));
-    #else // Object space
-        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
-        normalTS = lerp(normalTS, BlendNormalRNM(normalTS, detailNormalTS), detailMask);
-        #endif
-#else
-    normalTS = float3(0.0, 0.0, 1.0);
-#endif
-
-#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
-    #ifdef _DOUBLESIDED_LIGHTING_FLIP
-    float3 oppositeNormalTS = -normalTS;
-    #else
-    // Mirror the normal with the plane define by vertex normal
-    float3 oppositeNormalTS = reflect(normalTS, float3(0.0, 0.0, 1.0)); // Reflect around vertex normal (in tangent space this is z)
-#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);
-#endif
+    normalTS = ADD_IDX(GetNormalTS)(input, layerTexCoord, detailNormalTS, detailMask, false, 0.0f);
 
 #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     surfaceData.perceptualSmoothness = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_BaseColorMap), ADD_ZERO_IDX(sampler_BaseColorMap), ADD_IDX(layerTexCoord.base)).a;

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

 
 TEXTURE2D(_HeightMap);
 SAMPLER2D(sampler_HeightMap);
+float4 _HeightMap_TexelSize; // Unity facility. This will provide the size of the heightmap to the shader
 
 float _HeightAmplitude;
 float _HeightCenter;
 PROP_DECL(float, _NormalScale);
 
 PROP_DECL_TEX2D(_HeightMap);
+float4 _HeightMap0_TexelSize;
+float4 _HeightMap1_TexelSize;
+float4 _HeightMap2_TexelSize;
+float4 _HeightMap3_TexelSize;
 
 PROP_DECL_TEX2D(_DetailMask);
 PROP_DECL_TEX2D(_DetailMap);
 float _InheritBaseLayer1;
 float _InheritBaseLayer2;
 float _InheritBaseLayer3;
+
+// Blend Properties V2
+float _UseHeightBasedBlendV2;
+
+float _HeightCenterOffset1;
+float _HeightCenterOffset2;
+float _HeightCenterOffset3;
+float _BlendUsingHeight1;
+float _BlendUsingHeight2;
+float _BlendUsingHeight3;
+float _InheritBaseNormal1;
+float _InheritBaseNormal2;
+float _InheritBaseNormal3;
+float _InheritBaseHeight1;
+float _InheritBaseHeight2;
+float _InheritBaseHeight3;
+float _InheritBaseColor1;
+float _InheritBaseColor2;
+float _InheritBaseColor3;
+float _InheritBaseColorThreshold1;
+float _InheritBaseColorThreshold2;
+float _InheritBaseColorThreshold3;
+float _MinimumOpacity1;
+float _MinimumOpacity2;
+float _MinimumOpacity3;
+float _OpacityAsDensity1;
+float _OpacityAsDensity2;
+float _OpacityAsDensity3;
 
 float3 _EmissiveColor;
 TEXTURE2D(_EmissiveColorMap);

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

-float4 TessellationEdge(float3 p0, float3 p1, float3 p2, float3 n0, float3 n1, float3 n2)
+float4 GetTessellationFactors(float3 p0, float3 p1, float3 p2, float3 n0, float3 n1, float3 n2)
 {
     float maxDisplacement = ADD_ZERO_IDX(_HeightAmplitude);
 #ifdef _LAYER_COUNT
         float2(0.0, 0.0),
 #endif
         input.positionWS, 
-#ifdef VARYINGS_DS_NEED_NORMAL
-#else
-        float3(0.0, 0.0, 1.0),
-#endif
         layerTexCoord);
 
     // TODO: For now just use Layer0, but we are suppose to apply the same heightmap blending than in the pixel shader
     float height = 0.0;
 #endif
 
-#ifdef VARYINGS_DS_NEED_NORMAL
-    return height * input.normalWS;
-#else
-    return float3(0.0, 0.0, 0.0);
+    float3 displ = height * input.normalWS;
+
+        // Applying scaling of the object if requested
+#ifdef _TESSELLATION_OBJECT_SCALE
+    displ *= input.objectScale;
+
+    return displ;
 }

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

     #pragma shader_feature _ _DOUBLESIDED _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
     // Default is _TESSELLATION_PHONG
     #pragma shader_feature _ _TESSELLATION_DISPLACEMENT _TESSELLATION_DISPLACEMENT_PHONG
+    #pragma shader_feature _TESSELLATION_OBJECT_SCALE
 
     #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     #pragma shader_feature _MAPPING_TRIPLANAR
             // both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON.
 
 			// No tessellation for Meta pass
+            #undef TESSELLATION_ON
 
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../Material/Material.hlsl"            
 
             ENDHLSL
         }
-
+        
         Pass
         {
             Name "ShadowCaster"
 
             ENDHLSL
         }
-
+        
         Pass
         {
             Name "Motion Vectors"
 
             ENDHLSL
         }
-
+   
         Pass
         {
             Name "Distortion" // Name is not used
 
             ENDHLSL
         }
+
     }
 
     CustomEditor "Experimental.Rendering.HDPipeline.LitGUI"

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

             HLSLPROGRAM
             #pragma vertex Vert
             #pragma fragment Frag
-            #pragma target 5.0
-            #pragma only_renderers d3d11 ps4// TEMP: unitl we go futher in dev
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
 
             #include "Common.hlsl"
             #include "ImageBasedLighting.hlsl"

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

 #endif
 
 // Attributes
-#define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELATION_DISPLACEMENT) || defined(_TESSELATION_DISPLACEMENT_PHONG)))
+#define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELLATION_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
 #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)

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

 #endif
 
 // Attributes
-#define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELATION_DISPLACEMENT) || defined(_TESSELATION_DISPLACEMENT_PHONG)))
+#define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELLATION_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
 #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)

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

 // conflict with the normal in the semantic. This need to be fix! Also no per pixel displacement is possible either.
 
 // Attributes
-#define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELATION_DISPLACEMENT) || defined(_TESSELATION_DISPLACEMENT_PHONG)))
+#define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELLATION_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
 #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)
-// #define ATTRIBUTES_NEED_NORMAL
+// #define ATTRIBUTES_NEED_NORMAL - When reenable, think to also enable code in VertMesh.hlsl
 #endif
 #if REQUIRE_TANGENT_TO_WORLD
 #define ATTRIBUTES_NEED_TANGENT

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

 
     HLSLINCLUDE
 
-    #pragma target 5.0
-    #pragma only_renderers d3d11 ps4 // TEMP: unitl we go futher in dev
+    #pragma target 4.5
+    #pragma only_renderers d3d11 ps4 metal  // TEMP: unitl we go futher in dev
 
     //-------------------------------------------------------------------------------------
     // Variant

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/EyeAdaptation.shader

 
     HLSLINCLUDE
 
-        #pragma target 5.0
+        #pragma target 4.5
         #include "Common.hlsl"
         #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
         #include "EyeAdaptation.hlsl"

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

 
     HLSLINCLUDE
 
-        #pragma target 5.0
+        #pragma target 4.5
         #include "Common.hlsl"
         #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
         #include "ColorGrading.hlsl"

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/LutGen.shader

 {
     HLSLINCLUDE
 
-        #pragma target 5.0
+        #pragma target 4.5
         #include "Common.hlsl"
         #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
         #include "ColorGrading.hlsl"

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/TessellationShare.hlsl

     float3 p1 = varying1.vmesh.positionWS;
     float3 p2 = varying2.vmesh.positionWS;
 
-#ifdef VARYINGS_DS_NEED_NORMAL
-#else
-    float3 n0 = float3(0.0, 0.0, 0.0);
-    float3 n1 = float3(0.0, 0.0, 0.0);
-    float3 n2 = float3(0.0, 0.0, 0.0);
-#endif    
-    float4 tf = TessellationEdge(p0, p1, p2, n0, n1, n2);
+    float4 tf = GetTessellationFactors(p0, p1, p2, n0, n1, n2);
     TessellationFactors output;
     output.edge[0] = tf.x;
     output.edge[1] = tf.y;
     float3 p1 = varying1.vmesh.positionWS;
     float3 p2 = varying2.vmesh.positionWS;
 
-#ifdef VARYINGS_DS_NEED_NORMAL
-#else
-    float3 n0 = float3(0.0, 0.0, 0.0);
-    float3 n1 = float3(0.0, 0.0, 0.0);
-    float3 n2 = float3(0.0, 0.0, 0.0);
-#endif
 
     varying.vmesh.positionWS = PhongTessellation(   varying.vmesh.positionWS,
                                                     p0, p1, p2, n0, n1, n2,

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/VaryingMesh.hlsl

 // We can deduce these defines from the other defines
 // We need to pass to DS any varying required by pixel shader
 // If we have required an attributes that is not present in varyings it mean we will be for DS
-#if defined(VARYINGS_NEED_TANGENT_TO_WORLD) || defined(ATTRIBUTES_NEED_NORMAL)
-#define VARYINGS_DS_NEED_NORMAL
-#endif
 #if defined(VARYINGS_NEED_TANGENT_TO_WORLD) || defined(ATTRIBUTES_NEED_TANGENT)
 #define VARYINGS_DS_NEED_TANGENT
 #endif
 struct VaryingsMeshToDS
 {
     float3 positionWS;
-#ifdef VARYINGS_DS_NEED_NORMAL
-#endif
 #ifdef VARYINGS_DS_NEED_TANGENT
     float4 tangentWS;
 #endif
 #ifdef VARYINGS_DS_NEED_COLOR
     float4 color;
 #endif
+#ifdef _TESSELLATION_OBJECT_SCALE
+    float3 objectScale;
+#endif
+    float3 interpolators1 : NORMAL; // NormalWS
-#ifdef VARYINGS_DS_NEED_NORMAL
-    float3 interpolators1 : NORMAL;
-#endif
 #ifdef VARYINGS_DS_NEED_TANGENT
     float4 interpolators2 : TANGENT;
 #endif
 #ifdef VARYINGS_DS_NEED_COLOR
     float4 interpolators5 : TEXCOORD2;
 #endif
+
+#ifdef _TESSELLATION_OBJECT_SCALE
+    float3 interpolators6 : TEXCOORD3;
+#endif
 };
 
 // Functions to pack data to use as few interpolator as possible, the ShaderGraph should generate these functions
 
     output.interpolators0 = input.positionWS;
-#ifdef VARYINGS_DS_NEED_NORMAL
-#endif
 #ifdef VARYINGS_DS_NEED_TANGENT
     output.interpolators2 = input.tangentWS;
 #endif
 #ifdef VARYINGS_DS_NEED_COLOR
     output.interpolators5 = input.color;
 #endif
+#ifdef _TESSELLATION_OBJECT_SCALE
+    output.interpolators6 = input.objectScale;
+#endif
 
     return output;
 }
     VaryingsMeshToDS output;
 
     output.positionWS = input.interpolators0;
-#ifdef VARYINGS_DS_NEED_NORMAL
-#endif
 #ifdef VARYINGS_DS_NEED_TANGENT
     output.tangentWS = input.interpolators2;
 #endif
 #ifdef VARYINGS_DS_NEED_COLOR
     output.color = input.interpolators5;
 #endif
-
+#ifdef _TESSELLATION_OBJECT_SCALE
+    output.objectScale = input.interpolators6;
+#endif
     return output;
 }
 
 
     TESSELLATION_INTERPOLATE_BARY(positionWS, baryCoords);
-#ifdef VARYINGS_DS_NEED_NORMAL
-#endif
 #ifdef VARYINGS_DS_NEED_TANGENT
     // This will interpolate the sign but should be ok in practice as we may expect a triangle to have same sign (? TO CHECK)
     TESSELLATION_INTERPOLATE_BARY(tangentWS, baryCoords);
 #endif
 #ifdef VARYINGS_DS_NEED_COLOR 
     TESSELLATION_INTERPOLATE_BARY(color, baryCoords);
+#endif
+
+#ifdef _TESSELLATION_OBJECT_SCALE
+    // objectScale doesn't change for the whole object.
+    ouput.objectScale = input0.objectScale;
 #endif
 
     return ouput;

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/VertMesh.hlsl

 {
     VaryingsMeshType output;
 
-#if defined(TESSELLATION_ON)
+#ifdef TESSELLATION_ON
-    // TODO deal with camera center rendering and instancing (This is the reason why we always perform tow steps transform to clip space + instancing matrix)  
-    #if defined(VARYINGS_NEED_TANGENT_TO_WORLD) || defined(VARYINGS_DS_NEED_NORMAL)
+    #ifdef _TESSELLATION_OBJECT_SCALE
+    // Extract scaling from world transform
+    float4x4 worldTransform = GetObjectToWorldMatrix();
+    output.objectScale.x = length(float3(worldTransform._m00, worldTransform._m01, worldTransform._m02));
+    output.objectScale.y = length(float3(worldTransform._m10, worldTransform._m11, worldTransform._m12));
+    output.objectScale.z = length(float3(worldTransform._m20, worldTransform._m21, worldTransform._m22));
+    #endif
+    // TODO: deal with camera center rendering and instancing (This is the reason why we always perform tow steps transform to clip space + instancing matrix)  
+    // TODO: TEMP: Velocity has a flow as it doens't have normal. This need to be fix. In the mean time, generate fix normal so compiler doesn't complain - When fix, think to also enable ATTRIBUTES_NEED_NORMAL in LitVelocityPass.hlsl
+    #if SHADERPASS == SHADERPASS_VELOCITY
+    output.normalWS = float3(0.0, 0.0, 1.0);
+    #else
     output.normalWS = TransformObjectToWorldNormal(input.normalOS);
     #endif
     #if defined(VARYINGS_NEED_TANGENT_TO_WORLD) || defined(VARYINGS_DS_NEED_TANGENT)

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

     #pragma vertex Vert
     #pragma fragment Frag
 
-    #pragma target 5.0
-    #pragma only_renderers d3d11 ps4// TEMP: unitl we go futher in dev
+    #pragma target 4.5
+    #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
 
     #include "Color.hlsl"
     #include "Common.hlsl"

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

             Blend One OneMinusSrcAlpha, Zero One
 
             HLSLPROGRAM
-            #pragma target 5.0
-            #pragma only_renderers d3d11 ps4 // TEMP: unitl we go futher in dev
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 metal  // TEMP: unitl we go futher in dev
 
             #pragma vertex Vert
             #pragma fragment Frag

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/Resources/GGXConvolve.shader

             Blend One Zero
 
             HLSLPROGRAM
-            #pragma target 5.0
-            #pragma only_renderers d3d11 ps4 // TEMP: unitl we go futher in dev
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 metal  // TEMP: unitl we go futher in dev
 
             #pragma multi_compile _ USE_MIS
 

Assets/ScriptableRenderLoop/ShaderLibrary/API/D3D11.hlsl

 
 #define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) textureName.Sample(samplerName, coord2)
 #define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias) textureName.SampleBias(samplerName, float4(coord3, index), bias)
 #define SAMPLE_TEXTURE3D(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)

Assets/ScriptableRenderLoop/ShaderLibrary/API/PSSL.hlsl

 
 #define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) textureName.Sample(samplerName, coord2)
 #define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias) textureName.SampleBias(samplerName, float4(coord3, index), bias)
 #define SAMPLE_TEXTURE3D(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

 #include "API/PSSL.hlsl"
 #elif defined(SHADER_API_XBOXONE)
 #include "API/D3D11_1.hlsl"
+#elif defined(SHADER_API_METAL)
+#include "API/Metal.hlsl"
 #else
 #error unsupported shader api
 #endif
 float4 PositivePow(float4 base, float4 power)
 {
     return pow(max(abs(base), float4(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
+}
+
+// ----------------------------------------------------------------------------
+// Texture utilities
+// ----------------------------------------------------------------------------
+
+// texelSize is Unity XXX_TexelSize feature parameters
+// x contains 1.0/width, y contains 1.0 / height, z contains width, w contains height
+float ComputeTextureLOD(float2 uv, float4 texelSize)
+{
+    uv *= texelSize.zw;
+
+    float2 ddx_ = ddx(uv);
+    float2 ddy_ = ddy(uv);
+    float d = max(dot(ddx_, ddx_), dot(ddy_, ddy_));
+
+    return  max(0.5 * log2(d), 0.0);
 }
 
 // ----------------------------------------------------------------------------

Assets/ScriptableRenderLoop/ShaderLibrary/CommonMaterial.hlsl

 // Transforms 2D UV by scale/bias property
 #define TRANSFORM_TEX(tex, name) ((tex.xy) * name##_ST.xy + name##_ST.zw)
 
+#define GET_TEXELSIZE_NAME(name) (name##_TexelSize)
+
 #endif // UNITY_COMMON_MATERIAL_INCLUDED

Assets/ScriptableRenderLoop/fptl/Internal-DeferredComputeShading.compute

-#pragma kernel ShadeDeferred_Fptl				SHADE_DEFERRED_ENTRY=ShadeDeferred_Fptl				USE_FPTL_LIGHTLIST=1		ENABLE_DEBUG=0
-#pragma kernel ShadeDeferred_Clustered			SHADE_DEFERRED_ENTRY=ShadeDeferred_Clustered		USE_CLUSTERED_LIGHTLIST=1	ENABLE_DEBUG=0		//TODO: disabled clustered permutations so far as it leads to the error "All kernels must use same constant buffer layouts"
-#pragma kernel ShadeDeferred_Fptl_Debug			SHADE_DEFERRED_ENTRY=ShadeDeferred_Fptl_Debug		USE_FPTL_LIGHTLIST=1		ENABLE_DEBUG=1
-#pragma kernel ShadeDeferred_Clustered_Debug	SHADE_DEFERRED_ENTRY=ShadeDeferred_Clustered_Debug	USE_CLUSTERED_LIGHTLIST=1	ENABLE_DEBUG=1
-
-#define TILE_SIZE 8
-
-
-// Hacks to get the header to compile in compute
-#define SHADER_TARGET 50
-#define UNITY_PBS_USE_BRDF1
-#define fixed4 float4
-#include "UnityLightingCommon.cginc"
-#undef fixed4
-
-float3 EvalMaterial(UnityLight light, UnityIndirect ind);
-float3 EvalIndirectSpecular(UnityLight light, UnityIndirect ind);
-
-// uses the optimized single layered light list for opaques only
-
-#ifdef USE_FPTL_LIGHTLIST
-#define OPAQUES_ONLY
-#endif
-
-#include "TiledLightingTemplate.hlsl"
-#include "TiledReflectionTemplate.hlsl"
-
-Texture2D _CameraDepthTexture;
-Texture2D _CameraGBufferTexture0;
-Texture2D _CameraGBufferTexture1;
-Texture2D _CameraGBufferTexture2;
-Texture2D _CameraGBufferTexture3;
-
-RWTexture2D<float4> uavOutput : register(u0);
-
-struct v2f {
-	float4 vertex : SV_POSITION;
-	float2 texcoord : TEXCOORD0;
-};
-
-v2f vert(float4 vertex : POSITION, float2 texcoord : TEXCOORD0)
-{
-	v2f o;
-	o.vertex = UnityObjectToClipPos(vertex);
-	o.texcoord = texcoord.xy;
-	return o;
-}
-
-struct StandardData
-{
-	float3 specularColor;
-	float3 diffuseColor;
-	float3 normalWorld;
-	float smoothness;
-	float occlusion;
-	float3 emission;
-};
-
-struct LocalDataBRDF
-{
-	StandardData gbuf;
-
-	// extras
-	float oneMinusReflectivity;
-	float3 Vworld;
-};
-
-static LocalDataBRDF g_localParams;
-
-StandardData UnityStandardDataFromGbufferAux(float4 gbuffer0, float4 gbuffer1, float4 gbuffer2, float4 gbuffer3)
-{
-	StandardData data;
-
-	data.normalWorld = normalize(2 * gbuffer2.xyz - 1);
-	data.smoothness = gbuffer1.a;
-	data.diffuseColor = gbuffer0.xyz; data.specularColor = gbuffer1.xyz;
-	data.occlusion = gbuffer0.a;
-	data.emission = gbuffer3.xyz;
-	
-	return data;
-}
-
-half3 BRDF3_Direct2(half3 diffColor, half3 specColor, half rlPow4, half smoothness)
-{
-	half LUT_RANGE = 16.0; // must match range in NHxRoughness() function in GeneratedTextures.cpp
-						   // Lookup texture to save instructions
-	half specular = tex2Dlod(unity_NHxRoughness, half4(rlPow4, SmoothnessToPerceptualRoughness(smoothness), 0, 0)).UNITY_ATTEN_CHANNEL * LUT_RANGE;
-#if defined(_SPECULARHIGHLIGHTS_OFF)
-	specular = 0.0;
-#endif
-
-	return diffColor + specular * specColor;
-}
-
-
-float3 EvalMaterial(UnityLight light, UnityIndirect ind)
-{
-	StandardData data = g_localParams.gbuf;
-	return UNITY_BRDF_PBS(data.diffuseColor, data.specularColor, g_localParams.oneMinusReflectivity, data.smoothness, data.normalWorld, g_localParams.Vworld, light, ind);
-}
-
-float3 EvalIndirectSpecular(UnityLight light, UnityIndirect ind)
-{
-	StandardData data = g_localParams.gbuf;
-
-	return data.occlusion * UNITY_BRDF_PBS(0, data.specularColor, g_localParams.oneMinusReflectivity, data.smoothness, data.normalWorld, g_localParams.Vworld, light, ind).rgb;
-}
-
-[numthreads(TILE_SIZE, TILE_SIZE, 1)]
-void SHADE_DEFERRED_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
-{
-	uint2 pixCoord = dispatchThreadId;
-
-	float zbufDpth = FetchDepth(_CameraDepthTexture, pixCoord.xy).x;
-	float linDepth = GetLinearDepth(zbufDpth);
-
-	float3 vP = GetViewPosFromLinDepth(pixCoord, linDepth);
-	float3 vPw = mul(g_mViewToWorld, float4(vP, 1)).xyz;
-	float3 Vworld = normalize(mul((float3x3) g_mViewToWorld, -vP).xyz);     //unity_CameraToWorld
-
-	float4 gbuffer0 = _CameraGBufferTexture0.Load(uint3(pixCoord.xy, 0));
-	float4 gbuffer1 = _CameraGBufferTexture1.Load(uint3(pixCoord.xy, 0));
-	float4 gbuffer2 = _CameraGBufferTexture2.Load(uint3(pixCoord.xy, 0));
-	float4 gbuffer3 = _CameraGBufferTexture3.Load(uint3(pixCoord.xy, 0));
-
-	StandardData data = UnityStandardDataFromGbufferAux(gbuffer0, gbuffer1, gbuffer2, gbuffer3);
-
-	g_localParams.gbuf = data;
-	g_localParams.oneMinusReflectivity = 1.0 - SpecularStrength(data.specularColor.rgb);
-	g_localParams.Vworld = Vworld;
-
-	uint2 tileCoord = groupId >> 1;
-
-	uint numLightsProcessed = 0;
-	float3 c = data.emission + ExecuteLightList(numLightsProcessed, tileCoord, vP, vPw, Vworld);
-
-	uint numReflectionsProcessed = 0;
-	c += ExecuteReflectionList(numReflectionsProcessed, tileCoord, vP, data.normalWorld, Vworld, data.smoothness);
-
-#if ENABLE_DEBUG
-	c = OverlayHeatMap(pixCoord & 15, numLightsProcessed, c);
-#endif
-	
-	uavOutput[pixCoord] = float4(c, 1.0);
-}
-
+#pragma kernel ShadeDeferred_Fptl				SHADE_DEFERRED_ENTRY=ShadeDeferred_Fptl				USE_FPTL_LIGHTLIST=1		ENABLE_DEBUG=0
+#pragma kernel ShadeDeferred_Clustered			SHADE_DEFERRED_ENTRY=ShadeDeferred_Clustered		USE_CLUSTERED_LIGHTLIST=1	ENABLE_DEBUG=0		//TODO: disabled clustered permutations so far as it leads to the error "All kernels must use same constant buffer layouts"
+#pragma kernel ShadeDeferred_Fptl_Debug			SHADE_DEFERRED_ENTRY=ShadeDeferred_Fptl_Debug		USE_FPTL_LIGHTLIST=1		ENABLE_DEBUG=1
+#pragma kernel ShadeDeferred_Clustered_Debug	SHADE_DEFERRED_ENTRY=ShadeDeferred_Clustered_Debug	USE_CLUSTERED_LIGHTLIST=1	ENABLE_DEBUG=1
+
+#define TILE_SIZE 8
+
+
+// Hacks to get the header to compile in compute
+#define SHADER_TARGET 50
+#define UNITY_PBS_USE_BRDF1
+#define fixed4 float4
+#include "UnityLightingCommon.cginc"
+#undef fixed4
+
+float3 EvalMaterial(UnityLight light, UnityIndirect ind);
+float3 EvalIndirectSpecular(UnityLight light, UnityIndirect ind);
+
+// uses the optimized single layered light list for opaques only
+
+#ifdef USE_FPTL_LIGHTLIST
+#define OPAQUES_ONLY
+#endif
+
+#include "TiledLightingTemplate.hlsl"
+#include "TiledReflectionTemplate.hlsl"
+
+UNITY_DECLARE_TEX2D_FLOAT(_CameraDepthTexture);
+Texture2D _CameraGBufferTexture0;
+Texture2D _CameraGBufferTexture1;
+Texture2D _CameraGBufferTexture2;
+Texture2D _CameraGBufferTexture3;
+
+RWTexture2D<float4> uavOutput : register(u0);
+
+struct v2f {
+	float4 vertex : SV_POSITION;
+	float2 texcoord : TEXCOORD0;
+};
+
+v2f vert(float4 vertex : POSITION, float2 texcoord : TEXCOORD0)
+{
+	v2f o;
+	o.vertex = UnityObjectToClipPos(vertex);
+	o.texcoord = texcoord.xy;
+	return o;
+}
+
+struct StandardData
+{
+	float3 specularColor;
+	float3 diffuseColor;
+	float3 normalWorld;
+	float smoothness;
+	float occlusion;
+	float3 emission;
+};
+
+struct LocalDataBRDF
+{
+	StandardData gbuf;
+
+	// extras
+	float oneMinusReflectivity;
+	float3 Vworld;
+};
+
+static LocalDataBRDF g_localParams;
+
+StandardData UnityStandardDataFromGbufferAux(float4 gbuffer0, float4 gbuffer1, float4 gbuffer2, float4 gbuffer3)
+{
+	StandardData data;
+
+	data.normalWorld = normalize(2 * gbuffer2.xyz - 1);
+	data.smoothness = gbuffer1.a;
+	data.diffuseColor = gbuffer0.xyz; data.specularColor = gbuffer1.xyz;
+	data.occlusion = gbuffer0.a;
+	data.emission = gbuffer3.xyz;
+	
+	return data;
+}
+
+half3 BRDF3_Direct2(half3 diffColor, half3 specColor, half rlPow4, half smoothness)
+{
+	half LUT_RANGE = 16.0; // must match range in NHxRoughness() function in GeneratedTextures.cpp
+						   // Lookup texture to save instructions
+	half specular = tex2Dlod(unity_NHxRoughness, half4(rlPow4, SmoothnessToPerceptualRoughness(smoothness), 0, 0)).UNITY_ATTEN_CHANNEL * LUT_RANGE;
+#if defined(_SPECULARHIGHLIGHTS_OFF)
+	specular = 0.0;
+#endif
+
+	return diffColor + specular * specColor;
+}
+
+
+float3 EvalMaterial(UnityLight light, UnityIndirect ind)
+{
+	StandardData data = g_localParams.gbuf;
+	return UNITY_BRDF_PBS(data.diffuseColor, data.specularColor, g_localParams.oneMinusReflectivity, data.smoothness, data.normalWorld, g_localParams.Vworld, light, ind);
+}
+
+float3 EvalIndirectSpecular(UnityLight light, UnityIndirect ind)
+{
+	StandardData data = g_localParams.gbuf;
+
+	return data.occlusion * UNITY_BRDF_PBS(0, data.specularColor, g_localParams.oneMinusReflectivity, data.smoothness, data.normalWorld, g_localParams.Vworld, light, ind).rgb;
+}
+
+[numthreads(TILE_SIZE, TILE_SIZE, 1)]
+void SHADE_DEFERRED_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
+{
+	uint2 pixCoord = dispatchThreadId;
+
+	float zbufDpth = FetchDepth(_CameraDepthTexture, pixCoord.xy).x;
+	float linDepth = GetLinearDepth(zbufDpth);
+
+	float3 vP = GetViewPosFromLinDepth(pixCoord, linDepth);
+	float3 vPw = mul(g_mViewToWorld, float4(vP, 1)).xyz;
+	float3 Vworld = normalize(mul((float3x3) g_mViewToWorld, -vP).xyz);     //unity_CameraToWorld
+
+	float4 gbuffer0 = _CameraGBufferTexture0.Load(uint3(pixCoord.xy, 0));
+	float4 gbuffer1 = _CameraGBufferTexture1.Load(uint3(pixCoord.xy, 0));
+	float4 gbuffer2 = _CameraGBufferTexture2.Load(uint3(pixCoord.xy, 0));
+	float4 gbuffer3 = _CameraGBufferTexture3.Load(uint3(pixCoord.xy, 0));
+
+	StandardData data = UnityStandardDataFromGbufferAux(gbuffer0, gbuffer1, gbuffer2, gbuffer3);
+
+	g_localParams.gbuf = data;
+	g_localParams.oneMinusReflectivity = 1.0 - SpecularStrength(data.specularColor.rgb);
+	g_localParams.Vworld = Vworld;
+
+	uint2 tileCoord = groupId >> 1;
+
+	uint numLightsProcessed = 0;
+	float3 c = data.emission + ExecuteLightList(numLightsProcessed, tileCoord, vP, vPw, Vworld);
+
+	uint numReflectionsProcessed = 0;
+	c += ExecuteReflectionList(numReflectionsProcessed, tileCoord, vP, data.normalWorld, Vworld, data.smoothness);
+
+#if ENABLE_DEBUG
+	c = OverlayHeatMap(pixCoord & 15, numLightsProcessed, c);
+#endif
+	
+	uavOutput[pixCoord] = float4(c, 1.0);
+}
+

Assets/ScriptableRenderLoop/fptl/Internal-DeferredReflections.shader

 #include "TiledReflectionTemplate.hlsl"
 
 
-Texture2D _CameraDepthTexture;
+Texture2D_float _CameraDepthTexture;
 Texture2D _CameraGBufferTexture0;
 Texture2D _CameraGBufferTexture1;
 Texture2D _CameraGBufferTexture2;

Assets/ScriptableRenderLoop/fptl/Internal-DeferredShading.shader

 #include "TiledLightingTemplate.hlsl"
 
 
-Texture2D _CameraDepthTexture;
+Texture2D_float _CameraDepthTexture;
 Texture2D _CameraGBufferTexture0;
 Texture2D _CameraGBufferTexture1;
 Texture2D _CameraGBufferTexture2;

Assets/ScriptableRenderLoop/fptl/LightBoundsDebug.shader

             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
-            #pragma target 5.0
+            #pragma target 4.5
         
             #include "UnityCG.cginc"
             #include "LightDefinitions.cs.hlsl"

Assets/ScriptableRenderLoop/fptl/StandardTest.shader

             ZWrite [_ZWrite]
 
             CGPROGRAM
-            #pragma target 5.0
+            #pragma target 4.5
 
             // -------------------------------------
 
 			ZWrite On ZTest LEqual
 
             CGPROGRAM
-            #pragma target 5.0
+            #pragma target 4.5
 
             // TODO: figure out what's needed here wrt. alpha test etc.
 
             ZWrite On ZTest LEqual
 
             CGPROGRAM
-            #pragma target 5.0
+            #pragma target 4.5
 
             // -------------------------------------
 

Assets/ScriptableRenderLoop/fptl/lightlistbuild-bigtile.compute

 	const int totNrEdgePairs = 12*nrFrustEdges;
 	for(int l=0; l<iNrCoarseLights; l++)
 	{
-		const int idxCoarse = lightsListLDS[l];
-		[branch]if(idxCoarse<(uint) g_iNrVisibLights && g_vLightData[idxCoarse].lightType!=SPHERE_LIGHT)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+		const uint idxCoarse = lightsListLDS[l];
+    
+		bool canEnter = idxCoarse<(uint) g_iNrVisibLights;
+		if(canEnter) canEnter = g_vLightData[idxCoarse].lightType!=SPHERE_LIGHT;		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+		[branch]if(canEnter)
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
 	

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

         m_Offset: {x: 0, y: 0}
     - _BaseColorMap:
         m_Texture: {fileID: 2800000, guid: 0353c00d9bc99f14780836a6a51a6d97, type: 3}
-        m_Scale: {x: 1, y: 1}
+        m_Scale: {x: 2, y: 2}
         m_Offset: {x: 0, y: 0}
     - _BumpMap:
         m_Texture: {fileID: 0}
     - _GlossMapScale: 1
     - _Glossiness: 0.5
     - _GlossyReflections: 1
-    - _HeightAmplitude: 0.09
+    - _HeightAmplitude: 0.17
     - _HeightCenter: 0.5
     - _MaterialId: 0
     - _Metallic: 0
     - _OcclusionStrength: 1
-    - _PPDMaxSamples: 64
+    - _PPDMaxSamples: 15
     - _PPDMinSamples: 1
     - _Parallax: 0.02
     - _Smoothness: 0.5

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

         m_Offset: {x: 0, y: 0}
     - _BaseColorMap:
         m_Texture: {fileID: 2800000, guid: 0353c00d9bc99f14780836a6a51a6d97, type: 3}
-        m_Scale: {x: 1, y: 1}
+        m_Scale: {x: 2, y: 2}
         m_Offset: {x: 0, y: 0}
     - _BumpMap:
         m_Texture: {fileID: 0}
     - _SubSurfaceRadius: 0
     - _SurfaceType: 0
     - _TessellationBackFaceCullEpsilon: -0.25
-    - _TessellationFactor: 10
+    - _TessellationFactor: 15
     - _TessellationFactorMaxDistance: 50
     - _TessellationFactorMinDistance: 20
     - _TessellationFactorTriangleSize: 100

ProjectSettings/GraphicsSettings.asset

   - {fileID: 15106, guid: 0000000000000000f000000000000000, type: 0}
   - {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0}
   - {fileID: 10782, guid: 0000000000000000f000000000000000, type: 0}
-  - {fileID: 4800000, guid: 36c23fe83f8e7a54d8fb168fa6cf2a3d, type: 3}
+  - {fileID: 4800000, guid: 595434cc3b6405246b6cd3086d0b6f7d, type: 3}
   - {fileID: 16000, guid: 0000000000000000f000000000000000, type: 0}
   - {fileID: 16001, guid: 0000000000000000f000000000000000, type: 0}
   m_PreloadedShaders: []

ProjectSettings/ProjectSettings.asset

   defaultScreenHeight: 768
   defaultScreenWidthWeb: 960
   defaultScreenHeightWeb: 600
+  m_StereoRenderingPath: 0
   m_ActiveColorSpace: 1
   m_MTRendering: 1
   m_MobileMTRendering: 0
   n3dsDisableStereoscopicView: 0
   n3dsEnableSharedListOpt: 1
   n3dsEnableVSync: 0
-  uiUse16BitDepthBuffer: 0
   ignoreAlphaClear: 0
   xboxOneResolution: 0
   xboxOneMonoLoggingLevel: 0
   metroInputSource: 0
   m_HolographicPauseOnTrackingLoss: 1
   xboxOneDisableKinectGpuReservation: 0
-  singlePassStereoRendering: 0
+  xboxOneEnable7thCore: 0
+  vrSettings:
+    cardboard:
+      depthFormat: 0
+      enableTransitionView: 0
+    daydream:
+      depthFormat: 0
+      useSustainedPerformanceMode: 0
+    hololens:
+      depthFormat: 1
+  useHDRDisplay: 0
-  AndroidMinSdkVersion: 9
+  AndroidMinSdkVersion: 16
+  AndroidTargetSdkVersion: 0
-  apiCompatibilityLevel: 2
   stripEngineCode: 1
   iPhoneStrippingLevel: 0
   iPhoneScriptCallOptimization: 0
     serializedVersion: 2
     m_Bits: 238
   iPhoneSdkVersion: 988
-  iOSTargetOSVersionString: 6.0
+  iOSTargetOSVersionString: 8.0
   tvOSSdkVersion: 0
   tvOSRequireExtendedGameController: 0
   tvOSTargetOSVersionString: 9.0
   tvOSSmallIconLayers: []
   tvOSLargeIconLayers: []
   tvOSTopShelfImageLayers: []
+  tvOSTopShelfImageWideLayers: []
   iOSLaunchScreenType: 0
   iOSLaunchScreenPortrait: {fileID: 0}
   iOSLaunchScreenLandscape: {fileID: 0}
   iOSURLSchemes: []
   iOSBackgroundModes: 0
   iOSMetalForceHardShadows: 0
+  metalEditorSupport: 1
+  metalAPIValidation: 1
+  iOSManualSigningProvisioningProfileID: 
+  tvOSManualSigningProvisioningProfileID: 
+  appleEnableAutomaticSigning: 0
   AndroidTargetDevice: 0
   AndroidSplashScreenScale: 0
   androidSplashScreen: {fileID: 0}
   - m_BuildTarget: Standalone
     m_StaticBatching: 0
     m_DynamicBatching: 0
+  - m_BuildTarget: iPhone
+    m_StaticBatching: 0
+    m_DynamicBatching: 0
-    m_APIs: 11000000
+    m_APIs: 1000000011000000
+    m_Automatic: 1
+  - m_BuildTarget: iOSSupport
+    m_APIs: 10000000
     m_Automatic: 0
   m_BuildTargetVRSettings:
   - m_BuildTarget: Android
   cameraUsageDescription: 
   locationUsageDescription: 
   microphoneUsageDescription: 
+  switchNetLibKey: 
+  switchSocketMemoryPoolSize: 6144
+  switchSocketAllocatorPoolSize: 128
+  switchSocketConcurrencyLimit: 14
+  switchUseCPUProfiler: 0
+  switchApplicationID: 0x0005000C10000001
+  switchNSODependencies: 
+  switchTitleNames_0: 
+  switchTitleNames_1: 
+  switchTitleNames_2: 
+  switchTitleNames_3: 
+  switchTitleNames_4: 
+  switchTitleNames_5: 
+  switchTitleNames_6: 
+  switchTitleNames_7: 
+  switchTitleNames_8: 
+  switchTitleNames_9: 
+  switchTitleNames_10: 
+  switchTitleNames_11: 
+  switchTitleNames_12: 
+  switchTitleNames_13: 
+  switchTitleNames_14: 
+  switchPublisherNames_0: 
+  switchPublisherNames_1: 
+  switchPublisherNames_2: 
+  switchPublisherNames_3: 
+  switchPublisherNames_4: 
+  switchPublisherNames_5: 
+  switchPublisherNames_6: 
+  switchPublisherNames_7: 
+  switchPublisherNames_8: 
+  switchPublisherNames_9: 
+  switchPublisherNames_10: 
+  switchPublisherNames_11: 
+  switchPublisherNames_12: 
+  switchPublisherNames_13: 
+  switchPublisherNames_14: 
+  switchIcons_0: {fileID: 0}
+  switchIcons_1: {fileID: 0}
+  switchIcons_2: {fileID: 0}
+  switchIcons_3: {fileID: 0}
+  switchIcons_4: {fileID: 0}
+  switchIcons_5: {fileID: 0}
+  switchIcons_6: {fileID: 0}
+  switchIcons_7: {fileID: 0}
+  switchIcons_8: {fileID: 0}
+  switchIcons_9: {fileID: 0}
+  switchIcons_10: {fileID: 0}
+  switchIcons_11: {fileID: 0}
+  switchIcons_12: {fileID: 0}
+  switchIcons_13: {fileID: 0}
+  switchIcons_14: {fileID: 0}
+  switchSmallIcons_0: {fileID: 0}
+  switchSmallIcons_1: {fileID: 0}
+  switchSmallIcons_2: {fileID: 0}
+  switchSmallIcons_3: {fileID: 0}
+  switchSmallIcons_4: {fileID: 0}
+  switchSmallIcons_5: {fileID: 0}
+  switchSmallIcons_6: {fileID: 0}
+  switchSmallIcons_7: {fileID: 0}
+  switchSmallIcons_8: {fileID: 0}
+  switchSmallIcons_9: {fileID: 0}
+  switchSmallIcons_10: {fileID: 0}
+  switchSmallIcons_11: {fileID: 0}
+  switchSmallIcons_12: {fileID: 0}
+  switchSmallIcons_13: {fileID: 0}
+  switchSmallIcons_14: {fileID: 0}
+  switchManualHTML: 
+  switchAccessibleURLs: 
+  switchLegalInformation: 
+  switchMainThreadStackSize: 1048576
+  switchPresenceGroupId: 0x0005000C10000001
+  switchLogoHandling: 0
+  switchReleaseVersion: 0
+  switchDisplayVersion: 1.0.0
+  switchStartupUserAccount: 0
+  switchTouchScreenUsage: 0
+  switchSupportedLanguagesMask: 0
+  switchLogoType: 0
+  switchApplicationErrorCodeCategory: 
+  switchUserAccountSaveDataSize: 0
+  switchUserAccountSaveDataJournalSize: 0
+  switchAttribute: 0
+  switchCardSpecSize: 4
+  switchCardSpecClock: 25
+  switchRatingsMask: 0
+  switchRatingsInt_0: 0
+  switchRatingsInt_1: 0
+  switchRatingsInt_2: 0
+  switchRatingsInt_3: 0
+  switchRatingsInt_4: 0
+  switchRatingsInt_5: 0
+  switchRatingsInt_6: 0
+  switchRatingsInt_7: 0
+  switchRatingsInt_8: 0
+  switchRatingsInt_9: 0
+  switchRatingsInt_10: 0
+  switchRatingsInt_11: 0
+  switchLocalCommunicationIds_0: 0x0005000C10000001
+  switchLocalCommunicationIds_1: 
+  switchLocalCommunicationIds_2: 
+  switchLocalCommunicationIds_3: 
+  switchLocalCommunicationIds_4: 
+  switchLocalCommunicationIds_5: 
+  switchLocalCommunicationIds_6: 
+  switchLocalCommunicationIds_7: 
+  switchParentalControl: 0
+  switchAllowsScreenshot: 1
+  switchDataLossConfirmation: 0
   XboxTitleId: 
   XboxImageXexPath: 
   XboxSpaPath: 
   ps4ParamSfxPath: 
   ps4VideoOutPixelFormat: 0
   ps4VideoOutInitialWidth: 1920
+  ps4VideoOutBaseModeInitialWidth: 1920
   ps4VideoOutReprojectionRate: 120
   ps4PronunciationXMLPath: 
   ps4PronunciationSIGPath: 
   ps4ApplicationParam4: 0
   ps4DownloadDataSize: 0
   ps4GarlicHeapSize: 2048
+  ps4ProGarlicHeapSize: 2560
   ps4Passcode: frAQBc8Wsa1xVPfvJcrgRYwTiizs2trQ
   ps4UseDebugIl2cppLibs: 0
   ps4pnSessions: 1
   ps4attribShareSupport: 0
   ps4attribExclusiveVR: 0
   ps4disableAutoHideSplash: 0
+  ps4videoRecordingFeaturesUsed: 0
+  ps4contentSearchFeaturesUsed: 0
+  ps4attribEyeToEyeDistanceSettingVR: 0
   ps4IncludedModules: []
   monoEnv: 
   psp2Splashimage: {fileID: 0}
   spritePackerPolicy: 
   webGLMemorySize: 256
   webGLExceptionSupport: 1
+  webGLNameFilesAsHashes: 0
   webGLDataCaching: 0
   webGLDebugSymbols: 0
   webGLEmscriptenArgs: 
   incrementalIl2cppBuild:
     iOS: 0
   additionalIl2CppArgs: 
+  apiCompatibilityLevelPerPlatform: {}
   m_RenderingPath: 1
   m_MobileRenderingPath: 1
   metroPackageName: dev
   XboxOneSplashScreen: {fileID: 0}
   XboxOneAllowedProductIds: []
   XboxOnePersistentLocalStorageSize: 0
-  vrEditorSettings: {}
+  xboxOneScriptCompiler: 0
+  vrEditorSettings:
+    daydream:
+      daydreamIconForeground: {fileID: 0}
+      daydreamIconBackground: {fileID: 0}
   cloudServicesEnabled:
     Analytics: 0
     Build: 0
     UNet: 0
     Unity_Ads: 0
   facebookSdkVersion: 7.8.2
+  apiCompatibilityLevel: 2
+  enableNewInputSystem: 0

ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 5.6.0b5
+m_EditorVersion: 5.6.0b6

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/ScriptableRenderLoop/ShaderLibrary/API/Metal.hlsl

+// This file assumes SHADER_API_METAL is defined
+// TODO: This is a straight copy from D3D11.hlsl. Go through all this stuff and adjust where needed.
+
+#define UNITY_UV_STARTS_AT_TOP 1
+#define UNITY_REVERSED_Z 1
+#define UNITY_NEAR_CLIP_VALUE (1.0)
+// This value will not go through any matrix projection convertion
+#define UNITY_RAW_FAR_CLIP_VALUE (0.0)
+#define FRONT_FACE_SEMATIC SV_IsFrontFace
+#define FRONT_FACE_TYPE bool
+#define IS_FRONT_VFACE(VAL, FRONT, BACK) ((VAL) ? (FRONT) : (BACK))
+
+#define CBUFFER_START(name) cbuffer name {
+#define CBUFFER_END };
+
+// Initialize arbitrary structure with zero values.
+// Do not exist on some platform, in this case we need to have a standard name that call a function that will initialize all parameters to 0
+#define ZERO_INITIALIZE(type, name) name = (type)0;
+
+// Texture util abstraction
+
+#define CALCULATE_TEXTURE2D_LOD(textureName, samplerName, coord2) textureName.CalculateLevelOfDetail(samplerName, coord2)
+
+// Texture abstraction
+
+#define TEXTURE2D(textureName) Texture2D textureName
+#define TEXTURE2D_ARRAY(textureName) Texture2DArray textureName
+#define TEXTURECUBE(textureName) TextureCube textureName
+#define TEXTURECUBE_ARRAY(textureName) TextureCubeArray textureName
+#define TEXTURE3D(textureName) Texture3D textureName
+
+#define SAMPLER2D(samplerName) SamplerState samplerName
+#define SAMPLERCUBE(samplerName) SamplerState samplerName
+#define SAMPLER3D(samplerName) SamplerState samplerName
+#define SAMPLER2D_SHADOW(samplerName) SamplerComparisonState samplerName
+#define SAMPLERCUBE_SHADOW(samplerName) SamplerComparisonState samplerName
+
+#define TEXTURE2D_ARGS(textureName, samplerName) Texture2D textureName, SamplerState samplerName
+#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerState samplerName
+#define TEXTURECUBE_ARGS(textureName, samplerName) TextureCube textureName, SamplerState samplerName
+#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName) TextureCubeArray textureName, SamplerState samplerName
+#define TEXTURE3D_ARGS(textureName, samplerName) Texture3D textureName, SamplerState samplerName
+#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName) Texture2D textureName, SamplerComparisonState samplerName
+#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerComparisonState samplerName
+#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName) TextureCube textureName, SamplerComparisonState samplerName
+
+#define TEXTURE2D_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURECUBE_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURE3D_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
+
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy) textureName.SampleGrad(samplerName, coord2, ddx, ddy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod) textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod) textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod) textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias) textureName.SampleBias(samplerName, float4(coord3, index), bias)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
+#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
+#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
+
+#define TEXTURE2D_HALF TEXTURE2D
+#define TEXTURE2D_FLOAT TEXTURE2D
+#define SAMPLER2D_HALF SAMPLER2D
+#define SAMPLER2D_FLOAT SAMPLER2D
+
+#define LOAD_TEXTURE2D(textureName, unCoord2) textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod) textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex) textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index) textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
+
+#define GATHER_TEXTURE2D(textureName, samplerName, coord2) textureName.Gather(samplerName, coord2)
+#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Gather(samplerName, float3(coord2, index))
+#define GATHER_TEXTURECUBE(textureName, samplerName, coord3) textureName.Gather(samplerName, coord3)
+#define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Gather(samplerName, float4(coord3, index))

Assets/ScriptableRenderLoop/ShaderLibrary/API/Metal.hlsl.meta

+fileFormatVersion: 2
+guid: f4d51e77f119d4dc8899ff02b46bb621
+timeCreated: 1484817807
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/HDRenderLoopTest.meta

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