Prepared LayeredLit shader to allow switching mapping mode for each layer. Added planar mapping.

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

 {
     internal class LayeredLitGUI : LitGUI
     {
+        public enum LayerMapping
+        {
+            UV0,
+            UV1,
+            Planar,
+            Triplanar,
+        }
+
         private class Styles
         {
             public readonly GUIContent[] materialLayerLabels =
             public readonly GUIContent emission = new GUIContent("Emissive");
             public readonly GUIContent layerMapMask = new GUIContent("Layer Mask", "Layer mask (multiplied by vertex color)");
             public readonly GUIContent layerCount = new GUIContent("Layer Count", "Number of layers.");
+            public readonly GUIContent layerSize = new GUIContent("Size", "Size of the layer mapping in world units.");
+            public readonly GUIContent layerMapping = new GUIContent("Mapping", "Mapping mode of the layer.");
         }
 
         static Styles s_Styles = null;
 
         private const int kMaxLayerCount = 4;
         private const int kSyncButtonWidth = 58;
-        private string kLayerMaskMap = "_LayerMaskMap";
-        private string kLayerCount = "_LayerCount";
+        private const string kLayerMaskMap = "_LayerMaskMap";
+        private const string kLayerCount = "_LayerCount";
+        private const string kLayerMapping = "_LayerMapping";
+        private const string kLayerSize = "_LayerSize";
+        MaterialProperty[] layerMappingProperty = new MaterialProperty[kMaxLayerCount];
+        MaterialProperty[] layerSizeProperty = new MaterialProperty[kMaxLayerCount];
 
         int layerCount
         {
             }
         }
 
-        bool LayersGUI(AssetImporter materialImporter)
+        bool DoLayerGUI(AssetImporter materialImporter, int layerIndex)
+        {
+            bool result = false;
+            EditorGUI.BeginChangeCheck();
+            m_MaterialLayers[layerIndex] = EditorGUILayout.ObjectField(styles.materialLayerLabels[layerIndex], m_MaterialLayers[layerIndex], typeof(Material), true) as Material;
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(materialImporter, "Change layer material");
+                SynchronizeLayerProperties(layerIndex);
+                result = true;
+            }
+
+            EditorGUI.BeginChangeCheck();
+            m_MaterialEditor.ShaderProperty(layerMappingProperty[layerIndex], styles.layerMapping);
+            if (EditorGUI.EndChangeCheck())
+            {
+                result = true;
+            }
+            m_MaterialEditor.ShaderProperty(layerSizeProperty[layerIndex], styles.layerSize);
+
+            return result;
+        }
+
+        bool DoLayersGUI(AssetImporter materialImporter)
         {
             Material material = m_MaterialEditor.target as Material;
 
 
             for (int i = 0; i < layerCount; i++)
             {
-                EditorGUI.BeginChangeCheck();
-                m_MaterialLayers[i] = EditorGUILayout.ObjectField(styles.materialLayerLabels[i], m_MaterialLayers[i], typeof(Material), true) as Material;
-                if (EditorGUI.EndChangeCheck())
-                {
-                    Undo.RecordObject(materialImporter, "Change layer material");
-                    SynchronizeLayerProperties(i);
-                    layerChanged = true;
-                }
+                layerChanged |= DoLayerGUI(materialImporter, i);
             }
 
             EditorGUILayout.Space();
                 SetKeyword(material, "_LAYEREDLIT_4_LAYERS", false);
                 SetKeyword(material, "_LAYEREDLIT_3_LAYERS", false);
             }
+
+            const string kLayerMappingUV1 = "_LAYER_MAPPING_UV1_";
+            const string kLayerMappingPlanar = "_LAYER_MAPPING_PLANAR_";
+            const string kLayerMappingTriplanar = "_LAYER_MAPPING_TRIPLANAR_";
+
+            for (int i = 0 ; i <layerCount ; ++i)
+            {
+                string layerMappingParam = string.Format("{0}{1}", kLayerMapping, i);
+                LayerMapping layerMapping = (LayerMapping)material.GetFloat(layerMappingParam);
+
+                string currentLayerMappingUV1 = string.Format("{0}{1}", kLayerMappingUV1, i);
+                string currentLayerMappingPlanar = string.Format("{0}{1}", kLayerMappingPlanar, i);
+                string currentLayerMappingTriplanar = string.Format("{0}{1}", kLayerMappingTriplanar, i);
+
+                if(layerMapping == LayerMapping.UV1)
+                {
+                    SetKeyword(material, currentLayerMappingUV1, true);
+                    SetKeyword(material, currentLayerMappingPlanar, false);
+                    SetKeyword(material, currentLayerMappingTriplanar, false);
+                }
+                else if(layerMapping == LayerMapping.Planar)
+                {
+                    SetKeyword(material, currentLayerMappingUV1, false);
+                    SetKeyword(material, currentLayerMappingPlanar, true);
+                    SetKeyword(material, currentLayerMappingTriplanar, false);
+                }
+                else if(layerMapping == LayerMapping.Triplanar)
+                {
+                    SetKeyword(material, currentLayerMappingUV1, false);
+                    SetKeyword(material, currentLayerMappingPlanar, false);
+                    SetKeyword(material, currentLayerMappingTriplanar, true);
+                }
+            }
-        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        private void FindLayerProperties(MaterialProperty[] props)
-            FindOptionProperties(props);
+            for (int i = 0; i < layerCount; ++i)
+            {
+                layerMappingProperty[i] = FindProperty(string.Format("{0}{1}", kLayerMapping, i), props);
+                layerSizeProperty[i] = FindProperty(string.Format("{0}{1}", kLayerSize, i), props);
+            }
+        }
+
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        {
+            FindOptionProperties(props);
+            FindLayerProperties(props);
 
             m_MaterialEditor = materialEditor;
 
                 optionsChanged = true;
             }
 
-            bool layerChanged = LayersGUI(materialImporter);
+            bool layerChanged = DoLayersGUI(materialImporter);
 
             CheckLayerConsistency();
 

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

         _EmissiveIntensity2("EmissiveIntensity2", Float) = 0
         _EmissiveIntensity3("EmissiveIntensity3", Float) = 0
 
+        _LayerSize0("LayerSize0", Float) = 1.0
+        _LayerSize1("LayerSize1", Float) = 1.0
+        _LayerSize2("LayerSize2", Float) = 1.0
+        _LayerSize3("LayerSize3", Float) = 1.0
+
         _LayerMaskMap("LayerMaskMap", 2D) = "white" {}
 
         [ToggleOff]     _DistortionOnly("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
     }
 
     HLSLINCLUDE
     #pragma shader_feature _HEIGHTMAP_AS_DISPLACEMENT
     #pragma shader_feature _LAYERMASKMAP
     #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
 
     //-------------------------------------------------------------------------------------
     // Define
     // variable declaration
     //-------------------------------------------------------------------------------------
 
+
+    #define _MAX_LAYER 4
+
+    #if defined(_LAYEREDLIT_4_LAYERS)
+    #   define _LAYER_COUNT 4
+    #elif defined(_LAYEREDLIT_3_LAYERS)
+    #   define _LAYER_COUNT 3
+    #else
+    #   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;
     #define PROP_DECL_TEX2D(name)\
         TEXTURE2D(name##2); \
         TEXTURE2D(name##3);
-    #define PROP_SAMPLE(name, textureName, texcoord, swizzle)\
-        name##0 = SAMPLE_TEXTURE2D(textureName##0, sampler##textureName##0, texcoord).##swizzle; \
-        name##1 = SAMPLE_TEXTURE2D(textureName##1, sampler##textureName##0, texcoord).##swizzle; \
-        name##2 = SAMPLE_TEXTURE2D(textureName##2, sampler##textureName##0, texcoord).##swizzle; \
-        name##3 = SAMPLE_TEXTURE2D(textureName##3, sampler##textureName##0, texcoord).##swizzle;
+    #define PROP_SAMPLE(name, textureName, layerCoord, swizzle)\
+        name##0 = SampleLayer(TEXTURE2D_PARAM(textureName##0, sampler##textureName##0), layerCoord, 0).##swizzle; \
+        name##1 = SampleLayer(TEXTURE2D_PARAM(textureName##1, sampler##textureName##0), layerCoord, 1).##swizzle; \
+        name##2 = SampleLayer(TEXTURE2D_PARAM(textureName##2, sampler##textureName##0), layerCoord, 2).##swizzle; \
+        name##3 = SampleLayer(TEXTURE2D_PARAM(textureName##3, sampler##textureName##0), layerCoord, 3).##swizzle;
     #define PROP_MUL(name, multiplier, swizzle)\
         name##0 *= multiplier##0.##swizzle; \
         name##1 *= multiplier##1.##swizzle; \
     #define PROP_BLEND_COLOR(name, mask) name = BlendLayeredColor(name##0, name##1, name##2, name##3, mask);
     #define PROP_BLEND_SCALAR(name, mask) name = BlendLayeredScalar(name##0, name##1, name##2, name##3, mask);
 
-    #define _MAX_LAYER 4
-
-    #if defined(_LAYEREDLIT_4_LAYERS)
-    #   define _LAYER_COUNT 4
-    #elif defined(_LAYEREDLIT_3_LAYERS)
-    #   define _LAYER_COUNT 3
-    #else
-    #   define _LAYER_COUNT 2
-    #endif
-
     //-------------------------------------------------------------------------------------
     // variable declaration
     //-------------------------------------------------------------------------------------
     PROP_DECL(float, _HeightBias);
     PROP_DECL(float3, _EmissiveColor);
     PROP_DECL(float, _EmissiveIntensity);
+    PROP_DECL(float, _LayerSize);
 
     float _AlphaCutoff;
     TEXTURE2D(_LayerMaskMap);

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

 #if !defined(LAYERED_LIT_SHADER)
 
 void GetSurfaceAndBuiltinData(FragInput input, out SurfaceData surfaceData, 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
     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
+}
+    LayerCoordinates layerCoord;
+    ComputeLayerCoordinates(layerCoord, input);
+
     // Mask Values : Layer 1, 2, 3 are r, g, b
     float3 maskValues = float3(0.0, 0.0, 0.0);// input.vertexColor;
 
     ComputeMaskWeights(maskValues, weights);
 
     PROP_DECL(float3, baseColor);
-    PROP_SAMPLE(baseColor, _BaseColorMap, input.texCoord0, rgb);
+    PROP_SAMPLE(baseColor, _BaseColorMap, layerCoord, rgb);
     PROP_MUL(baseColor, _BaseColor, rgb);
     PROP_BLEND_COLOR(baseColor, weights);
 
 #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     PROP_ASSIGN(alpha, _BaseColor, a);
 #else
-    PROP_SAMPLE(alpha, _BaseColorMap, input.texCoord0, a);
+    PROP_SAMPLE(alpha, _BaseColorMap, layerCoord, a);
     PROP_MUL(alpha, _BaseColor, a);
 #endif
     PROP_BLEND_SCALAR(alpha, weights);
     PROP_DECL(float, specularOcclusion);
 #ifdef _SPECULAROCCLUSIONMAP
     // TODO: Do something. For now just take alpha channel
-    PROP_SAMPLE(specularOcclusion, _SpecularOcclusionMap, input.texCoord0, a);
+    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);
 
 #ifdef _NORMALMAP
     #ifdef _NORMALMAP_TANGENT_SPACE
-        float3 normalTS0 = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap0, sampler_NormalMap0, input.texCoord0));
-        float3 normalTS1 = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap1, sampler_NormalMap0, input.texCoord0));
-        float3 normalTS2 = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap2, sampler_NormalMap0, input.texCoord0));
-        float3 normalTS3 = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap3, sampler_NormalMap0, input.texCoord0));
+        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);
 
 
     PROP_DECL(float, perceptualSmoothness);
 #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    PROP_SAMPLE(perceptualSmoothness, _BaseColorMap, input.texCoord0, a);
+    PROP_SAMPLE(perceptualSmoothness, _BaseColorMap, layerCoord, a);
-    PROP_SAMPLE(perceptualSmoothness, _MaskMap, input.texCoord0, a);
+    PROP_SAMPLE(perceptualSmoothness, _MaskMap, layerCoord, a);
 #else
     PROP_ASSIGN_VALUE(perceptualSmoothness, 1.0);
 #endif
     PROP_DECL(float, metallic);
     PROP_DECL(float, ambientOcclusion);
 #ifdef _MASKMAP
-    PROP_SAMPLE(metallic, _MaskMap, input.texCoord0, a);
-    PROP_SAMPLE(ambientOcclusion, _MaskMap, input.texCoord0, g);
+    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);
     PROP_DECL(float3, emissiveColor);
 #ifdef _EMISSIVE_COLOR
 #ifdef _EMISSIVE_COLOR_MAP
-    PROP_SAMPLE(emissiveColor, _EmissiveColorMap, input.texCoord0, rgb);
+    PROP_SAMPLE(emissiveColor, _EmissiveColorMap, layerCoord, rgb);
-    PROP_SAMPLE(emissiveColor, _MaskMap, input.texCoord0, bbb);
+    PROP_SAMPLE(emissiveColor, _MaskMap, layerCoord, bbb);
     PROP_MUL(emissiveColor, baseColor, rgb);
 #else
     PROP_ASSIGN_VALUE(emissiveColor, float3(0.0, 0.0, 0.0));

Assets/TestScenes/HDTest/JulienTest.unity

   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &124873435
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &399229769
 MeshCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &1181847331
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1192842091
 SphereCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &1197900222
 MeshCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &1237103363
 MeshCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &1317825229
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &1330031311
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &1438296046
 MeshCollider:
   serializedVersion: 7
   m_Type: 1
   m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
-  m_Intensity: 1
+  m_Intensity: 10
   m_Range: 10
   m_SpotAngle: 30
   m_CookieSize: 10
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1893534342
 SphereCollider:

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

   m_Name: Layered
   m_Shader: {fileID: 4800000, guid: 81d02e8644315b742b154842a3a2f98c, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS _LAYERMASKMAP _MASKMAP _NORMALMAP
-    _NORMALMAP_TANGENT_SPACE
+    _EMISSION _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS _LAYERMASKMAP _LAYER_MAPPING_PLANAR0
+    _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_UV1_2 _MASKMAP
+    _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_CustomRenderQueue: -1
   stringTagMap: {}
     - _HeightScale2: 1
     - _HeightScale3: 1
     - _LayerCount: 4
+    - _LayerMapping0: 2
+    - _LayerMapping1: 2
+    - _LayerMapping2: 1
+    - _LayerMapping3: 0
+    - _LayerSize0: 4
+    - _LayerSize1: 4
+    - _LayerSize2: 1
+    - _LayerSize3: 1
+    - _LayerTiling0: 10
+    - _LayerTiling1: 10
+    - _LayerTiling2: 1
+    - _LayerTiling3: 1
     - _MaterialId: 0
     - _Metalic: 0
     - _Metalic0: 0
     - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
     - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
     - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
-    - _BaseColor3: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor3: {r: 1, g: 0, b: 0, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}