HDRenderLoop: Add detail map to lit shader

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

             Parallax,
             Displacement,
         }
+        public enum DetailMapMode
+        {
+            DetailWithNormal,
+            DetailWithAOHeight,
+        }
 
         private static class Styles
         {
+            public static GUIContent uvSetLabel = new GUIContent("UV Set");
+            public static string detailText = "Inputs Detail";
+            public static string lightingText = "Inputs Lighting";
 
             public static GUIContent alphaCutoffEnableText = new GUIContent("Alpha Cutoff Enable", "Threshold for alpha cutoff");
             public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
 
             public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel");
             public static GUIContent emissiveColorModeText = new GUIContent("Emissive Color Usage", "Use emissive color or emissive mask");
+            public static GUIContent detailMapModeText = new GUIContent("Detail Map with Normal", "Detail Map with AO / Height");
 
             public static string InputsText = "Inputs";
 
             public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (BC5) - DXT5 for test");
             public static GUIContent normalMapSpaceText = new GUIContent("Normal/Tangent Map space", "");
 
-            public static GUIContent heightMapText = new GUIContent("Height Map", "Height Map");
+            public static GUIContent heightMapText = new GUIContent("Height Map (R)", "Height Map");
-            public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map", "Anisotropy (R)");
+            public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map (G)", "Anisotropy");
+
+            public static GUIContent detailMapNormalText = new GUIContent("Detail Map A(R) Ny(G) S(B) Nx(A)", "Detail Map");
+            public static GUIContent detailMapAOHeightText = new GUIContent("Detail Map  A(R) AO(G) S(B) H(A)", "Detail Map");
+            public static GUIContent detailMaskText = new GUIContent("Detail Mask (B)", "Mask for detailMap");
+            public static GUIContent detailAlbedoScaleText = new GUIContent("Detail AlbedoScale", "Detail Albedo Scale factor");
+            public static GUIContent detailNormalScaleText = new GUIContent("Detail NormalScale", "Normal Scale factor");
+            public static GUIContent detailSmoothnessScaleText = new GUIContent("Detail SmoothnessScale", "Smoothness Scale factor");
+            public static GUIContent detailHeightScaleText = new GUIContent("Detail HeightScale", "Height Scale factor");
+            public static GUIContent detailAOScaleText = new GUIContent("Detail AOScale", "AO Scale factor");
 
             public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
             public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
 
         MaterialProperty surfaceType = null;
         MaterialProperty blendMode = null;
+        MaterialProperty UVDetail = null;
+        MaterialProperty detailMapMode = null;
 
         MaterialProperty baseColor = null;
         MaterialProperty baseColorMap = null;
         MaterialProperty anisotropy = null;
         MaterialProperty anisotropyMap = null;
         MaterialProperty heightMapMode = null;
+        MaterialProperty detailMap = null;
+        MaterialProperty detailMask = null;
+        MaterialProperty detailAlbedoScale = null;
+        MaterialProperty detailNormalScale = null;
+        MaterialProperty detailSmoothnessScale = null;
+        MaterialProperty detailHeightScale = null;
+        MaterialProperty detailAOScale = null;
         MaterialProperty emissiveColor = null;
         MaterialProperty emissiveColorMap = null;
         MaterialProperty emissiveIntensity = null;
 
         protected const string kSurfaceType = "_SurfaceType";
         protected const string kBlendMode = "_BlendMode";
+        protected const string kUVDetail = "_UVDetail";
         protected const string kAlphaCutoff = "_AlphaCutoff";
         protected const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
         protected const string kDoubleSidedMode = "_DoubleSidedMode";
         protected const string kHeightMapMode = "_HeightMapMode";
+        protected const string kDetailMapMode = "_DetailMapMode";
 
         protected const string kNormalMap = "_NormalMap";
         protected const string kMaskMap = "_MaskMap";
         protected const string kTangentMap = "_TangentMap";
         protected const string kAnisotropyMap = "_AnisotropyMap";
+        protected const string kDetailMap = "_DetailMap";
+        protected const string kDetailMask = "_DetailMask";
+        protected const string kDetailAlbedoScale = "_DetailAlbedoScale";
+        protected const string kDetailNormalScale = "_DetailNormalScale";
+        protected const string kDetailSmoothnessScale = "_DetailSmoothnessScale";
+        protected const string kDetailHeightScale = "_DetailHeightScale";
+        protected const string kDetailAOScale = "_DetailAOScale";
+            UVDetail = FindProperty(kUVDetail, props);
             alphaCutoff = FindProperty(kAlphaCutoff, props);
             alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
             doubleSidedMode = FindProperty(kDoubleSidedMode, props);
             heightMapMode = FindProperty(kHeightMapMode, props);
+            detailMapMode = FindProperty(kDetailMapMode, props);
         }
 
         public void FindInputProperties(MaterialProperty[] props)
             emissiveColor = FindProperty("_EmissiveColor", props);
             emissiveColorMap = FindProperty(kEmissiveColorMap, props);
             emissiveIntensity = FindProperty("_EmissiveIntensity", props);
