Merge remote-tracking branch 'refs/remotes/origin/master' into POM-cleanup

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

             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("Object Scale affect tiling", "Tiling will be affected by the object scale.");
+                        
+            public readonly GUIContent UVBlendMaskText = new GUIContent("BlendMask UV Mapping", "Base UV Mapping mode of the layer.");
             public readonly GUIContent UVDetailText = new GUIContent("Detail UV Mapping", "Detail UV Mapping mode of the layer.");
             public readonly GUIContent mainLayerInfluenceText = new GUIContent("Main layer influence", "Main layer influence.");
             public readonly GUIContent densityOpacityInfluenceText = new GUIContent("Density / Opacity", "Density / Opacity");
         MaterialProperty[] layerUVDetailsMappingMask = new MaterialProperty[kMaxLayerCount];
 
 
+        const string kObjectScaleAffectTile = "_ObjectScaleAffectTile";
+        MaterialProperty objectScaleAffectTile = null;
+        const string kUVBlendMask = "_UVBlendMask";
+        MaterialProperty UVBlendMask = null;
+        const string kUVMappingPlanarBlendMask = "_UVMappingPlanarBlendMask";
+        MaterialProperty UVMappingPlanarBlendMask = null;
+        const string kTexWorldScaleBlendMask = "_TexWorldScaleBlendMask";
+        MaterialProperty texWorldScaleBlendMask = null;
         const string kLayerTiling = "_LayerTiling";
         MaterialProperty[] layerTiling = new MaterialProperty[kMaxLayerCount];
         const string kkUseMainLayerInfluence = "_UseMainLayerInfluence";
             useHeightBasedBlend = FindProperty(kUseHeightBasedBlend, props);
             useDensityMode = FindProperty(kUseDensityMode, props);
 
+            objectScaleAffectTile = FindProperty(kObjectScaleAffectTile, props);
+            UVBlendMask = FindProperty(kUVBlendMask, props);
+            UVMappingPlanarBlendMask = FindProperty(kUVMappingPlanarBlendMask, props);
-           
+            texWorldScaleBlendMask = FindProperty(kTexWorldScaleBlendMask, props);
+                       
             for (int i = 0; i < kMaxLayerCount; ++i)
             {
                 layerTexWorldScale[i] = FindProperty(string.Format("{0}{1}", kTexWorldScale, i), props);
                 layerChanged = true;
             }
 
-
+            m_MaterialEditor.ShaderProperty(UVBlendMask, styles.UVBlendMaskText);
-            if (((LayerUVBaseMapping)layerUVBase[0].floatValue == LayerUVBaseMapping.Planar) ||
-                ((LayerUVBaseMapping)layerUVBase[0].floatValue == LayerUVBaseMapping.Triplanar))
+            if (((LayerUVBaseMapping)UVBlendMask.floatValue == LayerUVBaseMapping.Planar) ||
+                ((LayerUVBaseMapping)UVBlendMask.floatValue == LayerUVBaseMapping.Triplanar))
-                // for now reuse settings from main layer
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(texWorldScaleBlendMask, styles.layerTexWorldScaleText);
+                EditorGUI.indentLevel--;
             }
             else
             {
             {
                 useHeightBasedBlend.floatValue = enabled ? 1.0f : 0.0f;
             }
+
+            m_MaterialEditor.ShaderProperty(objectScaleAffectTile, styles.objectScaleAffectTileText);            
 
             EditorGUILayout.Space();
 
 
         void SetupLayersKeywords(Material material)
         {
+            // object scale affect tile
+            SetKeyword(material, "_LAYER_TILING_UNIFORM_SCALE", material.GetFloat(kObjectScaleAffectTile) > 0.0f);
+
+            // Blend mask
+            LayerUVBaseMapping UVBlendMaskMapping = (LayerUVBaseMapping)material.GetFloat(kUVBlendMask);
+            UVMappingPlanarBlendMask.floatValue = (UVBlendMaskMapping == LayerUVBaseMapping.Planar) ? 1.0f : 0.0f;
+            SetKeyword(material, "_LAYER_MAPPING_TRIPLANAR_BLENDMASK",  UVBlendMaskMapping == LayerUVBaseMapping.Triplanar);
+
+            // Layer
             if (numLayer == 4)
             {
                 SetKeyword(material, "_LAYEREDLIT_4_LAYERS", true);
                 Y = (layerUVBaseMapping == LayerUVBaseMapping.UV1) ? 1.0f : 0.0f;
                 Z = (layerUVBaseMapping == LayerUVBaseMapping.UV2) ? 1.0f : 0.0f;
                 W = (layerUVBaseMapping == LayerUVBaseMapping.UV3) ? 1.0f : 0.0f;
-                layerUVMappingMask[i].colorValue = new Color(X, Y, Z, W);
-                layerUVMappingPlanar[i].floatValue = (layerUVBaseMapping == LayerUVBaseMapping.Planar) ? 1.0f : 0.0f;
+                layerUVMappingMask[i].colorValue = (i == 0) ? new Color(1.0f, 0.0f, 0.0f, 0.0f) : new Color(X, Y, Z, W); // Special case for Main Layer and Blend Mask, only UV0. As Layer0 is share by both here, need to force X to 1.0 in all case
+                layerUVMappingPlanar[i].floatValue = (layerUVBaseMapping == LayerUVBaseMapping.Planar) ? 1.0f : 0.0f; // Planar have priority on UV0
 
                 SetKeyword(material, currentLayerMappingTriplanar, layerUVBaseMapping == LayerUVBaseMapping.Triplanar);
 

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

         [HideInInspector] _LayerCount("_LayerCount", Float) = 2.0
 
         [Enum(None, 0, Multiply, 1, Add, 2)] _VertexColorMode("Vertex color mode", Float) = 0
+        
+        [ToggleOff]  _ObjectScaleAffectTile("_ObjectScaleAffectTile", Float) = 0.0
+        [Enum(UV0, 0, Planar, 4, Triplanar, 5)] _UVBlendMask("UV Set for blendMask", Float) = 0
+        [HideInInspector] _UVMappingPlanarBlendMask("_UVMappingPlanarBlendMask", Float) = 0.0
+        _TexWorldScaleBlendMask("Tiling", Float) = 1.0
 
         // WARNING
         // All the following properties that concern the UV mapping are the same as in the Lit shader.
         _TexWorldScale1("Tiling", Float) = 1.0
         _TexWorldScale2("Tiling", Float) = 1.0
         _TexWorldScale3("Tiling", Float) = 1.0
-
+        
         [Enum(UV0, 0, Planar, 4, Triplanar, 5)] _UVBase0("UV Set for base0", Float) = 0 // no UV1/2/3 for main layer (matching Lit.shader and for PPDisplacement restriction)
         [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
         [HideInInspector] _UVMappingMask1("_UVMappingMask1", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVMappingMask2("_UVMappingMask2", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVMappingMask3("_UVMappingMask3", Color) = (1, 0, 0, 0)
-
+     
         [HideInInspector] _UVMappingPlanar0("_UVMappingPlanar0", Float) = 0.0
         [HideInInspector] _UVMappingPlanar1("_UVMappingPlanar1", Float) = 0.0
         [HideInInspector] _UVMappingPlanar2("_UVMappingPlanar2", Float) = 0.0
     #pragma shader_feature _ _DOUBLESIDED _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
 
     #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    #pragma shader_feature _LAYER_TILING_UNIFORM_SCALE
+    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_BLENDMASK
     #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_0
     #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_1
     #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_2

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

 
         [Enum(None, 0, Multiply, 1, Add, 2)] _VertexColorMode("Vertex color mode", Float) = 0
 
+        [ToggleOff]  _ObjectScaleAffectTile("_ObjectScaleAffectTile", Float) = 0.0
+        [Enum(UV0, 0, Planar, 4, Triplanar, 5)] _UVBlendMask("UV Set for blendMask", Float) = 0
+        [HideInInspector] _UVMappingPlanarBlendMask("_UVMappingPlanarBlendMask", Float) = 0.0
+        _TexWorldScaleBlendMask("Tiling", Float) = 1.0
+
         // WARNING
         // All the following properties that concern the UV mapping are the same as in the Lit shader.
         // This means that they will get overridden when synchronizing the various layers.
     #pragma shader_feature _TESSELLATION_OBJECT_SCALE
 
     #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    #pragma shader_feature _LAYER_TILING_UNIFORM_SCALE
+    #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_BLENDMASK
     #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_0
     #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_1
     #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_2

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

     // Be sure that the compiler is aware that we don't touch UV1 to UV3 for main layer so it can optimize code
     _UVMappingMask.yzw = float3(0.0, 0.0, 0.0);
     ComputeLayerTexCoord(   texCoord0, texCoord1, texCoord2, texCoord3, 
-                            positionWS, normalWS, isTriplanar, layerTexCoord);
+                            positionWS, normalWS,  _UVMappingPlanar > 0.0, isTriplanar, _TexWorldScale, layerTexCoord);
 }
 
 float GetMaxDisplacement()
 {
     ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
 
-#if defined(_LAYER_MAPPING_TRIPLANAR_0) || defined(_LAYER_MAPPING_TRIPLANAR_1) || defined(_LAYER_MAPPING_TRIPLANAR_2) || defined(_LAYER_MAPPING_TRIPLANAR_3)
+#if defined(_LAYER_MAPPING_TRIPLANAR_BLENDMASK) || defined(_LAYER_MAPPING_TRIPLANAR_0) || defined(_LAYER_MAPPING_TRIPLANAR_1) || defined(_LAYER_MAPPING_TRIPLANAR_2) || defined(_LAYER_MAPPING_TRIPLANAR_3)
-#ifdef _LAYER_MAPPING_TRIPLANAR_0
+#ifdef _LAYER_MAPPING_TRIPLANAR_BLENDMASK
-    // Note: Our BlendMask use the same uv mapping than the base layer but with its own tiling.
-    // Here we get a first time the base0 but with _LayerTilingBlendMask. Save the result and recall the function regularly for the main layer.
-    // It is just to share code.
+    // Note: Blend mask have its dedicated mapping adn tiling. And as Main layer it only use UV0
+    // To share code, we simply call the regular code from the main layer for it save the result, then do regular call for all layers.
-                            positionWS, normalWS, isTriplanar, layerTexCoord, _LayerTilingBlendMask);
+                            positionWS, normalWS, _UVMappingPlanarBlendMask > 0.0,  isTriplanar, _TexWorldScaleBlendMask, layerTexCoord, _LayerTilingBlendMask);
+    // On all layers (but not on blend mask) we can scale the tiling with object scale (only uniform supported)
+    // Note: the object scale doesn't affect planar/triplanar mapping as they already handle the object scale.
+    float tileObjectScale = 1.0;
+#ifdef _LAYER_TILING_UNIFORM_SCALE
+    // Extract scaling from world transform
+    float4x4 worldTransform = GetObjectToWorldMatrix();
+    // assuming uniform scaling, take only the first column
+    tileObjectScale = length(float3(worldTransform._m00, worldTransform._m01, worldTransform._m02));
+#endif  
+
+    isTriplanar = false;
+#ifdef _LAYER_MAPPING_TRIPLANAR_0
+    isTriplanar = true;
+#endif
+
-                            positionWS, normalWS, isTriplanar, layerTexCoord, _LayerTiling0);
+                            positionWS, normalWS, _UVMappingPlanar0 > 0.0, isTriplanar, _TexWorldScale0, layerTexCoord, _LayerTiling0 * tileObjectScale);
 
     isTriplanar = false;
 #ifdef _LAYER_MAPPING_TRIPLANAR_1
-                            positionWS, normalWS, isTriplanar, layerTexCoord, _LayerTiling1);
+                            positionWS, normalWS, _UVMappingPlanar1 > 0.0, isTriplanar, _TexWorldScale1, layerTexCoord, _LayerTiling1 * tileObjectScale);
 
     isTriplanar = false;
 #ifdef _LAYER_MAPPING_TRIPLANAR_2
-                            positionWS, normalWS, isTriplanar, layerTexCoord, _LayerTiling2);
+                            positionWS, normalWS, _UVMappingPlanar2 > 0.0, isTriplanar, _TexWorldScale2, layerTexCoord, _LayerTiling2 * tileObjectScale);
 
     isTriplanar = false;
 #ifdef _LAYER_MAPPING_TRIPLANAR_3
-                            positionWS, normalWS, isTriplanar, layerTexCoord, _LayerTiling3);
+                            positionWS, normalWS, _UVMappingPlanar3 > 0.0, isTriplanar, _TexWorldScale3, layerTexCoord, _LayerTiling3 * tileObjectScale);
 }
 
 #if defined(_HEIGHTMAP0)

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

 void ADD_IDX(ComputeLayerTexCoord)( float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3,
-                                    float3 positionWS, float3 vertexNormalWS, bool isTriplanar, inout LayerTexCoord layerTexCoord, float additionalTiling = 1.0)
+                                    float3 positionWS, float3 vertexNormalWS, bool isPlanar, bool isTriplanar, float worldScale, inout LayerTexCoord layerTexCoord, float additionalTiling = 1.0)
 {
     // Handle uv0, uv1, uv2, uv3 based on _UVMappingMask weight (exclusif 0..1)
     float2 uvBase = ADD_IDX(_UVMappingMask).x * texCoord0 +
     // TODO: Do we want to manage local or world triplanar/planar ? In this case update ApplyPerPixelDisplacement() too
     //float3 position = localTriplanar ? TransformWorldToObject(positionWS) : positionWS;
     float3 position = positionWS;
-    position *= ADD_IDX(_TexWorldScale);
+    position *= worldScale;
-    if (ADD_IDX(_UVMappingPlanar) > 0.0)
+    if (isPlanar)
     {
         uvBase = -position.xz;
         uvDetails = -position.xz;

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

 SAMPLER2D(sampler_EmissiveColorMap);
 float _EmissiveIntensity;
 
+float _TexWorldScaleBlendMask;
+float _UVMappingPlanarBlendMask;
 PROP_DECL(float, _UVMappingPlanar);  
 PROP_DECL(float4, _UVMappingMask);
 PROP_DECL(float4, _UVDetailsMappingMask);