HDRenderPipeline: LayeredLit - Remove layerTilingBlendMask parameter and replace it by propoer scale/bias attribute

- Remove layerTilingBlendMask parameter and replace it by propoer
scale/bias attribute from LayerBlendMask texture
- This also fix an issue with wrong tiling apply from layer0 on blend
mask
- Artists will require to report the ex-value of layerTilingBlendMask
to the new scale/bias, this must be done manually

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/Editor/LayeredLitUI.cs

             public readonly GUIContent layerInfluenceMapMaskText = new GUIContent("Layer Influence Mask", "Layer mask");
             public readonly GUIContent vertexColorModeText = new GUIContent("Vertex Color Mode", "Mode multiply: vertex color is multiply with the mask. Mode additive: vertex color values are remapped between -1 and 1 and added to the mask (neutral at 0.5 vertex color).");
             public readonly GUIContent layerCountText = new GUIContent("Layer Count", "Number of layers.");
-            public readonly GUIContent layerTilingBlendMaskText = new GUIContent("Tiling", "Tiling for the blend mask.");
             public readonly GUIContent objectScaleAffectTileText = new GUIContent("Lock layers 0123 tiling with object Scale", "Tiling of each layers will be affected by the object scale.");
             public readonly GUIContent objectScaleAffectTileText2 = new GUIContent("Lock layers  123 tiling with object Scale", "Tiling of each influenced layers (all except main layer) will be affected by the object scale.");
 
         const string kUVBlendMask = "_UVBlendMask";
         MaterialProperty UVMappingMaskBlendMask = null;
         const string kUVMappingMaskBlendMask = "_UVMappingMaskBlendMask";
-        MaterialProperty layerTilingBlendMask = null;
-        const string kLayerTilingBlendMask = "_LayerTilingBlendMask";
         MaterialProperty texWorldScaleBlendMask = null;
         const string kTexWorldScaleBlendMask = "_TexWorldScaleBlendMask";
         MaterialProperty useMainLayerInfluence = null;
             objectScaleAffectTile = FindProperty(kObjectScaleAffectTile, props);
             UVBlendMask = FindProperty(kUVBlendMask, props);
             UVMappingMaskBlendMask = FindProperty(kUVMappingMaskBlendMask, props);
-            layerTilingBlendMask = FindProperty(kLayerTilingBlendMask, props);
             texWorldScaleBlendMask = FindProperty(kTexWorldScaleBlendMask, props);
 
             useMainLayerInfluence = FindProperty(kkUseMainLayerInfluence, props);
             {
                 m_MaterialEditor.ShaderProperty(texWorldScaleBlendMask, styles.layerTexWorldScaleText);
             }
-            else
-            {
-                m_MaterialEditor.ShaderProperty(layerTilingBlendMask, styles.layerTilingBlendMaskText);
-            }
+            m_MaterialEditor.TextureScaleOffsetProperty(layerMaskMap);
             EditorGUI.indentLevel--;
 
             m_MaterialEditor.ShaderProperty(vertexColorMode, styles.vertexColorModeText);

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

         [ToggleOff] _OpacityAsDensity2("_OpacityAsDensity2", Float) = 0.0
         [ToggleOff] _OpacityAsDensity3("_OpacityAsDensity3", Float) = 0.0
 
-        _LayerTilingBlendMask("_LayerTilingBlendMask", Float) = 1
-
         [HideInInspector] _LayerCount("_LayerCount", Float) = 2.0
 
         [Enum(None, 0, Multiply, 1, Add, 2)] _VertexColorMode("Vertex color mode", Float) = 0
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _DOUBLESIDED_ON
     #pragma shader_feature _PER_PIXEL_DISPLACEMENT
-    #pragma shader_feature _PER_PIXEL_DISPLACEMENT_OBJECT_SCALE    
-    #pragma shader_feature _VERTEX_DISPLACEMENT    
+    #pragma shader_feature _PER_PIXEL_DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _VERTEX_DISPLACEMENT
     #pragma shader_feature _VERTEX_DISPLACEMENT_OBJECT_SCALE
     #pragma shader_feature _VERTEX_DISPLACEMENT_TILING_SCALE
     #pragma shader_feature _VERTEX_WIND

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

         [ToggleOff] _OpacityAsDensity2("_OpacityAsDensity2", Float) = 0.0
         [ToggleOff] _OpacityAsDensity3("_OpacityAsDensity3", Float) = 0.0
 
-        _LayerTilingBlendMask("_LayerTilingBlendMask", Float) = 1
-
         [HideInInspector] _LayerCount("_LayerCount", Float) = 2.0
 
         [Enum(None, 0, Multiply, 1, Add, 2)] _VertexColorMode("Vertex color mode", Float) = 0

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

 
     // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code
     ComputeLayerTexCoord(   texCoord0, texCoord1, texCoord2, texCoord3, float4(1.0, 0.0, 0.0, 0.0), _UVDetailsMappingMask,
-                            positionWS, mappingType, _TexWorldScale, layerTexCoord);
+                            _BaseColorMap_ST.xy, _BaseColorMap_ST.zw, _DetailMap_ST.xy, _DetailMap_ST.zw, 1.0,
+                            positionWS, _TexWorldScale,
+                            mappingType, layerTexCoord);
 }
 
 // This is call only in this file
     // Note: Blend mask have its dedicated mapping and tiling.
     // To share code, we simply call the regular code from the main layer for it then save the result, then do regular call for all layers.
     ComputeLayerTexCoord0(  texCoord0, texCoord1, texCoord2, texCoord3, _UVMappingMaskBlendMask, _UVMappingMaskBlendMask,
-                            positionWS, mappingType, _TexWorldScaleBlendMask, layerTexCoord, _LayerTilingBlendMask);
+                            _LayerMaskMap_ST.xy, _LayerMaskMap_ST.zw, float2(0.0, 0.0), float2(0.0, 0.0), 1.0,
+                            positionWS, _TexWorldScaleBlendMask,
+                            mappingType, layerTexCoord);
 
     layerTexCoord.blendMask = layerTexCoord.base0;
 
 #endif
 
     ComputeLayerTexCoord0(  texCoord0, texCoord1, texCoord2, texCoord3, _UVMappingMask0, _UVDetailsMappingMask0,
-                            positionWS, mappingType, _TexWorldScale0, layerTexCoord, 1.0
+                            _BaseColorMap0_ST.xy, _BaseColorMap0_ST.zw, _DetailMap0_ST.xy, _DetailMap0_ST.zw, 1.0
-                            );
+                            , positionWS, _TexWorldScale0,
+                            mappingType, layerTexCoord);
 
     mappingType = UV_MAPPING_UVSET;
 #if defined(_LAYER_MAPPING_PLANAR1)
 #endif
     ComputeLayerTexCoord1(  texCoord0, texCoord1, texCoord2, texCoord3, _UVMappingMask1, _UVDetailsMappingMask1,
-                            positionWS, mappingType, _TexWorldScale1, layerTexCoord, tileObjectScale);
+                            _BaseColorMap1_ST.xy, _BaseColorMap1_ST.zw, _DetailMap1_ST.xy, _DetailMap1_ST.zw, tileObjectScale,
+                            positionWS, _TexWorldScale1,
+                            mappingType, layerTexCoord);
 
     mappingType = UV_MAPPING_UVSET;
 #if defined(_LAYER_MAPPING_PLANAR2)
 #endif
     ComputeLayerTexCoord2(  texCoord0, texCoord1, texCoord2, texCoord3, _UVMappingMask2, _UVDetailsMappingMask2,
-                            positionWS, mappingType, _TexWorldScale2, layerTexCoord, tileObjectScale);
+                            _BaseColorMap2_ST.xy, _BaseColorMap2_ST.zw, _DetailMap2_ST.xy, _DetailMap2_ST.zw, tileObjectScale,
+                            positionWS, _TexWorldScale2,
+                            mappingType, layerTexCoord);
 
     mappingType = UV_MAPPING_UVSET;
 #if defined(_LAYER_MAPPING_PLANAR3)
 #endif
     ComputeLayerTexCoord3(  texCoord0, texCoord1, texCoord2, texCoord3, _UVMappingMask3, _UVDetailsMappingMask3,
-                            positionWS, mappingType, _TexWorldScale3, layerTexCoord, tileObjectScale);
+                            _BaseColorMap3_ST.xy, _BaseColorMap3_ST.zw, _DetailMap3_ST.xy, _DetailMap3_ST.zw, tileObjectScale,
+                            positionWS, _TexWorldScale3,
+                            mappingType, layerTexCoord);
 }
 
 // This is call only in this file

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl

-void ADD_IDX(ComputeLayerTexCoord)( float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, float4 uvMappingMask, float4 uvMappingMaskDetail,
-                                    float3 positionWS, int mappingType, float worldScale, inout LayerTexCoord layerTexCoord, float additionalTiling = 1.0)
+void ADD_IDX(ComputeLayerTexCoord)( // Uv related parameters
+                                    float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, float4 uvMappingMask, float4 uvMappingMaskDetails,
+                                    // scale and bias for base and detail + global tiling factor (for layered lit only)
+                                    float2 texScale, float2 texBias, float2 texScaleDetails, float2 texBiasDetails, float additionalTiling,
+                                    // parameter for planar/triplanar
+                                    float3 positionWS, float worldScale,
+                                    // mapping type and output
+                                    int mappingType, inout LayerTexCoord layerTexCoord)
 {
     // Handle uv0, uv1, uv2, uv3 based on _UVMappingMask weight (exclusif 0..1)
     float2 uvBase = uvMappingMask.x * texCoord0 +
     uvBase *= additionalTiling.xx;
 
 
-    float2 uvDetails =  uvMappingMaskDetail.x * texCoord0 +
-                        uvMappingMaskDetail.y * texCoord1 +
-                        uvMappingMaskDetail.z * texCoord2 +
-                        uvMappingMaskDetail.w * texCoord3;
+    float2 uvDetails =  uvMappingMaskDetails.x * texCoord0 +
+                        uvMappingMaskDetails.y * texCoord1 +
+                        uvMappingMaskDetails.z * texCoord2 +
+                        uvMappingMaskDetails.w * texCoord3;
 
     uvDetails *= additionalTiling.xx;
 
     }
 
     // Apply tiling options
-    ADD_IDX(layerTexCoord.base).uv = TRANSFORM_TEX(uvBase, ADD_IDX(_BaseColorMap));
+    ADD_IDX(layerTexCoord.base).uv = uvBase * texScale + texBias;
-    ADD_IDX(layerTexCoord.details).uv = TRANSFORM_TEX(TRANSFORM_TEX(uvDetails, ADD_IDX(_BaseColorMap)), ADD_IDX(_DetailMap));
+    ADD_IDX(layerTexCoord.details).uv = (uvDetails * texScaleDetails + texBiasDetails) * texScale + texBias;
-    ADD_IDX(layerTexCoord.base).uvXZ = TRANSFORM_TEX(uvXZ, ADD_IDX(_BaseColorMap));
-    ADD_IDX(layerTexCoord.base).uvXY = TRANSFORM_TEX(uvXY, ADD_IDX(_BaseColorMap));
-    ADD_IDX(layerTexCoord.base).uvZY = TRANSFORM_TEX(uvZY, ADD_IDX(_BaseColorMap));
-    
-    ADD_IDX(layerTexCoord.details).uvXZ = TRANSFORM_TEX(TRANSFORM_TEX(uvXZ, ADD_IDX(_BaseColorMap)), ADD_IDX(_DetailMap));
-    ADD_IDX(layerTexCoord.details).uvXY = TRANSFORM_TEX(TRANSFORM_TEX(uvXY, ADD_IDX(_BaseColorMap)), ADD_IDX(_DetailMap));
-    ADD_IDX(layerTexCoord.details).uvZY = TRANSFORM_TEX(TRANSFORM_TEX(uvZY, ADD_IDX(_BaseColorMap)), ADD_IDX(_DetailMap));
+    ADD_IDX(layerTexCoord.base).uvXZ = uvXZ * texScale + texBias;
+    ADD_IDX(layerTexCoord.base).uvXY = uvXY * texScale + texBias;
+    ADD_IDX(layerTexCoord.base).uvZY = uvZY * texScale + texBias;
+
+    ADD_IDX(layerTexCoord.details).uvXZ = (uvXZ * texScaleDetails + texBiasDetails) * texScale + texBias;
+    ADD_IDX(layerTexCoord.details).uvXY = (uvXY * texScaleDetails + texBiasDetails) * texScale + texBias;
+    ADD_IDX(layerTexCoord.details).uvZY = (uvZY * texScaleDetails + texBiasDetails) * texScale + texBias;
 
     #ifdef SURFACE_GRADIENT
     // This part is only relevant for normal mapping with UV_MAPPING_UVSET
                                                 uvMappingMask.z * layerTexCoord.vertexBitangentWS2 +
                                                 uvMappingMask.w * layerTexCoord.vertexBitangentWS3;
 
-    ADD_IDX(layerTexCoord.details).tangentWS =  uvMappingMaskDetail.x * layerTexCoord.vertexTangentWS0 +
-                                                uvMappingMaskDetail.y * layerTexCoord.vertexTangentWS1 +
-                                                uvMappingMaskDetail.z * layerTexCoord.vertexTangentWS2 +
-                                                uvMappingMaskDetail.w * layerTexCoord.vertexTangentWS3;
+    ADD_IDX(layerTexCoord.details).tangentWS =  uvMappingMaskDetails.x * layerTexCoord.vertexTangentWS0 +
+                                                uvMappingMaskDetails.y * layerTexCoord.vertexTangentWS1 +
+                                                uvMappingMaskDetails.z * layerTexCoord.vertexTangentWS2 +
+                                                uvMappingMaskDetails.w * layerTexCoord.vertexTangentWS3;
-    ADD_IDX(layerTexCoord.details).bitangentWS =    uvMappingMaskDetail.x * layerTexCoord.vertexBitangentWS0 +
-                                                    uvMappingMaskDetail.y * layerTexCoord.vertexBitangentWS1 +
-                                                    uvMappingMaskDetail.z * layerTexCoord.vertexBitangentWS2 +
-                                                    uvMappingMaskDetail.w * layerTexCoord.vertexBitangentWS3;
+    ADD_IDX(layerTexCoord.details).bitangentWS =    uvMappingMaskDetails.x * layerTexCoord.vertexBitangentWS0 +
+                                                    uvMappingMaskDetails.y * layerTexCoord.vertexBitangentWS1 +
+                                                    uvMappingMaskDetails.z * layerTexCoord.vertexBitangentWS2 +
+                                                    uvMappingMaskDetails.w * layerTexCoord.vertexBitangentWS3;
     #endif
 }
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 float _InheritBaseColor1;
 float _InheritBaseColor2;
 float _InheritBaseColor3;
-float _LayerTilingBlendMask;
+float4 _LayerMaskMap_ST;
 float _TexWorldScaleBlendMask;
 PROP_DECL(float, _TexWorldScale);
 float4 _UVMappingMaskBlendMask;