+            detailMap = FindProperty(kDetailMap, props);
+            detailMask = FindProperty(kDetailMask, props);
+            detailAlbedoScale = FindProperty(kDetailAlbedoScale, props);
+            detailNormalScale = FindProperty(kDetailNormalScale, props);
+            detailSmoothnessScale = FindProperty(kDetailSmoothnessScale, props);
+            detailHeightScale = FindProperty(kDetailHeightScale, props);
+            detailAOScale = FindProperty(kDetailAOScale, props);
         }
 
         public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
             m_MaterialEditor.ShaderProperty(emissiveColorMode, Styles.emissiveColorModeText.text);
             m_MaterialEditor.ShaderProperty(normalMapSpace, Styles.normalMapSpaceText.text);
             m_MaterialEditor.ShaderProperty(heightMapMode, Styles.heightMapModeText.text);
+            m_MaterialEditor.ShaderProperty(detailMapMode, Styles.detailMapModeText.text);
             EditorGUI.indentLevel--;
         }
 
             bool smoothnessInAlbedoAlpha = (SmoothnessMapChannel)smoothnessMapChannel.floatValue == SmoothnessMapChannel.AlbedoAlpha;
             bool useEmissiveMask = (EmissiveColorMode)emissiveColorMode.floatValue == EmissiveColorMode.UseEmissiveMask;
+            bool useDetailMapWithNormal = (DetailMapMode)detailMapMode.floatValue == DetailMapMode.DetailWithNormal;
 
             GUILayout.Label(Styles.InputsText, EditorStyles.boldLabel);
             m_MaterialEditor.TexturePropertySingleLine(smoothnessInAlbedoAlpha ? Styles.baseColorSmoothnessText : Styles.baseColorText, baseColorMap, baseColor);
             
             m_MaterialEditor.TexturePropertySingleLine(Styles.anisotropyMapText, anisotropyMap);
 
+            EditorGUILayout.Space();
+            GUILayout.Label(Styles.detailText, EditorStyles.boldLabel);
+
+            m_MaterialEditor.TexturePropertySingleLine(Styles.detailMaskText, detailMask); 
+			m_MaterialEditor.ShaderProperty(UVDetail, Styles.uvSetLabel.text);          
+
+            if (useDetailMapWithNormal)
+            {
+                m_MaterialEditor.TexturePropertySingleLine(Styles.detailMapNormalText, detailMap);
+            }
+            else
+            {
+                m_MaterialEditor.TexturePropertySingleLine(Styles.detailMapAOHeightText, detailMap);
+            }
+            m_MaterialEditor.TextureScaleOffsetProperty(detailMap);
+            EditorGUI.indentLevel++;
+            m_MaterialEditor.ShaderProperty(detailAlbedoScale, Styles.detailAlbedoScaleText);
+            m_MaterialEditor.ShaderProperty(detailNormalScale, Styles.detailNormalScaleText);
+            m_MaterialEditor.ShaderProperty(detailSmoothnessScale, Styles.detailSmoothnessScaleText);
+            m_MaterialEditor.ShaderProperty(detailHeightScale, Styles.detailHeightScaleText);
+            m_MaterialEditor.ShaderProperty(detailAOScale, Styles.detailAOScaleText);
+            EditorGUI.indentLevel--;
+
+            EditorGUILayout.Space();
+            GUILayout.Label(Styles.lightingText, EditorStyles.boldLabel);
+
             if (!useEmissiveMask)
             {
                 m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
 
         protected virtual void SetupKeywordsForInputMaps(Material material)
         {
-            SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap));
+            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, "_DETAIL_MAP", material.GetTexture(kDetailMap));
         }
 
         protected virtual void SetupEmissionGIFlags(Material material)
             SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", ((SmoothnessMapChannel)material.GetFloat(kSmoothnessTextureChannelProp)) == SmoothnessMapChannel.AlbedoAlpha);
             SetKeyword(material, "_EMISSIVE_COLOR", ((EmissiveColorMode)material.GetFloat(kEmissiveColorMode)) == EmissiveColorMode.UseEmissiveColor);
             SetKeyword(material, "_HEIGHTMAP_AS_DISPLACEMENT", (HeightmapMode)material.GetFloat(kHeightMapMode) == HeightmapMode.Displacement);
+            SetKeyword(material, "_DETAIL_MAP_WITH_NORMAL", (DetailMapMode)material.GetFloat(kDetailMapMode) == DetailMapMode.DetailWithNormal);
 
             SetupKeywordsForInputMaps(material);
             SetupEmissionGIFlags(material);

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

         _Anisotropy("Anisotropy", Range(0.0, 1.0)) = 0
         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 
+        _DetailMap("DetailMap", 2D) = "black" {}
+        _DetailMask("DetailMask", 2D) = "white" {}
+        _DetailAlbedoScale("_DetailAlbedoScale", Range(-2.0, 2.0)) = 1
+        _DetailNormalScale("_DetailNormalScale", Range(0.0, 2.0)) = 1
+        _DetailSmoothnessScale("_DetailSmoothnessScale", Range(-2.0, 2.0)) = 1
+        _DetailHeightScale("_DetailHeightScale", Range(-2.0, 2.0)) = 1
+        _DetailAOScale("_DetailAOScale", Range(-2.0, 2.0)) = 1
+        [Enum(UV0, 0, UV1, 1)] _UVDetail("UV Set for detailMap", Float) = 0
+
         _SubSurfaceRadius("SubSurfaceRadius", Range(0.0, 1.0)) = 0
         _SubSurfaceRadiusMap("SubSurfaceRadiusMap", 2D) = "white" {}
         //_Thickness("Thickness", Range(0.0, 1.0)) = 0
         [Enum(Mask Alpha, 0, BaseColor Alpha, 1)] _SmoothnessTextureChannel("Smoothness texture channel", Float) = 1
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
         [Enum(None, 0, DoubleSided, 1, DoubleSidedLigthingFlip, 2, DoubleSidedLigthingMirror, 3)] _DoubleSidedMode("Double sided mode", Float) = 0
+        [Enum(DetailMapNormal, 0, DetailMapAOHeight, 1)] _DetailMapMode("DetailMap mode", Float) = 0
     }
 
     HLSLINCLUDE
     #pragma shader_feature _HEIGHTMAP_AS_DISPLACEMENT
     #pragma shader_feature _TANGENTMAP
     #pragma shader_feature _ANISOTROPYMAP
+    #pragma shader_feature _DETAIL_MAP
+    #pragma shader_feature _DETAIL_MAP_WITH_NORMAL
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
 
     TEXTURE2D(_NormalMap);
     SAMPLER2D(sampler_NormalMap);
+
+    TEXTURE2D(_DetailMask);
+    SAMPLER2D(sampler_DetailMask);
+    TEXTURE2D(_DetailMap);
+    SAMPLER2D(sampler_DetailMap);
+    float4  _DetailMap_ST;
+    float _UVDetail;
+    float _DetailAlbedoScale;
+    float _DetailNormalScale;
+    float _DetailSmoothnessScale;
+    float _DetailHeightScale;
+    float _DetailAOScale;
+
     TEXTURE2D(_HeightMap);
     SAMPLER2D(sampler_HeightMap);
 

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

     return float2(0.0, 0.0);
 #endif
 }
-                                           
+                                
+float3 LerpWhiteTo(float3 b, float t)
+{
+    float oneMinusT = 1.0 - t;
+    return float3(oneMinusT, oneMinusT, oneMinusT) + b * t;
+}
+
+// Transforms 2D UV by scale/bias property
+#define TRANSFORM_TEX(tex,name) ((tex.xy) * name##_ST.xy + name##_ST.zw)
+
+
 #if !defined(LAYERED_LIT_SHADER)
 
 void GetSurfaceAndBuiltinData(FragInput input, out SurfaceData surfaceData, out BuiltinData builtinData)
     #endif
 #endif
 
+#ifdef _DETAIL_MAP
+    float2 texCoordDetail = TRANSFORM_TEX(_UVDetail ? input.texCoord1 : input.texCoord0, _DetailMap);
+    float detailMask = SAMPLE_TEXTURE2D(_DetailMask, sampler_DetailMask, input.texCoord0).b;
+    float4 detail = SAMPLE_TEXTURE2D(_DetailMap, sampler_DetailMap, texCoordDetail);
+    float detailAlbedo = detail.r;
+    float detailSmoothness = detail.b;
+    #ifdef _DETAIL_MAP_WITH_NORMAL
+    float3 detailNormalTS = UnpackNormalAG(detail, _DetailNormalScale);
+    //float detailAO = 0.0;
+    #else
+    // TODO: Use heightmap as a derivative with Morten Mikklesen approach
+    // Or reconstruct
+    float U = SAMPLE_TEXTURE2D(_DetailMap, sampler_DetailMap, texCoordDetail + float2(0.005, 0)).a;
+    float V = SAMPLE_TEXTURE2D(_DetailMap, sampler_DetailMap, texCoordDetail + float2(0, 0.005)).a;
+    float dHdU = U - detail.a;	//create bump map U offset
+    float dHdV = V - detail.a;	//create bump map V offset
+    //float3 detailNormal = 1 - float3(dHdU, dHdV, 0.05);	//create the tangent space normal
+    float3 detailNormalTS = float3(0.0, 0.0, 1.0);
+    //float3 detailNormal = UnpackNormalAG(unifiedDetail.r).a;
+    //float detailAO = detail.b;
+    #endif
+#endif
+
+#ifdef _DETAIL_MAP
+    surfaceData.baseColor *= LerpWhiteTo(2.0 * saturate(detailAlbedo * _DetailAlbedoScale), detailMask);
+#endif
+
 #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     float alpha = _BaseColor.a;
 #else
 
 #ifdef _NORMALMAP
     #ifdef _NORMALMAP_TANGENT_SPACE
-    float3 normalTS = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, input.texCoord0));
-    surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
-    #else // Object space (TODO: We need to apply the world rotation here! - Require to pass world transform)
-    surfaceData.normalWS = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, input.texCoord0).rgb;
+        float3 normalTS = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, input.texCoord0));
+        #ifdef _DETAIL_MAP
+        normalTS = lerp(normalTS, blendNormal(normalTS, detailNormalTS), detailMask);
+        #endif
+        surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
+    #else // Object space
+        float3 normalOS = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, input.texCoord0).rgb;
+        surfaceData.normalWS = TransformObjectToWorldDir(normalOS);
+        #ifdef _DETAIL_MAP
+        float3 detailNormalWS = TransformTangentToWorld(detailNormalTS, input.tangentToWorld);
+        surfaceData.normalWS = lerp(surfaceData.normalWS, blendNormal(surfaceData.normalWS, detailNormalWS), detailMask);
+        #endif
     #endif
 #else
     surfaceData.normalWS = vertexNormalWS;
     surfaceData.perceptualSmoothness = 1.0;
 #endif
     surfaceData.perceptualSmoothness *= _Smoothness;
