HDREnderLoop: First draft of new layeredLit shader

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

 #ifdef PROCESS_PUNCTUAL_LIGHT
     uint punctualLightStart;
     uint punctualLightCount;
-    GetCountAndStart(coord, DIRECT_LIGHT, linearDepth, start, punctualLightCount);
+    GetCountAndStart(coord, DIRECT_LIGHT, linearDepth, punctualLightStart, punctualLightCount);
     for (i = 0; i < punctualLightCount; ++i)
     {
         float3 localDiffuseLighting, localSpecularLighting;
     // TODO: Area lights are where the sorting is important (Morten approach with while loop)
     uint areaLightStart;
     uint areaLightCount;
-    GetCountAndStart(coord, LightCatergory.AreaLight, linearDepth, start, punctualLightCount);
+    GetCountAndStart(coord, LightCatergory.AreaLight, linearDepth, areaLightStart, areaLightCount);
     for (i = 0; i < areaLightCount; ++i)
     {
         float3 localDiffuseLighting, localSpecularLighting;
 #ifdef PROCESS_ENV_LIGHT
     uint envLightStart;
     uint envLightCount;
-    GetCountAndStart(coord, REFLECTION_LIGHT, linearDepth, start, envLightCount);
+    GetCountAndStart(coord, REFLECTION_LIGHT, linearDepth, envLightStart, envLightCount);
 
     float3 iblDiffuseLighting = float3(0.0, 0.0, 0.0);
     float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
         float3 localDiffuseLighting, localSpecularLighting;
         float2 weight;
         context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
-        EvaluateBSDF_Env(context, V, positionWS, prelightData, _EnvLightList[FetchIndex(punctualLightStart, i)], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+        EvaluateBSDF_Env(context, V, positionWS, prelightData, _EnvLightList[FetchIndex(envLightStart, i)], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
         iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
         iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
     }

Assets/ScriptableRenderLoop/HDRenderLoop/Material/LayeredLit/LayeredLit.shader

         // They are use to fill a SurfaceData. With a MaterialGraph this should not exist.
 
         // Reminder. Color here are in linear but the UI (color picker) do the conversion sRGB to linear
-        _BaseColor0("BaseColor0", Color) = (1,1,1,1)
+        _BaseColor0("BaseColor0", Color) = (1, 1, 1, 1)
         _BaseColor1("BaseColor1", Color) = (1, 1, 1, 1)
         _BaseColor2("BaseColor2", Color) = (1, 1, 1, 1)
         _BaseColor3("BaseColor3", Color) = (1, 1, 1, 1)
 
         [Enum(Parallax, 0, Displacement, 1)] _HeightMapMode("Heightmap usage", Float) = 0
 
-        _EmissiveColor0("EmissiveColor0", Color) = (0, 0, 0)
-        _EmissiveColor1("EmissiveColor1", Color) = (0, 0, 0)
-        _EmissiveColor2("EmissiveColor2", Color) = (0, 0, 0)
-        _EmissiveColor3("EmissiveColor3", Color) = (0, 0, 0)
+        _DetailMap0("DetailMap0", 2D) = "black" {}
+        _DetailMap1("DetailMap1", 2D) = "black" {}
+        _DetailMap2("DetailMap2", 2D) = "black" {}
+        _DetailMap3("DetailMap3", 2D) = "black" {}
-        _EmissiveColorMap0("EmissiveColorMap0", 2D) = "white" {}
-        _EmissiveColorMap1("EmissiveColorMap1", 2D) = "white" {}
-        _EmissiveColorMap2("EmissiveColorMap2", 2D) = "white" {}
-        _EmissiveColorMap3("EmissiveColorMap3", 2D) = "white" {}
+        _DetailMask0("DetailMask0", 2D) = "white" {}
+        _DetailMask1("DetailMask1", 2D) = "white" {}
+        _DetailMask2("DetailMask2", 2D) = "white" {}
+        _DetailMask3("DetailMask3", 2D) = "white" {}
-        _EmissiveIntensity0("EmissiveIntensity0", Float) = 0
-        _EmissiveIntensity1("EmissiveIntensity1", Float) = 0
-        _EmissiveIntensity2("EmissiveIntensity2", Float) = 0
-        _EmissiveIntensity3("EmissiveIntensity3", Float) = 0
+        _DetailAlbedoScale0("_DetailAlbedoScale0", Range(-2.0, 2.0)) = 1
+        _DetailAlbedoScale1("_DetailAlbedoScale1", Range(-2.0, 2.0)) = 1
+        _DetailAlbedoScale2("_DetailAlbedoScale2", Range(-2.0, 2.0)) = 1
+        _DetailAlbedoScale3("_DetailAlbedoScale3", Range(-2.0, 2.0)) = 1
-        _LayerSize0("LayerSize0", Float) = 1.0
-        _LayerSize1("LayerSize1", Float) = 1.0
-        _LayerSize2("LayerSize2", Float) = 1.0
-        _LayerSize3("LayerSize3", Float) = 1.0
+        _DetailNormalScale0("_DetailNormalScale0", Range(0.0, 2.0)) = 1
+        _DetailNormalScale1("_DetailNormalScale1", Range(0.0, 2.0)) = 1
+        _DetailNormalScale2("_DetailNormalScale2", Range(0.0, 2.0)) = 1
+        _DetailNormalScale3("_DetailNormalScale3", Range(0.0, 2.0)) = 1
+        _DetailSmoothnessScale0("_DetailSmoothnessScale0", Range(-2.0, 2.0)) = 1
+        _DetailSmoothnessScale1("_DetailSmoothnessScale1", Range(-2.0, 2.0)) = 1
+        _DetailSmoothnessScale2("_DetailSmoothnessScale2", Range(-2.0, 2.0)) = 1
+        _DetailSmoothnessScale3("_DetailSmoothnessScale3", Range(-2.0, 2.0)) = 1
+
+        _DetailHeightScale0("_DetailHeightScale0", Range(-2.0, 2.0)) = 1
+        _DetailHeightScale1("_DetailHeightScale1", Range(-2.0, 2.0)) = 1
+        _DetailHeightScale2("_DetailHeightScale2", Range(-2.0, 2.0)) = 1
+        _DetailHeightScale3("_DetailHeightScale3", Range(-2.0, 2.0)) = 1
+
+        _DetailAOScale0("_DetailAOScale0", Range(-2.0, 2.0)) = 1
+        _DetailAOScale1("_DetailAOScale1", Range(-2.0, 2.0)) = 1
+        _DetailAOScale2("_DetailAOScale2", Range(-2.0, 2.0)) = 1
+        _DetailAOScale3("_DetailAOScale3", Range(-2.0, 2.0)) = 1
+
+        [Enum(UV0, 0, UV1, 1)] _UVDetail("UV Set for detailMap", Float) = 0
+
+        // Specific to planar mapping
+        _TexWorldScale0("TexWorldScale0", Float) = 1.0
+        _TexWorldScale1("TexWorldScale1", Float) = 1.0
+        _TexWorldScale2("TexWorldScale2", Float) = 1.0
+        _TexWorldScale3("TexWorldScale3", Float) = 1.0
+
+        // Blend mask between layer
+
+        _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
+        _EmissiveColorMap("EmissiveColorMap", 2D) = "white" {}
+        _EmissiveIntensity("EmissiveIntensity", Float) = 0
 
         [ToggleOff]     _DistortionOnly("Distortion Only", Float) = 0.0
         [ToggleOff]     _DistortionDepthTest("Distortion Only", Float) = 0.0
         [Enum(Mask Alpha, 0, BaseColor Alpha, 1)] _SmoothnessTextureChannel("Smoothness texture channel", Float) = 1
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
         [Enum(None, 0, DoubleSided, 1, DoubleSidedLigthingFlip, 2, DoubleSidedLigthingMirror, 3)] _DoubleSidedMode("Double sided mode", Float) = 0
-
-        //[Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping0("Layer 0 Mapping", Float) = 0
-        //[Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping1("Layer 1 Mapping", Float) = 0
-        //[Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping2("Layer 2 Mapping", Float) = 0
-        //[Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping3("Layer 3 Mapping", Float) = 0
+        [Enum(DetailMapNormal, 0, DetailMapAOHeight, 1)] _DetailMapMode("DetailMap mode", Float) = 0
-        [Enum(UV0, 0, UV1, 1, Planar, 2)] _LayerMapping0("Layer 0 Mapping", Float) = 0
-        [Enum(UV0, 0, UV1, 1, Planar, 2)] _LayerMapping1("Layer 1 Mapping", Float) = 0
-        [Enum(UV0, 0, UV1, 1, Planar, 2)] _LayerMapping2("Layer 2 Mapping", Float) = 0
-        [Enum(UV0, 0, UV1, 1, Planar, 2)] _LayerMapping3("Layer 3 Mapping", Float) = 0
+        [Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping0("Layer 0 Mapping", Float) = 0
+        [Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping1("Layer 1 Mapping", Float) = 0
+        [Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping2("Layer 2 Mapping", Float) = 0
+        [Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping3("Layer 3 Mapping", Float) = 0
+        // Following store the result of the enum above
+        _CoordWeight0("CoordWeight0", Color) = (1, 0, 0, 0)
+        _CoordWeight1("CoordWeight1", Color) = (1, 0, 0, 0)
+        _CoordWeight2("CoordWeight2", Color) = (1, 0, 0, 0)
+        _CoordWeight3("CoordWeight3", Color) = (1, 0, 0, 0)
     }
 
     HLSLINCLUDE
     #pragma shader_feature _EMISSIVE_COLOR_MAP
     #pragma shader_feature _HEIGHTMAP
     #pragma shader_feature _HEIGHTMAP_AS_DISPLACEMENT
-    #pragma shader_feature _LAYER_MASK_MAP
-    #pragma shader_feature _LAYER_MASK_VERTEX_COLOR
-    #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
-    #pragma shader_feature _ _LAYER_MAPPING_UV1_0 _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_TRIPLANAR_0
-    #pragma shader_feature _ _LAYER_MAPPING_UV1_1 _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_TRIPLANAR_1
-    #pragma shader_feature _ _LAYER_MAPPING_UV1_2 _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_TRIPLANAR_2
-    #pragma shader_feature _ _LAYER_MAPPING_UV1_3 _LAYER_MAPPING_PLANAR_3 _LAYER_MAPPING_TRIPLANAR_3
+    #pragma shader_feature _DETAIL_MAP
+    #pragma shader_feature _DETAIL_MAP_WITH_NORMAL
+    #pragma shader_feature _LAYER_MASK_MAP _LAYER_VERTEX_COLOR _LAYER_MASK_MAP_VERTEX_COLOR
+    #pragma shader_feature _LAYEREDLIT_2_LAYERS _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
+    #pragma shader_feature _ _LAYER_MAPPING_TRIPLANAR_0
+    #pragma shader_feature _ _LAYER_MAPPING_TRIPLANAR_1
+    #pragma shader_feature _ _LAYER_MAPPING_TRIPLANAR_2
+    #pragma shader_feature _ _LAYER_MAPPING_TRIPLANAR_3
+
+    #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+    #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+    #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
 
     //-------------------------------------------------------------------------------------
     // Define
     #   define _LAYER_COUNT 2
     #endif
 
-    struct LayerCoordinates
-    {
-        float2  texcoord[_MAX_LAYER];
-        bool    isTriplanar[_MAX_LAYER];
-    };
-    float4 SampleLayer(TEXTURE2D_ARGS(layerTex, layerSampler), LayerCoordinates layerCoord, int layerIndex)
-    {
-        if (layerCoord.isTriplanar[layerIndex])
-        {
-            // TODO 
-            return SAMPLE_TEXTURE2D(layerTex, layerSampler, layerCoord.texcoord[layerIndex]);
-        }
-        else
-        {
-            return SAMPLE_TEXTURE2D(layerTex, layerSampler, layerCoord.texcoord[layerIndex]);
-        }
-    }
 
     // Set of users variables
     #define PROP_DECL(type, name) type name, name##0, name##1, name##2, name##3;
     // Set of users variables
     PROP_DECL(float4, _BaseColor);
     PROP_DECL_TEX2D(_BaseColorMap);
+
+
+
+    PROP_DECL_TEX2D(_DetailMask);
+    PROP_DECL_TEX2D(_DetailMap);
+    PROP_DECL(float4, _DetailMap_ST);
+    PROP_DECL(float, _UVDetail);
+    PROP_DECL(float, _DetailAlbedoScale);
+    PROP_DECL(float, _DetailNormalScale);
+    PROP_DECL(float, _DetailSmoothnessScale);
+    PROP_DECL(float, _DetailHeightScale);
+    PROP_DECL(float, _DetailAOScale);
+
-    PROP_DECL(float3, _EmissiveColor);
-    PROP_DECL(float, _EmissiveIntensity);
-    PROP_DECL(float, _LayerSize);
+
+    TEXTURE2D(_DiffuseLightingMap);
+    SAMPLER2D(sampler_DiffuseLightingMap);
+
+    float3 _EmissiveColor;
+    TEXTURE2D(_EmissiveColorMap);
+    SAMPLER2D(sampler_EmissiveColorMap);
+
+    float _EmissiveIntensity;
+
+    PROP_DECL(float, _TexWorldScale);
+    PROP_DECL(float, _CoordWeight);
-    float _AlphaCutoff;
+
+    float _AlphaCutoff;
 
     ENDHLSL
 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Lit.shader

     TEXTURE2D(_AnisotropyMap);
     SAMPLER2D(sampler_AnisotropyMap);
 
-    TEXTURE2D(_DiffuseLightingMap);
-    SAMPLER2D(sampler_DiffuseLightingMap);
-
-    float3 _EmissiveColor;
-    TEXTURE2D(_EmissiveColorMap);
-    SAMPLER2D(sampler_EmissiveColorMap);
-
-    float _EmissiveIntensity;
-
     float _SubSurfaceRadius;
     TEXTURE2D(_SubSurfaceRadiusMap);
     SAMPLER2D(sampler_SubSurfaceRadiusMap);
     // float _CoatRoughness;
     //TEXTURE2D(_CoatRoughnessMap);
     //SAMPLER2D(sampler_CoatRoughnessMap);
+
+    TEXTURE2D(_DiffuseLightingMap);
+    SAMPLER2D(sampler_DiffuseLightingMap);
+
+    float3 _EmissiveColor;
+    TEXTURE2D(_EmissiveColorMap);
+    SAMPLER2D(sampler_EmissiveColorMap);
+
+    float _EmissiveIntensity;
  
     float _AlphaCutoff;
 

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

     return float3(oneMinusT, oneMinusT, oneMinusT) + b * t;
 }
 
-// Transforms 2D UV by scale/bias property
-#define TRANSFORM_TEX(tex,name) ((tex.xy) * name##_ST.xy + name##_ST.zw)
-
-
-#if !defined(LAYERED_LIT_SHADER)
-
-void GetSurfaceAndBuiltinData(FragInput input, out SurfaceData surfaceData, out BuiltinData builtinData)
+void GetBuiltinData(FragInput input, SurfaceData surfaceData, float alpha, out BuiltinData builtinData)
-#ifdef _HEIGHTMAP
-    // TODO: in case of shader graph, a node like parallax must be nullify if use to generate code for Meta pass
-    #ifndef _HEIGHTMAP_AS_DISPLACEMENT
-    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS); // This should be remove by the compiler as we usually cal it before.
-    float height = SAMPLE_TEXTURE2D(_HeightMap, sampler_HeightMap, input.texCoord0).r * _HeightScale + _HeightBias;
-    // Transform view vector in tangent space
-    float3 viewDirTS = TransformWorldToTangent(V, input.tangentToWorld);
-    float2 offset = ParallaxOffset(viewDirTS, height);
-    input.texCoord0 += offset;
-    input.texCoord1 += offset;
-    #endif
-#endif
-
-#ifdef _DETAIL_MAP
-    float2 texCoordDetail = TRANSFORM_TEX(_UVDetail ? input.texCoord1 : input.texCoord0, _DetailMap);
-    float detailMask = SAMPLE_TEXTURE2D(_DetailMask, sampler_DetailMask, input.texCoord0).b;
-    float4 detail = SAMPLE_TEXTURE2D(_DetailMap, sampler_DetailMap, texCoordDetail);
-    float detailAlbedo = detail.r;
-    float detailSmoothness = detail.b;
-    #ifdef _DETAIL_MAP_WITH_NORMAL
-    float3 detailNormalTS = UnpackNormalAG(detail, _DetailNormalScale);
-    //float detailAO = 0.0;
-    #else
-    // TODO: Use heightmap as a derivative with Morten Mikklesen approach
-    // Or reconstruct
-    float U = SAMPLE_TEXTURE2D(_DetailMap, sampler_DetailMap, texCoordDetail + float2(0.005, 0)).a;
-    float V = SAMPLE_TEXTURE2D(_DetailMap, sampler_DetailMap, texCoordDetail + float2(0, 0.005)).a;
-    float dHdU = U - detail.a;	//create bump map U offset
-    float dHdV = V - detail.a;	//create bump map V offset
-    //float3 detailNormal = 1 - float3(dHdU, dHdV, 0.05);	//create the tangent space normal
-    float3 detailNormalTS = float3(0.0, 0.0, 1.0);
-    //float3 detailNormal = UnpackNormalAG(unifiedDetail.r).a;
-    //float detailAO = detail.b;
-    #endif
-#endif
-
-    surfaceData.baseColor = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, input.texCoord0).rgb * _BaseColor.rgb;
-#ifdef _DETAIL_MAP
-    surfaceData.baseColor *= LerpWhiteTo(2.0 * saturate(detailAlbedo * _DetailAlbedoScale), detailMask);
-#endif
-
-#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    float alpha = _BaseColor.a;
-#else
-    float alpha = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, input.texCoord0).a * _BaseColor.a;
-#endif
-
-#ifdef _ALPHATEST_ON
-    clip(alpha - _AlphaCutoff);
-#endif
-
-#ifdef _SPECULAROCCLUSIONMAP
-    // TODO: Do something. For now just take alpha channel
-    surfaceData.specularOcclusion = SAMPLE_TEXTURE2D(_SpecularOcclusionMap, sampler_SpecularOcclusionMap, input.texCoord0).a;
-#else
-    // Horizon Occlusion for Normal Mapped Reflections: http://marmosetco.tumblr.com/post/81245981087
-    //surfaceData.specularOcclusion = saturate(1.0 + horizonFade * dot(r, input.tangentToWorld[2].xyz);
-    // smooth it
-    //surfaceData.specularOcclusion *= surfaceData.specularOcclusion;
-    surfaceData.specularOcclusion = 1.0;
-#endif
-
-    // TODO: think about using BC5
-    float3 vertexNormalWS = input.tangentToWorld[2].xyz;
-
-#ifdef _NORMALMAP
-    #ifdef _NORMALMAP_TANGENT_SPACE
-        float3 normalTS = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, input.texCoord0));
-        #ifdef _DETAIL_MAP
-        normalTS = lerp(normalTS, blendNormal(normalTS, detailNormalTS), detailMask);
-        #endif
-        surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
-    #else // Object space
-        float3 normalOS = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, input.texCoord0).rgb;
-        surfaceData.normalWS = TransformObjectToWorldDir(normalOS);
-        #ifdef _DETAIL_MAP
-        float3 detailNormalWS = TransformTangentToWorld(detailNormalTS, input.tangentToWorld);
-        surfaceData.normalWS = lerp(surfaceData.normalWS, blendNormal(surfaceData.normalWS, detailNormalWS), detailMask);
-        #endif
-    #endif
-#else
-    surfaceData.normalWS = vertexNormalWS;
-#endif
-
-#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
-    #ifdef _DOUBLESIDED_LIGHTING_FLIP
-    float3 oppositeNormalWS = -surfaceData.normalWS;
-    #else
-    // Mirror the normal with the plane define by vertex normal
-    float3 oppositeNormalWS = reflect(surfaceData.normalWS, vertexNormalWS);
-#endif
-    // TODO : Test if GetOdddNegativeScale() is necessary here in case of normal map, as GetOdddNegativeScale is take into account in CreateTangentToWorld();
-    surfaceData.normalWS =  input.isFrontFace ? 
-                                (GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS) :
-                                (-GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS);
-#endif
-
-#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    surfaceData.perceptualSmoothness = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, input.texCoord0).a;
-#elif defined(_MASKMAP)
-    surfaceData.perceptualSmoothness = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, input.texCoord0).a;
-#else
-    surfaceData.perceptualSmoothness = 1.0;
-#endif
-    surfaceData.perceptualSmoothness *= _Smoothness;
-#ifdef _DETAIL_MAP
-    surfaceData.perceptualSmoothness *= LerpWhiteTo(2.0 * saturate(detailSmoothness * _DetailSmoothnessScale), detailMask);
-#endif
-
-    surfaceData.materialId = 0;
-
-    // MaskMap is Metallic, Ambient Occlusion, (Optional) - emissive Mask, Optional - Smoothness (in alpha)
-#ifdef _MASKMAP
-    surfaceData.metallic = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, input.texCoord0).r;
-    surfaceData.ambientOcclusion = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, input.texCoord0).g;
-#else
-    surfaceData.metallic = 1.0;
-    surfaceData.ambientOcclusion = 1.0;
-#endif
-    surfaceData.metallic *= _Metallic;
-
-    // TODO: think about using BC5
-#ifdef _TANGENTMAP
-#ifdef _NORMALMAP_TANGENT_SPACE // Normal and tangent use same space
-    float3 tangentTS = UnpackNormalAG(SAMPLE_TEXTURE2D(_TangentMap, sampler_TangentMap, input.texCoord0));
-    surfaceData.tangentWS = TransformTangentToWorld(tangentTS, input.tangentToWorld);
-#else // Object space (TODO: We need to apply the world rotation here! - Require to pass world transform)
-    surfaceData.tangentWS = SAMPLE_TEXTURE2D(_TangentMap, sampler_TangentMap, input.texCoord0).rgb;
-#endif
-#else
-    surfaceData.tangentWS = input.tangentToWorld[0].xyz;
-#endif
-    // TODO: Is there anything todo regarding flip normal but for the tangent ?
-
-#ifdef _ANISOTROPYMAP
-    surfaceData.anisotropy = SAMPLE_TEXTURE2D(_AnisotropyMap, sampler_AnisotropyMap, input.texCoord0).g;
-#else
-    surfaceData.anisotropy = 1.0;
-#endif
-    surfaceData.anisotropy *= _Anisotropy;
-
-    surfaceData.specular = 0.04;
-
-    surfaceData.subSurfaceRadius = 1.0;
-    surfaceData.thickness = 0.0;
-    surfaceData.subSurfaceProfile = 0;
-
-    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
-    surfaceData.coatPerceptualSmoothness = 1.0;
-    surfaceData.specularColor = float3(0.0, 0.0, 0.0);
-
-
     // Builtin Data
     builtinData.opacity = alpha;
 
 
     // If we chose an emissive color, we have a dedicated texture for it and don't use MaskMap
 #ifdef _EMISSIVE_COLOR
-    #ifdef _EMISSIVE_COLOR_MAP
+#ifdef _EMISSIVE_COLOR_MAP
-    #else
+#else
-    #endif
+#endif
 #elif defined(_MASKMAP) // If we have a MaskMap, use emissive slot as a mask on baseColor
     builtinData.emissiveColor = surfaceData.baseColor * (SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, input.texCoord0).b * builtinData.emissiveIntensity).xxx;
 #else
     builtinData.distortionBlur = 0.0;
 }
 
-#else
+struct LayerUV
+{
+    float2 uv;
+    // triplanar
+    bool isTriplanar;
+    float2 uvYZ;
+    float2 uvZX;
+    float2 uvXY;
+};
+
+struct LayerTexCoord
+{
+    // Regular texcoord
+    LayerUV base0;
+    LayerUV base1;
+    LayerUV base2;
+    LayerUV base3;
+
+    LayerUV details0;
+    LayerUV details1;
+    LayerUV details2;
+    LayerUV details3;
+    float2 uvStaticLightmap;
+    float2 uvDynamicLightmap;
-float3 BlendLayeredColor(float3 rgb0, float3 rgb1, float3 rgb2, float3 rgb3, float weight[4])
+    // triplanar weight
+    float3 weights;
+};
+
+// Transforms 2D UV by scale/bias property
+#define TRANSFORM_TEX(tex,name) ((tex.xy) * name##_ST.xy + name##_ST.zw)
+
+float4 SampleLayer(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights)
-    float3 result = float3(0.0, 0.0, 0.0);
+    if (layerUV.isTriplanar)
+    {
+        float4 val = float4(0.0, 0.0, 0.0, 0.0);
-    result = rgb0 * weight[0] + rgb1 * weight[1];
-#if _LAYER_COUNT >= 3
-    result += (rgb2 * weight[2]);
-#endif
-#if _LAYER_COUNT >= 4
-    result += rgb3 * weight[3];
-#endif
+        if (weights.x > 0.0)
+        {
+            val += outCoord.blendWeights.x * SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ);
+        }
+        if (weights.y > 0.0)
+        {
+            val += outCoord.blendWeights.y * SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX);
+        }
+        if (weights.z > 0.0)
+        {
+            val += outCoord.blendWeights.z * SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY);
+        }
-    return result;
+        return val;
+    }
+    else
+    {
+        return SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv);
+    }
-float3 BlendLayeredNormal(float3 normal0, float3 normal1, float3 normal2, float3 normal3, float weight[4])
-{
-    float3 result = float3(0.0, 0.0, 0.0);
+#ifndef LAYERED_LIT_SHADER
-        // TODO : real normal map blending function
-        result = normal0 * weight[0] + normal1 * weight[1];
-#if _LAYER_COUNT >= 3
-    result += normal2 * weight[2];
-#endif
-#if _LAYER_COUNT >= 4
-    result += normal3 * weight[3];
-#endif
+#define SAMPLE_LAYER_TEXTURE2D(textureName, samplerName, coord) SampleLayer(TEXTURE2D_PASS(textureName, samplerName), coord, coord.weights);
-    return result;
-}
+#define SAMPLE_LAYER_DETAIL_TEXTURE2D
+#define ADD_IDX(Name) Name
+#include "LitSurfaceData.hlsl"
-float BlendLayeredScalar(float x0, float x1, float x2, float x3, float weight[4])
+void GetSurfaceAndBuiltinData(FragInput input, out SurfaceData surfaceData, out BuiltinData builtinData)
-    float result = 0.0;
+    bool isTriplanar = false;
+    LayerTexCoord layerTexCoord[_MAX_LAYER];
-    result = x0 * weight[0] + x1 * weight[1];
-#if _LAYER_COUNT >= 3
-    result += x2 * weight[2];
+
+    // one weight for each direction XYZ - Use vertex normal for triplanar
+    float3 triplanarBlendWeights = ComputeTriplanarWeights(input.tangentToWorld[2].xyz); // Will be remove if triplanar not used
+
+    // For each layer
+#if defined(_LAYER_MAPPING_TRIPLANAR_0)
+    isTriplanar = true;
+#else
+    isTriplanar = false;
-#if _LAYER_COUNT >= 4
-    result += x3 * weight[3];
-#endif
+    ComputeLayerTexCoord0(input, isTriplanar, texCoord.layerTexCoord[0]);
+    ApplyDisplacement0(input, texCoord.layerTexCoord[0]);
+    GetSurfaceData0(input, texCoord.layerTexCoord[0]);
+
+#if define _LAYEREDLIT_2_LAYERS
+        
+            
-    return result;
+        ComputeLayerTexCoord
+
+    float2 offset = GetHeigthData(input, surfaceData);
+    input.texCoord0 += offset;
+    input.texCoord1 += offset;
+    float alpha = GetSurfaceData(input, surfaceData);
+    GetBuiltinData(input, surfaceData, alpha, builtinData);
+
+#else
 
 void ComputeMaskWeights(float3 inputMasks, out float outWeights[_MAX_LAYER])
 {
     outWeights[0] = left;
 }
 
-float2 ComputePlanarXZCoord(float3 worldPos, float layerSize)
-{
-    return frac(worldPos.xz / layerSize);
-}
-void ComputeLayerCoordinates(out LayerCoordinates outCoord, FragInput input)
-{
-#if defined(_LAYER_MAPPING_UV1_0)
-    outCoord.texcoord[0] = input.texCoord1;
-    outCoord.isTriplanar[0] = false;
-#elif defined(_LAYER_MAPPING_PLANAR_0)
-    outCoord.texcoord[0] = ComputePlanarXZCoord(input.positionWS, _LayerSize0);
-    outCoord.isTriplanar[0] = false;
-#elif defined(_LAYER_MAPPING_TRIPLANAR_0)
-    outCoord.texcoord[0] = input.texCoord0;
-    outCoord.isTriplanar[0] = true;
-#else
-    outCoord.texcoord[0] = input.texCoord0;
-    outCoord.isTriplanar[0] = false;
-#endif
-
-#if defined(_LAYER_MAPPING_UV1_1)
-    outCoord.texcoord[1] = input.texCoord1;
-    outCoord.isTriplanar[1] = false;
-#elif defined(_LAYER_MAPPING_PLANAR_1)
-    outCoord.texcoord[1] = ComputePlanarXZCoord(input.positionWS, _LayerSize1);
-    outCoord.isTriplanar[1] = false;
-#elif defined(_LAYER_MAPPING_TRIPLANAR_1)
-    outCoord.texcoord[1] = input.texCoord0;
-    outCoord.isTriplanar[1] = true;
-#else
-    outCoord.texcoord[1] = input.texCoord0;
-    outCoord.isTriplanar[1] = false;
-#endif
-
-#if defined(_LAYER_MAPPING_UV1_2)
-    outCoord.texcoord[2] = input.texCoord1;
-    outCoord.isTriplanar[2] = false;
-#elif defined(_LAYER_MAPPING_PLANAR_2)
-    outCoord.texcoord[2] = ComputePlanarXZCoord(input.positionWS, _LayerSize2);
-    outCoord.isTriplanar[2] = false;
-#elif defined(_LAYER_MAPPING_TRIPLANAR_2)
-    outCoord.texcoord[2] = input.texCoord0;
-    outCoord.isTriplanar[2] = true;
-#else
-    outCoord.texcoord[2] = input.texCoord0;
-    outCoord.isTriplanar[2] = false;
-#endif
-
-#if defined(_LAYER_MAPPING_UV1_3)
-    outCoord.texcoord[3] = input.texCoord1;
-    outCoord.isTriplanar[3] = false;
-#elif defined(_LAYER_MAPPING_PLANAR_3)
-    outCoord.texcoord[3] = ComputePlanarXZCoord(input.positionWS, _LayerSize3);
-    outCoord.isTriplanar[3] = false;
-#elif defined(_LAYER_MAPPING_TRIPLANAR_3)
-    outCoord.texcoord[3] = input.texCoord0;
-    outCoord.isTriplanar[3] = true;
-#else
-    outCoord.texcoord[3] = input.texCoord0;
-    outCoord.isTriplanar[3] = false;
-#endif
-}
+#define SAMPLE_LAYER_TEXTURE2D(textureName, samplerName, coord2) SampleLayer(TEXTURE2D_ARGS(textureName##0, samplerName##0), LayerCoordinates layerCoord, 0)
+#include "LitSurfaceData.hlsl"
+    GetHeigthData0();
+
-    float3 maskValues = float3(0.0, 0.0, 0.0);
-
-#if defined(_LAYER_MASK_MAP)
-    maskValues = SAMPLE_TEXTURE2D(_LayerMaskMap, sampler_LayerMaskMap, input.texCoord0).rgb;
-#endif
+    float3 maskValues = float3(1.0, 1.0, 1.0);
-#if defined(_LAYER_MASK_VERTEX_COLOR)
-    maskValues = input.vertexColor.rgb;
+#if defined(_LAYER_MASK_MAP) || defined(_LAYER_MASK_MAP_VERTEX_COLOR)
+    maskValues *= SAMPLE_TEXTURE2D(_LayerMaskMap, sampler_LayerMaskMap, input.texCoord0).rgb;
-
-#if defined(_LAYER_MASK_MAP) && defined(_LAYER_MASK_VERTEX_COLOR)
-    maskValues = input.vertexColor.rgb * SAMPLE_TEXTURE2D(_LayerMaskMap, sampler_LayerMaskMap, input.texCoord0).rgb;
+#if defined(_LAYER_MASK_VERTEX_COLOR) || defined(_LAYER_MASK_MAP_VERTEX_COLOR)
+    maskValues *= input.vertexColor.rgb;
-    PROP_DECL(float3, baseColor);
-    PROP_SAMPLE(baseColor, _BaseColorMap, layerCoord, rgb);
-    PROP_MUL(baseColor, _BaseColor, rgb);
-    PROP_BLEND_COLOR(baseColor, weights);
+    SurfaceData surfaceData0;
+    SurfaceData surfaceData1;
+    SurfaceData surfaceData2;
+    SurfaceData surfaceData3;
-    surfaceData.baseColor = baseColor;
+    float alpha = GetSurfaceData0(input, surfaceData0);
+    GetBuiltinData(input, surfaceData, alpha, builtinData);
+}
-    PROP_DECL(float, alpha);
-#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    PROP_ASSIGN(alpha, _BaseColor, a);
-#else
-    PROP_SAMPLE(alpha, _BaseColorMap, layerCoord, a);
-    PROP_MUL(alpha, _BaseColor, a);
-#endif
-    PROP_BLEND_SCALAR(alpha, weights);
-#ifdef _ALPHATEST_ON
-    clip(alpha - _AlphaCutoff);
-#endif
+#if !defined(LAYERED_LIT_SHADER)
-    builtinData.opacity = alpha;
+float3 BlendLayeredColor(float3 rgb0, float3 rgb1, float3 rgb2, float3 rgb3, float weight[4])
+{
+    float3 result = float3(0.0, 0.0, 0.0);
-    PROP_DECL(float, specularOcclusion);
-#ifdef _SPECULAROCCLUSIONMAP
-    // TODO: Do something. For now just take alpha channel
-    PROP_SAMPLE(specularOcclusion, _SpecularOcclusionMap, layerCoord, a);
-#else
-    // Horizon Occlusion for Normal Mapped Reflections: http://marmosetco.tumblr.com/post/81245981087
-    //surfaceData.specularOcclusion = saturate(1.0 + horizonFade * dot(r, input.tangentToWorld[2].xyz);
-    // smooth it
-    //surfaceData.specularOcclusion *= surfaceData.specularOcclusion;
-    PROP_ASSIGN_VALUE(specularOcclusion, 1.0);
+    result = rgb0 * weight[0] + rgb1 * weight[1];
+#if _LAYER_COUNT >= 3
+    result += (rgb2 * weight[2]);
-    PROP_BLEND_SCALAR(specularOcclusion, weights);
-    surfaceData.specularOcclusion = specularOcclusion;
-
-    // TODO: think about using BC5
-    float3 vertexNormalWS = input.tangentToWorld[2].xyz;
-
-#ifdef _NORMALMAP
-    #ifdef _NORMALMAP_TANGENT_SPACE
-        float3 normalTS0 = UnpackNormalAG(SampleLayer(TEXTURE2D_PARAM(_NormalMap0, sampler_NormalMap0), layerCoord, 0));
-        float3 normalTS1 = UnpackNormalAG(SampleLayer(TEXTURE2D_PARAM(_NormalMap1, sampler_NormalMap0), layerCoord, 1));
-        float3 normalTS2 = UnpackNormalAG(SampleLayer(TEXTURE2D_PARAM(_NormalMap2, sampler_NormalMap0), layerCoord, 2));
-        float3 normalTS3 = UnpackNormalAG(SampleLayer(TEXTURE2D_PARAM(_NormalMap3, sampler_NormalMap0), layerCoord, 3));
-
-        float3 normalTS = BlendLayeredNormal(normalTS0, normalTS1, normalTS2, normalTS3, weights);
-
-        surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
-    #else // Object space (TODO: We need to apply the world rotation here!)
-        surfaceData.normalWS = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, input.texCoord0).rgb;
-    #endif
-#else
-        surfaceData.normalWS = vertexNormalWS;
+#if _LAYER_COUNT >= 4
+    result += rgb3 * weight[3];
-#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
-#ifdef _DOUBLESIDED_LIGHTING_FLIP
-    float3 oppositeNormalWS = -surfaceData.normalWS;
-#else
-    // Mirror the normal with the plane define by vertex normal
-    float3 oppositeNormalWS = reflect(surfaceData.normalWS, vertexNormalWS);
-#endif
-        // TODO : Test if GetOdddNegativeScale() is necessary here in case of normal map, as GetOdddNegativeScale is take into account in CreateTangentToWorld();
-        surfaceData.normalWS = IS_FRONT_VFACE(input.cullFace, GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS, -GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS);
-#endif
+    return result;
+}
+float3 BlendLayeredNormal(float3 normal0, float3 normal1, float3 normal2, float3 normal3, float weight[4])
+{
+    float3 result = float3(0.0, 0.0, 0.0);
-    PROP_DECL(float, perceptualSmoothness);
-#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    PROP_SAMPLE(perceptualSmoothness, _BaseColorMap, layerCoord, a);
-#elif defined(_MASKMAP)
-    PROP_SAMPLE(perceptualSmoothness, _MaskMap, layerCoord, a);
-#else
-    PROP_ASSIGN_VALUE(perceptualSmoothness, 1.0);
+        // TODO : real normal map blending function
+        result = normal0 * weight[0] + normal1 * weight[1];
+#if _LAYER_COUNT >= 3
+    result += normal2 * weight[2];
-    PROP_MUL(perceptualSmoothness, _Smoothness, r);
-    PROP_BLEND_SCALAR(perceptualSmoothness, weights);
-
-    surfaceData.perceptualSmoothness = perceptualSmoothness;
-
-    surfaceData.materialId = 0;
-
-    // MaskMap is Metallic, Ambient Occlusion, (Optional) - emissive Mask, Optional - Smoothness (in alpha)
-    PROP_DECL(float, metallic);
-    PROP_DECL(float, ambientOcclusion);
-#ifdef _MASKMAP
-    PROP_SAMPLE(metallic, _MaskMap, layerCoord, a);
-    PROP_SAMPLE(ambientOcclusion, _MaskMap, layerCoord, g);
-#else
-    PROP_ASSIGN_VALUE(metallic, 1.0);
-    PROP_ASSIGN_VALUE(ambientOcclusion, 1.0);
+#if _LAYER_COUNT >= 4
+    result += normal3 * weight[3];
-    PROP_MUL(metallic, _Metallic, r);
-    PROP_BLEND_SCALAR(metallic, weights);
-    PROP_BLEND_SCALAR(ambientOcclusion, weights);
-
-    surfaceData.metallic = metallic;
-    surfaceData.ambientOcclusion = ambientOcclusion;
-
-    surfaceData.tangentWS = float3(1.0, 0.0, 0.0);
-    surfaceData.anisotropy = 0;
-    surfaceData.specular = 0.04;
-
-    surfaceData.subSurfaceRadius = 1.0;
-    surfaceData.thickness = 0.0;
-    surfaceData.subSurfaceProfile = 0;
-
-    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
-    surfaceData.coatPerceptualSmoothness = 1.0;
-    surfaceData.specularColor = float3(0.0, 0.0, 0.0);
-
-    // Builtin Data
-
-    // TODO: Sample lightmap/lightprobe/volume proxy
-    // This should also handle projective lightmap
-    // Note that data input above can be use to sample into lightmap (like normal)
-    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionWS, surfaceData.normalWS, input.texCoord1, input.texCoord2);
+    return result;
+}
-    // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
-    PROP_DECL(float, emissiveIntensity);
-    PROP_ASSIGN(emissiveIntensity, _EmissiveIntensity, r);
-    PROP_BLEND_SCALAR(emissiveIntensity, weights);
-    builtinData.emissiveIntensity = emissiveIntensity; // We still store intensity here so we can reuse it with debug code
+float BlendLayeredScalar(float x0, float x1, float x2, float x3, float weight[4])
+{
+    float result = 0.0;
-    // If we chose an emissive color, we have a dedicated texture for it and don't use MaskMap
-    PROP_DECL(float3, emissiveColor);
-#ifdef _EMISSIVE_COLOR
-#ifdef _EMISSIVE_COLOR_MAP
-    PROP_SAMPLE(emissiveColor, _EmissiveColorMap, layerCoord, rgb);
-#else
-    PROP_ASSIGN(emissiveColor, _EmissiveColor, rgb);
+    result = x0 * weight[0] + x1 * weight[1];
+#if _LAYER_COUNT >= 3
+    result += x2 * weight[2];
-#elif defined(_MASKMAP) // If we have a MaskMap, use emissive slot as a mask on baseColor
-    PROP_SAMPLE(emissiveColor, _MaskMap, layerCoord, bbb);
-    PROP_MUL(emissiveColor, baseColor, rgb);
-#else
-    PROP_ASSIGN_VALUE(emissiveColor, float3(0.0, 0.0, 0.0));
+#if _LAYER_COUNT >= 4
+    result += x3 * weight[3];
-    PROP_BLEND_COLOR(emissiveColor, weights);
-    builtinData.emissiveColor = emissiveColor * builtinData.emissiveIntensity;
-    builtinData.velocity = CalculateVelocity(input.positionCS, input.previousPositionCS);
-
-    builtinData.distortion = float2(0.0, 0.0);
-    builtinData.distortionBlur = 0.0;
+    return result;
 }
 
 #endif

Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl

     return mul(GetObjectToWorldMatrix(), float4(positionOS, 1.0)).xyz;
 }
 
+float3 TransformWorldToObject(float3 positionWS)
+{
+    return mul(GetWorldToObjectMatrix(), float4(positionWS, 1.0)).xyz;
+}
+
 float3 TransformObjectToView(float3 positionOS)
 {
     return mul(GetObjectToWorldViewMatrix(), float4(positionOS, 1.0)).xyz;

Assets/ScriptableRenderLoop/ShaderLibrary/CommonMaterial.hlsl

     return normalize(float3(n1.xy * n2.z + n2.xy * n1.z, n1.z * n2.z));
 }
 
+// Ref: http://http.developer.nvidia.com/GPUGems3/gpugems3_ch01.html
+float3 ComputeTriplanarWeights(float3 normal)
+{ 
+    // Determine the blend weights for the 3 planar projections.  
+    // N_orig is the vertex-interpolated normal vector.  
+    float3 blendWeights = abs(normal);
+    // Tighten up the blending zone
+    blendWeights = (blendWeights - 0.2) * 7.0;
+    // Force weights to sum to 1.0 (very important!)  
+    blendWeights = max(blendWeights, float3(0.0, 0.0, 0.0));
+    blendWeights /= dot(blendWeights.x, 1.0);
+    return blendWeights;
+}
 
 #endif // UNITY_COMMON_MATERIAL_INCLUDED

ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 5.6.0a4
+m_EditorVersion: 5.6.0a5

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/LitSurfaceData.hlsl

+void ADD_IDX(ComputeLayerTexCoord)(FragInput input, int index, bool isTriplanar, out LayerTexCoord outLayerTexCoord)
+{
+    // Handle uv0, uv1 and plnar XZ coordinate based on _CoordWeight weight (exclusif 0..1)
+    ADD_IDX(layerTexCoord.base).uv =    ADD_IDX(_UVMappingMask).x * input.texCoord0 +
+                                        ADD_IDX(_UVMappingMask).y * input.texCoord1 + 
+                                        ADD_IDX(_UVMappingMask).z * input.positionWS.xz * ADD_IDX(_TexWorldScale);
+    float2 uvDetails =  ADD_IDX(_UVDetailsMappingMask).x * input.texCoord0 +
+                        ADD_IDX(_UVDetailsMappingMask).y * input.texCoord1;
+    ADD_IDX(layerTexCoord.details).uv = TRANSFORM_TEX(uvDetails, ADD_IDX(_DetailMap));
+
+    // triplanar
+    ADD_IDX(layerTexCoord.base).isTriplanar = isTriplanar;
+
+    // TODO: local or world triplanar
+    //float3 position = localTriplanar ? TransformWorldToObject(input.positionWS) : input.positionWS;
+    float3 position = input.positionWS;
+    position *= ADD_IDX(_TexWorldScale);
+
+    ADD_IDX(layerTexCoord.base).uvYZ = position.yz;
+    ADD_IDX(layerTexCoord.base).uvZX = position.xy;
+    ADD_IDX(layerTexCoord.base).uvXY = position.xz;
+
+    ADD_IDX(layerTexCoord.details).uvYZ = TRANSFORM_TEX(position.yz, ADD_IDX(_DetailMap));
+    ADD_IDX(layerTexCoord.details).uvZX = TRANSFORM_TEX(position.xy, ADD_IDX(_DetailMap));
+    ADD_IDX(layerTexCoord.details).uvXY = TRANSFORM_TEX(position.xz, ADD_IDX(_DetailMap));
+
+    layerTexCoord.uvStaticLightmap = input.texCoord1;
+    layerTexCoord.uvDynamicLightmap = input.texCoord2;
+}
+
+void ADD_IDX(ApplyDisplacement)(FragInput input, inout LayerTexCoord layerTexCoord)
+{
+#ifdef _HEIGHTMAP
+    // TODO: in case of shader graph, a node like parallax must be nullify if use to generate code for Meta pass
+    #ifndef _HEIGHTMAP_AS_DISPLACEMENT
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS); // This should be remove by the compiler as we usually cal it before.
+    float height = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_HeightMap), ADD_IDX(sampler_HeightMap), ADD_IDX(layerTexCoord.base)).r * ADD_IDX(_HeightScale) + ADD_IDX(_HeightBias);
+    // Transform view vector in tangent space
+    float3 viewDirTS = TransformWorldToTangent(V, input.tangentToWorld);
+    float2 offset = ParallaxOffset(viewDirTS, height);
+
+    ADD_IDX(layerTexCoord.base).uv += offset;
+    ADD_IDX(layerTexCoord.base).uvYZ += offset;
+    ADD_IDX(layerTexCoord.base).uvZX += offset;
+    ADD_IDX(layerTexCoord.base).uvXY += offset;
+
+    ADD_IDX(layerTexCoord.details).uv += offset;
+    ADD_IDX(layerTexCoord.details).uvYZ += offset;
+    ADD_IDX(layerTexCoord.details).uvZX += offset;
+    ADD_IDX(layerTexCoord.details).uvXY += offset;
+
+    if (LAYER_INDEX == 0)
+    {
+        layerTexCoord.uvStaticLightmap += offset;
+        layerTexCoord.uvDynamicLightmap += offset;
+    }
+    #endif
+#endif
+}
+
+// Return opacity
+float ADD_IDX(GetSurfaceData)(FragInput input, int index, inout LayerTexCoord layerTexCoord, out SurfaceData surfaceData)
+{
+#ifdef _DETAIL_MAP
+    float detailMask = SAMPLE_LAYER_TEXTURE2D(_DetailMask, sampler_DetailMask, layerTexCoord).b;
+    float4 detail = SAMPLE_LAYER_DETAIL_TEXTURE2D(_DetailMap, sampler_DetailMap, layerTexCoord);
+    float detailAlbedo = detail.r;
+    float detailSmoothness = detail.b;
+    #ifdef _DETAIL_MAP_WITH_NORMAL
+    float3 detailNormalTS = UnpackNormalAG(detail, _DetailNormalScale);
+    //float detailAO = 0.0;
+    #else
+    // TODO: Use heightmap as a derivative with Morten Mikklesen approach
+    // Or reconstruct
+    float U = SAMPLE_LAYER_TEXTURE2D(_DetailMap, sampler_DetailMap, texCoordDetail + float2(0.005, 0)).a;
+    float V = SAMPLE_LAYER_TEXTURE2D(_DetailMap, sampler_DetailMap, texCoordDetail + float2(0, 0.005)).a;
+    float dHdU = U - detail.a;	//create bump map U offset
+    float dHdV = V - detail.a;	//create bump map V offset
+    //float3 detailNormal = 1 - float3(dHdU, dHdV, 0.05);	//create the tangent space normal
+    float3 detailNormalTS = float3(0.0, 0.0, 1.0);
+    //float3 detailNormal = UnpackNormalAG(unifiedDetail.r).a;
+    //float detailAO = detail.b;
+    #endif
+#endif
+
+    surfaceData.baseColor = SAMPLE_LAYER_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, input.texCoord0).rgb * _BaseColor.rgb;
+#ifdef _DETAIL_MAP
+    surfaceData.baseColor *= LerpWhiteTo(2.0 * saturate(detailAlbedo * _DetailAlbedoScale), detailMask);
+#endif
+
+#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    float alpha = _BaseColor.a;
+#else
+    float alpha = SAMPLE_LAYER_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, input.texCoord0).a * _BaseColor.a;
+#endif
+
+#ifdef _ALPHATEST_ON
+    clip(alpha - _AlphaCutoff);
+#endif
+
+#ifdef _SPECULAROCCLUSIONMAP
+    // TODO: Do something. For now just take alpha channel
+    surfaceData.specularOcclusion = SAMPLE_LAYER_TEXTURE2D(_SpecularOcclusionMap, sampler_SpecularOcclusionMap, input.texCoord0).a;
+#else
+    // Horizon Occlusion for Normal Mapped Reflections: http://marmosetco.tumblr.com/post/81245981087
+    //surfaceData.specularOcclusion = saturate(1.0 + horizonFade * dot(r, input.tangentToWorld[2].xyz);
+    // smooth it
+    //surfaceData.specularOcclusion *= surfaceData.specularOcclusion;
+    surfaceData.specularOcclusion = 1.0;
+#endif
+
+    // TODO: think about using BC5
+    float3 vertexNormalWS = input.tangentToWorld[2].xyz;
+
+#ifdef _NORMALMAP
+    #ifdef _NORMALMAP_TANGENT_SPACE
+        float3 normalTS = UnpackNormalAG(SAMPLE_LAYER_TEXTURE2D(_NormalMap, sampler_NormalMap, input.texCoord0));
+        #ifdef _DETAIL_MAP
+        normalTS = lerp(normalTS, blendNormal(normalTS, detailNormalTS), detailMask);
+        #endif
+        surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
+    #else // Object space
+        float3 normalOS = SAMPLE_LAYER_TEXTURE2D(_NormalMap, sampler_NormalMap, input.texCoord0).rgb;
+        surfaceData.normalWS = TransformObjectToWorldDir(normalOS);
+        #ifdef _DETAIL_MAP
+        float3 detailNormalWS = TransformTangentToWorld(detailNormalTS, input.tangentToWorld);
+        surfaceData.normalWS = lerp(surfaceData.normalWS, blendNormal(surfaceData.normalWS, detailNormalWS), detailMask);
+        #endif
+    #endif
+#else
+    surfaceData.normalWS = vertexNormalWS;
+#endif
+
+#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
+    #ifdef _DOUBLESIDED_LIGHTING_FLIP
+    float3 oppositeNormalWS = -surfaceData.normalWS;
+    #else
+    // Mirror the normal with the plane define by vertex normal
+    float3 oppositeNormalWS = reflect(surfaceData.normalWS, vertexNormalWS);
+#endif
+    // TODO : Test if GetOdddNegativeScale() is necessary here in case of normal map, as GetOdddNegativeScale is take into account in CreateTangentToWorld();
+    surfaceData.normalWS =  input.isFrontFace ? 
+                                (GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS) :
+                                (-GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS);
+#endif
+
+#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    surfaceData.perceptualSmoothness = SAMPLE_LAYER_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, input.texCoord0).a;
+#elif defined(_MASKMAP)
+    surfaceData.perceptualSmoothness = SAMPLE_LAYER_TEXTURE2D(_MaskMap, sampler_MaskMap, input.texCoord0).a;
+#else
+    surfaceData.perceptualSmoothness = 1.0;
+#endif
+    surfaceData.perceptualSmoothness *= _Smoothness;
+#ifdef _DETAIL_MAP
+    surfaceData.perceptualSmoothness *= LerpWhiteTo(2.0 * saturate(detailSmoothness * _DetailSmoothnessScale), detailMask);
+#endif
+
+    surfaceData.materialId = 0;
+
+    // MaskMap is Metallic, Ambient Occlusion, (Optional) - emissive Mask, Optional - Smoothness (in alpha)
+#ifdef _MASKMAP
+    surfaceData.metallic = SAMPLE_LAYER_TEXTURE2D(_MaskMap, sampler_MaskMap, input.texCoord0).r;
+    surfaceData.ambientOcclusion = SAMPLE_LAYER_TEXTURE2D(_MaskMap, sampler_MaskMap, input.texCoord0).g;
+#else
+    surfaceData.metallic = 1.0;
+    surfaceData.ambientOcclusion = 1.0;
+#endif
+    surfaceData.metallic *= _Metallic;
+
+#if !defined(LAYERED_LIT_SHADER)
+
+    // TODO: think about using BC5
+#ifdef _TANGENTMAP
+#ifdef _NORMALMAP_TANGENT_SPACE // Normal and tangent use same space
+    float3 tangentTS = UnpackNormalAG(SAMPLE_TEXTURE2D(_TangentMap, sampler_TangentMap, input.texCoord0));
+    surfaceData.tangentWS = TransformTangentToWorld(tangentTS, input.tangentToWorld);
+#else // Object space (TODO: We need to apply the world rotation here! - Require to pass world transform)
+    surfaceData.tangentWS = SAMPLE_TEXTURE2D(_TangentMap, sampler_TangentMap, input.texCoord0).rgb;
+#endif
+#else
+    surfaceData.tangentWS = input.tangentToWorld[0].xyz;
+#endif
+    // TODO: Is there anything todo regarding flip normal but for the tangent ?
+
+#ifdef _ANISOTROPYMAP
+    surfaceData.anisotropy = SAMPLE_TEXTURE2D(_AnisotropyMap, sampler_AnisotropyMap, input.texCoord0).g;
+#else
+    surfaceData.anisotropy = 1.0;
+#endif
+    surfaceData.anisotropy *= _Anisotropy;
+
+    surfaceData.specular = 0.04;
+
+    surfaceData.subSurfaceRadius = 1.0;
+    surfaceData.thickness = 0.0;
+    surfaceData.subSurfaceProfile = 0;
+
+    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
+    surfaceData.coatPerceptualSmoothness = 1.0;
+    surfaceData.specularColor = float3(0.0, 0.0, 0.0);
+
+#else // #if !defined(LAYERED_LIT_SHADER)
+    surfaceData.tangentWS = input.tangentToWorld[0].xyz;
+#endif // #if !defined(LAYERED_LIT_SHADER)
+
+    return alpha;
+}
+

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/LitSurfaceData.hlsl.meta

+fileFormatVersion: 2
+guid: b24a503f5b489bb4896bc43d861f7f49
+timeCreated: 1479984801
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Chrome
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _MaterialId: 0
+    - _Metallic: 1
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 1
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _UVDetail: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Chrome.mat.meta

+fileFormatVersion: 2
+guid: e2a91f1184ed1c9429dc2c4385e3c6fe
+timeCreated: 1479808235
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: