Merge remote-tracking branch 'refs/remotes/origin/Unity-2017.3' into Add-Per-Pixel-scale

# Conflicts:

#	ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

SampleScenes/OnTileDeferredTest/Common/MobileTestSceneManager.cs

 	int detectSwipe() {
 		if (Input.touchCount == 1 && Input.GetTouch (0).phase == TouchPhase.Ended) {
 			Vector2 endPosition = Input.GetTouch (0).position;
-			Vector2 delta = endPosition - startPosition;
+			//Vector2 delta = endPosition - startPosition;
 
 			if (startPosition.x < endPosition.x)
 				return 1;
 		detectTouchBegan();
 #endif
 
-	}	
+	}
 }

ScriptableRenderPipeline/Core/Debugging/DebugItemHandler.cs

             m_DebugItem = item;
         }
 
-        // Method user needs to override for specific value clamping.
-        public virtual void ClampValues(Func<object> getter, Action<object> setter) {}
+        // Method user needs to override for specific value validation.
+        public virtual void ValidateValues(Func<object> getter, Action<object> setter) {}
         // Method that will create UI items for runtime debug menu.
         public abstract DebugItemUI BuildGUI(GameObject parent);
 
             m_Max = max;
         }
 
-        public override void ClampValues(Func<object> getter, Action<object> setter)
+        public override void ValidateValues(Func<object> getter, Action<object> setter)
         {
             setter(Mathf.Clamp((float)getter(), m_Min, m_Max));
         }
             m_Max = max;
         }
 
-        public override void ClampValues(Func<object> getter, Action<object> setter)
+        public override void ValidateValues(Func<object> getter, Action<object> setter)
         {
             setter(Math.Min(m_Max, Math.Max(m_Min, (uint)getter())));
         }

ScriptableRenderPipeline/Core/Debugging/DebugItemUI.cs

 
         public bool dynamicDisplay { get { return (m_DebugItem.flags & DebugItemFlag.DynamicDisplay) != 0; } }
 
+        public DebugItem debugItem { get { return m_DebugItem; } }
+
         protected DebugItemUI(DebugItem debugItem)
         {
             m_DebugItem = debugItem;

ScriptableRenderPipeline/Core/Debugging/DebugMenuState.cs

 
 namespace UnityEngine.Experimental.Rendering
 {
-    [Serializable]
     public abstract class DebugItemState
         : ScriptableObject
     {
                     if (debugItemState == null)
                     {
                         debugItemState = item.handler.CreateDebugItemState();
-                        debugItemState.hideFlags = HideFlags.DontSave;
-                        debugItemState.Initialize(item);
-                        debugItemState.SetValue(item.GetValue());
-                        AddDebugItemState(debugItemState);
+                        if(debugItemState != null)
+                        {
+                            debugItemState.hideFlags = HideFlags.DontSave;
+                            debugItemState.Initialize(item);
+                            debugItemState.SetValue(item.GetValue());
+                            AddDebugItemState(debugItemState);
+                        }
+                        else
+                        {
+                            Debug.LogWarning(String.Format("DebugItemState for item {0} of type {1} is not provided.\nDid you implement CreateDebugItemState in your custom Handler?", item.name, item.type));
+                        }
                     }
                 }
             }

ScriptableRenderPipeline/Core/Debugging/DebugPanel.cs

             if(m_Setter != null)
             {
                 m_Setter(value);
-                m_Handler.ClampValues(m_Getter, m_Setter);
+                m_Handler.ValidateValues(m_Getter, m_Setter);
             }
 
             if (record && OnItemDirty != null)

ScriptableRenderPipeline/Core/Debugging/DebugPanelUI.cs

                 GameObject.Destroy(child.gameObject);
             }
 
+            m_ItemsUI.Clear();
+
+        protected void AddDebugItemUI(DebugItem item, GameObject parent)
+        {
+#if UNITY_EDITOR
+            // We don't want runtime only items even in the "player" debug menu if we are in the editor.
+            if (item.runtimeOnly)
+                return;
+#endif
+            if(item.editorOnly)
+                return;
+
+            DebugItemUI itemUI = item.handler.BuildGUI(parent);
+            if(itemUI == null)
+            {
+                Debug.LogWarning(String.Format("DebugItemUI not provided for item {0} of type {1}.\n Did you implement BuildGUI for your custom Handler?", item.name, item.type));
+            }
+            else
+            {
+                m_ItemsUI.Add(itemUI);
+            }
+        }
+
-            m_ItemsUI.Clear();
-#if UNITY_EDITOR
-                // We don't want runtime only items even in the "player" debug menu if we are in the editor.
-                if (item.runtimeOnly)
-                    continue;
-#endif
-                if(!item.editorOnly)
-                {
-                    DebugItemHandler handler = item.handler; // Should never be null, we have at least the default handler
-                    m_ItemsUI.Add(handler.BuildGUI(parent));
-                }
+                AddDebugItemUI(item, parent);
             }
         }
 
         {
             if (m_SelectedItem != -1)
             {
-                return m_DebugPanel.GetDebugItem(m_SelectedItem);
+                return m_ItemsUI[m_SelectedItem].debugItem;
             }
 
             return null;
 
         public void OnMoveHorizontal(float value)
         {
-            if (m_SelectedItem != -1 && !m_DebugPanel.GetDebugItem(m_SelectedItem).readOnly)
+            if (m_SelectedItem != -1 && !m_ItemsUI[m_SelectedItem].debugItem.readOnly)
             {
                 if (value > 0.0f)
                     m_ItemsUI[m_SelectedItem].OnIncrement();
 
         public void OnValidate()
         {
-            if (m_SelectedItem != -1 && !m_DebugPanel.GetDebugItem(m_SelectedItem).readOnly)
+            if (m_SelectedItem != -1 && !m_ItemsUI[m_SelectedItem].debugItem.readOnly)
                 m_ItemsUI[m_SelectedItem].OnValidate();
         }
 

ScriptableRenderPipeline/Core/ShaderLibrary/ImageBasedLighting.hlsl

 // approximating the cone of the specular lobe, and then computing the MIP map level
 // which (approximately) covers the footprint of the lobe with a single texel.
 // Improves the perceptual roughness distribution.
-float PerceptualRoughnessToMipmapLevel(float perceptualRoughness)
+float PerceptualRoughnessToMipmapLevel(float perceptualRoughness, uint mipMapCount)
-    return perceptualRoughness * UNITY_SPECCUBE_LOD_STEPS;
+    return perceptualRoughness * mipMapCount;
+}
+
+float PerceptualRoughnessToMipmapLevel(float perceptualRoughness)
+{
+    return PerceptualRoughnessToMipmapLevel(perceptualRoughness, UNITY_SPECCUBE_LOD_STEPS);
 }
 
 // The *accurate* version of the non-linear remapping. It works by

ScriptableRenderPipeline/HDRenderPipeline/Debug/LightingDebugPanel.cs

 
         }
 
-        public override void ClampValues(Func<object> getter, Action<object> setter)
+        public override void ValidateValues(Func<object> getter, Action<object> setter)
         {
             HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
             m_Max = (uint)hdPipeline.GetShadowAtlasCount() - 1;
 
         }
 
-        public override void ClampValues(Func<object> getter, Action<object> setter)
+        public override void ValidateValues(Func<object> getter, Action<object> setter)
         {
             HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
             m_Max = (uint)hdPipeline.GetCurrentShadowCount() - 1;

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

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/Lit.hlsl

 // Color pyramid (width, height, lodcount, Unused)
 float4 _GaussianPyramidColorMipSize;
 TEXTURE2D(_GaussianPyramidColorTexture);
-SAMPLER2D(sampler_GaussianPyramidColorTexture);
-SAMPLER2D(sampler_PyramidDepthTexture);
+SamplerState ltc_trilinear_clamp_sampler;
 // TODO: This one should be set into a constant Buffer at pass frequency (with _Screensize)
 TEXTURE2D(_PreIntegratedFGD);
 TEXTURE2D_ARRAY(_LtcData); // We pack the 3 Ltc data inside a texture array
     // Encode normal on 20bit with oct compression + 2bit of sign
     float2 octNormalWS = PackNormalOctEncode((surfaceData.materialId == MATERIALID_LIT_CLEAR_COAT) ? surfaceData.coatNormalWS : surfaceData.normalWS);
     // To have more precision encode the sign of xy in a separate uint
-    uint octNormalSign = (octNormalWS.x > 0.0 ? 1 : 0) + (octNormalWS.y > 0.0 ? 2 : 0);
+    uint octNormalSign = (octNormalWS.x < 0.0 ? 1 : 0) | (octNormalWS.y < 0.0 ? 2 : 0);
     // Store octNormalSign on two bits with perceptualRoughness
     outGBuffer1 = float4(abs(octNormalWS), PackFloatInt10bit(PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness), octNormalSign, 4.0), PackMaterialId(surfaceData.materialId));
 
     {
         // Encode tangent on 16bit with oct compression
         float2 octTangentWS = PackNormalOctEncode(surfaceData.tangentWS);
-            outGBuffer2 = float4(octTangentWS * 0.5 + 0.5, surfaceData.anisotropy, PackFloatInt8bit(surfaceData.metallic, 0.0, 4.0));
+        // To have more precision encode the sign of xy in a separate uint
+        uint octTangentSign = (octTangentWS.x < 0.0 ? 1 : 0) | (octTangentWS.y < 0.0 ? 2 : 0);
+
+        outGBuffer2 = float4(abs(octTangentWS), surfaceData.anisotropy, PackFloatInt8bit(surfaceData.metallic, octTangentSign, 4.0));
     }
     else if (surfaceData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
 
     int octNormalSign;
     UnpackFloatInt10bit(inGBuffer1.b, 4.0, bsdfData.perceptualRoughness, octNormalSign);
-    inGBuffer1.r *= (octNormalSign & 1) ? 1.0 : -1.0;
-    inGBuffer1.g *= (octNormalSign & 2) ? 1.0 : -1.0;
+    inGBuffer1.r = (octNormalSign & 1) ? -inGBuffer1.r : inGBuffer1.r;
+    inGBuffer1.g = (octNormalSign & 2) ? -inGBuffer1.g : inGBuffer1.g;
+
     bsdfData.normalWS = UnpackNormalOctEncode(float2(inGBuffer1.r, inGBuffer1.g));
 
     bsdfData.roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
     else if (bsdfData.materialId == MATERIALID_LIT_ANISO && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_ANISO))
     {
         float metallic;
-        int unused;
-        UnpackFloatInt8bit(inGBuffer2.a, 4.0, metallic, unused);
+        int octTangentSign;
+        UnpackFloatInt8bit(inGBuffer2.a, 4.0, metallic, octTangentSign);
-        float3 tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
+        inGBuffer2.r = (octTangentSign & 1) ? -inGBuffer2.r : inGBuffer2.r;
+        inGBuffer2.g = (octTangentSign & 2) ? -inGBuffer2.g : inGBuffer2.g;
+        float3 tangentWS = UnpackNormalOctEncode(inGBuffer2.rg);
         float anisotropy = inGBuffer2.b;
         FillMaterialIdAnisoData(bsdfData.roughness, bsdfData.normalWS, tangentWS, anisotropy, bsdfData);
     }
     float3 refractedBackPointWS = float3(0.0, 0.0, 0.0);
     float opticalDepth = 0.0;
 
+    uint2 depthSize = uint2(_PyramidDepthMipSize.xy);
+
     // For all refraction approximation, to calculate the refracted point in world space,
     //   we approximate the scene as a plane (back plane) with normal -V at the depth hit point.
     //   (We avoid to raymarch the depth texture to get the refracted point.)
     float3 R = refract(-V, bsdfData.normalWS, 1.0 / bsdfData.ior);
 
     // Get the depth of the approximated back plane
-    float pyramidDepth = SAMPLE_TEXTURE2D_LOD(_PyramidDepthTexture, sampler_PyramidDepthTexture, posInput.positionSS, 2.0).r;
+    float pyramidDepth = LOAD_TEXTURE2D_LOD(_PyramidDepthTexture, posInput.positionSS * (depthSize >> 2), 2).r;
     float depth = LinearEyeDepth(pyramidDepth, _ZBufferParams);
 
     // Distance from point to the back plane
     //  So the light is refracted twice: in and out of the tangent sphere
 
     // Get the depth of the approximated back plane
-    float pyramidDepth = SAMPLE_TEXTURE2D_LOD(_PyramidDepthTexture, sampler_PyramidDepthTexture, posInput.positionSS, 2.0).r;
+    float pyramidDepth = LOAD_TEXTURE2D_LOD(_PyramidDepthTexture, posInput.positionSS * (depthSize >> 2), 2).r;
     float depth = LinearEyeDepth(pyramidDepth, _ZBufferParams);
 
     // Distance from point to the back plane
     float3 R = refract(-V, bsdfData.normalWS, 1.0 / bsdfData.ior);
 
     // Get the depth of the approximated back plane
-    float pyramidDepth = SAMPLE_TEXTURE2D_LOD(_PyramidDepthTexture, sampler_PyramidDepthTexture, posInput.positionSS, 2.0).r;
+    float pyramidDepth = LOAD_TEXTURE2D_LOD(_PyramidDepthTexture, posInput.positionSS * (depthSize >> 2), 2).r;
     float depth = LinearEyeDepth(pyramidDepth, _ZBufferParams);
 
     // Distance from point to the back plane
     // Calculate screen space coordinates of refracted point in back plane
     float4 refractedBackPointCS = mul(_ViewProjMatrix, float4(refractedBackPointWS, 1.0));
     float2 refractedBackPointSS = ComputeScreenSpacePosition(refractedBackPointCS);
-    float refractedBackPointDepth = LinearEyeDepth(SAMPLE_TEXTURE2D_LOD(_PyramidDepthTexture, sampler_PyramidDepthTexture, refractedBackPointSS, 0.0).r, _ZBufferParams);
+    float refractedBackPointDepth = LinearEyeDepth(LOAD_TEXTURE2D_LOD(_PyramidDepthTexture, refractedBackPointSS * depthSize, 0).r, _ZBufferParams);
 
     // Exit if texel is out of color buffer
     // Or if the texel is from an object in front of the object
     {
-        diffuseLighting = SAMPLE_TEXTURE2D_LOD(_GaussianPyramidColorTexture, sampler_GaussianPyramidColorTexture, posInput.positionSS, 0.0).rgb;
+        diffuseLighting = SAMPLE_TEXTURE2D_LOD(_GaussianPyramidColorTexture, ltc_trilinear_clamp_sampler, posInput.positionSS, 0.0).rgb;
-    float mipLevel = PerceptualRoughnessToMipmapLevel(bsdfData.perceptualRoughness);
-    diffuseLighting = SAMPLE_TEXTURE2D_LOD(_GaussianPyramidColorTexture, sampler_GaussianPyramidColorTexture, refractedBackPointSS.xy, mipLevel).rgb;
+    float mipLevel = PerceptualRoughnessToMipmapLevel(bsdfData.perceptualRoughness, uint(_GaussianPyramidColorMipSize.z));
+    diffuseLighting = SAMPLE_TEXTURE2D_LOD(_GaussianPyramidColorTexture, ltc_trilinear_clamp_sampler, refractedBackPointSS, mipLevel).rgb;
 
     // Beer-Lamber law for absorption
     float3 transmittance = exp(-bsdfData.absorptionCoefficient * opticalDepth);
     // Use perfect flat transparency when we cannot fetch the correct pixel color for the refracted point
-    diffuseLighting = SAMPLE_TEXTURE2D_LOD(_GaussianPyramidColorTexture, sampler_GaussianPyramidColorTexture, posInput.positionSS, 0.0).rgb;
+    diffuseLighting = SAMPLE_TEXTURE2D_LOD(_GaussianPyramidColorTexture, ltc_trilinear_clamp_sampler, posInput.positionSS, 0.0).rgb;
 #endif
 }
 

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
 #ifdef _DEPTHOFFSET_ON
     ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput);
 #endif
-
-    float3 interpolatedVertexNormal = input.worldToTangent[2].xyz;
 
     // We perform the conversion to world of the normalTS outside of the GetSurfaceData
     // so it allow us to correctly deal with detail normal map and optimize the code for the layered shaders
     // 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
 // Calculate displacement for per vertex displacement mapping
 float ComputePerVertexDisplacement(LayerTexCoord layerTexCoord, float4 vertexColor, float lod)
 {
-    float4 inputBlendMasks = GetBlendMask(layerTexCoord, vertexColor, true, lod);
-
-    float weights[_MAX_LAYER];
-
 #if defined(_HEIGHTMAP0) || defined(_HEIGHTMAP1) || defined(_HEIGHTMAP2) || defined(_HEIGHTMAP3)
     float height0 = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap0, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base0, lod).r - _HeightCenter0) * _HeightAmplitude0;
     float height1 = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap1, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base1, lod).r - _HeightCenter1) * _HeightAmplitude1;
-    SetEnabledHeightByLayer(height0, height1, height2, height3);
-    float4 resultBlendMasks = inputBlendMasks;
-#if defined(_HEIGHT_BASED_BLEND)
-    resultBlendMasks = ApplyHeightBlend(float4(height0, height1, height2, height3), inputBlendMasks);
-#endif
-
-    ComputeMaskWeights(resultBlendMasks, weights);
-    float heightResult = BlendLayeredScalar(height0, height1, height2, height3, weights);
+    float4 blendMask = GetBlendMask(layerTexCoord, vertexColor, true, lod);
+    #if defined(_MAIN_LAYER_INFLUENCE_MODE)
+    // Add main layer influence if any (simply add main layer add on other layer)
+    // We multiply by the input mask for the first layer (blendMask.a) because if the mask here is black it means that the layer
+    // is not actually underneath any visible layer so we don't want to inherit its height.
+    float influenceMask = blendMask.a * GetInfluenceMask(layerTexCoord, true, lod);
+    height1 += height0 * _InheritBaseHeight1 * influenceMask;
+    height2 += height0 * _InheritBaseHeight2 * influenceMask;
+    height3 += height0 * _InheritBaseHeight3 * influenceMask;
+    #endif
-#if defined(_MAIN_LAYER_INFLUENCE_MODE)
-    // Think that inheritbasedheight will be 0 if height0 is fully visible in weights. So there is no double contribution of height0
-    float influenceMask = GetInfluenceMask(layerTexCoord, true, lod);
-    float inheritBaseHeight = BlendLayeredScalar(0.0, _InheritBaseHeight1, _InheritBaseHeight2, _InheritBaseHeight3, weights);
-    return heightResult + height0 * inheritBaseHeight * inputBlendMasks.a * influenceMask; // We multiply by the input mask for the first layer because if the mask here is black it means that the layer is not actually underneath any visible layer so we don't want to inherit its height.
-#endif
+    SetEnabledHeightByLayer(height0, height1, height2, height3);
+    #if defined(_HEIGHT_BASED_BLEND)
+    blendMask = ApplyHeightBlend(float4(height0, height1, height2, height3), blendMask);
+    #endif
+    float weights[_MAX_LAYER];
+    ComputeMaskWeights(blendMask, weights);
+    return BlendLayeredScalar(height0, height1, height2, height3, weights);
-    float heightResult = 0.0;
+    return 0.0;
-    return heightResult;
 }
 
 // Calculate weights to apply to each layer

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);
 PROP_DECL(float, _InvTilingScale);

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

 
         private Camera m_CurrCamera = null;
 
-        private int m_LightIndicesCount = 0;
         private ComputeBuffer m_LightIndexListBuffer;
 
         private static readonly int kMaxCascades = 4;
         private RenderTargetIdentifier m_CameraColorRT;
         private RenderTargetIdentifier m_CameraDepthRT;
 
-        private bool m_RenderToIntermediateTarget = false;
         private bool m_IntermediateTextureArray = false;
 
         private const int kShadowDepthBufferBits = 16;
             {
                 m_LightIndexListBuffer.Dispose();
                 m_LightIndexListBuffer = null;
-                m_LightIndicesCount = 0;
             }
         }
 
 
         private void ShadowPass(VisibleLight[] visibleLights, ref ScriptableRenderContext context, ref LightData lightData)
         {
-            if (m_Asset.AreShadowsEnabled() && lightData.mainLightIndex != -1) 
+            if (m_Asset.AreShadowsEnabled() && lightData.mainLightIndex != -1)
             {
                 VisibleLight mainLight = visibleLights[lightData.mainLightIndex];
                 if (mainLight.light.shadows != LightShadows.None)
 
             // Setup camera matrices
             context.SetupCameraProperties(m_CurrCamera, stereoEnabled);
- 
+
             RendererConfiguration rendererSettings = GetRendererSettings(ref lightData);
 
             BeginForwardRendering(ref context, renderingConfig);
         // shadow lights types.
         // Lightweight pipeline only supports 1 single directional shadow light.
         // Any additional pixel lights don't cast shadows.
-        // 
+        //
         // 2) If shadows are disabled or no shadow light is present then main light is the main brighest directional
         // 3) If neither a shadow light or main light is first visible light.
         private int GetMainLightIndex(VisibleLight[] lights)
             int mainShadowLight = -1;
 
-            for (int i = 0; i < lights.Length; ++i) 
+            for (int i = 0; i < lights.Length; ++i)
-                if (shadowsEnabled && LightweightUtils.IsSupportedShadowType (lights[i].lightType) && lights[i].light.shadows != LightShadows.None) 
+                if (shadowsEnabled && LightweightUtils.IsSupportedShadowType (lights[i].lightType) && lights[i].light.shadows != LightShadows.None)
                 {
                     // Shadow Type priority: Soft > Hard > None
                     if (mainShadowLight < 0 || lights[i].light.shadows > lights[mainShadowLight].light.shadows)
-                if (lights[i].lightType == LightType.Directional) 
+                if (lights[i].lightType == LightType.Directional)
                 {
                     if (mainDirectional < 0 || lights[i].light.intensity > lights[mainDirectional].light.intensity)
                         mainDirectional = i;
-            if (mainShadowLight >= 0) 
+            if (mainShadowLight >= 0)
-            } 
+            }
-            
+
             return 0;
         }
 
         {
             // Main light has an optimized shader path for main light. This will benefit games that only care about a single light.
             // Lightweight pipeline also supports only a single shadow light, if available it will be the main light.
-            if (lightData.mainLightIndex != -1) 
+            if (lightData.mainLightIndex != -1)
             {
                 SetupMainLightConstants (cmd, lights, lightData.mainLightIndex, ref context);
                 if (lightData.shadowsRendered)
 
             int[] lightIndexMap = m_CullResults.GetLightIndexMap();
             int lightIter = 0;
-            for (int i = 0; i < totalLightCount; ++i) 
+            for (int i = 0; i < totalLightCount; ++i)
-                if (i == lightData.mainLightIndex || lightIter >= maxLights) 
+                if (i == lightData.mainLightIndex || lightIter >= maxLights)
                 {
                     lightIndexMap[i] = -1;
                     continue;