+#ifdef _DETAIL_MAP
+    surfaceData.perceptualSmoothness *= LerpWhiteTo(2.0 * saturate(detailSmoothness * _DetailSmoothnessScale), detailMask);
+#endif
 
     surfaceData.materialId = 0;
 
     // TODO: Is there anything todo regarding flip normal but for the tangent ?
 
 #ifdef _ANISOTROPYMAP
-    surfaceData.anisotropy = SAMPLE_TEXTURE2D(_AnisotropyMap, sampler_AnisotropyMap, input.texCoord0).r;
+    surfaceData.anisotropy = SAMPLE_TEXTURE2D(_AnisotropyMap, sampler_AnisotropyMap, input.texCoord0).g;
 #else
     surfaceData.anisotropy = 1.0;
 #endif

Assets/ScriptableRenderLoop/ShaderLibrary/CommonMaterial.hlsl

     return viewDirTS.xy * height;
 }
 
+// ref http://blog.selfshadow.com/publications/blending-in-detail/
+// ref https://gist.github.com/selfshadow/8048308
+// Reoriented Normal Mapping
+// Blending when n1 and n2 are already 'unpacked' and normalised
+float3 blendNormalRNM(float3 n1, float3 n2)
+{
+    float3 t = n1.xyz + float3(0.0, 0.0, 1.0);
+    float3 u = n2.xyz * float3(-1.0, -1.0, 1.0);
+    float3 r = (t / t.z) * dot(t, u) - u;
+    return r;
+}
+
+float3 blendNormal(float3 n1, float3 n2)
+{
+    return normalize(float3(n1.xy * n2.z + n2.xy * n1.z, n1.z * n2.z));
+}
+
+
 
 #endif // UNITY_COMMON_MATERIAL_INCLUDED

Assets/ScriptableRenderLoop/ShaderLibrary/Packing.hlsl

     return normalize(n);
 }
 
-float3 UnpackNormalAG(float4 packedNormal)
+float3 UnpackNormalAG(float4 packedNormal, float scale = 1.0)
+    normal.xy *= scale;
     normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));
     return normal;
 }

Assets/TestScenes/HDTest/HDRenderLoopTest.unity

     - target: {fileID: 2374582, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_Materials.Array.data[0]
       value: 
-      objectReference: {fileID: 2100000, guid: 87c86082ee14fbd4b8426a8794f2060d, type: 2}
+      objectReference: {fileID: 2100000, guid: 5dd25721c8df9b24b90a773fca15e636, type: 2}
     m_RemovedComponents: []
   m_ParentPrefab: {fileID: 100100000, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
   m_IsPrefabParent: 0

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/test details.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: test details
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AmbientOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatCoverageMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatRoughnessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 2800000, guid: d896c388b98bb614ebe6bb48e0f56dcf, type: 3}
+        m_Scale: {x: 0.99, y: 1}
+        m_Offset: {x: 1.52, y: 1}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailsMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DiffuseLightingMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DiffuseMap:
+        m_Texture: {fileID: 2800000, guid: d734753529ca78148a43944515a64bc5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MettalicMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 2800000, guid: fe2ed6aee0b5acd42bc15ee53e939e03, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SmoothnessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CoatCoverage: 0
+    - _CoatRoughness: 0
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSided: 1
+    - _DoubleSidedLigthing: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _MaterialID: 0
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metallic: 0
+    - _Mettalic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 0.524
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceProfile: 0
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _Thickness: 0
+    - _UVDetail: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.5588235, g: 0.5588235, b: 0.5588235, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DiffuseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.04, g: 0.04, b: 0.04, a: 1}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/test details.mat.meta

+fileFormatVersion: 2
+guid: 5dd25721c8df9b24b90a773fca15e636
+timeCreated: 1474299392
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: