HDRenderLoop: Add UV2 control

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

         {
             UV0,
             UV1,
+            UV2,
             UV3,
             Planar,
             Triplanar,
             SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR", material.GetFloat(kLayerMaskVertexColor) != 0.0f);
 
 			// We have to check for each layer if the UV3 is needed.
+            SetKeyword(material, "_REQUIRE_UV2", false);
 			SetKeyword(material, "_REQUIRE_UV3", false);
 			for (int layer = 0; layer < numLayer; ++layer)
 			{
 				if (
+					 ((UVDetailMapping)material.GetFloat(uvDetail) == UVDetailMapping.UV2) ||
+					 ((LayerUVBaseMapping)material.GetFloat(uvBase) == LayerUVBaseMapping.UV2)
+					)
+				{
+					SetKeyword(material, "_REQUIRE_UV2", true);
+					break;
+				}
+
+				if (
 					 ((UVDetailMapping)material.GetFloat(uvDetail) == UVDetailMapping.UV3) ||
 					 ((LayerUVBaseMapping)material.GetFloat(uvBase) == LayerUVBaseMapping.UV3)
 					)
                 SetKeyword(material, "_LAYEREDLIT_3_LAYERS", false);
             }
 
+            const string kLayerMappingPlanar = "_LAYER_MAPPING_PLANAR_";
             const string kLayerMappingTriplanar = "_LAYER_MAPPING_TRIPLANAR_";
 
             for (int i = 0 ; i < numLayer; ++i)
                 LayerUVBaseMapping layerUVBaseMapping = (LayerUVBaseMapping)material.GetFloat(layerUVBaseParam);
                 string layerUVDetailParam = string.Format("{0}{1}", kUVDetail, i);
                 UVDetailMapping layerUVDetailMapping = (UVDetailMapping)material.GetFloat(layerUVDetailParam);
-                string currentLayerMappingTriplanar = string.Format("{0}{1}", kLayerMappingTriplanar, i);
+                string currentLayerMappingPlanar = string.Format("{0}{1}", kLayerMappingPlanar, i);
+                string currentLayerMappingTriplanar = string.Format("{0}{1}", kLayerMappingTriplanar, i);                
-                Z = (layerUVBaseMapping == LayerUVBaseMapping.UV3) ? 1.0f : 0.0f;
-                W = (layerUVBaseMapping == LayerUVBaseMapping.Planar) ? 1.0f : 0.0f;
+                Z = (layerUVBaseMapping == LayerUVBaseMapping.UV2) ? 1.0f : 0.0f;
+                W = (layerUVBaseMapping == LayerUVBaseMapping.UV3) ? 1.0f : 0.0f;
+                SetKeyword(material, currentLayerMappingPlanar, layerUVBaseMapping == LayerUVBaseMapping.Planar);
-                // If base is planar mode, detail is planar too
-                if (W > 0.0f)
-                {
-                    X = Y = Z = 0.0f;
-                }
-                else
-                {
-                    X = (layerUVDetailMapping == UVDetailMapping.UV0) ? 1.0f : 0.0f;
-                    Y = (layerUVDetailMapping == UVDetailMapping.UV1) ? 1.0f : 0.0f;
-                    Z = (layerUVDetailMapping == UVDetailMapping.UV3) ? 1.0f : 0.0f;
-                }
-                layerUVDetailsMappingMask[i].colorValue = new Color(X, Y, Z, 0.0f); // W Reuse planar mode from base
+                X = (layerUVDetailMapping == UVDetailMapping.UV0) ? 1.0f : 0.0f;
+                Y = (layerUVDetailMapping == UVDetailMapping.UV1) ? 1.0f : 0.0f;
+                Z = (layerUVDetailMapping == UVDetailMapping.UV2) ? 1.0f : 0.0f;
+                W = (layerUVDetailMapping == UVDetailMapping.UV3) ? 1.0f : 0.0f;
+                layerUVDetailsMappingMask[i].colorValue = new Color(X, Y, Z, W);
             }
         }
 

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

         _TexWorldScale2("Tiling", Float) = 1.0
         _TexWorldScale3("Tiling", Float) = 1.0
 
