Fixed LayeredLit test scene for UV3 case (data was corrupted by Vertex Tool Pro...)

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

             Triplanar,
         }
 
-        public enum LayerUVDetailMapping
-        {
-            UV0,
-            UV1,
-            UV3
-        }
-
         private class StylesLayer
         {
             public readonly GUIContent[] layerLabels =
         MaterialProperty layerEmissiveColorMap = null;
         MaterialProperty layerEmissiveIntensity = null;
 
-        private void FindLayerProperties(MaterialProperty[] props)
+        override protected void FindMaterialProperties(MaterialProperty[] props)
+			FindMaterialOptionProperties(props);
+
             layerMaskMap = FindProperty(kLayerMaskMap, props);
             layerMaskVertexColor = FindProperty(kLayerMaskVertexColor, props);
             layerCount = FindProperty(kLayerCount, props);
             return layerChanged;
         }
 
-        protected override void SetupKeywordsForInputMaps(Material material)
+		protected override void SetupMaterialKeywords(Material material)
+			SetupCommonOptionsKeywords(material);
+			SetupLayersKeywords(material);
+
             // Find first non null layer
             int i = 0;
             while (i < numLayer && (m_MaterialLayers[i] == null)) ++i;
 
             SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
             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_UV3", false);
+			for (int layer = 0; layer < numLayer; ++layer)
+			{
+				string uvBase = string.Format("{0}{1}", kUVBase, layer);
+				string uvDetail = string.Format("{0}{1}", kUVDetail, layer);
+
+				if (
+					 ((UVDetailMapping)material.GetFloat(uvDetail) == UVDetailMapping.UV3) ||
+					 ((LayerUVBaseMapping)material.GetFloat(uvBase) == LayerUVBaseMapping.UV3)
+					)
+				{
+					SetKeyword(material, "_REQUIRE_UV3", true);
+					break;
+				}
+			}
-        void SetupMaterialForLayers(Material material)
+		void SetupLayersKeywords(Material material)
         {
             if (numLayer == 4)
             {
                 string layerUVBaseParam = string.Format("{0}{1}", kUVBase, i);
                 LayerUVBaseMapping layerUVBaseMapping = (LayerUVBaseMapping)material.GetFloat(layerUVBaseParam);
                 string layerUVDetailParam = string.Format("{0}{1}", kUVDetail, i);
-                LayerUVDetailMapping layerUVDetailMapping = (LayerUVDetailMapping)material.GetFloat(layerUVDetailParam);
+                UVDetailMapping layerUVDetailMapping = (UVDetailMapping)material.GetFloat(layerUVDetailParam);
                 string currentLayerMappingTriplanar = string.Format("{0}{1}", kLayerMappingTriplanar, i);
 
                 float X, Y, Z, W;
                 }
                 else
                 {
-                    X = (layerUVDetailMapping == LayerUVDetailMapping.UV0) ? 1.0f : 0.0f;
-                    Y = (layerUVDetailMapping == LayerUVDetailMapping.UV1) ? 1.0f : 0.0f;
-                    Z = (layerUVDetailMapping == LayerUVDetailMapping.UV3) ? 1.0f : 0.0f;
+                    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
             }
         {
-            FindOptionProperties(props);
-            FindLayerProperties(props);
+            FindCommonOptionProperties(props);
+            FindMaterialProperties(props);
 
             m_MaterialEditor = materialEditor;
 
 
                 foreach (var obj in m_MaterialEditor.targets)
                 {
-                    SetupMaterial((Material)obj);
-                    SetupMaterialForLayers((Material)obj);
+					SetupMaterialKeywords((Material)obj);
                 }
 
                 SaveMaterialLayers(materialImporter);

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

         [HideInInspector] _UVDetailsMappingMask1("_UVDetailsMappingMask1", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVDetailsMappingMask2("_UVDetailsMappingMask2", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVDetailsMappingMask3("_UVDetailsMappingMask3", Color) = (1, 0, 0, 0)
-
-        // Unused but to be able to share litUI.Sahder and layeredUI.Shader
-        [HideInInspector] _UVBase("UV Set for base", Float) = 0
-        [HideInInspector] _UVDetail("UV Set for base", Float) = 0
-        [HideInInspector] _TexWorldScale("Tiling", Float) = 1.0
-        [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
-        [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0)
     }
 
     HLSLINCLUDE

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

             EditorGUI.showMixedValue = false;
         }
 
-        protected void FindOptionProperties(MaterialProperty[] props)
+        protected void FindCommonOptionProperties(MaterialProperty[] props)
         {
             surfaceType = FindProperty(kSurfaceType, props);
             blendMode = FindProperty(kBlendMode, props);
-            FindInputOptionProperties(props);
-        protected void SetupMaterial(Material material)
+        protected void SetupCommonOptionsKeywords(Material material)
         {
             bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
             SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
             }
 
             SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
-            SetupInputMaterial(material);
+
             SetupEmissionGIFlags(material);
         }
 
             if (EditorGUI.EndChangeCheck())
             {
                 foreach (var obj in m_MaterialEditor.targets)
-                    SetupMaterial((Material)obj);
+                    SetupMaterialKeywords((Material)obj);
-            FindOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
-            FindInputProperties(props);
+            FindCommonOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
+			FindMaterialProperties(props);
 
             m_MaterialEditor = materialEditor;
             Material material = materialEditor.target as Material;
         const string kDoubleSidedMode = "_DoubleSidedMode";
         protected static string[] reservedProperties = new string[] { kSurfaceType, kBlendMode, kAlphaCutoff, kAlphaCutoffEnabled, kDoubleSidedMode };
 
-        protected abstract void FindInputProperties(MaterialProperty[] props);
-        protected abstract void ShaderInputGUI();
+        protected abstract void FindMaterialProperties(MaterialProperty[] props);
+		protected abstract void ShaderInputGUI();
-        protected abstract void FindInputOptionProperties(MaterialProperty[] props);
-        protected abstract void SetupInputMaterial(Material material);
+        protected abstract void SetupMaterialKeywords(Material material);
         protected abstract bool ShouldEmissionBeEnabled(Material material);
     }
 } // namespace UnityEditor

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

         protected MaterialProperty emissiveIntensity = null;
         protected const string kEmissiveIntensity = "_EmissiveIntensity";
 
-        override protected void FindInputOptionProperties(MaterialProperty[] props)
+        // These are options that are shared with the LayeredLit shader. Don't put anything that can't be shared here:
+        // For instance, properties like BaseColor and such don't exist in the LayeredLit so don't put them here.
+        protected void FindMaterialOptionProperties(MaterialProperty[] props)
-            UVBase = FindProperty(kUVBase, props);
-            TexWorldScale = FindProperty(kTexWorldScale, props);
-            UVMappingMask = FindProperty(kUVMappingMask, props);
-            UVDetail = FindProperty(kUVDetail, props);
-            UVDetailsMappingMask = FindProperty(kUVDetailsMappingMask, props);    
-        override protected void FindInputProperties(MaterialProperty[] props)
+        override protected void FindMaterialProperties(MaterialProperty[] props)
+            FindMaterialOptionProperties(props);
+
             baseColor = FindProperty(kBaseColor, props);
             baseColorMap = FindProperty(kBaseColorMap, props);
             metallic = FindProperty(kMetallic, props);
             anisotropy = FindProperty(kAnisotropy, props);
             anisotropyMap = FindProperty(kAnisotropyMap, props);
 
+            UVBase = FindProperty(kUVBase, props);
+            UVDetail = FindProperty(kUVDetail, props);
+            TexWorldScale = FindProperty(kTexWorldScale, props);
+            UVMappingMask = FindProperty(kUVMappingMask, props);
+            UVDetailsMappingMask = FindProperty(kUVDetailsMappingMask, props);    
+            
             detailMap = FindProperty(kDetailMap, props);
             detailMask = FindProperty(kDetailMask, props);
             detailAlbedoScale = FindProperty(kDetailAlbedoScale, props);
             base.AssignNewShaderToMaterial(material, oldShader, newShader);
         }
 
-        protected virtual void SetupKeywordsForInputMaps(Material material)
-        {
-            SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap) || material.GetTexture(kDetailMap)); // With details map, we always use a normal map and Unity provide a default (0, 0, 1) normal map for ir
-            SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap));
-            SetKeyword(material, "_SPECULAROCCLUSIONMAP", material.GetTexture(kSpecularOcclusionMap));
-            SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
-            SetKeyword(material, "_HEIGHTMAP", material.GetTexture(kHeightMap));
-            SetKeyword(material, "_TANGENTMAP", material.GetTexture(kTangentMap));
-            SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));
-            SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
-        }
-
         protected override bool ShouldEmissionBeEnabled(Material mat)
         {
             float emissiveIntensity = mat.GetFloat(kEmissiveIntensity);
 
-        override protected void SetupInputMaterial(Material material)
+        override protected void SetupMaterialKeywords(Material material)
+			SetupCommonOptionsKeywords(material);
+
             // 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, "_DETAIL_MAP_WITH_NORMAL", ((DetailMapMode)material.GetFloat(kDetailMapMode)) == DetailMapMode.DetailWithNormal);
-            SetKeyword(material, "_REQUIRE_UV3", ((UVDetailMapping)material.GetFloat(kUVDetail)) == UVDetailMapping.UV3 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0);
- 
-            SetupKeywordsForInputMaps(material);
+
+			SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap) || material.GetTexture(kDetailMap)); // With details map, we always use a normal map and Unity provide a default (0, 0, 1) normal map for ir
+			SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap));
+			SetKeyword(material, "_SPECULAROCCLUSIONMAP", material.GetTexture(kSpecularOcclusionMap));
+			SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
+			SetKeyword(material, "_HEIGHTMAP", material.GetTexture(kHeightMap));
+			SetKeyword(material, "_TANGENTMAP", material.GetTexture(kTangentMap));
+			SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));
+			SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
+
+			SetKeyword(material, "_REQUIRE_UV3", ((UVDetailMapping)material.GetFloat(kUVDetail)) == UVDetailMapping.UV3 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0);
+
         }
     }
 } // namespace UnityEditor

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

     output.texCoord2 = input.uv2;
 #endif
 