-        [Enum(UV0, 0, UV1, 1, UV3, 2, Planar, 3, Triplanar, 4)] _UVBase0("UV Set for base0", Float) = 0
-        [Enum(UV0, 0, UV1, 1, UV3, 2, Planar, 3, Triplanar, 4)] _UVBase1("UV Set for base1", Float) = 0
-        [Enum(UV0, 0, UV1, 1, UV3, 2, Planar, 3, Triplanar, 4)] _UVBase2("UV Set for base2", Float) = 0
-        [Enum(UV0, 0, UV1, 1, UV3, 2, Planar, 3, Triplanar, 4)] _UVBase3("UV Set for base3", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVBase0("UV Set for base0", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVBase1("UV Set for base1", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVBase2("UV Set for base2", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVBase3("UV Set for base3", Float) = 0
 
         [HideInInspector] _UVMappingMask0("_UVMappingMask0", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVMappingMask1("_UVMappingMask1", Color) = (1, 0, 0, 0)
-        [Enum(UV0, 0, UV1, 1, UV3, 2)] _UVDetail0("UV Set for detail0", Float) = 0
-        [Enum(UV0, 0, UV1, 1, UV3, 2)] _UVDetail1("UV Set for detail1", Float) = 0
-        [Enum(UV0, 0, UV1, 1, UV3, 2)] _UVDetail2("UV Set for detail2", Float) = 0
-        [Enum(UV0, 0, UV1, 1, UV3, 2)] _UVDetail3("UV Set for detail3", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail0("UV Set for detail0", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail1("UV Set for detail1", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail2("UV Set for detail2", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail3("UV Set for detail3", Float) = 0
 
         [HideInInspector] _UVDetailsMappingMask0("_UVDetailsMappingMask0", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVDetailsMappingMask1("_UVDetailsMappingMask1", Color) = (1, 0, 0, 0)
     #pragma shader_feature _ _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
 
     #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    #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 shader_feature _ _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_TRIPLANAR_0
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_TRIPLANAR_1
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_TRIPLANAR_2
+    #pragma shader_feature _ _LAYER_MAPPING_PLANAR_3 _LAYER_MAPPING_TRIPLANAR_3
+    #pragma shader_feature _REQUIRE_UV2
     #pragma shader_feature _REQUIRE_UV3
     #pragma shader_feature _EMISSIVE_COLOR
 

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

         {
             UV0,
             UV1,
+            UV2,
             UV3
         }
 
 
             float X, Y, Z, W;
             X = ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.UV0) ? 1.0f : 0.0f;
-            W = ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Planar) ? 1.0f : 0.0f;
-            UVMappingMask.colorValue = new Color(X, 0.0f, 0.0f, W);
+            UVMappingMask.colorValue = new Color(X, 0.0f, 0.0f, 0.0f);
             if (((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Planar) || ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Triplanar))
             {
                 EditorGUI.indentLevel++;
                 m_MaterialEditor.ShaderProperty(UVDetail, Styles.UVDetailMappingText.text);
             }
 
-            // If base is planar mode, detail is planar too
-            if (W > 0.0f)
-            {
-                X = Y = Z = 0.0f;
-            }
-            else
-            {
-                X = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV0) ? 1.0f : 0.0f;
-                Y = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV1) ? 1.0f : 0.0f;
-                Z = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV3) ? 1.0f : 0.0f;
-            }
-            UVDetailsMappingMask.colorValue = new Color(X, Y, Z, 0.0f); // W Reuse planar mode from base
+            X = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV0) ? 1.0f : 0.0f;
+            Y = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV1) ? 1.0f : 0.0f;
+            Z = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV2) ? 1.0f : 0.0f;
+            W = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV3) ? 1.0f : 0.0f;
+            UVDetailsMappingMask.colorValue = new Color(X, Y, Z, W);
 
             m_MaterialEditor.ShaderProperty(detailMapMode, Styles.detailMapModeText.text);
             m_MaterialEditor.ShaderProperty(normalMapSpace, Styles.normalMapSpaceText.text);
             // Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation
             // (MaterialProperty value might come from renderer material property block)
             SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", ((SmoothnessMapChannel)material.GetFloat(kSmoothnessTextureChannel)) == SmoothnessMapChannel.AlbedoAlpha);
+            SetKeyword(material, "_MAPPING_PLANAR", ((UVBaseMapping)material.GetFloat(kUVBase)) == UVBaseMapping.Planar);
             SetKeyword(material, "_MAPPING_TRIPLANAR", ((UVBaseMapping)material.GetFloat(kUVBase)) == UVBaseMapping.Triplanar);
             SetKeyword(material, "_NORMALMAP_TANGENT_SPACE", ((NormalMapSpace)material.GetFloat(kNormalMapSpace)) == NormalMapSpace.TangentSpace);
             SetKeyword(material, "_HEIGHTMAP_AS_DISPLACEMENT", ((HeightmapMode)material.GetFloat(kHeightMapMode)) == HeightmapMode.Displacement);
 			SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));
 			SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
 
+            SetKeyword(material, "_REQUIRE_UV2", ((UVDetailMapping)material.GetFloat(kUVDetail)) == UVDetailMapping.UV2 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0);
-
         }
     }
 } // namespace UnityEditor

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

         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
         [Enum(Parallax, 0, Displacement, 1)] _HeightMapMode("Heightmap usage", Float) = 0
         [Enum(DetailMapNormal, 0, DetailMapAOHeight, 1)] _DetailMapMode("DetailMap mode", Float) = 0
-        [Enum(UV0, 0, UV1, 1,  UV3, 2)] _UVDetail("UV Set for detail", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail("UV Set for detail", Float) = 0
         [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1,0,0,0)
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
     }
     #pragma shader_feature _ _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
 
     #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    #pragma shader_feature _MAPPING_TRIPLANAR
+    #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR    
-    #pragma shader_feature _HEIGHTMAP_AS_DISPLACEMENT
+    #pragma shader_feature _HEIGHTMAP_AS_DISPLACEMENT    
+    #pragma shader_feature _REQUIRE_UV2
     #pragma shader_feature _REQUIRE_UV3
     #pragma shader_feature _EMISSIVE_COLOR
 

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

     layerTexCoord.weights = ComputeTriplanarWeights(input.tangentToWorld[2].xyz);
 #endif
 
-    // Be sure that the compiler is aware that we don't touch UV1 and UV3 for base layer in case of non layer shader
+    // Be sure that the compiler is aware that we don't touch UV1 to UV3 for base layer in case of non layer shader
-    _UVMappingMask.yz = float2(0.0, 0.0);
+    _UVMappingMask.yzw = float3(0.0, 0.0, 0.0);
+    bool isPlanar = false;
+#elif defined(_MAPPING_PLANAR)
+    isPlanar = true;
-    ComputeLayerTexCoord(input, isTriplanar, layerTexCoord);
+    ComputeLayerTexCoord(input, isPlanar, isTriplanar, layerTexCoord);
     // Transform view vector in tangent space
     float3 viewDirTS = TransformWorldToTangent(V, input.tangentToWorld);
     ApplyDisplacement(input, viewDirTS, layerTexCoord);
     layerTexCoord.weights = ComputeTriplanarWeights(input.tangentToWorld[2].xyz);
 #endif
 
+    bool isPlanar = false;
+#elif defined(_LAYER_MAPPING_PLANAR_0)
+    isPlanar = true;
-    ComputeLayerTexCoord0(input, isTriplanar, layerTexCoord);
+    ComputeLayerTexCoord0(input, isPlanar,  isTriplanar, layerTexCoord);
+#elif defined(_LAYER_MAPPING_PLANAR_1)
+    isPlanar = true;
-    ComputeLayerTexCoord1(input, isTriplanar, layerTexCoord);
+    ComputeLayerTexCoord1(input, isPlanar, isTriplanar, layerTexCoord);
+#elif defined(_LAYER_MAPPING_PLANAR_2)
+    isPlanar = true;
-    ComputeLayerTexCoord2(input, isTriplanar, layerTexCoord);
+    ComputeLayerTexCoord2(input, isPlanar, isTriplanar, layerTexCoord);
+#elif defined(_LAYER_MAPPING_PLANAR_3)
+    isPlanar = true;
-    ComputeLayerTexCoord3(input, isTriplanar, layerTexCoord);
+    ComputeLayerTexCoord3(input, isPlanar, isTriplanar, layerTexCoord);
 
     // Transform view vector in tangent space
     float3 viewDirTS = TransformWorldToTangent(V, input.tangentToWorld);

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

     float3 normalOS     : NORMAL;
     float2 uv0          : TEXCOORD0;
     float2 uv1		    : TEXCOORD1;
-#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL) || defined(_REQUIRE_UV2)
     float2 uv2		    : TEXCOORD2;
 #endif
 #ifdef _REQUIRE_UV3
     float3 positionWS;
     float2 texCoord0;
     float2 texCoord1;
-#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL) || defined(_REQUIRE_UV2)
     float2 texCoord2;
 #endif
 #ifdef _REQUIRE_UV3
 struct PackedVaryings
 {
     float4 positionCS : SV_Position;
-#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL) || defined(_REQUIRE_UV3)
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL) || defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
     float4 interpolators[6] : TEXCOORD0;
 #else
     float4 interpolators[5] : TEXCOORD0;
 
     output.interpolators[4] = input.color;
 
-#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL) || defined(_REQUIRE_UV3)
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL) || defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
-#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL) || defined(_REQUIRE_UV2)
     output.interpolators[5].xy = input.texCoord2.xy;
 #endif
 
 
     output.vertexColor = input.interpolators[4];
 
-#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL) || defined(_REQUIRE_UV2)
     output.texCoord2 = input.interpolators[5].xy;
 #endif
 #ifdef _REQUIRE_UV3
 
     output.texCoord0 = input.uv0;
     output.texCoord1 = input.uv1;
-#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL) || defined(_REQUIRE_UV2)
     output.texCoord2 = input.uv2;
 #endif
 

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

-void ADD_IDX(ComputeLayerTexCoord)(FragInputs input, bool isTriplanar, inout LayerTexCoord layerTexCoord)
+void ADD_IDX(ComputeLayerTexCoord)(FragInputs input, bool isPlanar, bool isTriplanar, inout LayerTexCoord layerTexCoord)
+    // Handle uv0, uv1, uv2, uv3 based on _UVMappingMask weight (exclusif 0..1)
+    float2 uvBase = ADD_IDX(_UVMappingMask).x * input.texCoord0 +
+                    ADD_IDX(_UVMappingMask).y * input.texCoord1 + 
+                    ADD_IDX(_UVMappingMask).z * input.texCoord2 +
+                    ADD_IDX(_UVMappingMask).w * input.texCoord3;
+                    
+
+    float2 uvDetails =  ADD_IDX(_UVDetailsMappingMask).x * input.texCoord0 +
+                        ADD_IDX(_UVDetailsMappingMask).y * input.texCoord1 +
+                        ADD_IDX(_UVDetailsMappingMask).z * input.texCoord2 +
+                        ADD_IDX(_UVDetailsMappingMask).w * input.texCoord3;
+
+    // Note that if base is planar/triplanar, detail map is too
+
+    // planar
-    // Handle uv0, uv1 and plnar XZ coordinate based on _CoordWeight weight (exclusif 0..1)
-    float2 uvBase = ADD_IDX(_UVMappingMask).x * input.texCoord0 +
-                    ADD_IDX(_UVMappingMask).y * input.texCoord1 + 
-                    ADD_IDX(_UVMappingMask).z * input.texCoord3 +
-                    ADD_IDX(_UVMappingMask).w * -position.xz;
+    if (isPlanar)
+    {
+        uvBase = -position.xz;
+        uvDetails = -position.xz;
+    }
-
-    float2 uvDetails =  ADD_IDX(_UVDetailsMappingMask).x * input.texCoord0 +
-                        ADD_IDX(_UVDetailsMappingMask).y * input.texCoord1 +
-                        ADD_IDX(_UVDetailsMappingMask).z * input.texCoord3 +
-                        // Note that if base is planar, detail map is planar
-                        ADD_IDX(_UVMappingMask).w * -position.xz;
-
     ADD_IDX(layerTexCoord.details).uv = TRANSFORM_TEX(uvDetails, ADD_IDX(_DetailMap));
 
     // triplanar