+#ifdef _REQUIRE_UV3
+	output.texCoord3 = input.uv3;
+#endif
+
     float4 tangentWS = float4(TransformObjectToWorldDir(input.tangentOS.xyz), input.tangentOS.w);
 
     float3x3 tangentToWorld = CreateTangentToWorld(normalWS, tangentWS.xyz, tangentWS.w);

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Unlit/Editor/BaseUnlitUI.cs

 
         protected MaterialEditor m_MaterialEditor;
 
-        public void FindOptionProperties(MaterialProperty[] props)
+        public void FindCommonOptionProperties(MaterialProperty[] props)
         {
             surfaceType = FindProperty(kSurfaceType, props);
             blendMode = FindProperty(kBlendMode, props);
-            FindInputOptionProperties(props);
-            FindOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
-            FindInputProperties(props);
+            FindCommonOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
+            FindMaterialProperties(props);
 
             m_MaterialEditor = materialEditor;
             Material material = materialEditor.target as Material;
             if (EditorGUI.EndChangeCheck())
             {
                 foreach (var obj in m_MaterialEditor.targets)
-                    SetupMaterial((Material)obj);
+                    SetupMaterialKeywords((Material)obj);
             }
         }
 
             EditorGUI.showMixedValue = false;
         }
 
-        protected void SetupMaterial(Material material)
-        {
-            // Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation
+		protected void SetupCommonOptionsKeywords(Material material)
+		{
+			// 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)
 
             bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
             }
 
             SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
-            SetupInputMaterial(material);
 
             // Setup lightmap emissive flags
             MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
 
                 material.globalIlluminationFlags = flags;
             }
-        }
+		}
 
         bool HasValidEmissiveKeyword(Material material)
         {
                 m.DisableKeyword(keyword);
         }
 
-        protected abstract void FindInputProperties(MaterialProperty[] props);
+        protected abstract void FindMaterialProperties(MaterialProperty[] props);
-        protected abstract void FindInputOptionProperties(MaterialProperty[] props);
-        protected abstract void SetupInputMaterial(Material material);
+		protected abstract void SetupMaterialKeywords(Material material);
-}
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Unlit/Editor/UnlitUI.cs

         protected const string kEmissiveColorMap = "_EmissiveColorMap";
         protected const string kEmissiveIntensity = "_EmissiveIntensity";
 
-        override protected void FindInputProperties(MaterialProperty[] props)
+        override protected void FindMaterialProperties(MaterialProperty[] props)
         {
             color = FindProperty("_Color", props);
             colorMap = FindProperty("_ColorMap", props);
         {
         }
 
-        protected override void FindInputOptionProperties(MaterialProperty[] props)
+        protected override void SetupMaterialKeywords(Material material)
-        }
-
-        protected override void SetupInputMaterial(Material material)
-        {
+			SetupCommonOptionsKeywords(material);
             SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
         }
 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer0_UV3.mat

   m_Shader: {fileID: 4800000, guid: 81d02e8644315b742b154842a3a2f98c, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
     _DISTORTIONONLY_OFF _EMISSION _EMISSIVE_COLOR _LAYER_MASK_VERTEX_COLOR _NORMALMAP_TANGENT_SPACE
+    _REQUIRE_UV3
   m_LightmapFlags: 1
   m_CustomRenderQueue: -1
   stringTagMap: {}
     - _TexWorldScale3: 1
     - _UVBase: 0
     - _UVBase0: 2
-    - _UVBase1: 0
+    - _UVBase1: 2
     - _UVBase2: 0
     - _UVBase3: 0
     - _UVDetail: 0
     - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask0: {r: 0, g: 0, b: 1, a: 0}
-    - _UVMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 0, g: 0, b: 1, a: 0}
     - _UVMappingMask2: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask3: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer0_UV3.mat.meta

 fileFormatVersion: 2
 guid: 3e3a7e6d5f3b8164eb7c110dd465185d
-timeCreated: 1480934266
+timeCreated: 1481280690
 licenseType: Pro
 NativeFormatImporter:
   userData: '{"GUIDArray":["a02ccd7b5946da643a654ccea743375b","686eb5593c0e94f4eb86ca1d3cfef7fa","",""]}'

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer3_UV3.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: Layered_Layer3_UV3
   m_Shader: {fileID: 4800000, guid: 81d02e8644315b742b154842a3a2f98c, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+  disabledShaderPasses: []
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _DetailMap0:
-        m_Texture: {fileID: 0}
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
-        m_Texture: {fileID: 0}
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
-        m_Texture: {fileID: 0}
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
-        m_Texture: {fileID: 0}
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _DetailMask:

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer3_UV3.mat.meta

 fileFormatVersion: 2
 guid: b5dde76940778384c891440343094268
-timeCreated: 1480681119
+timeCreated: 1481281006
 licenseType: Pro
 NativeFormatImporter:
   userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","6c40a6ba55a62fc4c92fdc1cdee2f85a"]}'