Merge branch 'master' into scriptablerenderloop-graphicssettings

.gitignore

 
 Library/*
 Temp/*
+obj/*
 *.csproj
 *.sln
 *.suo
 *.aspx
 *.sdf
 *.userprefs
-
-Assets/UnityHDRI.meta
-Assets/UnityHDRI/Gareoult/GareoultWhiteBalanced.exr
-obj/Debug/Assembly-CSharp.csproj.FileListAbsolute.txt

Assets/BasicRenderLoopTutorial/BasicRenderLoop.cs

 {
 
 #if UNITY_EDITOR
-    [UnityEditor.MenuItem("Renderloop/CreateBasicRenderLoop")]
+    [UnityEditor.MenuItem("Renderloop/Create BasicRenderLoop")]
-        UnityEditor.AssetDatabase.CreateAsset(instance, "Assets/basicrenderloop.asset");
+        UnityEditor.AssetDatabase.CreateAsset(instance, "Assets/BasicRenderLoopTutorial/BasicRenderLoop.asset");
     }
 #endif
 
 
             // Draw opaque objects using BasicPass shader pass
             var settings = new DrawRendererSettings (cull, camera, shaderPassBasic);
-            settings.sorting.sortOptions = SortOptions.SortByMaterialThenMesh;
+            settings.sorting.flags = SortFlags.CommonOpaque;
             settings.inputFilter.SetQueuesOpaque ();
             loop.DrawRenderers (ref settings);
 
             // Draw transparent objects using BasicPass shader pass
-            settings.sorting.sortOptions = SortOptions.BackToFront; // sort back to front
+            settings.sorting.flags = SortFlags.CommonTransparent;
             settings.inputFilter.SetQueuesTransparent ();
             loop.DrawRenderers (ref settings);
 

Assets/BasicRenderLoopTutorial/BasicRenderLoopScene.unity

   m_ReflectionIntensity: 0.5
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.09067501, g: 0.11147752, b: 0.14205909, a: 0.5}
+  m_IndirectSpecularColor: {r: 0.09067552, g: 0.11147809, b: 0.14205924, a: 0.5}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
     minRegionArea: 2
     manualCellSize: 0
     cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
     accuratePlacement: 0
   m_NavMeshData: {fileID: 0}
 --- !u!1 &261580742
   m_Father: {fileID: 0}
   m_RootOrder: 10
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1084503476
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1084503480}
+  - component: {fileID: 1084503479}
+  - component: {fileID: 1084503478}
+  - component: {fileID: 1084503477}
+  m_Layer: 5
+  m_Name: Canvas
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1084503477
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1084503476}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1301386320, guid: f70555f144d8491a825f0804e09c671c, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IgnoreReversedGraphics: 1
+  m_BlockingObjects: 0
+  m_BlockingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+--- !u!114 &1084503478
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1084503476}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1980459831, guid: f70555f144d8491a825f0804e09c671c, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 1
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 1
+  m_ReferenceResolution: {x: 800, y: 600}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0
+  m_PhysicalUnit: 3
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+--- !u!223 &1084503479
+Canvas:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1084503476}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_RenderMode: 0
+  m_Camera: {fileID: 0}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 0
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+  m_TargetDisplay: 0
+--- !u!224 &1084503480
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1084503476}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_Children:
+  - {fileID: 1177504218}
+  m_Father: {fileID: 0}
+  m_RootOrder: 11
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}
+--- !u!1 &1177504217
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1177504218}
+  - component: {fileID: 1177504220}
+  - component: {fileID: 1177504219}
+  m_Layer: 5
+  m_Name: Text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1177504218
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1177504217}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1084503480}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 163, y: 47.8}
+  m_SizeDelta: {x: 314, y: 82}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1177504219
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1177504217}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 708705254, guid: f70555f144d8491a825f0804e09c671c, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: UnityEngine.UI.MaskableGraphic+CullStateChangedEvent, UnityEngine.UI,
+      Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 14
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 40
+    m_Alignment: 6
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: Select "BasicRenderLoop" as the render pipeline in Edit -> Project Settings
+    -> Graphics
+--- !u!222 &1177504220
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1177504217}
 --- !u!1 &1280249095
 GameObject:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1677622456}
   m_Enabled: 1
-  serializedVersion: 7
+  serializedVersion: 8
   m_Type: 0
   m_Color: {r: 0.75, g: 1, b: 0.78275865, a: 1}
   m_Intensity: 1.5
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
+  m_CCT: 6570
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &1677622458
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1900527473}
   m_Enabled: 1
-  serializedVersion: 7
+  serializedVersion: 8
   m_Type: 2
   m_Color: {r: 1, g: 0.6911765, b: 0.6911765, a: 1}
   m_Intensity: 3
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
+  m_CCT: 6570
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &1900527475
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 2011495862}
   m_Enabled: 1
-  serializedVersion: 7
+  serializedVersion: 8
   m_Type: 1
   m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
   m_Intensity: 1
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
+  m_CCT: 6570
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &2011495864
   m_Father: {fileID: 0}
   m_RootOrder: 7
   m_LocalEulerAnglesHint: {x: -6.8960004, y: -33.794003, z: -20.829}
+--- !u!1 &2054727025
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 2054727028}
+  - component: {fileID: 2054727027}
+  - component: {fileID: 2054727026}
+  m_Layer: 0
+  m_Name: EventSystem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &2054727026
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2054727025}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1077351063, guid: f70555f144d8491a825f0804e09c671c, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_HorizontalAxis: Horizontal
+  m_VerticalAxis: Vertical
+  m_SubmitButton: Submit
+  m_CancelButton: Cancel
+  m_InputActionsPerSecond: 10
+  m_RepeatDelay: 0.5
+  m_ForceModuleActive: 0
+--- !u!114 &2054727027
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2054727025}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: -619905303, guid: f70555f144d8491a825f0804e09c671c, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_FirstSelected: {fileID: 0}
+  m_sendNavigationEvents: 1
+  m_DragThreshold: 5
+--- !u!4 &2054727028
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2054727025}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 12
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

Assets/ScriptableRenderLoop/HDRenderLoop/Debug/Resources/DebugViewMaterialGBuffer.shader

             #pragma target 5.0
             #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
 
-            #pragma vertex VertDeferred
-            #pragma fragment FragDeferred
+            #pragma vertex Vert
+            #pragma fragment Frag
 
             #include "Common.hlsl"
             #include "Color.hlsl"
                 float4 positionCS : SV_POSITION;
             };
 
-            Varyings VertDeferred(Attributes input)
+            Varyings Vert(Attributes input)
             {
                 // TODO: implement SV_vertexID full screen quad
                 Varyings output;
                 return output;
             }
 
-            float4 FragDeferred(Varyings input) : SV_Target
+            float4 Frag(Varyings input) : SV_Target
-                float depth = _CameraDepthTexture.Load(uint3(coord.unPositionSS, 0)).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
 
                 FETCH_GBUFFER(gbuffer, _GBufferTexture, coord.unPositionSS);
                 BSDFData bsdfData;

Assets/ScriptableRenderLoop/HDRenderLoop/Debug/Resources/DebugViewTiles.shader

 Shader "Hidden/HDRenderLoop/DebugViewTiles"
 {
-	SubShader
-	{
+    SubShader
+    {
-		Pass
-	    {
-		    ZWrite Off
-		    Blend SrcAlpha OneMinusSrcAlpha
+        Pass
+        {
+            ZWrite Off
+            Blend SrcAlpha OneMinusSrcAlpha
-		    HLSLPROGRAM
+            HLSLPROGRAM
-            #pragma vertex VertViewTiles
-            #pragma fragment FragViewTiles
+            #pragma vertex Vert
+            #pragma fragment Frag
-            #define LIGHTLOOP_TILE_PASS 1
-            #define USE_FPTL_LIGHTLIST	1		//TODO: make it also work with clustered
+            #define LIGHTLOOP_TILE_PASS 1            
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-		    //-------------------------------------------------------------------------------------
-		    // Include
-		    //-------------------------------------------------------------------------------------
+            //-------------------------------------------------------------------------------------
+            // Include
+            //-------------------------------------------------------------------------------------
-		    // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
-		    // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
-		    // the deferred shader will require to use multicompile.
+            // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
+            // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
+            // the deferred shader will require to use multicompile.
-		    //-------------------------------------------------------------------------------------
-		    // variable declaration
-		    //-------------------------------------------------------------------------------------
+            //-------------------------------------------------------------------------------------
+            // variable declaration
+            //-------------------------------------------------------------------------------------
-	        uint _ViewTilesFlags;
+            uint _ViewTilesFlags;
-	        TEXTURE2D(_CameraDepthTexture);
-	        SAMPLER2D(sampler_CameraDepthTexture);
+            TEXTURE2D(_CameraDepthTexture);
+            SAMPLER2D(sampler_CameraDepthTexture);
-	        float4 VertViewTiles(float3 positionOS : POSITION): SV_POSITION
-	        {
-		        return TransformWorldToHClip(TransformObjectToWorld(positionOS));
-	        }
+            float4x4 _InvViewProjMatrix;
+
+            float4 Vert(float3 positionOS : POSITION): SV_POSITION
+            {
+                return TransformWorldToHClip(TransformObjectToWorld(positionOS));
+            }
 
             float4 OverlayHeatMap(uint2 pixCoord, uint numLights)
             {
                     float4(1.0, 0.0, 0.0, 0.9)    // strong red
                 };
 
-                float maxNrLightsPerTile = 31;
+                float maxNrLightsPerTile = 31; // TODO: setup a constant for that
-                int nColorIndex = numLights == 0 ? 0 : (1 + (int)floor(10 * (log2((float)numLights) / log2(maxNrLightsPerTile))));
-                nColorIndex = nColorIndex<0 ? 0 : nColorIndex;
-                float4 col = nColorIndex>11 ? float4(1.0, 1.0, 1.0, 1.0) : kRadarColors[nColorIndex];
+                int colorIndex = numLights == 0 ? 0 : (1 + (int)floor(10 * (log2((float)numLights) / log2(maxNrLightsPerTile))));
+                colorIndex = colorIndex < 0 ? 0 : colorIndex;
+                float4 col = colorIndex > 11 ? float4(1.0, 1.0, 1.0, 1.0) : kRadarColors[colorIndex];
 
                 int2 coord = pixCoord - int2(1, 1);
 
                 return color;
             }
 
-	        float4 FragViewTiles(float4 positionCS : SV_POSITION) : SV_Target
-	        {
-		        Coordinate coord = GetCoordinate(positionCS.xy, _ScreenSize.zw);
+            float4 Frag(float4 positionCS : SV_POSITION) : SV_Target
+            {
+                Coordinate coord = GetCoordinate(positionCS.xy, _ScreenSize.zw);
-                #if USE_FPTL_LIGHTLIST
-		        float linearDepth = 0.0;
+                #ifdef USE_CLUSTERED_LIGHTLIST
+                // Perform same calculation than in deferred.shader
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
+                float3 positionWS = UnprojectToWorld(depth, coord.positionSS, _InvViewProjMatrix);
+                float linearDepth = TransformWorldToView(positionWS).z; // View space linear depth
-		        float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
-		        float linearDepth = GetLinearDepth(depth);
+                float linearDepth = 0.0; // unused
-		        int n = 0;
-		        if (_ViewTilesFlags & DEBUGVIEWTILESFLAGS_DIRECT_LIGHTING)
-		        {
-			        uint punctualLightStart;
-			        uint punctualLightCount;
-			        GetCountAndStart(coord, DIRECT_LIGHT, linearDepth, punctualLightStart, punctualLightCount);
-			        n += punctualLightCount;
-		        }
+                int n = 0;
+                for (int category = 0; category < LIGHTCATEGORY_COUNT; category++)
+                {
+                    uint mask = 1u << category;
+                    if (mask & _ViewTilesFlags)
+                    {
+                        uint start;
+                        uint count;
+                        GetCountAndStart(coord, category, linearDepth, start, count);
+                        n += count;
+                    }
+                }
+                
+                if (n > 0)
+                {
+                    return OverlayHeatMap(int2(coord.unPositionSS.xy) & 15, n);
+                }
+                else
+                {
+                    return 0.0;
+                }
+            }
-		        if (_ViewTilesFlags & DEBUGVIEWTILESFLAGS_REFLECTION)
-		        {
-			        uint envLightStart;
-			        uint envLightCount;
-			        GetCountAndStart(coord, REFLECTION_LIGHT, linearDepth, envLightStart, envLightCount);
-			        n += envLightCount;
-		        }
-
-		        if (n > 0)
-		        {
-			        return OverlayHeatMap(int2(coord.unPositionSS.xy) & 15, n);
-		        }
-		        else
-		        {
-			        return 0.0;
-		        }
-	        }
-
-		    ENDHLSL
-	    }
-	}
-	Fallback Off
-}
+            ENDHLSL
+        }
+    }
+    Fallback Off
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/HDRenderLoopInspector.cs

 
             public readonly GUIContent useForwardRenderingOnly = new GUIContent("Use Forward Rendering Only");
             public readonly GUIContent useDepthPrepass = new GUIContent("Use Depth Prepass");
-            public readonly GUIContent useSinglePassLightLoop = new GUIContent("Use single Pass light loop");
 
             public bool isDebugViewMaterialInit = false;
             public GUIContent[] debugViewMaterialStrings = null;
+            public readonly GUIContent skyResolution = new GUIContent("Sky Resolution");
             public readonly GUIContent skyExposure = new GUIContent("Sky Exposure");
             public readonly GUIContent skyRotation = new GUIContent("Sky Rotation");
             public readonly GUIContent skyMultiplier = new GUIContent("Sky Multiplier");
             public readonly GUIContent shadowsCascades = new GUIContent("Cascade values");
 
             public readonly GUIContent tileLightLoopSettings = new GUIContent("Tile Light Loop settings");
-            public readonly GUIContent tileLightLoopDebugMode = new GUIContent("Enable Debug mode", "Toggle overheat map mode");
-            public readonly GUIContent directIndirectSinglePass = new GUIContent("Enable direct and indirect lighting in single pass", "Toggle");
+            public readonly string[] tileLightLoopDebugTileFlagStrings = new string[] { "Punctual Light", "Area Light", "Env Light"};
+            public readonly GUIContent splitLightEvaluation = new GUIContent("Split light and reflection evaluation", "Toggle");
-            public readonly GUIContent clustered = new GUIContent("Enable clusted", "Toggle");   
+            public readonly GUIContent clustered = new GUIContent("Enable clustered", "Toggle");
+            public readonly GUIContent disableTileAndCluster = new GUIContent("Disable Tile/clustered", "Toggle");
+            
+
+
+            public readonly GUIContent textureSettings = new GUIContent("texture Settings");
+
+            public readonly GUIContent spotCookieSize = new GUIContent("spotCookie Size");
+            public readonly GUIContent pointCookieSize = new GUIContent("pointCookie Size");
+            public readonly GUIContent reflectionCubemapSize = new GUIContent("reflectionCubemap Size");              
         }
 
         private static Styles s_Styles = null;
                 FillWithProperties(typeof(Builtin.BuiltinData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Lit.SurfaceData)), ref index);
                 FillWithProperties(typeof(Lit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Lit.SurfaceData)), ref index);
                 FillWithProperties(typeof(Builtin.BuiltinData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);
-                FillWithProperties(typeof(Unlit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);                
+                FillWithProperties(typeof(Unlit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);
 
                 // Engine
                 FillWithPropertiesEnum(typeof(Attributes.DebugViewGbuffer), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, "", true, ref index);
             EditorGUILayout.Space();
             debugParameters.displayOpaqueObjects = EditorGUILayout.Toggle(styles.displayOpaqueObjects, debugParameters.displayOpaqueObjects);
             debugParameters.displayTransparentObjects = EditorGUILayout.Toggle(styles.displayTransparentObjects, debugParameters.displayTransparentObjects);
-			debugParameters.useForwardRenderingOnly = EditorGUILayout.Toggle(styles.useForwardRenderingOnly, debugParameters.useForwardRenderingOnly);
+            debugParameters.useForwardRenderingOnly = EditorGUILayout.Toggle(styles.useForwardRenderingOnly, debugParameters.useForwardRenderingOnly);
-            debugParameters.useSinglePassLightLoop = EditorGUILayout.Toggle(styles.useSinglePassLightLoop, debugParameters.useSinglePassLightLoop);     
 
             if (EditorGUI.EndChangeCheck())
             {
             EditorGUI.BeginChangeCheck();
 
             skyParameters.skyHDRI = (Texture)EditorGUILayout.ObjectField("Cubemap", skyParameters.skyHDRI, typeof(Cubemap), false);
+
+            skyParameters.skyResolution = (SkyResolution)EditorGUILayout.EnumPopup(styles.skyResolution, skyParameters.skyResolution);
             skyParameters.exposure = Mathf.Max(Mathf.Min(EditorGUILayout.FloatField(styles.skyExposure, skyParameters.exposure), 32), -32);
             skyParameters.multiplier = Mathf.Max(EditorGUILayout.FloatField(styles.skyMultiplier, skyParameters.multiplier), 0);
             skyParameters.rotation = Mathf.Max(Mathf.Min(EditorGUILayout.FloatField(styles.skyRotation, skyParameters.rotation), 360), -360);
             EditorGUI.indentLevel++;
             EditorGUI.BeginChangeCheck();
 
-
             shadowParameters.enabled = EditorGUILayout.Toggle(styles.shadowsEnabled, shadowParameters.enabled);
             shadowParameters.shadowAtlasWidth = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasWidth, shadowParameters.shadowAtlasWidth));
             shadowParameters.shadowAtlasHeight = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasHeight, shadowParameters.shadowAtlasHeight));
             EditorGUI.indentLevel++;
-            for (int i = 0; i < shadowParameters.directionalLightCascadeCount-1; i++)
+            for (int i = 0; i < shadowParameters.directionalLightCascadeCount - 1; i++)
-            
             if (EditorGUI.EndChangeCheck())
             {
                 EditorUtility.SetDirty(renderLoop); // Repaint
             EditorGUILayout.Space();
-            EditorGUILayout.LabelField(styles.tileLightLoopSettings);
+            var textureParameters = renderLoop.textureSettings;
+
+            EditorGUILayout.LabelField(styles.textureSettings);
-            renderLoop.tilePassLightLoop.debugViewTilesFlags = (TilePass.DebugViewTilesFlags)EditorGUILayout.EnumMaskField("DebugView Tiles", renderLoop.tilePassLightLoop.debugViewTilesFlags);
-            renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass = EditorGUILayout.Toggle(styles.directIndirectSinglePass, renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass);
-            renderLoop.tilePassLightLoop.enableBigTilePrepass = EditorGUILayout.Toggle(styles.bigTilePrepass, renderLoop.tilePassLightLoop.enableBigTilePrepass);
-            renderLoop.tilePassLightLoop.enableClustered = EditorGUILayout.Toggle(styles.clustered, renderLoop.tilePassLightLoop.enableClustered);
+            textureParameters.spotCookieSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.spotCookieSize, textureParameters.spotCookieSize), 16, 1024));
+            textureParameters.pointCookieSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.pointCookieSize, textureParameters.pointCookieSize), 16, 1024));
+            textureParameters.reflectionCubemapSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.reflectionCubemapSize, textureParameters.reflectionCubemapSize), 64, 1024));
 
             if (EditorGUI.EndChangeCheck())
             {
+
+
+            EditorGUILayout.Space();
+
+            // TODO: we should call a virtual method or something similar to setup the UI, inspector should not know about it
+            TilePass.LightLoop tilePass = renderLoop.lightLoop as TilePass.LightLoop;
+            if (tilePass != null)
+            {
+                EditorGUILayout.LabelField(styles.tileLightLoopSettings);
+                EditorGUI.indentLevel++;
+                EditorGUI.BeginChangeCheck();
+
+                tilePass.enableBigTilePrepass = EditorGUILayout.Toggle(styles.bigTilePrepass, tilePass.enableBigTilePrepass);
+                tilePass.enableClustered = EditorGUILayout.Toggle(styles.clustered, tilePass.enableClustered);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    EditorUtility.SetDirty(renderLoop); // Repaint
+
+                    // If something is chanage regarding tile/cluster rendering we need to force a OnValidate() OnHDRenderLoop, else change Rebuild() will not be call
+                    renderLoop.OnValidate();
+                }
+
+                EditorGUI.BeginChangeCheck();
+
+                tilePass.debugViewTilesFlags = EditorGUILayout.MaskField("DebugView Tiles", tilePass.debugViewTilesFlags, styles.tileLightLoopDebugTileFlagStrings);
+                tilePass.enableSplitLightEvaluation = EditorGUILayout.Toggle(styles.splitLightEvaluation, tilePass.enableSplitLightEvaluation);
+                tilePass.disableTileAndCluster = EditorGUILayout.Toggle(styles.disableTileAndCluster, tilePass.disableTileAndCluster);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    EditorUtility.SetDirty(renderLoop); // Repaint
+                    UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+                }
+                EditorGUI.indentLevel--;
+            }
         }
     }
 }

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset

     rotation: 0
     exposure: 0
     multiplier: 1
+    skyResolution: 256
   m_ShadowSettings:
     enabled: 1
     shadowAtlasWidth: 4096
     spotCookieSize: 128
     pointCookieSize: 512
     reflectionCubemapSize: 128
+  m_Dirty: 0

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset.meta

 fileFormatVersion: 2
 guid: 2400b74f5ce370c4481e5dc417d03703
-timeCreated: 1480436907
+timeCreated: 1481084818
 licenseType: Pro
 NativeFormatImporter:
   userData: 

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

         SkyRenderer m_SkyRenderer = null;
         [SerializeField]
         SkyParameters m_SkyParameters = new SkyParameters();
- 
+
         public SkyParameters skyParameters
         {
             get { return m_SkyParameters; }
 
             public bool enableTonemap = true;
             public float exposure = 0;
-
-            public bool useSinglePassLightLoop = true;
         }
 
         DebugParameters m_DebugParameters = new DebugParameters();
 
                 return colorMRTs;
             }
-        
+
             /*
             public void BindBuffers(Material mat)
             {
 
         ShadowRenderPass m_ShadowPass;
 
-
-        public const int k_MaxDirectionalLightsOnSCreen = 2;
-        public const int k_MaxPunctualLightsOnSCreen = 512;
-        public const int k_MaxAreaLightsOnSCreen = 128;
-        public const int k_MaxEnvLightsOnSCreen = 64;
-        public const int k_MaxShadowOnScreen = 16;
-        public const int k_MaxCascadeCount = 4; //Should be not less than m_Settings.directionalLightCascadeCount;
-
+        public TextureSettings textureSettings
+        {
+            get { return m_TextureSettings; }
+        }
+
         // Various set of material use in render loop
         Material m_FinalPassMaterial;
         Material m_DebugViewMaterialGBuffer;
         int m_VelocityBuffer;
         int m_DistortionBuffer;
 
-        bool m_Dirty = false;
+        public bool m_Dirty = false;
-		
-        public class LightList
-        {
-            public List<DirectionalLightData> directionalLights;
-            public List<DirectionalShadowData> directionalShadows;
-            public List<LightData> punctualLights;
-            public List<PunctualShadowData> punctualShadows;
-            public List<LightData> areaLights;
-            public List<EnvLightData> envLights;
-            public Vector4[] directionalShadowSplitSphereSqr;
-
-            // Index mapping list to go from GPU lights (above) to CPU light (in cullResult)
-            public List<int> directionalCullIndices;
-            public List<int> punctualCullIndices;
-            public List<int> areaCullIndices;
-            public List<int> envCullIndices;
-
-            public void Clear()
-            {
-                directionalLights.Clear();
-                directionalShadows.Clear();
-                punctualLights.Clear();
-                punctualShadows.Clear();
-                areaLights.Clear();
-                envLights.Clear();
-
-                directionalCullIndices.Clear();
-                punctualCullIndices.Clear();
-                areaCullIndices.Clear();
-                envCullIndices.Clear();
-            }
-
-            public void Allocate()
-            {
-                directionalLights = new List<DirectionalLightData>();
-                punctualLights = new List<LightData>();
-                areaLights = new List<LightData>();
-                envLights = new List<EnvLightData>();
-                punctualShadows = new List<PunctualShadowData>();
-                directionalShadows = new List<DirectionalShadowData>();
-                directionalShadowSplitSphereSqr = new Vector4[k_MaxCascadeCount];
-
-                directionalCullIndices = new List<int>();
-                punctualCullIndices = new List<int>();
-                areaCullIndices = new List<int>();
-                envCullIndices = new List<int>();
-            }
-        }
-
-        LightList m_lightList;
-        // TODO: Find a way to automatically create/iterate through lightloop
-        SinglePass.LightLoop m_SinglePassLightLoop;
-        TilePass.LightLoop m_TilePassLightLoop = null;
-        public TilePass.LightLoop tilePassLightLoop
+        // This must be allocate outside of Rebuild() else the option in the class can't be set in the inspector (as it will in this case recreate the class with default value)
+        BaseLightLoop m_lightLoop = new TilePass.LightLoop();
+
+        public BaseLightLoop lightLoop
-            get { return m_TilePassLightLoop; }
+            get { return m_lightLoop; }
-        Lit.RenderLoop m_LitRenderLoop;
-
-        TextureCacheCubemap m_CubeReflTexArray;
-        TextureCache2D m_CookieTexArray;
-        TextureCacheCubemap m_CubeCookieTexArray;
+        // TODO TO CHECK: SebL I move allocation from Rebuild() to here, but there was a comment "// Our object can be garbage collected, so need to be allocate here", it is still true ?
+        Lit.RenderLoop m_LitRenderLoop = new Lit.RenderLoop();
-        private void OnValidate()
+        public void OnValidate()
+            // Calling direction Rebuild() here cause this warning:
+            // "SendMessage cannot be called during Awake, CheckConsistency, or OnValidate UnityEngine.Experimental.ScriptableRenderLoop.HDRenderLoop:OnValidate()"
+            // Workaround is to declare this dirty flag and call REbuild in Render()
-            m_CameraColorBuffer  = Shader.PropertyToID("_CameraColorTexture");
+            // We call Cleanup() here because Rebuild() can be call by OnValidate(), i.e when inspector is touch
+            // Note that module don't need to do the same as the call here is propagated correctly
+            Cleanup();
+
+            m_CameraColorBuffer = Shader.PropertyToID("_CameraColorTexture");
             m_CameraDepthBuffer  = Shader.PropertyToID("_CameraDepthTexture");
 
             m_CameraColorBufferRT = new RenderTargetIdentifier(m_CameraColorBuffer);
             m_ShadowPass = new ShadowRenderPass(m_ShadowSettings);
 
             // Init Gbuffer description
-            m_LitRenderLoop = new Lit.RenderLoop(); // Our object can be garbage collected, so need to be allocate here
 
             m_gbufferManager.gbufferCount = m_LitRenderLoop.GetMaterialGBufferCount();
             RenderTextureFormat[] RTFormat; RenderTextureReadWrite[] RTReadWrite;
             m_DistortionBufferRT = new RenderTargetIdentifier(m_DistortionBuffer);
 
             m_LitRenderLoop.Rebuild();
-
-            m_CookieTexArray = new TextureCache2D();
-            m_CookieTexArray.AllocTextureArray(8, (int)m_TextureSettings.spotCookieSize, (int)m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
-            m_CubeCookieTexArray = new TextureCacheCubemap();
-            m_CubeCookieTexArray.AllocTextureArray(4, (int)m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
-            m_CubeReflTexArray = new TextureCacheCubemap();
-            m_CubeReflTexArray.AllocTextureArray(32, (int)m_TextureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
-
-            // Init various light loop
-            m_SinglePassLightLoop = new SinglePass.LightLoop();
-            m_SinglePassLightLoop.Rebuild();
-            m_TilePassLightLoop = new TilePass.LightLoop();
-            tilePassLightLoop.Rebuild();
-
-            m_lightList = new LightList();
-            m_lightList.Allocate();
+            m_lightLoop.Rebuild(m_TextureSettings);
 
             m_Dirty = false;
         }
 
         public override void Cleanup()
         {
-            m_LitRenderLoop.OnDisable();
-            m_SinglePassLightLoop.OnDisable();
-            tilePassLightLoop.OnDisable();
+            m_LitRenderLoop.Cleanup();
+            m_lightLoop.Cleanup();
-            m_CubeReflTexArray.Release();
-            m_CookieTexArray.Release();
-            m_CubeCookieTexArray.Release();
-
-            m_SkyRenderer.OnDisable();
+            if (m_SkyRenderer != null)
+            {
+                m_SkyRenderer.Cleanup();
+            }
 
 #if UNITY_EDITOR
             UnityEditor.SupportedRenderingFeatures.active = UnityEditor.SupportedRenderingFeatures.Default;
-        void NewFrame()
-        {
-            m_CookieTexArray.NewFrame();
-            m_CubeCookieTexArray.NewFrame();
-            m_CubeReflTexArray.NewFrame();
-        }
-
-            // We clear only the depth buffer, no need to clear the various color buffer as we overwrite them.
-            // Clear depth/stencil and init buffers
+                // We clear only the depth buffer, no need to clear the various color buffer as we overwrite them.
+                // Clear depth/stencil and init buffers
-                        cmd.name = "";
+                    cmd.name = "";
 
                     // Init buffer
                     // With scriptable render loop we must allocate ourself depth and color buffer (We must be independent of backbuffer for now, hope to fix that later).
                 // TEMP: As we are in development and have not all the setup pass we still clear the color in emissive buffer and gbuffer, but this will be removed later.
 
                 // Clear HDR target
-                    using (new Utilities.ProfilingSample("Clear HDR target", renderLoop))
+                using (new Utilities.ProfilingSample("Clear HDR target", renderLoop))
-                        Utilities.SetRenderTarget(renderLoop, m_CameraColorBufferRT, m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black);
+                    Utilities.SetRenderTarget(renderLoop, m_CameraColorBufferRT, m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black);
-                    using (new Utilities.ProfilingSample("Clear GBuffer", renderLoop))
+                using (new Utilities.ProfilingSample("Clear GBuffer", renderLoop))
-                        Utilities.SetRenderTarget(renderLoop, m_gbufferManager.GetGBuffers(), m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black);
+                    Utilities.SetRenderTarget(renderLoop, m_gbufferManager.GetGBuffers(), m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black);
                 }
 
                 // END TEMP
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
             {
                 rendererConfiguration = rendererConfiguration,
-                sorting = { sortOptions = SortOptions.SortByMaterialThenMesh }
-            };        
+                sorting = { flags = SortFlags.CommonOpaque }
+            };
             settings.inputFilter.SetQueuesOpaque();
             renderLoop.DrawRenderers(ref settings);
         }
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
             {
                 rendererConfiguration = rendererConfiguration,
-                sorting = { sortOptions = SortOptions.BackToFront }
+                sorting = { flags = SortFlags.CommonTransparent }
             };
             settings.inputFilter.SetQueuesTransparent();
             renderLoop.DrawRenderers(ref settings);
 
             using (new Utilities.ProfilingSample("Depth Prepass", renderLoop))
             {
-                // TODO: Must do opaque then alpha masked for performance! 
+                // TODO: Must do opaque then alpha masked for performance!
                 // TODO: front to back for opaque and by materal for opaque tested when we split in two
                 Utilities.SetRenderTarget(renderLoop, m_CameraDepthBufferRT);
                 RenderOpaqueRenderList(cull, camera, renderLoop, "DepthOnly");
             if (debugParameters.useDepthPrepass)
                 return;
 
-            using (new Utilities.ProfilingSample("Depth Prepass", renderLoop))
+            using (new Utilities.ProfilingSample("Forward opaque depth", renderLoop))
+                // or use the new MAterial.SetPassEnable ?
                 Utilities.SetRenderTarget(renderLoop, m_CameraDepthBufferRT);
                 RenderOpaqueRenderList(cull, camera, renderLoop, "DepthOnly");
             }
                 return ;
             }
 
-            using (new Utilities.ProfilingSample("Single Pass - Deferred Lighting Pass", renderLoop))
-            {
-                // Bind material data
-                m_LitRenderLoop.Bind();
-                if (debugParameters.useSinglePassLightLoop)
-                {
-                    m_SinglePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
-                }
-                else
-                {
-                    tilePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBufferRT);
-                }
-            }
+            // Bind material data
+            m_LitRenderLoop.Bind();
+            m_lightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
         }
 
         void RenderSky(Camera camera, RenderLoop renderLoop)
 
-        void RenderForward(CullResults cullResults, Camera camera, RenderLoop renderLoop)
+        void RenderForward(CullResults cullResults, Camera camera, RenderLoop renderLoop, bool renderOpaque)
+            // TODO: Currently we can't render opaque object forward when deferred is enabled
+            // miss option
+            if (!debugParameters.useForwardRenderingOnly && renderOpaque)
+                return;
+
             using (new Utilities.ProfilingSample("Forward Pass", renderLoop))
             {
                 // Bind material data
 
-                if (debugParameters.useForwardRenderingOnly)
+                m_lightLoop.RenderForward(camera, renderLoop, renderOpaque);
+
+                if (renderOpaque)
-
-                RenderTransparentRenderList(cullResults, camera, renderLoop, "Forward", Utilities.kRendererConfigurationBakedLighting);
+                else
+                {
+                    RenderTransparentRenderList(cullResults, camera, renderLoop, "Forward", Utilities.kRendererConfigurationBakedLighting);
+                }
             }
         }
 
             }
         }
 
+#if UNITY_EDITOR
+        public override void RenderSceneView(Camera camera, RenderLoop renderLoop)
+        {
+            base.RenderSceneView(camera, renderLoop);
+            renderLoop.PrepareForEditorRendering(camera, m_CameraDepthBufferRT);
+            renderLoop.Submit();
+        }
+#endif
 
         void FinalPass(RenderLoop renderLoop)
         {
             }
         }
 
+
-        void PrepareLightsForGPU(CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput, ref LightList lightList)
+        void PrepareLightsForGPU(CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput)
-            lightList.Clear();
-
-            for (int lightIndex = 0, numLights = cullResults.visibleLights.Length; lightIndex < numLights; ++lightIndex)
-            {
-                var light = cullResults.visibleLights[lightIndex];
-
-                // We only process light with additional data
-                var additionalData = light.light.GetComponent<AdditionalLightData>();
-
-                if (additionalData == null)
-                {
-                    Debug.LogWarning("Light entity detected without additional data, will not be taken into account " + light.light.name);
-                    continue;
-                }
-
-                // Linear intensity calculation (different Unity 5.5)
-                var lightColorR = light.light.intensity * Mathf.GammaToLinearSpace(light.light.color.r);
-                var lightColorG = light.light.intensity * Mathf.GammaToLinearSpace(light.light.color.g);
-                var lightColorB = light.light.intensity * Mathf.GammaToLinearSpace(light.light.color.b);
-
-                if (light.lightType == LightType.Directional)
-                {
-                    if (lightList.directionalLights.Count >= k_MaxDirectionalLightsOnSCreen)
-                        continue;
-
-                    var directionalLightData = new DirectionalLightData();
-                    // Light direction for directional and is opposite to the forward direction
-                    directionalLightData.direction = -light.light.transform.forward;
-                    directionalLightData.color = new Vector3(lightColorR, lightColorG, lightColorB);
-                    directionalLightData.diffuseScale = additionalData.affectDiffuse ? 1.0f : 0.0f;
-                    directionalLightData.specularScale = additionalData.affectSpecular ? 1.0f : 0.0f;
-                    directionalLightData.cosAngle = 0.0f;
-                    directionalLightData.sinAngle = 0.0f;
-                    directionalLightData.shadowIndex = -1;
-
-                    bool hasDirectionalShadows = light.light.shadows != LightShadows.None && shadowOutput.GetShadowSliceCountLightIndex(lightIndex) != 0;
-                    bool hasDirectionalNotReachMaxLimit = lightList.directionalShadows.Count == 0; // Only one cascade shadow allowed
-
-                    if (hasDirectionalShadows && hasDirectionalNotReachMaxLimit) // Note  < MaxShadows should be check at shadowOutput creation
-                    {
-                        // When we have a point light, we assumed that there is 6 consecutive PunctualShadowData
-                        directionalLightData.shadowIndex = 0;
-
-                        for (int sliceIndex = 0; sliceIndex < shadowOutput.GetShadowSliceCountLightIndex(lightIndex); ++sliceIndex)
-                        {
-                            DirectionalShadowData directionalShadowData = new DirectionalShadowData();
-
-                            int shadowSliceIndex = shadowOutput.GetShadowSliceIndex(lightIndex, sliceIndex);
-                            directionalShadowData.worldToShadow = shadowOutput.shadowSlices[shadowSliceIndex].shadowTransform.transpose; // Transpose for hlsl reading ?
-
-                            directionalShadowData.bias = light.light.shadowBias;
-
-                            lightList.directionalShadows.Add(directionalShadowData);
-                        }
-
-                        // Fill split information for shaders
-                        for (int s = 0; s < k_MaxCascadeCount; ++s)
-                        {
-                            lightList.directionalShadowSplitSphereSqr[s] = shadowOutput.directionalShadowSplitSphereSqr[s];
-                        }
-                    }
-
-                    lightList.directionalLights.Add(directionalLightData);
-                    lightList.directionalCullIndices.Add(lightIndex);
-
-                    continue;
-                }
-
-                // Note: LightType.Area is offline only, use for baking, no need to test it
-                var lightData = new LightData();
-
-                // Test whether we should treat this punctual light as an area light.
-                // It's a temporary hack until the proper UI support is added.
-                if (additionalData.archetype != LightArchetype.Punctual)
-                {
-                    // Early out if we reach the maximum
-                    if (lightList.areaLights.Count >= k_MaxAreaLightsOnSCreen)
-                        continue;
-
-                    if (additionalData.archetype == LightArchetype.Rectangle)
-                    {
-                        lightData.lightType = GPULightType.Rectangle;
-                    }
-                    else
-                    {
-                        lightData.lightType = GPULightType.Line;
-                    }
-                }
-                else
-                {
-                    if (lightList.punctualLights.Count >= k_MaxPunctualLightsOnSCreen)
-                        continue;
-
-                    switch (light.lightType)
-                    {
-                        case LightType.Directional: lightData.lightType = GPULightType.Directional; break;
-                        case LightType.Spot: lightData.lightType = GPULightType.Spot; break;
-                        case LightType.Point: lightData.lightType = GPULightType.Point; break;
-                    }
-                }
-
-                lightData.positionWS = light.light.transform.position;
-                lightData.invSqrAttenuationRadius = 1.0f / (light.range * light.range);
-
-                lightData.color = new Vector3(lightColorR, lightColorG, lightColorB);
-                
-                lightData.forward = light.light.transform.forward; // Note: Light direction is oriented backward (-Z)
-                lightData.up = light.light.transform.up;
-                lightData.right = light.light.transform.right;
-
-                if (lightData.lightType == GPULightType.Spot)
-                {
-                    var spotAngle = light.spotAngle;
-
-                    var innerConePercent = additionalData.GetInnerSpotPercent01();
-                    var cosSpotOuterHalfAngle = Mathf.Clamp(Mathf.Cos(spotAngle * 0.5f * Mathf.Deg2Rad), 0.0f, 1.0f);
-                    var cosSpotInnerHalfAngle = Mathf.Clamp(Mathf.Cos(spotAngle * 0.5f * innerConePercent * Mathf.Deg2Rad), 0.0f, 1.0f); // inner cone
-
-                    var val = Mathf.Max(0.001f, (cosSpotInnerHalfAngle - cosSpotOuterHalfAngle));
-                    lightData.angleScale = 1.0f / val;
-                    lightData.angleOffset = -cosSpotOuterHalfAngle * lightData.angleScale;
-                }
-                else
-                {
-                    // 1.0f, 2.0f are neutral value allowing GetAngleAnttenuation in shader code to return 1.0
-                    lightData.angleScale = 1.0f;
-                    lightData.angleOffset = 2.0f;
-                }
-
-                lightData.diffuseScale = additionalData.affectDiffuse ? 1.0f : 0.0f;
-                lightData.specularScale = additionalData.affectSpecular ? 1.0f : 0.0f;
-                lightData.shadowDimmer = additionalData.shadowDimmer;
-
-                lightData.IESIndex = -1;
-                lightData.cookieIndex = -1;
-                lightData.shadowIndex = -1;
-
-                bool hasCookie = light.light.cookie != null;
-                if (hasCookie)
-                {
-                    if (light.lightType == LightType.Point)
-                    {
-                        lightData.cookieIndex = m_CubeCookieTexArray.FetchSlice(light.light.cookie);
-                    }
-                    else if (light.lightType == LightType.Spot)
-                    {
-                        lightData.cookieIndex = m_CookieTexArray.FetchSlice(light.light.cookie);
-                    }
-                }
-
-                // Setup shadow data arrays
-                bool hasShadows = light.light.shadows != LightShadows.None && shadowOutput.GetShadowSliceCountLightIndex(lightIndex) != 0;
-                bool hasNotReachMaxLimit = lightList.punctualShadows.Count + (lightData.lightType == GPULightType.Point ? 6 : 1) <= k_MaxShadowOnScreen;
-
-                if (hasShadows && hasNotReachMaxLimit) // Note  < MaxShadows should be check at shadowOutput creation
-                {
-                    // When we have a point light, we assumed that there is 6 consecutive PunctualShadowData
-                    lightData.shadowIndex = lightList.punctualShadows.Count;
-
-                    for (int sliceIndex = 0; sliceIndex < shadowOutput.GetShadowSliceCountLightIndex(lightIndex); ++sliceIndex)
-                    {
-                        PunctualShadowData punctualShadowData = new PunctualShadowData();
-
-                        int shadowSliceIndex = shadowOutput.GetShadowSliceIndex(lightIndex, sliceIndex);
-                        punctualShadowData.worldToShadow = shadowOutput.shadowSlices[shadowSliceIndex].shadowTransform.transpose; // Transpose for hlsl reading ?
-                        punctualShadowData.lightType = lightData.lightType;
-
-                        punctualShadowData.bias = light.light.shadowBias;
-
-                        lightList.punctualShadows.Add(punctualShadowData);
-                    }
-                }
-
-                lightData.size = new Vector2(additionalData.areaLightLength, additionalData.areaLightWidth);
-                lightData.twoSided = additionalData.isDoubleSided;
-
-                if (additionalData.archetype == LightArchetype.Punctual)
-                {
-                    lightList.punctualLights.Add(lightData);
-                    lightList.punctualCullIndices.Add(lightIndex);
-                }
-                else
-                {
-                    // Area and line lights are both currently stored as area lights on the GPU.
-                    lightList.areaLights.Add(lightData);
-                    lightList.areaCullIndices.Add(lightIndex);
-                }
-            }
-
-            for (int probeIndex = 0, numProbes = cullResults.visibleReflectionProbes.Length; probeIndex < numProbes; probeIndex++)
-            {
-                var probe = cullResults.visibleReflectionProbes[probeIndex];
-
-                // If probe have not been rendered discard
-                if (probe.texture == null)
-                    continue;
-
-                if (lightList.envLights.Count >= k_MaxEnvLightsOnSCreen)
-                    continue;
-
-                var envLightData = new EnvLightData();
-
-                // CAUTION: localToWorld is the transform for the widget of the reflection probe. i.e the world position of the point use to do the cubemap capture (mean it include the local offset)
-                envLightData.positionWS = probe.localToWorld.GetColumn(3);
-
-                envLightData.envShapeType = EnvShapeType.None;
-
-                // TODO: Support sphere in the interface
-                if (probe.boxProjection != 0)
-                {
-                    envLightData.envShapeType = EnvShapeType.Box;
-                }
-
-                // remove scale from the matrix (Scale in this matrix is use to scale the widget)
-                envLightData.right = probe.localToWorld.GetColumn(0);
-                envLightData.right.Normalize();
-                envLightData.up = probe.localToWorld.GetColumn(1);
-                envLightData.up.Normalize();
-                envLightData.forward = probe.localToWorld.GetColumn(2);
-                envLightData.forward.Normalize();
-
-                // Artists prefer to have blend distance inside the volume!
-                // So we let the current UI but we assume blendDistance is an inside factor instead
-                // Blend distance can't be larger than the max radius
-                // probe.bounds.extents is BoxSize / 2
-                float maxBlendDist = Mathf.Min(probe.bounds.extents.x, Mathf.Min(probe.bounds.extents.y, probe.bounds.extents.z));
-                float blendDistance = Mathf.Min(maxBlendDist, probe.blendDistance);
-                envLightData.innerDistance = probe.bounds.extents - new Vector3(blendDistance, blendDistance, blendDistance);
-
-                envLightData.envIndex = m_CubeReflTexArray.FetchSlice(probe.texture);
-
-                envLightData.offsetLS = probe.center; // center is misnamed, it is the offset (in local space) from center of the bounding box to the cubemap capture point
-                envLightData.blendDistance = blendDistance;
-                lightList.envLights.Add(envLightData);
-                lightList.envCullIndices.Add(probeIndex);
-            }
-
-            if (debugParameters.useSinglePassLightLoop)
-            {
-                m_SinglePassLightLoop.PrepareLightsForGPU(cullResults, camera, m_lightList);
-            }
-            else
-            {
-                tilePassLightLoop.PrepareLightsForGPU(cullResults, camera, m_lightList);
-            }            
+            m_lightLoop.PrepareLightsForGPU(cullResults, camera, ref shadowOutput);
-            if (camera.pixelWidth != m_WidthOnRecord || camera.pixelHeight != m_HeightOnRecord || tilePassLightLoop.NeedResize())
+            // TODO: Detect if renderdoc just load and force a resize in this case, as often renderdoc require to realloc resource.
+
+            // TODO: This is the wrong way to handle resize/allocation. We can have several different camera here, mean that the loop on camera will allocate and deallocate
+            // the below buffer which is bad. Best is to have a set of buffer for each camera that is persistent and reallocate resource if need
+            // For now consider we have only one camera that go to this code, the main one.
+            m_SkyRenderer.Resize(m_SkyParameters); // TODO: Also a bad naming, here we just want to realloc texture if skyparameters change (usefull for lookdev)
+
+            if (camera.pixelWidth != m_WidthOnRecord || camera.pixelHeight != m_HeightOnRecord || m_lightLoop.NeedResize())
-                    tilePassLightLoop.ReleaseResolutionDependentBuffers();
+                    m_lightLoop.ReleaseResolutionDependentBuffers();
-                tilePassLightLoop.AllocResolutionDependentBuffers(camera.pixelWidth, camera.pixelHeight);
+                m_lightLoop.AllocResolutionDependentBuffers(camera.pixelWidth, camera.pixelHeight);
 
                 // update recorded window resolution
                 m_WidthOnRecord = camera.pixelWidth;
 
-        public void PushGlobalParams(Camera camera, RenderLoop renderLoop, HDRenderLoop.LightList lightList)
+        public void PushGlobalParams(Camera camera, RenderLoop renderLoop)
-            //Shader.SetGlobalTexture("_CookieTextures", m_CookieTexArray.GetTexCache());
-            //Shader.SetGlobalTexture("_CubeCookieTextures", m_CubeCookieTexArray.GetTexCache());
-            Shader.SetGlobalTexture("_EnvTextures", m_CubeReflTexArray.GetTexCache());
-            m_SkyRenderer.SetGlobalSkyTexture();
-
-            if (debugParameters.useSinglePassLightLoop)
+            if (m_SkyRenderer.IsSkyValid(m_SkyParameters))
-                m_SinglePassLightLoop.PushGlobalParams(camera, renderLoop, lightList);
+                m_SkyRenderer.SetGlobalSkyTexture();
+                Shader.SetGlobalInt("_EnvLightSkyEnabled", 1);
-                tilePassLightLoop.PushGlobalParams(camera, renderLoop, lightList);
-            }            
+                Shader.SetGlobalInt("_EnvLightSkyEnabled", 0);
+            }
+
+            m_lightLoop.PushGlobalParams(camera, renderLoop);
         }
 
         public override void Render(Camera[] cameras, RenderLoop renderLoop)
             }
 
             // Do anything we need to do upon a new frame.
-            NewFrame();
+            m_lightLoop.NewFrame();
 
             // Set Frame constant buffer
             // TODO...
 
                 RenderDepthPrepass(cullResults, camera, renderLoop);
 
-                RenderGBuffer(cullResults, camera, renderLoop); 
+                RenderGBuffer(cullResults, camera, renderLoop);
-                // For tile lighting with forward opaque
+                // Forward opaque with deferred tile require that we fill the depth buffer
+                // correctly to build the light list.
+                // TODO: avoid double lighting by tagging stencil or gbuffer that we must not lit.
+                // TODO: ask Morten why this pass is not before GBuffer ? Will make more sense and avoid
+                // to do gbuffer pass on unseen mesh.
+                // TODO: how do we select only the object that must be render forward ?
+                // this is all object with gbuffer pass disabled ?
                 //RenderForwardOpaqueDepth(cullResults, camera, renderLoop);
 
                 if (debugParameters.debugViewMaterial != 0)
 
                     using (new Utilities.ProfilingSample("Build Light list", renderLoop))
                     {
-                        PrepareLightsForGPU(cullResults, camera, ref shadows, ref m_lightList);
-                        if (!debugParameters.useSinglePassLightLoop)
-                            tilePassLightLoop.BuildGPULightLists(camera, renderLoop, m_lightList, m_CameraDepthBufferRT);
+                        m_lightLoop.PrepareLightsForGPU(cullResults, camera, ref shadows);
+                        m_lightLoop.BuildGPULightLists(camera, renderLoop, m_CameraDepthBufferRT);
-                        PushGlobalParams(camera, renderLoop, m_lightList);
+                        PushGlobalParams(camera, renderLoop);
+                    // TODO: enable this for tile forward opaque
+               //     RenderForward(cullResults, camera, renderLoop, true);
+
-                    RenderForward(cullResults, camera, renderLoop); // Note: We want to render forward opaque before RenderSky, then RenderTransparent - can only do that once we have material.SetPass feature...
+                    RenderForward(cullResults, camera, renderLoop, false);
+
-                    RenderVelocity(cullResults, camera, renderLoop); // Note we may have to render velocity earlier if we do temporalAO, temporal volumetric etc... Mean we will not take into account forward opaque in case of deferred rendering ? 
+                    RenderVelocity(cullResults, camera, renderLoop); // Note we may have to render velocity earlier if we do temporalAO, temporal volumetric etc... Mean we will not take into account forward opaque in case of deferred rendering ?
 
                     // TODO: Check with VFX team.
                     // Rendering distortion here have off course lot of artifact.

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs

     public enum GPULightType
     {
         Directional,
-        Spot, 
+        Spot,
         Point,
         ProjectorOrtho,
         ProjectorPyramid,
         public float invSqrAttenuationRadius;
 
         public Vector3 color;
-        public float angleScale; // Spot light
+        public float angleScale;  // Spot light
-        public float angleOffset;
+        public float angleOffset; // Spot light
-        public float diffuseScale; // Spot light
+        public float diffuseScale;
-        
+
         public float shadowDimmer;
         // index are -1 if not used
         public int shadowIndex;
-        public GPULightType lightType;   
+        public GPULightType lightType;
-        public Vector2 size;
+        public Vector2 size; // x = cot(outerHalfAngle) for spot lights
         public bool twoSided;
     };
 
-        public Vector3 direction;
-        public float diffuseScale;
+        public Vector3 forward;
+        public float   diffuseScale;
+
+        public Vector3 up;
+        public float   invScaleY;
+
+        public Vector3 right;
+        public float   invScaleX;
+
+        public Vector3 positionWS;
+        public bool    tileCookie;
-        public float specularScale;        
+        public float   specularScale;
-        // Sun disc size 
-        public float cosAngle; // Distance to disk
-        public float sinAngle; // Disk radius
-        public int shadowIndex;
-        public float unused;
+        // Sun disc size
+        public float cosAngle;  // Distance to the disk
+        public float sinAngle;  // Disk radius
+        public int shadowIndex; // -1 if unused
+        public int cookieIndex; // -1 if unused
     };
 
 
-    public struct PunctualShadowData
+    public struct ShadowData
     {
         // World to ShadowMap matrix
         // Include scale and bias for shadow atlas if any
         public float bias;
         public float quality;
         public float unused;
-    };
-
-    [GenerateHLSL]
-    public struct DirectionalShadowData
-    {
-        // World to ShadowMap matrix
-        // Include scale and bias for shadow atlas if any
-        public Matrix4x4 worldToShadow;
-
-        public float bias;
-        public float quality;
-        public Vector2 unused2;
     };
 
     [GenerateHLSL]

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs.hlsl

 // PackingRules = Exact
 struct DirectionalLightData
 {
-	float3 direction;
+	float3 forward;
+	float3 up;
+	float invScaleY;
+	float3 right;
+	float invScaleX;
+	float3 positionWS;
+	bool tileCookie;
-	float unused;
+	int cookieIndex;
-// Generated from UnityEngine.Experimental.ScriptableRenderLoop.PunctualShadowData
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.ShadowData
-struct PunctualShadowData
+struct ShadowData
 {
 	float4x4 worldToShadow;
 	int lightType;
-};
-
-// Generated from UnityEngine.Experimental.ScriptableRenderLoop.DirectionalShadowData
-// PackingRules = Exact
-struct DirectionalShadowData
-{
-	float4x4 worldToShadow;
-	float bias;
-	float quality;
-	float2 unused2;
 };
 
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.EnvLightData
 //
 // Accessors for UnityEngine.Experimental.ScriptableRenderLoop.DirectionalLightData
 //
-float3 GetDirection(DirectionalLightData value)
+float3 GetForward(DirectionalLightData value)
-	return value.direction;
+	return value.forward;
+float3 GetUp(DirectionalLightData value)
+{
+	return value.up;
+}
+float GetInvScaleY(DirectionalLightData value)
+{
+	return value.invScaleY;
+}
+float3 GetRight(DirectionalLightData value)
+{
+	return value.right;
+}
+float GetInvScaleX(DirectionalLightData value)
+{
+	return value.invScaleX;
+}
+float3 GetPositionWS(DirectionalLightData value)
+{
+	return value.positionWS;
+}
+bool GetTileCookie(DirectionalLightData value)
+{
+	return value.tileCookie;
+}
 float3 GetColor(DirectionalLightData value)
 {
 	return value.color;
 {
 	return value.shadowIndex;
 }
-float GetUnused(DirectionalLightData value)
+int GetCookieIndex(DirectionalLightData value)
-	return value.unused;
+	return value.cookieIndex;
-// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.PunctualShadowData
+// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.ShadowData
-float4x4 GetWorldToShadow(PunctualShadowData value)
+float4x4 GetWorldToShadow(ShadowData value)
-int GetLightType(PunctualShadowData value)
+int GetLightType(ShadowData value)
-float GetBias(PunctualShadowData value)
+float GetBias(ShadowData value)
-float GetQuality(PunctualShadowData value)
+float GetQuality(ShadowData value)
-float GetUnused(PunctualShadowData value)
+float GetUnused(ShadowData value)
-}
-
-//
-// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.DirectionalShadowData
-//
-float4x4 GetWorldToShadow(DirectionalShadowData value)
-{
-	return value.worldToShadow;
-}
-float GetBias(DirectionalShadowData value)
-{
-	return value.bias;
-}
-float GetQuality(DirectionalShadowData value)
-{
-	return value.quality;
-}
-float2 GetUnused2(DirectionalShadowData value)
-{
-	return value.unused2;
 }
 
 //

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Lighting.hlsl

 #define HAS_LIGHTLOOP // Allow to not define LightLoop related function in Material.hlsl
 
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs.hlsl"
-
-#ifdef LIGHTLOOP_SINGLE_PASS
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.hlsl"
-#elif defined(LIGHTLOOP_TILE_PASS)
+
+#if defined(LIGHTLOOP_SINGLE_PASS) || defined(LIGHTLOOP_TILE_PASS)
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.hlsl"
 #endif
 
 
 // LightLoop use evaluation BSDF function for light type define in Material.hlsl
-#ifdef LIGHTLOOP_SINGLE_PASS 
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePassLoop.hlsl"
-#elif defined(LIGHTLOOP_TILE_PASS)
+#if defined(LIGHTLOOP_SINGLE_PASS) || defined(LIGHTLOOP_TILE_PASS)
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePassLoop.hlsl"
 #endif
 

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Resources/Deferred.shader

             #pragma target 5.0
             #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
 
-            #pragma vertex VertDeferred
-            #pragma fragment FragDeferred
+            #pragma vertex Vert
+            #pragma fragment Frag
 
             // Chose supported lighting architecture in case of deferred rendering
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
                 float4 positionCS : SV_POSITION;
             };
 
-            Varyings VertDeferred(Attributes input)
+            Varyings Vert(Attributes input)
             {
                 // TODO: implement SV_vertexID full screen quad
                 // Lights are draw as one fullscreen quad
                 return output;
             }
 
-            float4 FragDeferred(Varyings input) : SV_Target
+            float4 Frag(Varyings input) : SV_Target
             {
 				float4 unPositionSS = input.positionCS; // as input we have the vpos
                 Coordinate coord = GetCoordinate(unPositionSS.xy, _ScreenSize.zw);

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/Resources/lightlistbuild-bigtile.compute

 uniform float4x4 g_mScrProjection;
 uniform float g_fNearPlane;
 uniform float g_fFarPlane;
+uniform int _EnvLightIndexShift;
-StructuredBuffer<SFiniteLightData> g_vLightData : register( t2 );
+StructuredBuffer<LightVolumeData> _LightVolumeData : register(t2);
 StructuredBuffer<SFiniteLightBound> g_data : register( t3 );
 
 
 	int offs = tileIDX.y*nrBigTilesX + tileIDX.x;
 
 	for(i=t; i<(iNrCoarseLights+1); i+=NR_THREADS)
-		g_vLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*offs + i] = t==0 ? iNrCoarseLights : lightsListLDS[i-1];
+		g_vLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*offs + i] = i==0 ? iNrCoarseLights : lightsListLDS[i-1];
 }
 
 
 	for(int l=0; l<iNrCoarseLights; l++)
 	{
 		const uint idxCoarse = lightsListLDS[l];
-		[branch]if(idxCoarse<(uint) g_iNrVisibLights && g_vLightData[idxCoarse].lightType!=SPHERE_LIGHT)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+        [branch]if (idxCoarse<(uint)g_iNrVisibLights && _LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
 	

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/Resources/lightlistbuild-clustered.compute

 uniform int g_iNrVisibLights;
 uniform float4x4 g_mInvScrProjection;
 uniform float4x4 g_mScrProjection;
+uniform int _EnvLightIndexShift;
 
 uniform float g_fClustScale;
 uniform float g_fClustBase;
 Texture2D g_depth_tex : register( t0 );
 #endif
 StructuredBuffer<float3> g_vBoundsBuffer : register( t1 );
-StructuredBuffer<SFiniteLightData> g_vLightData : register( t2 );
+StructuredBuffer<LightVolumeData> _LightVolumeData : register(t2);
 StructuredBuffer<SFiniteLightBound> g_data : register( t3 );
 
 #ifdef USE_TWO_PASS_TILED_LIGHTING
 		InterlockedAdd(g_LayeredSingleIdxBuffer[0], (uint) iSpaceAvail, start);		// alloc list memory
 	}
 
-	int modelListCount[NR_LIGHT_MODELS]={0,0};		// direct light count and reflection lights
+    // All our cull data are in the same list, but at render time envLights are separated so we need to shit the index
+    // to make it work correctly
+    int shiftIndex[LIGHTCATEGORY_COUNT] = {0, 0, _EnvLightIndexShift}; // 3 for now, will throw an error if we change LIGHTCATEGORY_COUNT
+
+	int categoryListCount[LIGHTCATEGORY_COUNT]={0,0,0};		// direct light count and reflection lights
 	uint offs = start;
 	for(int ll=0; ll<iNrCoarseLights; ll+=4)
 	{
 		{
 			if(offs<(start+iSpaceAvail) && i<nrClusters && CheckIntersection(l, i, viTilLL.xy, viTilUR.xy, suggestedBase) )
 			{
-				uint lightModel = g_vLightData[ coarseList[l] ].lightModel;
-				++modelListCount[ lightModel==REFLECTION_LIGHT ? 1 : 0];
-				g_vLayeredLightList[offs++] = coarseList[l];			// reflection lights will be last since we sorted
+                uint lightCategory = _LightVolumeData[coarseList[l]].lightCategory;
+                ++categoryListCount[lightCategory];
+				g_vLayeredLightList[offs++] = coarseList[l] - shiftIndex[lightCategory];			// reflection lights will be last since we sorted
 			}
 		}
 
 
 	uint localOffs=0;
 	offs = i*nrTilesX*nrTilesY + tileIDX.y*nrTilesX + tileIDX.x;
-	for(int m=0; m<NR_LIGHT_MODELS; m++)
+	for(int category=0; category<LIGHTCATEGORY_COUNT; category++)
-		int numLights = min(modelListCount[m],31);		// only allow 5 bits
+		int numLights = min(categoryListCount[category],31);		// only allow 5 bits
-			localOffs += modelListCount[m];		// use unclamped count for localOffs
+			localOffs += categoryListCount[category];		// use unclamped count for localOffs
 		}
 	}
 
 		GroupMemoryBarrierWithGroupSync();
 #endif
 		const int idxCoarse = coarseList[l];
-		[branch]if(g_vLightData[idxCoarse].lightType!=SPHERE_LIGHT)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+        [branch]if (_LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
 	

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/Resources/lightlistbuild.compute

 
 
 uniform int g_iNrVisibLights;
-uniform int _PunctualLightCount;
-
+uniform int _EnvLightIndexShift;
-StructuredBuffer<SFiniteLightData> g_vLightData : register( t2 );
+StructuredBuffer<LightVolumeData> _LightVolumeData : register(t2);
 StructuredBuffer<SFiniteLightBound> g_data : register( t3 );
 
 #ifdef USE_TWO_PASS_TILED_LIGHTING
 #endif
 groupshared int ldsNrLightsFinal;
 
-groupshared int ldsModelListCount[NR_LIGHT_MODELS];		// since NR_LIGHT_MODELS is 2
+groupshared int ldsCategoryListCount[LIGHTCATEGORY_COUNT];		// since LIGHTCATEGORY_COUNT is 3
 
 #ifdef PERFORM_SPHERICAL_INTERSECTION_TESTS
 groupshared uint lightOffsSph;
 #endif
 
 	//
-	if(t<NR_LIGHT_MODELS) ldsModelListCount[t]=0;
+	if(t<LIGHTCATEGORY_COUNT) ldsCategoryListCount[t]=0;
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 	GroupMemoryBarrierWithGroupSync();
 	int nrLightsCombinedList = min(ldsNrLightsFinal,MAX_NR_COARSE_ENTRIES);
 	for(int i=t; i<nrLightsCombinedList; i+=NR_THREADS) 
 	{
-		InterlockedAdd(ldsModelListCount[ g_vLightData[ prunedList[i] ].lightModel ], 1);
+        InterlockedAdd(ldsCategoryListCount[_LightVolumeData[prunedList[i]].lightCategory], 1);
 	}
 
 
 	int localOffs=0;
 	int offs = tileIDX.y*nrTilesX + tileIDX.x;
 
-    // This should thow a warning if NR_LIGHT_MODELS change
-    int indicesShift[NR_LIGHT_MODELS] = {0, _PunctualLightCount};
+    // All our cull data are in the same list, but at render time envLights are separated so we need to shit the index
+    // to make it work correctly
+    int shiftIndex[LIGHTCATEGORY_COUNT] = {0, 0, _EnvLightIndexShift}; // 3 for now, will throw an error if we change LIGHTCATEGORY_COUNT
-	for(int m=0; m<NR_LIGHT_MODELS; m++)
+	for(int category=0; category<LIGHTCATEGORY_COUNT; category++)
-		int nrLightsFinal = ldsModelListCount[ m ];
+		int nrLightsFinal = ldsCategoryListCount[category];
 		int nrLightsFinalClamped = nrLightsFinal<MAX_NR_PRUNED_ENTRIES ? nrLightsFinal : MAX_NR_PRUNED_ENTRIES;
 		
 
-			uint uLow = l==0 ? nrLightsFinalClamped : prunedList[2*l-1+localOffs] - indicesShift[m];
-			uint uHigh = prunedList[2*l+0+localOffs] - indicesShift[m];
+            // We remap the prunedList index to the original LightData / EnvLightData indices
+			uint uLow = l==0 ? nrLightsFinalClamped : prunedList[2*l-1+localOffs] - shiftIndex[category];
+            uint uHigh = prunedList[2 * l + 0 + localOffs] - shiftIndex[category];
 
 			g_vLightList[16*offs + l] = (uLow&0xffff) | (uHigh<<16);
 		}
 	
 	for(l=threadID; l<iNrCoarseLights; l+=NR_THREADS)
 	{
-		SFiniteLightBound lightData = g_data[coarseList[l]];
+		SFiniteLightBound lightData = g_data[prunedList[l]];
 	
 		if( DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lightData.center.xyz, lightData.radius) )
 		{
 	{
 		// fetch light
 		int idxCoarse = l<iNrCoarseLights ? coarseList[l] : 0;
-		uint uLgtType = l<iNrCoarseLights ? g_vLightData[idxCoarse].lightType : 0;
+        uint uLightVolume = l<iNrCoarseLights ? _LightVolumeData[idxCoarse].lightVolume : 0;
-		while(l<iNrCoarseLights && uLgtType==SPOT_LIGHT)
+		while(l<iNrCoarseLights && uLightVolume==LIGHTVOLUMETYPE_CONE)
-			SFiniteLightData lightData = g_vLightData[idxCoarse];
+            LightVolumeData lightData = _LightVolumeData[idxCoarse];
             // TODO: Change by SebL
             const bool bIsSpotDisc = true; // (lightData.flags&IS_CIRCULAR_SPOT_SHAPE) != 0;
 				
 
 			uLightsFlags[l<32 ? 0 : 1] |= (uVal<<(l&31));
 			++l; idxCoarse = l<iNrCoarseLights ? coarseList[l] : 0;
-			uLgtType = l<iNrCoarseLights ? g_vLightData[idxCoarse].lightType : 0;
+            uLightVolume = l<iNrCoarseLights ? _LightVolumeData[idxCoarse].lightVolume : 0;
-		while(l<iNrCoarseLights && uLgtType==SPHERE_LIGHT)
+		while(l<iNrCoarseLights && uLightVolume==LIGHTVOLUMETYPE_SPHERE)
-			SFiniteLightData lightData = g_vLightData[idxCoarse];
+            LightVolumeData lightData = _LightVolumeData[idxCoarse];
 
 			// serially check 4 pixels
 			uint uVal = 0;
 
 			uLightsFlags[l<32 ? 0 : 1] |= (uVal<<(l&31));
 			++l; idxCoarse = l<iNrCoarseLights ? coarseList[l] : 0;
-			uLgtType = l<iNrCoarseLights ? g_vLightData[idxCoarse].lightType : 0;
+            uLightVolume = l<iNrCoarseLights ? _LightVolumeData[idxCoarse].lightVolume : 0;
-		while(l<iNrCoarseLights && uLgtType==BOX_LIGHT)
+		while(l<iNrCoarseLights && uLightVolume==LIGHTVOLUMETYPE_BOX)
-			SFiniteLightData lightData = g_vLightData[idxCoarse];
+            LightVolumeData lightData = _LightVolumeData[idxCoarse];
 
 			// serially check 4 pixels
 			uint uVal = 0;
 
 			uLightsFlags[l<32 ? 0 : 1] |= (uVal<<(l&31));
 			++l; idxCoarse = l<iNrCoarseLights ? coarseList[l] : 0;
-			uLgtType = l<iNrCoarseLights ? g_vLightData[idxCoarse].lightType : 0;
+			uLightVolume = l<iNrCoarseLights ? _LightVolumeData[idxCoarse].lightVolume : 0;
-		if(uLgtType>=MAX_TYPES) ++l;
+		if(uLightVolume >=LIGHTVOLUMETYPE_COUNT) ++l;
 	}
 
 	InterlockedOr(ldsDoesLightIntersect[0], uLightsFlags[0]);

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/ShaderBase.hlsl

 
 float FetchDepth(Texture2D depthTexture, uint2 pixCoord)
 {
-    return 1.0 - LOAD_TEXTURE2D(depthTexture, pixCoord.xy).x;
+	float zdpth = LOAD_TEXTURE2D(depthTexture, pixCoord.xy).x;
+#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+	zdpth = 1.0 - zdpth;
+#endif
+	return zdpth;
-    return 1.0 - LOAD_TEXTURE2D_MSAA(depthTexture, pixCoord.xy, sampleIdx).x;
+	float zdpth = LOAD_TEXTURE2D_MSAA(depthTexture, pixCoord.xy, sampleIdx).x;
+#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+    zdpth = 1.0 - zdpth;
+#endif
+	return zdpth;
 }
 
 #endif

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.cs.hlsl

 #ifndef TILEPASS_CS_HLSL
 #define TILEPASS_CS_HLSL
 //
+// UnityEngine.Experimental.ScriptableRenderLoop.TilePass.LightVolumeType:  static fields
+//
+#define LIGHTVOLUMETYPE_CONE (0)
+#define LIGHTVOLUMETYPE_SPHERE (1)
+#define LIGHTVOLUMETYPE_BOX (2)
+#define LIGHTVOLUMETYPE_COUNT (3)
+
+//
+// UnityEngine.Experimental.ScriptableRenderLoop.TilePass.LightCategory:  static fields
+//
+#define LIGHTCATEGORY_PUNCTUAL (0)
+#define LIGHTCATEGORY_AREA (1)
+#define LIGHTCATEGORY_ENV (2)
+#define LIGHTCATEGORY_COUNT (3)
+
+//
 // UnityEngine.Experimental.ScriptableRenderLoop.TilePass.LightDefinitions:  static fields
 //
 #define MAX_NR_LIGHTS_PER_CAMERA (1024)
 #define HAS_COOKIE_TEXTURE (2)
 #define IS_BOX_PROJECTED (4)
 #define HAS_SHADOW (8)
-#define MAX_TYPES (3)
-#define SPOT_LIGHT (0)
-#define SPHERE_LIGHT (1)
-#define BOX_LIGHT (2)
-#define DIRECTIONAL_LIGHT (3)
-#define NR_LIGHT_MODELS (2)
-#define DIRECT_LIGHT (0)
-#define REFLECTION_LIGHT (1)
-
-//
-// UnityEngine.Experimental.ScriptableRenderLoop.TilePass.DebugViewTilesFlags:  static fields
-//
-#define DEBUGVIEWTILESFLAGS_DIRECT_LIGHTING (1)
-#define DEBUGVIEWTILESFLAGS_REFLECTION (2)
 
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.TilePass.SFiniteLightBound
 // PackingRules = Exact
 	float radius;
 };
 
-// Generated from UnityEngine.Experimental.ScriptableRenderLoop.TilePass.SFiniteLightData
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.TilePass.LightVolumeData
-struct SFiniteLightData
+struct LightVolumeData
+	uint lightVolume;
-	uint lightType;
+	uint lightCategory;
-	uint lightModel;
+	float unused;
 	float3 boxInvRange;
 	float unused2;
 };
 }
 
 //
-// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.TilePass.SFiniteLightData
+// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.TilePass.LightVolumeData
-float3 GetLightPos(SFiniteLightData value)
+float3 GetLightPos(LightVolumeData value)
-float3 GetLightAxisX(SFiniteLightData value)
+uint GetLightVolume(LightVolumeData value)
+{
+	return value.lightVolume;
+}
+float3 GetLightAxisX(LightVolumeData value)
-uint GetLightType(SFiniteLightData value)
+uint GetLightCategory(LightVolumeData value)
-	return value.lightType;
+	return value.lightCategory;
-float3 GetLightAxisY(SFiniteLightData value)
+float3 GetLightAxisY(LightVolumeData value)
-float GetRadiusSq(SFiniteLightData value)
+float GetRadiusSq(LightVolumeData value)
-float3 GetLightAxisZ(SFiniteLightData value)
+float3 GetLightAxisZ(LightVolumeData value)
-float GetCotan(SFiniteLightData value)
+float GetCotan(LightVolumeData value)
-float3 GetBoxInnerDist(SFiniteLightData value)
+float3 GetBoxInnerDist(LightVolumeData value)
-uint GetLightModel(SFiniteLightData value)
+float GetUnused(LightVolumeData value)
-	return value.lightModel;
+	return value.unused;
-float3 GetBoxInvRange(SFiniteLightData value)
+float3 GetBoxInvRange(LightVolumeData value)
-float GetUnused2(SFiniteLightData value)
+float GetUnused2(LightVolumeData value)
 {
 	return value.unused2;
 }

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.hlsl

 // these uniforms are only needed for when OPAQUES_ONLY is NOT defined
 // but there's a problem with our front-end compilation of compute shaders with multiple kernels causing it to error
 //#ifdef USE_CLUSTERED_LIGHTLIST
+float4x4 g_mInvScrProjection;
+
 float g_fClustScale;
 float g_fClustBase;
 float g_fNearPlane;
 uint g_isLogBaseBufferEnabled;
-uint g_isOpaquesOnlyEnabled;
+uint _UseTileLightList;
-#ifdef USE_CLUSTERED_LIGHTLIST
+//#ifdef USE_CLUSTERED_LIGHTLIST
+//#endif
+
+StructuredBuffer<DirectionalLightData>  _DirectionalLightDatas;
+StructuredBuffer<LightData>             _LightDatas;
+StructuredBuffer<EnvLightData>          _EnvLightDatas;
+StructuredBuffer<ShadowData>            _ShadowDatas;
+
+// Use texture atlas for shadow map
+//TEXTURE2D(_ShadowAtlas);
+//SAMPLER2D_SHADOW(sampler_ShadowAtlas);
+//SAMPLER2D(sampler_ManualShadowAtlas); // TODO: settings sampler individually is not supported in shader yet...
+TEXTURE2D(g_tShadowBuffer) // TODO: No choice, the name is hardcoded in ShadowrenderPass.cs for now. Need to change this!
+SAMPLER2D_SHADOW(samplerg_tShadowBuffer);
+
+// Use texture array for IES
+TEXTURE2D_ARRAY(_IESArray);
+SAMPLER2D(sampler_IESArray);
+
+// Used by directional and spot lights
+TEXTURE2D_ARRAY(_CookieTextures);
+SAMPLER2D(sampler_CookieTextures);
+
+// Used by point lights
+TEXTURECUBE_ARRAY(_CookieCubeTextures);
+SAMPLERCUBE(sampler_CookieCubeTextures);
+
+// Use texture array for reflection
+TEXTURECUBE_ARRAY(_EnvTextures);
+SAMPLERCUBE(sampler_EnvTextures);
+
+TEXTURECUBE(_SkyTexture);
+SAMPLERCUBE(sampler_SkyTexture); // NOTE: Sampler could be share here with _EnvTextures. Don't know if the shader compiler will complain...
+
+CBUFFER_START(UnityPerLightLoop)
+uint _DirectionalLightCount;
+uint _PunctualLightCount;
+uint _AreaLightCount;
+uint _EnvLightCount;
+float4 _DirShadowSplitSpheres[4]; // TODO: share this max between C# and hlsl
+
+int  _EnvLightSkyEnabled;         // TODO: make it a bool	
+CBUFFER_END
+
+struct LightLoopContext
+{
+    int sampleShadow;
+    int sampleReflection;
+};
+
+//-----------------------------------------------------------------------------
+// Shadow sampling function
+// ----------------------------------------------------------------------------
+
+float GetPunctualShadowAttenuation(LightLoopContext lightLoopContext, float3 positionWS, int index, float3 L, float2 unPositionSS)
+{
+    int faceIndex = 0;
+    if (_ShadowDatas[index].lightType == GPULIGHTTYPE_POINT)
+    {
+        GetCubeFaceID(L, faceIndex);
+    }
+
+    ShadowData shadowData = _ShadowDatas[index + faceIndex];
+
+    // Note: scale and bias of shadow atlas are included in ShadowTransform but could be apply here.
+    float4 positionTXS = mul(float4(positionWS, 1.0), shadowData.worldToShadow);
+    positionTXS.xyz /= positionTXS.w;
+    //	positionTXS.z -=  shadowData.bias; // Apply a linear bias
+    positionTXS.z -= 0.001;
+
+#if UNITY_REVERSED_Z
+    positionTXS.z = 1.0 - positionTXS.z;
-// TODO: Need to correctly define the shadow framework, WIP
-#include "../SinglePass/SinglePass.hlsl"
+    // float3 shadowPosDX = ddx_fine(positionTXS);
+    // float3 shadowPosDY = ddy_fine(positionTXS);
+
+    return SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, positionTXS);
+}
+
+// Gets the cascade weights based on the world position of the fragment and the positions of the split spheres for each cascade.
+// Returns an invalid split index if past shadowDistance (ie 4 is invalid for cascade)
+uint GetSplitSphereIndexForDirshadows(float3 positionWS, float4 dirShadowSplitSpheres[4])
+{
+    float3 fromCenter0 = positionWS.xyz - dirShadowSplitSpheres[0].xyz;
+    float3 fromCenter1 = positionWS.xyz - dirShadowSplitSpheres[1].xyz;
+    float3 fromCenter2 = positionWS.xyz - dirShadowSplitSpheres[2].xyz;
+    float3 fromCenter3 = positionWS.xyz - dirShadowSplitSpheres[3].xyz;
+    float4 distances2 = float4(dot(fromCenter0, fromCenter0), dot(fromCenter1, fromCenter1), dot(fromCenter2, fromCenter2), dot(fromCenter3, fromCenter3));
+
+    float4 dirShadowSplitSphereSqRadii;
+    dirShadowSplitSphereSqRadii.x = dirShadowSplitSpheres[0].w;
+    dirShadowSplitSphereSqRadii.y = dirShadowSplitSpheres[1].w;
+    dirShadowSplitSphereSqRadii.z = dirShadowSplitSpheres[2].w;
+    dirShadowSplitSphereSqRadii.w = dirShadowSplitSpheres[3].w;
+
+    float4 weights = float4(distances2 < dirShadowSplitSphereSqRadii);
+    weights.yzw = saturate(weights.yzw - weights.xyz);
+
+    return uint(4.0 - dot(weights, float4(4.0, 3.0, 2.0, 1.0)));
+}
+
+float GetDirectionalShadowAttenuation(LightLoopContext lightLoopContext, float3 positionWS, int index, float3 L, float2 unPositionSS)
+{
+    // Note Index is 0 for now, but else we need to provide the correct index in _DirShadowSplitSpheres and _ShadowDatas
+    uint shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _DirShadowSplitSpheres);
+
+    ShadowData shadowData = _ShadowDatas[shadowSplitIndex];
+
+    // Note: scale and bias of shadow atlas are included in ShadowTransform but could be apply here.
+    float4 positionTXS = mul(float4(positionWS, 1.0), shadowData.worldToShadow);
+    positionTXS.xyz /= positionTXS.w;
+    //	positionTXS.z -=  shadowData.bias; // Apply a linear bias
+    positionTXS.z -= 0.003;
+
+#if UNITY_REVERSED_Z
+    positionTXS.z = 1.0 - positionTXS.z;
+#endif
+
+    // float3 shadowPosDX = ddx_fine(positionTXS);
+    // float3 shadowPosDY = ddy_fine(positionTXS);
+
+    return SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, positionTXS);
+}
+
+//-----------------------------------------------------------------------------
+// Cookie sampling functions
+// ----------------------------------------------------------------------------
+
+// Used by directional and spot lights.
+// Returns the color in the RGB components, and the transparency (lack of occlusion) in A.
+float4 SampleCookie2D(LightLoopContext lightLoopContext, float2 coord, int index)
+{
+    return SAMPLE_TEXTURE2D_ARRAY_LOD(_CookieTextures, sampler_CookieTextures, coord, index, 0);
+}
+
+// Used by point lights.
+// Returns the color in the RGB components, and the transparency (lack of occlusion) in A.
+float4 SampleCookieCube(LightLoopContext lightLoopContext, float3 coord, int index)
+{
+    return SAMPLE_TEXTURECUBE_ARRAY_LOD(_CookieCubeTextures, sampler_CookieCubeTextures, coord, index, 0);
+}
+
+//-----------------------------------------------------------------------------
+// IES sampling function
+// ----------------------------------------------------------------------------
+
+// sphericalTexCoord is theta and phi spherical coordinate
+float4 SampleIES(LightLoopContext lightLoopContext, int index, float2 sphericalTexCoord, float lod)
+{
+    return SAMPLE_TEXTURE2D_ARRAY_LOD(_IESArray, sampler_IESArray, sphericalTexCoord, index, 0);
+}
+
+//-----------------------------------------------------------------------------
+// Reflection proble / Sky sampling function
+// ----------------------------------------------------------------------------
+
+#define SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES 0
+#define SINGLE_PASS_CONTEXT_SAMPLE_SKY 1
+
+// Note: index is whatever the lighting architecture want, it can contain information like in which texture to sample (in case we have a compressed BC6H texture and an uncompressed for real time reflection ?)
+// EnvIndex can also be use to fetch in another array of struct (to  atlas information etc...).
+float4 SampleEnv(LightLoopContext lightLoopContext, int index, float3 texCoord, float lod)
+{
+    // This code will be inlined as lightLoopContext is hardcoded in the light loop
+    if (lightLoopContext.sampleReflection == SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES)
+    {
+        return SAMPLE_TEXTURECUBE_ARRAY_LOD(_EnvTextures, sampler_EnvTextures, texCoord, index, lod);
+    }
+    else // SINGLE_PASS_SAMPLE_SKY
+    {
+        return SAMPLE_TEXTURECUBE_LOD(_SkyTexture, sampler_SkyTexture, texCoord, lod);
+    }
+}
+

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePassLoop.hlsl

 // LightLoop
 // ----------------------------------------------------------------------------
 
+#ifdef LIGHTLOOP_TILE_PASS
+
 // Calculate the offset in global light index light for current light category
 int GetTileOffset(Coordinate coord, uint lightCategory)
 {
 
-void GetCountAndStartOpaque(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
+void GetCountAndStartTile(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
 {
     const int tileOffset = GetTileOffset(coord, lightCategory);
 
 }
 
-uint FetchIndexOpaque(uint tileOffset, uint lightIndex)
+uint FetchIndexTile(uint tileOffset, uint lightIndex)
+
-    GetCountAndStartOpaque(coord, lightCategory, linearDepth, start, lightCount);
+    GetCountAndStartTile(coord, lightCategory, linearDepth, start, lightCount);
-    return FetchIndexOpaque(tileOffset, lightIndex);
+    return FetchIndexTile(tileOffset, lightIndex);
 }
 
 #else
-void GetCountAndStart(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
+void GetCountAndStartCluster(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
-    if(g_isOpaquesOnlyEnabled)
+    uint2 tileIndex = coord.unPositionSS / TILE_SIZE;
+
+    float logBase = g_fClustBase;
+    if (g_isLogBaseBufferEnabled)
-        GetCountAndStartOpaque(coord, lightCategory, linearDepth, start, lightCount);
+        logBase = g_logBaseBuffer[tileIndex.y * _NumTileX + tileIndex.x];
-    else
-    {
-        uint2 tileIndex = coord.unPositionSS / TILE_SIZE;
-        float logBase = g_fClustBase;
-        if (g_isLogBaseBufferEnabled)
-        {
-            logBase = g_logBaseBuffer[tileIndex.y * _NumTileX + tileIndex.x];
-        }
+    int clustIdx = SnapToClusterIdxFlex(linearDepth, logBase, g_isLogBaseBufferEnabled != 0);
-        int clustIdx = SnapToClusterIdxFlex(linearDepth, logBase, g_isLogBaseBufferEnabled != 0);
+    int nrClusters = (1 << g_iLog2NumClusters);
+    const int idx = ((lightCategory * nrClusters + clustIdx) * _NumTileY + tileIndex.y) * _NumTileX + tileIndex.x;
+    uint dataPair = g_vLayeredOffsetsBuffer[idx];
+    start = dataPair & 0x7ffffff;
+    lightCount = (dataPair >> 27) & 31;
+}
-        int nrClusters = (1 << g_iLog2NumClusters);
-        const int idx = ((model * nrClusters + clustIdx) * _NumTileY + tileIndex.y) * _NumTileX + tileIndex.x;
-        uint dataPair = g_vLayeredOffsetsBuffer[idx];
-        start = dataPair & 0x7ffffff;
-        lightCount = (dataPair >> 27) & 31;
-    }
+uint FetchIndexCluster(uint tileOffset, uint lightIndex)
+{
+    return g_vLightListGlobal[tileOffset + lightIndex];
-uint FetchIndex(uint tileOffset, uint lightIndex)
+void GetCountAndStart(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
-    if(g_isOpaquesOnlyEnabled)
-        return FetchIndexOpaque(tileOffset, lightIndex);
+    if (_UseTileLightList)
+        GetCountAndStartTile(coord, lightCategory, linearDepth, start, lightCount);
-        return g_vLightListGlobal[tileOffset + lightIndex];
+        GetCountAndStartCluster(coord, lightCategory, linearDepth, start, lightCount);
-float GetLinearDepth(float zDptBufSpace)    // 0 is near 1 is far
+uint FetchIndex(uint tileOffset, uint lightIndex)
-    // todo (simplify): m22 is zero and m23 is +1/-1 (depends on left/right hand proj)
-    float m22 = g_mInvScrProjection[2].z, m23 = g_mInvScrProjection[2].w;
-    float m32 = g_mInvScrProjection[3].z, m33 = g_mInvScrProjection[3].w;
-
-    return (m22 * zDptBufSpace + m23) / (m32 * zDptBufSpace + m33);
-
-    //float3 vP = float3(0.0f,0.0f,zDptBufSpace);
-    //float4 v4Pres = mul(g_mInvScrProjection, float4(vP,1.0));
-    //return v4Pres.z / v4Pres.w;
+    if (_UseTileLightList)
+        return FetchIndexTile(tileOffset, lightIndex);
+    else
+        return FetchIndexCluster(tileOffset, lightIndex);
 }
 
 #endif
                 out float3 diffuseLighting,
                 out float3 specularLighting)
 {
-#if USE_CLUSTERED_LIGHTLIST
-    // TODO: Think more about the design, it is ok to do that ? hope the compiler could optimize it out as we do it before LightLoop call, else need to pass it as argument...
-    float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
-    float linearDepth = GetLinearDepth(depth); // View space linear depth
+#ifdef USE_CLUSTERED_LIGHTLIST
+    float linearDepth = TransformWorldToView(positionWS).z; // View space linear depth
-    float linearDepth = 0.0; // unsued
+    float linearDepth = 0.0; // unused
 #endif
 
     LightLoopContext context;
     {
         float3 localDiffuseLighting, localSpecularLighting;
 
-        EvaluateBSDF_Directional(   context, V, positionWS, prelightData, _DirectionalLightList[i], bsdfData,
+        EvaluateBSDF_Directional(   context, V, positionWS, prelightData, _DirectionalLightDatas[i], bsdfData,
                                     localDiffuseLighting, localSpecularLighting);
 
         diffuseLighting += localDiffuseLighting;
 
 #ifdef PROCESS_PUNCTUAL_LIGHT
+    // TODO: Convert the for loop below to a while on each type as we know we are sorted!
-    GetCountAndStart(coord, DIRECT_LIGHT, linearDepth, punctualLightStart, punctualLightCount);
+    GetCountAndStart(coord, LIGHTCATEGORY_PUNCTUAL, linearDepth, punctualLightStart, punctualLightCount);
-        EvaluateBSDF_Punctual(  context, V, positionWS, prelightData, _PunctualLightList[FetchIndex(punctualLightStart, i)], bsdfData,
+        EvaluateBSDF_Punctual(  context, V, positionWS, prelightData, _LightDatas[FetchIndex(punctualLightStart, i)], bsdfData,
                                 localDiffuseLighting, localSpecularLighting);
 
         diffuseLighting += localDiffuseLighting;
 
 #ifdef PROCESS_AREA_LIGHT
-    /*
-    // TODO: Area lights are where the sorting is important (Morten approach with while loop)
+    // TODO: Convert the for loop below to a while on each type as we know we are sorted!
-    GetCountAndStart(coord, LightCatergory.AreaLight, linearDepth, areaLightStart, areaLightCount);
+    GetCountAndStart(coord, LIGHTCATEGORY_AREA, linearDepth, areaLightStart, areaLightCount);
-        EvaluateBSDF_Area(  context, V, positionWS, prelightData, _AreaLightList[FetchIndex(areaLightStart, i)], bsdfData,
-                            localDiffuseLighting, localSpecularLighting);
+        uint areaIndex = FetchIndex(areaLightStart, i);
+
+        if(_LightDatas[areaIndex].lightType == GPULIGHTTYPE_LINE)
+        {
+            EvaluateBSDF_Line(  context, V, positionWS, prelightData, _LightDatas[areaIndex], bsdfData,
+                                localDiffuseLighting, localSpecularLighting);
+        }
+        else
+        {
+            EvaluateBSDF_Area(  context, V, positionWS, prelightData, _LightDatas[areaIndex], bsdfData,
+                                localDiffuseLighting, localSpecularLighting);
+        }
+
-    */
-    uint envLightStart;
-    uint envLightCount;
-    GetCountAndStart(coord, REFLECTION_LIGHT, linearDepth, envLightStart, envLightCount);
+    // Only apply sky IBL if the sky texture is available.
+    if (_EnvLightSkyEnabled)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+        float2 weight;
+        // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
+        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
+        EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
+        EvaluateBSDF_Env(context, V, positionWS, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+        iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
+        iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
+    }
+
+    uint envLightStart;
+    uint envLightCount;
+    GetCountAndStart(coord, LIGHTCATEGORY_ENV, linearDepth, envLightStart, envLightCount);
+
-        EvaluateBSDF_Env(context, V, positionWS, prelightData, _EnvLightList[FetchIndex(envLightStart, i)], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+        EvaluateBSDF_Env(context, V, positionWS, prelightData, _EnvLightDatas[FetchIndex(envLightStart, i)], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
         iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
         iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
     }
 #endif
 
-    // Currently do lightmap with indirect specula
-    // TODO: test what is the most appropriate here...
+    // TODO: currently apply GI at the same time as reflection
+
+#else // LIGHTLOOP_SINGLE_PASS
+
+// bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)
+void LightLoop( float3 V, float3 positionWS, Coordinate coord, PreLightData prelightData, BSDFData bsdfData, float3 bakeDiffuseLighting,
+                out float3 diffuseLighting,
+                out float3 specularLighting)
+{
+    LightLoopContext context;
+    ZERO_INITIALIZE(LightLoopContext, context);
+
+    diffuseLighting = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+
+    uint i = 0; // Declare once to avoid the D3D11 compiler warning.
+
+    for (i = 0; i < _DirectionalLightCount; ++i)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+
+        EvaluateBSDF_Directional(   context, V, positionWS, prelightData, _DirectionalLightDatas[i], bsdfData,
+                                    localDiffuseLighting, localSpecularLighting);
+
+        diffuseLighting += localDiffuseLighting;
+        specularLighting += localSpecularLighting;
+    }
+
+    for (i = 0; i < _PunctualLightCount; ++i)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+
+        EvaluateBSDF_Punctual(  context, V, positionWS, prelightData, _LightDatas[i], bsdfData,
+                                localDiffuseLighting, localSpecularLighting);
+
+        diffuseLighting += localDiffuseLighting;
+        specularLighting += localSpecularLighting;
+    }
+
+    // Area are store with punctual, just offset the index
+    for (i = _PunctualLightCount; i < _AreaLightCount + _PunctualLightCount; ++i)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+
+        if (_LightDatas[i].lightType == GPULIGHTTYPE_LINE)
+        {
+            EvaluateBSDF_Line(  context, V, positionWS, prelightData, _LightDatas[i], bsdfData,
+                                localDiffuseLighting, localSpecularLighting);
+        }
+        else
+        {
+            EvaluateBSDF_Area(  context, V, positionWS, prelightData, _LightDatas[i], bsdfData,
+                                localDiffuseLighting, localSpecularLighting);
+        }
+
+        diffuseLighting += localDiffuseLighting;
+        specularLighting += localSpecularLighting;
+    }
+
+    // TODO: Check the reflection hierarchy, for the current system (matching legacy unity) we must sort from bigger solid angle to lower (lower override bigger). So begging by sky
+    // TODO: Change the way it is done by reversing the order, from smaller solid angle to bigger, so we can early out when the weight is 1.
+    float3 iblDiffuseLighting = float3(0.0, 0.0, 0.0);
+    float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
+
+    // Only apply sky IBL if the sky texture is available.
+    if (_EnvLightSkyEnabled)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+        float2 weight;
+        // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
+        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
+        EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
+        EvaluateBSDF_Env(context, V, positionWS, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+        iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
+        iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
+    }
+
+    for (i = 0; i < _EnvLightCount; ++i)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+        float2 weight;
+        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
+        EvaluateBSDF_Env(context, V, positionWS, prelightData, _EnvLightDatas[i], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+        iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
+        iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
+    }
+
+    diffuseLighting += iblDiffuseLighting;
+    specularLighting += iblSpecularLighting;
+
+    // Add indirect diffuse + emissive (if any)
+    diffuseLighting += bakeDiffuseLighting;
+}
+
+#endif

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Attributes.hlsl

     switch (paramId)
     {
     case DEBUGVIEWVARYING_TEXCOORD0:
-        result = float3(input.texCoord0 * 0.5 + 0.5, 0.0);
+        result = float3(input.texCoord0, 0.0);
-        result = float3(input.texCoord1 * 0.5 + 0.5, 0.0);
+        result = float3(input.texCoord1, 0.0);
-        result = float3(input.texCoord2 * 0.5 + 0.5, 0.0);
+        result = float3(input.texCoord2, 0.0);
-        result = float3(input.texCoord3 * 0.5 + 0.5, 0.0);
+        result = float3(input.texCoord3, 0.0);
         break;
     case DEBUGVIEWVARYING_VERTEX_TANGENT_WS:
         result = input.tangentToWorld[0].xyz * 0.5 + 0.5;

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

 using UnityEngine;
 using UnityEngine.Rendering;
 
+using System.Linq;
+
 namespace UnityEditor.Experimental.ScriptableRenderLoop
 {
     internal class LayeredLitGUI : LitGUI
             public readonly GUIContent layerMapMaskText = new GUIContent("Layer Mask", "Layer mask (multiplied by vertex color if enabled)");
             public readonly GUIContent layerMapVertexColorText = new GUIContent("Use Vertex Color", "Layer mask (multiplied by layer mask if enabled)");
             public readonly GUIContent layerCountText = new GUIContent("Layer Count", "Number of layers.");
-            public readonly GUIContent layerTexWorldScaleText = new GUIContent("Tex world scale", "Scale to apply to world position for Planar/Trilinear");
+            public readonly GUIContent layerTexWorldScaleText = new GUIContent("Tiling", "Tiling factor applied to Planar/Trilinear mapping");
             public readonly GUIContent UVBaseText = new GUIContent("Base 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.");
         }
         MaterialProperty layerCount = null;
         const string kLayerCount = "_LayerCount";
         MaterialProperty[] layerTexWorldScale = new MaterialProperty[kMaxLayerCount];
-        const string kLayerTexWorldScale = "_TexWorldScale";
-        const string kLayerUVBase = "_UVBase";
-        const string kLayerUVMappingMask = "_UVMappingMask";
-        const string kLayerUVDetail = "_UVDetail";
-        const string kLayerUVDetailsMappingMask = "_UVDetailsMappingMask";
-        const string kLayerEmissiveColor = "_EmissiveColor";
-        const string kLayerEmissiveColorMap = "_EmissiveColorMap";
-        const string kLayerEmissiveIntensity = "_EmissiveIntensity";
 
         private void FindLayerProperties(MaterialProperty[] props)
         {
             for (int i = 0; i < numLayer; ++i)
             {
-                layerTexWorldScale[i] = FindProperty(string.Format("{0}{1}", kLayerTexWorldScale, i), props);
-                layerUVBase[i] = FindProperty(string.Format("{0}{1}", kLayerUVBase, i), props);
-                layerUVMappingMask[i] = FindProperty(string.Format("{0}{1}", kLayerUVMappingMask, i), props);
-                layerUVDetail[i] = FindProperty(string.Format("{0}{1}", kLayerUVDetail, i), props);
-                layerUVDetailsMappingMask[i] = FindProperty(string.Format("{0}{1}", kLayerUVDetailsMappingMask, i), props);
+                layerTexWorldScale[i] = FindProperty(string.Format("{0}{1}", kTexWorldScale, i), props);
+                layerUVBase[i] = FindProperty(string.Format("{0}{1}", kUVBase, i), props);
+                layerUVMappingMask[i] = FindProperty(string.Format("{0}{1}", kUVMappingMask, i), props);
+                layerUVDetail[i] = FindProperty(string.Format("{0}{1}", kUVDetail, i), props);
+                layerUVDetailsMappingMask[i] = FindProperty(string.Format("{0}{1}", kUVDetailsMappingMask, i), props);
-            layerEmissiveColor = FindProperty(kLayerEmissiveColor, props);
-            layerEmissiveColorMap = FindProperty(kLayerEmissiveColorMap, props);
-            layerEmissiveIntensity = FindProperty(kLayerEmissiveIntensity, props);
+            layerEmissiveColor = FindProperty(kEmissiveColor, props);
+            layerEmissiveColorMap = FindProperty(kEmissiveColorMap, props);
+            layerEmissiveIntensity = FindProperty(kEmissiveIntensity, props);
         }
 
         int numLayer
 
         void SynchronizeLayerProperties(int layerIndex)
         {
+			string[] exclusionList = { kTexWorldScale, kUVBase, kUVMappingMask, kUVDetail, kUVDetailsMappingMask };
+
             Material material = m_MaterialEditor.target as Material;
             Material layerMaterial = m_MaterialLayers[layerIndex];
 
                 {
                     string propertyName = ShaderUtil.GetPropertyName(layerShader, i);
                     string layerPropertyName = propertyName + layerIndex;
-                    if (material.HasProperty(layerPropertyName))
-                    {
-                        ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(layerShader, i);
-                        switch (type)
-                        {
-                            case ShaderUtil.ShaderPropertyType.Color:
-                            {
-                                material.SetColor(layerPropertyName, layerMaterial.GetColor(propertyName));
-                                break;
-                            }
-                            case ShaderUtil.ShaderPropertyType.Float:
-                            case ShaderUtil.ShaderPropertyType.Range:
-                            {
-                                material.SetFloat(layerPropertyName, layerMaterial.GetFloat(propertyName));
-                                break;
-                            }
-                            case ShaderUtil.ShaderPropertyType.Vector:
-                            {
-                                material.SetVector(layerPropertyName, layerMaterial.GetVector(propertyName));
-                                break;
-                            }
-                            case ShaderUtil.ShaderPropertyType.TexEnv:
-                            {
-                                material.SetTexture(layerPropertyName, layerMaterial.GetTexture(propertyName));
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
+
+					if(!exclusionList.Contains(propertyName))
+					{
+						if (material.HasProperty(layerPropertyName))
+						{
+							ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(layerShader, i);
+							switch (type)
+							{
+								case ShaderUtil.ShaderPropertyType.Color:
+								{
+									material.SetColor(layerPropertyName, layerMaterial.GetColor(propertyName));
+									break;
+								}
+								case ShaderUtil.ShaderPropertyType.Float:
+								case ShaderUtil.ShaderPropertyType.Range:
+								{
+									material.SetFloat(layerPropertyName, layerMaterial.GetFloat(propertyName));
+									break;
+								}
+								case ShaderUtil.ShaderPropertyType.Vector:
+								{
+									material.SetVector(layerPropertyName, layerMaterial.GetVector(propertyName));
+									break;
+								}
+								case ShaderUtil.ShaderPropertyType.TexEnv:
+								{
+									material.SetTexture(layerPropertyName, layerMaterial.GetTexture(propertyName));
+									material.SetTextureOffset(layerPropertyName, layerMaterial.GetTextureOffset(propertyName));
+									material.SetTextureScale(layerPropertyName, layerMaterial.GetTextureScale(propertyName));
+									break;
+								}
+							}
+						}
+					}
+				}
+			}
         }
 
         void InitializeMaterialLayers(AssetImporter materialImporter)
             m_MaterialEditor.ShaderProperty(layerUVBase[layerIndex], styles.UVBaseText);
             if (EditorGUI.EndChangeCheck())
             {
+				SynchronizeLayerProperties(layerIndex);
                 result = true;
             }
             if (((LayerUVBaseMapping)layerUVBase[layerIndex].floatValue == LayerUVBaseMapping.Planar) ||
                 m_MaterialEditor.ShaderProperty(layerUVDetail[layerIndex], styles.UVDetailText);
                 if (EditorGUI.EndChangeCheck())
                 {
+					SynchronizeLayerProperties(layerIndex);
                     result = true;
                 }
             }
                 SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap + i));
                 SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap + i));
                 SetKeyword(material, "_SPECULAROCCLUSIONMAP", material.GetTexture(kSpecularOcclusionMap + i));
-                SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap + i));
+				SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap + i));
+            SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
             SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR", material.GetFloat(kLayerMaskVertexColor) != 0.0f);
         }
 
             {
                 // We setup the masking map based on the enum for each layer.
                 // using mapping mask allow to reduce the number of generated combination for a very small increase in ALU
-                string layerUVBaseParam = string.Format("{0}{1}", kLayerUVBase, i);
+                string layerUVBaseParam = string.Format("{0}{1}", kUVBase, i);
-                string layerUVDetailParam = string.Format("{0}{1}", kLayerUVDetail, i);
+                string layerUVDetailParam = string.Format("{0}{1}", kUVDetail, i);
                 LayerUVDetailMapping layerUVDetailMapping = (LayerUVDetailMapping)material.GetFloat(layerUVDetailParam);
                 string currentLayerMappingTriplanar = string.Format("{0}{1}", kLayerMappingTriplanar, i);
 
                 W = (layerUVBaseMapping == LayerUVBaseMapping.Planar) ? 1.0f : 0.0f;
                 layerUVMappingMask[i].colorValue = new Color(X, Y, Z, W);
 
-                if (layerUVBaseMapping == LayerUVBaseMapping.Triplanar)
-                {
-                    SetKeyword(material, currentLayerMappingTriplanar, true);
-                }
+                SetKeyword(material, currentLayerMappingTriplanar, layerUVBaseMapping == LayerUVBaseMapping.Triplanar);
 
                 // If base is planar mode, detail is planar too
                 if (W > 0.0f)

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

 
         [HideInInspector] _LayerCount("_LayerCount", Float) = 2.0
 
-        _TexWorldScale0("Scale to apply on world coordinate", Float) = 1.0
-        _TexWorldScale1("Scale to apply on world coordinate", Float) = 1.0
-        _TexWorldScale2("Scale to apply on world coordinate", Float) = 1.0
-        _TexWorldScale3("Scale to apply on world coordinate", 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.
+		// To avoid this, make sure that all properties here are in the exclusion list in LayeredLitUI.SynchronizeLayerProperties
+        _TexWorldScale0("Tiling", Float) = 1.0
+        _TexWorldScale1("Tiling", Float) = 1.0
+        _TexWorldScale2("Tiling", Float) = 1.0
+        _TexWorldScale3("Tiling", Float) = 1.0
 
         [Enum(UV0, 0, UV1, 1, UV3, 2, Planar, 3, Triplanar, 4)] _UVBase0("UV Set for base0", Float) = 0
         [Enum(UV0, 0, UV1, 1, UV3, 2, Planar, 3, Triplanar, 4)] _UVBase1("UV Set for base1", Float) = 0
         [Enum(UV0, 0, UV1, 1, UV3, 2)] _UVDetail2("UV Set for detail2", Float) = 0
         [Enum(UV0, 0, UV1, 1, UV3, 2)] _UVDetail3("UV Set for detail3", Float) = 0
 
-        [HideInInspector] _UVDetailsMappingMask0("_UVDetailsMappingMask0", Float) = 0
-        [HideInInspector] _UVDetailsMappingMask1("_UVDetailsMappingMask1", Float) = 0
-        [HideInInspector] _UVDetailsMappingMask2("_UVDetailsMappingMask2", Float) = 0
-        [HideInInspector] _UVDetailsMappingMask3("_UVDetailsMappingMask3", Float) = 0
+        [HideInInspector] _UVDetailsMappingMask0("_UVDetailsMappingMask0", Color) = (1, 0, 0, 0)
+        [HideInInspector] _UVDetailsMappingMask1("_UVDetailsMappingMask1", Color) = (1, 0, 0, 0)
+        [HideInInspector] _UVDetailsMappingMask2("_UVDetailsMappingMask2", Color) = (1, 0, 0, 0)
+        [HideInInspector] _UVDetailsMappingMask3("_UVDetailsMappingMask3", Color) = (1, 0, 0, 0)
-        [HideInInspector] _TexWorldScale("Scale to apply on world coordinate", Float) = 1.0
+        [HideInInspector] _TexWorldScale("Tiling", Float) = 1.0
         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0)
     }
             #define SHADERPASS SHADERPASS_FORWARD
             // TEMP until pragma work in include
             // #include "../../Lighting/Forward.hlsl"
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
             #define LAYERED_LIT_SHADER
             //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF
 

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

 
             public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel");
             public static GUIContent UVBaseMappingText = new GUIContent("UV set for Base", "");
-            public static GUIContent texWorldScaleText = new GUIContent("Scale to apply on world coordinate in case of Planar/Triplanar", "");
+            public static GUIContent texWorldScaleText = new GUIContent("Tiling", "Tiling factor applied to Planar/Trilinear mapping");
             public static GUIContent UVBaseDetailMappingText = new GUIContent("UV set for Base and Detail", "");
             public static GUIContent normalMapSpaceText = new GUIContent("Normal/Tangent Map space", "");
             public static GUIContent heightMapModeText = new GUIContent("Height Map Mode", "");

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

                 isInit = false;
             }
 
-            public void OnDisable()
+            public void Cleanup()
-                if (m_InitPreFGD) DestroyImmediate(m_InitPreFGD);
+                Utilities.Destroy(m_InitPreFGD);
+
                 // TODO: how to delete RenderTexture ?
                 isInit = false;
             }

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

 
 // TODO: I haven't configure this sampler in the code, we should be able to do it (but Unity don't allow it for now...)
 // By default Unity provide MIG_MAG_LINEAR_POINT sampler, so it fit with our need.
-#ifdef LIT_DISPLAY_REFERENCE_IBL
+// TODO: to avoid the message Fragment program 'Frag' : sampler 'sampler_PreIntegratedFGD' has no matching texture and will be undefined.
+// We need to test this define LIGHTLOOP_TILE_DIRECT, this is a bad workaround but no alternative until we can setup sampler correctly...
+#if defined(LIT_DISPLAY_REFERENCE_IBL) || defined(LIGHTLOOP_TILE_DIRECT)
 // When reference mode is enabled, then we need to chose another sampler not related to cubemap code...
 SAMPLER2D(sampler_LtcGGXMatrix);
 #define SRL_BilinearSampler sampler_LtcGGXMatrix // Used for all textures
     // Aniso
     float TdotV;
     float BdotV;
-    
+
-    // image based lighting
-    // These variables aim to be use with EvaluateBSDF_Env 
-    float3 iblNormalWS; // Normal to be use with image based lighting
-    float3 iblR;        // Reflection vector, same as above.
+    float3 iblDirWS;    // Dominant specular direction, used for IBL in EvaluateBSDF_Env()
 
     float3 specularFGD; // Store preconvole BRDF for both specular and diffuse
     float diffuseFGD;
 
     preLightData.ggxLambdaV = GetSmithJointGGXLambdaV(preLightData.NdotV, bsdfData.roughness);
 
-    float iblNdotV = preLightData.NdotV;
+    float  iblNdotV    = preLightData.NdotV;
     float3 iblNormalWS = bsdfData.normalWS;
 
     // Check if we precompute anisotropy too
         preLightData.anisoGGXLambdaV = GetSmithJointGGXAnisoLambdaV(preLightData.TdotV, preLightData.BdotV, preLightData.NdotV, bsdfData.roughnessT, bsdfData.roughnessB);
         // Tangent = highlight stretch (anisotropy) direction. Bitangent = grain (brush) direction.
         iblNormalWS = GetAnisotropicModifiedNormal(bsdfData.bitangentWS, bsdfData.normalWS, V, bsdfData.anisotropy);
-        
+
         // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NDotV) and use iblNormalWS
         // into function like GetSpecularDominantDir(). However modified normal is just a hack. The goal is just to stretch a cubemap, no accuracy here.
         // With this in mind and for performance reasons we chose to only use modified normal to calculate R.
-    // We need to take into account the modified normal for faking anisotropic here.
-    preLightData.iblR = reflect(-V, iblNormalWS);
+
+    // We need to take into account the modified normal for faking anisotropic here.
+    float3 iblR = reflect(-V, iblNormalWS);
+    preLightData.iblDirWS = GetSpecularDominantDir(bsdfData.normalWS, iblR, bsdfData.roughness);
 
     // #if SHADERPASS == SHADERPASS_GBUFFER
     // preLightData.ambientOcclusion = LOAD_TEXTURE2D(_AmbientOcclusion, coord.unPositionSS).x;
                                 out float3 diffuseLighting,
                                 out float3 specularLighting)
 {
-    float3 L = lightData.direction;
+    float3 L = -lightData.forward; // Lights are pointing backward in Unity
-    diffuseLighting = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
+    diffuseLighting    = float3(0.0, 0.0, 0.0);
+    specularLighting   = float3(0.0, 0.0, 0.0);
+    float3 cookieColor = float3(1.0, 1.0, 1.0);
 
     [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0f)
     {
     }
 
+    [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
+    {
+        float3 unL = positionWS - lightData.positionWS;
+
+        // Project 'unL' onto the light's axes.
+        float2 coord = float2(dot(unL, lightData.right), dot(unL, lightData.up));
+
+        // Rescale the texture.
+        coord.x *= lightData.invScaleX;
+        coord.y *= lightData.invScaleY;
+
+        // Remap the texture coordinates from [-1, 1]^2 to [0, 1]^2.
+        coord = coord * 0.5 + 0.5;
+
+        // Tile the texture if the 'repeat' wrap mode is enabled.
+        if (lightData.tileCookie) coord = frac(coord);
+
+        float4 cookie = SampleCookie2D(lightLoopContext, coord, lightData.cookieIndex);
+
+        cookieColor  = cookie.rgb;
+        illuminance *= cookie.a;
+    }
+
-        diffuseLighting *= lightData.color * illuminance * lightData.diffuseScale;
-        specularLighting *= lightData.color * illuminance * lightData.specularScale;
+        diffuseLighting  *= (cookieColor * lightData.color) * (illuminance * lightData.diffuseScale);
+        specularLighting *= (cookieColor * lightData.color) * (illuminance * lightData.specularScale);
     }
 }
 
     attenuation *= GetAngleAttenuation(L, -lightData.forward, lightData.angleScale, lightData.angleOffset);
     float illuminance = saturate(dot(bsdfData.normalWS, L)) * attenuation;
 
-    diffuseLighting = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
+    diffuseLighting    = float3(0.0, 0.0, 0.0);
+    specularLighting   = float3(0.0, 0.0, 0.0);
+    float3 cookieColor = float3(1.0, 1.0, 1.0);
-    /*
-    [branch] if (lightData.cookieIndex && illuminance > 0.0f)
+    [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
-        illuminance *= SampleCookie(lightData.cookieIndex, lightToWorld, L);
+
+        // Rotate 'L' into the light space.
+        // We perform the negation because lights are oriented backwards (-Z).
+        float3 coord = mul(-L, transpose(lightToWorld));
+
+        float4 cookie;
+
+        [branch] if (lightData.lightType == GPULIGHTTYPE_SPOT)
+        {
+            // Perform the perspective projection of the hemisphere onto the disk.
+            coord.xy /= coord.z;
+
+            // Rescale the projective coordinates to fit into the [-1, 1]^2 range.
+            float cotOuterHalfAngle = lightData.size.x;
+            coord.xy *= cotOuterHalfAngle;
+
+            // Remap the texture coordinates from [-1, 1]^2 to [0, 1]^2.
+            coord.xy = coord.xy * 0.5 + 0.5;
+
+            cookie = SampleCookie2D(lightLoopContext, coord.xy, lightData.cookieIndex);
+        }
+        else // GPULIGHTTYPE_POINT
+        {
+            cookie = SampleCookieCube(lightLoopContext, coord, lightData.cookieIndex);
+        }
+
+        cookieColor  = cookie.rgb;
+        illuminance *= cookie.a;
-    */
-    [branch] if (lightData.IESIndex >= 0 && illuminance > 0.0f)
+    [branch] if (lightData.IESIndex >= 0 && illuminance > 0.0)
     {
         float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
         float2 sphericalCoord = GetIESTextureCoordinate(lightToWorld, L);
-    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0f)
+    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
     {
         float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
         float shadowAttenuation = GetPunctualShadowAttenuation(lightLoopContext, positionWS + offset, lightData.shadowIndex, L, preLightData.unPositionSS);
     }
 
-    [branch] if (illuminance > 0.0f)
+    [branch] if (illuminance > 0.0)
-        diffuseLighting *= lightData.color * illuminance * lightData.diffuseScale;
-        specularLighting *= lightData.color * illuminance * lightData.specularScale;
+
+        diffuseLighting  *= (cookieColor * lightData.color) * (illuminance * lightData.diffuseScale);
+        specularLighting *= (cookieColor * lightData.color) * (illuminance * lightData.specularScale);
     }
 }
 
 
     float3 unL = positionWS - lightData.positionWS;
 
-    // Pick the axis along which to expand the fade-out sphere into an ellipsoid.
+    // Pick the major axis of the ellipsoid.
-    // We define the ellipsoid s.t. r1 = r, r2 = (r + len / 2).
+    // We define the ellipsoid s.t. r1 = (r + len / 2), r2 = r3 = r.
     // TODO: This could be precomputed.
     float radius         = rsqrt(lightData.invSqrAttenuationRadius);
     float invAspectRatio = radius / (radius + (0.5 * len));
         ltcValue *= lightData.specularScale;
         specularLighting = fresnelTerm * lightData.color * ltcValue;
     }
-#endif
+#endif // LIT_DISPLAY_REFERENCE_AREA
 }
 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // EvaluateBSDF_Area - Approximation with Linearly Transformed Cosines
 //-----------------------------------------------------------------------------
+
+// #define ELLIPSOIDAL_ATTENUATION
 
 void EvaluateBSDF_Area(LightLoopContext lightLoopContext,
                        float3 V, float3 positionWS,
 
     float3 unL = positionWS - lightData.positionWS;
 
-    // Pick the axis along which to expand the fade-out sphere into an ellipsoid.
-    float3 axis = (halfWidth >= halfHeight) ? lightData.right : lightData.up;
+    // Rotate the light direction into the light space.
+    float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
+    unL = mul(unL, transpose(lightToWorld));
-    // We define the ellipsoid s.t. r1 = r, r2 = (r + |w - h| / 2).
+    // Define the dimensions of the attenuation volume.
-    float radius         = rsqrt(lightData.invSqrAttenuationRadius);
-    float invAspectRatio = radius / (radius + abs(halfWidth - halfHeight));
+    float  radius     = rsqrt(lightData.invSqrAttenuationRadius);
+    float3 invHalfDim = rcp(float3(radius + halfWidth,
+                                   radius + halfHeight,
+                                   radius));
-    float intensity = GetEllipsoidalDistanceAttenuation(unL,  lightData.invSqrAttenuationRadius,
-                                                        axis, invAspectRatio);
+#ifdef ELLIPSOIDAL_ATTENUATION
+    // The attenuation volume is an axis-aligned ellipsoid s.t.
+    // r1 = (r + w / 2), r2 = (r + h / 2), r3 = r.
+    float intensity = GetEllipsoidalDistanceAttenuation(unL, invHalfDim);
+#else
+    // The attenuation volume is an axis-aligned box s.t.
+    // hX = (r + w / 2), hY = (r + h / 2), hZ = r.
+    float intensity = GetBoxDistanceAttenuation(unL, invHalfDim);
+#endif
 
     // Terminate if the shaded point is too far away.
     if (intensity == 0.0) return;
         ltcValue *= lightData.specularScale;
         specularLighting = fresnelTerm * lightData.color * ltcValue;
     }
-#endif
+#endif // LIT_DISPLAY_REFERENCE_AREA
 }
 
 //-----------------------------------------------------------------------------
 
     // TODO: test the strech from Tomasz
     // float shrinkedRoughness = AnisotropicStrechAtGrazingAngle(bsdfData.roughness, bsdfData.perceptualRoughness, NdotV);
-    
-    // Note: As explain in GetPreLightData we use normalWS and not iblNormalWS here (in case of anisotropy)
-    float3 rayWS = GetSpecularDominantDir(bsdfData.normalWS, preLightData.iblR, bsdfData.roughness);
-
-    float3 R = rayWS;
-    weight = float2(1.0, 1.0);
-    
-    // In Unity the cubemaps are capture with the localToWorld transform of the component. 
+
+    // In Unity the cubemaps are capture with the localToWorld transform of the component.
-    
+
+    float3 R = preLightData.iblDirWS;
     float3x3 worldToLocal = transpose(float3x3(lightData.right, lightData.up, lightData.forward)); // worldToLocal assume no scaling
     float3 positionLS = positionWS - lightData.positionWS;
     positionLS = mul(positionLS, worldToLocal).xyz - lightData.offsetLS; // We want to calculate the intersection from the center of the bounding box.
-        float3 rayLS = mul(rayWS, worldToLocal);
+        float3 dirLS = mul(R, worldToLocal);
-        float dist = BoxRayIntersectSimple(positionLS, rayLS, -boxOuterDistance, boxOuterDistance);
+        float dist = BoxRayIntersectSimple(positionLS, dirLS, -boxOuterDistance, boxOuterDistance);
-        R = (positionWS + dist * rayWS) - lightData.positionWS;
-        
+        R = (positionWS + dist * R) - lightData.positionWS;
+
-    } 
+    }
-        float3 rayLS = mul(rayWS, worldToLocal);
+        float3 dirLS = mul(R, worldToLocal);
-        float dist = SphereRayIntersectSimple(positionLS, rayLS, sphereOuterDistance);
+        float dist = SphereRayIntersectSimple(positionLS, dirLS, sphereOuterDistance);
-        R = (positionWS + dist * rayWS) - lightData.positionWS;
+        R = (positionWS + dist * R) - lightData.positionWS;
+    weight.y = 1.0;
+
     if (lightData.envShapeType == ENVSHAPETYPE_SPHERE)
     {
         float distFade = max(length(positionLS) - lightData.innerDistance.x, 0.0);

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

         _NormalMap("NormalMap", 2D) = "bump" {}
 
         _HeightMap("HeightMap", 2D) = "black" {}
-        _HeightScale("Height Scale", Float) = 1
+        _HeightScale("Height Scale", Float) = 0.01
         _HeightBias("Height Bias", Float) = 0
 
         _TangentMap("TangentMap", 2D) = "bump" {}
         _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
+        _DetailSmoothnessScale("_DetailSmoothnessScale", Range(-2.0, 2.0)) = 0.01
         _DetailHeightScale("_DetailHeightScale", Range(-2.0, 2.0)) = 1
         _DetailAOScale("_DetailAOScale", Range(-2.0, 2.0)) = 1        
 
             #define SHADERPASS SHADERPASS_FORWARD
             // TEMP until pragma work in include
             // #include "../../Lighting/Forward.hlsl"
-            // LIGHTLOOP_TILE_PASS
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
             //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF
 
             #include "../../Lighting/Lighting.hlsl"

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

     ADD_IDX(layerTexCoord.base).uv =    ADD_IDX(_UVMappingMask).x * input.texCoord0 +
                                         ADD_IDX(_UVMappingMask).y * input.texCoord1 + 
                                         ADD_IDX(_UVMappingMask).z * input.texCoord3 +
-                                        ADD_IDX(_UVMappingMask).w * position.xz;
+                                        ADD_IDX(_UVMappingMask).w * -position.xz;
-                        ADD_IDX(_UVMappingMask).w * position.xz;
+                        ADD_IDX(_UVMappingMask).w * -position.xz;
 
     ADD_IDX(layerTexCoord.details).uv = TRANSFORM_TEX(uvDetails, ADD_IDX(_DetailMap));
 
-    ADD_IDX(layerTexCoord.base).uvYZ = position.yz;
-    ADD_IDX(layerTexCoord.base).uvZX = position.zx;
-    ADD_IDX(layerTexCoord.base).uvXY = position.xy;
+    float3 direction = sign(input.tangentToWorld[2].xyz);
+
+    // In triplanar, if we are facing away from the world axis, a different axis will be flipped for each direction.
+    // This is particularly problematic for tangent space normal maps which need to be in the right direction.
+    // So we multiplying the offending coordinate by the sign of the normal.
+    ADD_IDX(layerTexCoord.base).uvYZ = float2(direction.x * position.z, position.y);
+    ADD_IDX(layerTexCoord.base).uvZX = -float2(position.x, direction.y * position.z);
+    ADD_IDX(layerTexCoord.base).uvXY = float2(-position.x, direction.z * position.y);
-    ADD_IDX(layerTexCoord.details).uvYZ = TRANSFORM_TEX(position.yz, ADD_IDX(_DetailMap));
-    ADD_IDX(layerTexCoord.details).uvZX = TRANSFORM_TEX(position.zx, ADD_IDX(_DetailMap));
-    ADD_IDX(layerTexCoord.details).uvXY = TRANSFORM_TEX(position.xy, ADD_IDX(_DetailMap));
+    ADD_IDX(layerTexCoord.details).uvYZ = TRANSFORM_TEX(ADD_IDX(layerTexCoord.base).uvYZ, ADD_IDX(_DetailMap));
+    ADD_IDX(layerTexCoord.details).uvZX = TRANSFORM_TEX(ADD_IDX(layerTexCoord.base).uvZX, ADD_IDX(_DetailMap));
+    ADD_IDX(layerTexCoord.details).uvXY = TRANSFORM_TEX(ADD_IDX(layerTexCoord.base).uvXY, ADD_IDX(_DetailMap));
 }
 
 void ADD_IDX(ApplyDisplacement)(inout FragInput input, inout LayerTexCoord layerTexCoord)
 #else
     surfaceData.perceptualSmoothness = 1.0;
 #endif
-    surfaceData.perceptualSmoothness *= _Smoothness;
+    surfaceData.perceptualSmoothness *= ADD_IDX(_Smoothness);
 #ifdef _DETAIL_MAP
     surfaceData.perceptualSmoothness *= LerpWhiteTo(2.0 * saturate(detailSmoothness * ADD_IDX(_DetailSmoothnessScale)), detailMask);
 #endif
     surfaceData.metallic = 1.0;
     surfaceData.ambientOcclusion = 1.0;
 #endif
-    surfaceData.metallic *= _Metallic;
+    surfaceData.metallic *= ADD_IDX(_Metallic);
 
     // This part of the code is not used in case of layered shader but we keep the same macro system for simplicity
 #if !defined(LAYERED_LIT_SHADER)
     // TODO: think about using BC5
 #ifdef _TANGENTMAP
 #ifdef _NORMALMAP_TANGENT_SPACE // Normal and tangent use same space
-    float3 tangentTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base)));
+    float3 tangentTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base));
     surfaceData.tangentWS = TransformTangentToWorld(tangentTS, input.tangentToWorld);
 #else // Object space (TODO: We need to apply the world rotation here! - Require to pass world transform)
     surfaceData.tangentWS = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base)).rgb;
 #else
     surfaceData.anisotropy = 1.0;
 #endif
-    surfaceData.anisotropy *= _Anisotropy;
+    surfaceData.anisotropy *= ADD_IDX(_Anisotropy);
 
     surfaceData.specular = 0.04;
 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Material.hlsl

 #include "GeometricTools.hlsl"
 #include "CommonMaterial.hlsl"
 #include "EntityLighting.hlsl"
+#include "ImageBasedLighting.hlsl"
 
 //-----------------------------------------------------------------------------
 // BuiltinData

Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl

 // TODO: move this to constant buffer by Pass
 float4		_ScreenSize;
 
+float4x4 GetWorldToViewMatrix()
+{
+    return unity_MatrixV;
+}
 
 float4x4 GetObjectToWorldMatrix()
 {
     return unity_WorldTransformParams.w;
 }
 
-
+}
+
+float3 TransformWorldToView(float3 positionWS)
+{
+    return mul(GetWorldToViewMatrix(), float4(positionWS, 1.0)).xyz;
 }
 
 float3 TransformObjectToWorld(float3 positionOS)

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/AtmosphericParameters.cs

         if (instance == this)
         {
             // TODO: what's the point of doing this?
-            OnDisable();
+            Cleanup();
             OnEnable();
         }
 
         instance = this;
     }
 
-    void OnDisable()
+    void Cleanup()
     {
         // Undefine all preprocessor symbols.
         UpdateKeywords(false);

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/GGXConvolve.shader

                                             PerceptualRoughnessToRoughness(perceptualRoughness),
                                             _MipMapCount,
                                             _InvOmegaP,
-                                            2048,
-                                            false);
+                                            64,
+                                            true);
 
                 return val;
             }

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/SkyHDRI.shader

                 float3 rotDirY = float3(sinPhi, 0, cosPhi);
                 dir = float3(dot(rotDirX, dir), dir.y, dot(rotDirY, dir));
 
+                /*
                 Coordinate coord = GetCoordinate(input.positionCS.xy, _ScreenSize.zw);
 
                 // If the sky box is too far away (depth set to 0), the resulting look is too foggy.
                     }
                 #endif
 
+                */
+
+                return float4(skyColor, 1.0);
-                return float4(skyColor * (skyTexWeight * extinction) + scatter, extinction);
+                //return float4(skyColor * (skyTexWeight * extinction) + scatter, extinction);
             }
 
             ENDHLSL

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/SkyRenderer.cs

 namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     [Serializable]
+    public enum SkyResolution
+    {
+        SkyResolution128 = 128,
+        SkyResolution256 = 256,
+        SkyResolution512 = 512,
+        SkyResolution1024 = 1024,
+        // TODO: Anything above 1024 cause a crash in Unity...
+        //SkyResolution2048 = 2048,
+        //SkyResolution4096 = 4096
+    }
+
+    [Serializable]
-        public float multiplier = 1.0f;
+        public float multiplier = 1.0f;       
+        public SkyResolution skyResolution = SkyResolution.SkyResolution256;
+
-        const int kSkyCubemapSize = 256;
-
         RenderTexture m_SkyboxCubemapRT = null;
         RenderTexture m_SkyboxGGXCubemapRT = null;
 
 
+        SkyParameters m_bakedSkyParameters = new SkyParameters(); // This is the SkyParam used when baking and convolving the sky.
+
+        Mesh[] m_CubemapFaceMesh = new Mesh[6];
 
         Mesh BuildSkyMesh(Camera camera, bool forceUVBottom)
         {
             vertData[2] = new Vector3(vertData2.x, vertData2.y, vertData2.z);
             vertData[3] = new Vector3(vertData3.x, vertData3.y, vertData3.z);
 
-            // Get view vector vased on the frustrum, i.e (invert transform frustrum get position etc...)
+            // Get view vector based on the frustum, i.e (invert transform frustum get position etc...)
             Vector3[] eyeVectorData = new Vector3[4];
 
             Matrix4x4 transformMatrix = camera.cameraToWorldMatrix * camera.projectionMatrix.inverse;
             };
         }
 
-        void RebuildTextures()
+        void RebuildTextures(SkyParameters skyParameters)
-            if(m_SkyboxCubemapRT == null)
+            if ((m_SkyboxCubemapRT != null) && (m_SkyboxCubemapRT.width != (int)skyParameters.skyResolution))
+            {
+                Utilities.Destroy(m_SkyboxCubemapRT);
+                Utilities.Destroy(m_SkyboxGGXCubemapRT);
+            }
+            
+            if (m_SkyboxCubemapRT == null)
-                m_SkyboxCubemapRT = new RenderTexture(kSkyCubemapSize, kSkyCubemapSize, 1, RenderTextureFormat.ARGBHalf);
+                m_SkyboxCubemapRT = new RenderTexture((int)skyParameters.skyResolution, (int)skyParameters.skyResolution, 1, RenderTextureFormat.ARGBHalf);
-                m_SkyboxCubemapRT.autoGenerateMips = true;
-                m_SkyboxCubemapRT.filterMode = FilterMode.Point;
+                m_SkyboxCubemapRT.autoGenerateMips = true; // Generate regular mipmap for filtered importance sampling
+                m_SkyboxCubemapRT.filterMode = FilterMode.Trilinear;
-            }
-            if(m_SkyboxGGXCubemapRT == null)
-            {
-                m_SkyboxGGXCubemapRT = new RenderTexture(kSkyCubemapSize, kSkyCubemapSize, 1, RenderTextureFormat.ARGBHalf);
+                m_SkyboxGGXCubemapRT = new RenderTexture((int)skyParameters.skyResolution, (int)skyParameters.skyResolution, 1, RenderTextureFormat.ARGBHalf);
                 m_SkyboxGGXCubemapRT.dimension = TextureDimension.Cube;
                 m_SkyboxGGXCubemapRT.useMipMap = true;
                 m_SkyboxGGXCubemapRT.autoGenerateMips = false;
             Shader.SetGlobalTexture("_SkyTexture", m_SkyboxGGXCubemapRT);
         }
 
+        public void Resize(SkyParameters skyParameters)
+        {
+            // When loading RenderDoc, RenderTextures will go null
+            RebuildTextures(skyParameters);
+        }
+
         public void Rebuild()
         {
             // TODO: We need to have an API to send our sky information to Enlighten. For now use a workaround through skybox/cubemap material...
             m_GGXConvolveMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/GGXConvolve");
 
-            m_RenderSkyPropertyBlock = new MaterialPropertyBlock();
-
-            RebuildTextures();
+            m_RenderSkyPropertyBlock = new MaterialPropertyBlock();            
 
             Matrix4x4 cubeProj = Matrix4x4.Perspective(90.0f, 1.0f, 0.1f, 1.0f);
 
                 camera.projectionMatrix = cubeProj;
                 Transform transform = camera.GetComponent<Transform>();
                 transform.LookAt(lookAtList[i], UpVectorList[i]);
+
+                // When rendering into a texture the render will be flip (due to legacy unity openGL behavior), so we need to flip UV here...
+                m_CubemapFaceMesh[i] = BuildSkyMesh(camera, true);
-        public void OnDisable()
+        public void Cleanup()
         {
             Utilities.Destroy(m_StandardSkyboxMaterial);
             Utilities.Destroy(m_SkyHDRIMaterial);
 
         }
 
-        bool IsSkyValid(SkyParameters parameters)
+        public bool IsSkyValid(SkyParameters parameters)
-        private void RenderSky(Camera camera, SkyParameters skyParameters, bool forceUVBottom, RenderLoop renderLoop)
+        private void RenderSky(Camera camera, SkyParameters skyParameters, Mesh skyMesh, RenderLoop renderLoop)
-            Mesh skyMesh = BuildSkyMesh(camera, forceUVBottom);
-
             Shader.EnableKeyword("PERFORM_SKY_OCCLUSION_TEST");
 
             m_RenderSkyPropertyBlock.SetTexture("_Cubemap", skyParameters.skyHDRI);
             {
                 Utilities.SetRenderTarget(renderLoop, target, 0, (CubemapFace)i);
                 Camera faceCamera = m_CubemapFaceCamera[i].GetComponent<Camera>();
-                RenderSky(faceCamera, skyParameters, true, renderLoop);
+                RenderSky(faceCamera, skyParameters, m_CubemapFaceMesh[i], renderLoop);
             }
         }
 
                 }
 
                 // Copy the first mip.
+
+                // TEMP code until CopyTexture is implemented for command buffer
                 // All parameters are neutral because exposure/multiplier have already been applied in the first copy.
                 SkyParameters skyParams = new SkyParameters();
                 skyParams.exposure = 0.0f;
                 RenderSkyToCubemap(skyParams, target, renderLoop);
+                // End temp
+
+                // 
+                //for (int f = 0; f < 6; f++)
+                //    Graphics.CopyTexture(input, f, 0, target, f, 0);
+
 
                 // Do the convolution on remaining mipmaps
                 float invOmegaP = (6.0f * input.width * input.width) / (4.0f * Mathf.PI); // Solid angle associated to a pixel of the cubemap;
                     for (int face = 0; face < 6; ++face)
                     {
                         Utilities.SetRenderTarget(renderLoop, target, mip, (CubemapFace)face);
-                        Camera faceCamera = m_CubemapFaceCamera[face].GetComponent<Camera>();
-
-                        Mesh skyMesh = BuildSkyMesh(faceCamera, true);
-
+ 
-                        cmd.DrawMesh(skyMesh, Matrix4x4.identity, m_GGXConvolveMaterial, 0, 0, propertyBlock);
+                        cmd.DrawMesh(m_CubemapFaceMesh[face], Matrix4x4.identity, m_GGXConvolveMaterial, 0, 0, propertyBlock);
                         renderLoop.ExecuteCommandBuffer(cmd);
                         cmd.Dispose();
                     }
         {
             using (new Utilities.ProfilingSample("Sky Pass", renderLoop))
             {
-                //using (new EditorGUI.DisabledScope(m_LookDevEnvLibrary.hdriList.Count <= 1))
-                    // When loading RenderDoc, RenderTextures will go null
-                    RebuildTextures();
+                    // Trigger a rebuild of cubemap / convolution
+                    // TODO: can we have some kind of hash value here ? +> use or override GetHashCode() + include a refresh rate value in parameters
+                    // TODO: we could apply multiplier/exposure and rotation on the final result (i.e on the sky ibl and on lightprobe / lightmap, but can be tricky as Unity seems to merge sky information with 
+                    // other lighting into SH / lightmap.
+                    if (skyParameters.skyResolution != m_bakedSkyParameters.skyResolution ||
+                        skyParameters.exposure != m_bakedSkyParameters.exposure ||
+                        skyParameters.rotation != m_bakedSkyParameters.rotation ||
+                        skyParameters.multiplier != m_bakedSkyParameters.multiplier)
+                    {
+                        using (new Utilities.ProfilingSample("Sky Pass: Render Cubemap", renderLoop))
+                        {
+                            // Render sky into a cubemap - doesn't happen every frame, can be controlled
+                            RenderSkyToCubemap(skyParameters, m_SkyboxCubemapRT, renderLoop);
+                            // Convolve downsampled cubemap
+                            RenderCubemapGGXConvolution(m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT, renderLoop);
-                    using (new Utilities.ProfilingSample("Sky Pass: Render Cubemap", renderLoop))
-                    {
-                        // Render sky into a cubemap - doesn't happen every frame, can be controlled
-                        RenderSkyToCubemap(skyParameters, m_SkyboxCubemapRT, renderLoop);
-                        // Convolve downsampled cubemap
-                        RenderCubemapGGXConvolution(m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT, renderLoop);
+                            // TODO: Properly send the cubemap to Enlighten. Currently workaround is to set the cubemap in a Skybox/cubemap material
+                            m_StandardSkyboxMaterial.SetTexture("_Tex", m_SkyboxCubemapRT);
+                            RenderSettings.skybox = m_StandardSkyboxMaterial; // Setup this material as the default to be use in RenderSettings
+                            RenderSettings.ambientIntensity = 1.0f; // fix this to 1, this parameter should not exist!
+                            RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox; // Force skybox for our HDRI
+                            RenderSettings.reflectionIntensity = 1.0f;
+                            RenderSettings.customReflection = null;
+                            DynamicGI.UpdateEnvironment();
+                        }
-                        // TODO: Properly send the cubemap to Enlighten. Currently workaround is to set the cubemap in a Skybox/cubemap material
-                        m_StandardSkyboxMaterial.SetTexture("_Tex", m_SkyboxCubemapRT);
-                        RenderSettings.skybox = m_StandardSkyboxMaterial; // Setup this material as the default to be use in RenderSettings
-                        RenderSettings.ambientIntensity = 1.0f; // fix this to 1, this parameter should not exist!
-                        RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox; // Force skybox for our HDRI
-                        RenderSettings.reflectionIntensity = 1.0f;
-                        RenderSettings.customReflection = null;
-                        //DynamicGI.UpdateEnvironment();
+                        // Cleanup all this...
+                        m_bakedSkyParameters.skyResolution = skyParameters.skyResolution;
+                        m_bakedSkyParameters.exposure = skyParameters.exposure;
+                        m_bakedSkyParameters.rotation = skyParameters.rotation;
+                        m_bakedSkyParameters.multiplier = skyParameters.multiplier;
-                    RenderSky(camera, skyParameters, false, renderLoop);
+                    RenderSky(camera, skyParameters, BuildSkyMesh(camera, false), renderLoop);
                 }
             }
         }

Assets/ScriptableRenderLoop/HDRenderLoop/Utilities.cs

 #else
                     UnityObject.Destroy(obj);
 #endif
+                obj = null;
+            }
+        }
+
+        public static void SafeRelease(ComputeBuffer buffer)
+        {
+            if (buffer != null)
+            {
+                buffer.Release();
+                buffer = null;
             }
         }
 

Assets/ScriptableRenderLoop/RenderPasses/ShadowRenderPass.cs

                 if (!cullResults.GetShadowCasterBounds(lightIndex, out bounds))
                 {
                     Profiler.EndSample();
-                    return;
+                    continue;
                 }
                 Profiler.EndSample();
 

Assets/ScriptableRenderLoop/ShaderLibrary/AreaLighting.hlsl

     float tLDDL2 = l2rcpD / (d * d + l2 * l2);
     float intWt  = LineFwt(tLDDL2, l2) - LineFwt(tLDDL1, l1);
     float intP0  = LineFpo(tLDDL2, l2rcpD, rcp(d)) - LineFpo(tLDDL1, l1rcpD, rcp(d));
-    // Guard against numerical precision issues.
-    return max(intP0 * normal.z + intWt * tangent.z, 0.0);
+    return intP0 * normal.z + intWt * tangent.z;
 }
 
 // Computes 1.0 / length(mul(ortho, transpose(inverse(invM)))).
 
     float width = ComputeLineWidthFactor(invM, B);
 
-    if (P2.z <= 0.0)
+    if (P1.z > P2.z)
-        // Convention: 'P2' is above the horizon.
+        // Convention: 'P2' is above 'P1', with the tangent pointing upwards.
         Swap(P1, P2);
     }
 
     // Integrate the clamped cosine over the line segment.
     float irradiance = LineIrradiance(l1, l2, P0, T);
 
-    return INV_PI * width * irradiance;
+    // Guard against numerical precision issues.
+    return max(INV_PI * width * irradiance, 0.0);
 }
 
 #endif // UNITY_AREA_LIGHTING_INCLUDED

Assets/ScriptableRenderLoop/ShaderLibrary/CommonLighting.hlsl

 // Light direction is oriented backward (-Z). i.e in shader code, light direction is -lightData.forward
 
 //-----------------------------------------------------------------------------
+// Helper functions
+//-----------------------------------------------------------------------------
+
+// Performs the mapping of the vector 'v' centered within the axis-aligned cube
+// of dimensions [-1, 1]^3 to a vector centered within the unit sphere.
+// The function expects 'v' to be within the cube (possibly unexpected results otherwise).
+// Ref: http://mathproofs.blogspot.com/2005/07/mapping-cube-to-sphere.html
+float3 MapCubeToSphere(float3 v)
+{
+    float3 v2 = v * v;
+    float2 vr3 = v2.xy * rcp(3.0);
+    return v * sqrt((float3)1.0 - 0.5 * v2.yzx - 0.5 * v2.zxy + vr3.yxx * v2.zzy);
+}
+
+// Computes the squared magnitude of the vector computed by MapCubeToSphere().
+float ComputeCubeToSphereMapSqMagnitude(float3 v)
+{
+    float3 v2 = v * v;
+    // Note: dot(v, v) is often computed before this function is called,
+    // so the compiler should optimize and use the precomputed result here.
+    return dot(v, v) - v2.x * v2.y - v2.y * v2.z - v2.z * v2.x + v2.x * v2.y * v2.z;
+}
+
+//-----------------------------------------------------------------------------
 // Attenuation functions
 //-----------------------------------------------------------------------------
 
     return attenuation;
 }
 
-// Applies SmoothDistanceAttenuation() after stretching the fade-out sphere of the given radius
-// into an ellipsoid with the specified aspect ratio and the longest axis.
-float GetEllipsoidalDistanceAttenuation(float3 unL,  float invSqrAttenuationRadius,
+// Applies SmoothDistanceAttenuation() after transforming the attenuation ellipsoid into a sphere.
+// If r = rsqrt(invSqRadius), then the ellipsoid is defined s.t. r1 = r / invAspectRatio, r2 = r3 = r.
+// The transformation is performed along the major axis of the ellipsoid (corresponding to 'r1').
+// Both the ellipsoid (e.i. 'axis') and 'unL' should be in the same coordinate system.
+// 'unL' should be computed from the center of the ellipsoid.
+float GetEllipsoidalDistanceAttenuation(float3 unL,  float invSqRadius,
-    // Project the unnormalized light vector onto the expansion axis.
+    // Project the unnormalized light vector onto the axis.
-    // We want 'unL' to shrink along 'axis' by the aspect ratio. Therefore, we compute
-    // the difference between the length of the original projection and the shrunk one.
-    // It is equivalent to the expansion of the fade-out sphere into an ellipsoid.
-    float scale = projL - projL * invAspectRatio;
-    unL -= scale * axis;
+    // Transform the light vector instead of transforming the ellipsoid.
+    float diff = projL - projL * invAspectRatio;
+    unL -= diff * axis;
+
+    float sqDist = dot(unL, unL);
+    return SmoothDistanceAttenuation(sqDist, invSqRadius);
+}
+
+// Applies SmoothDistanceAttenuation() using the axis-aligned ellipsoid of the given dimensions.
+// Both the ellipsoid and 'unL' should be in the same coordinate system.
+// 'unL' should be computed from the center of the ellipsoid.
+float GetEllipsoidalDistanceAttenuation(float3 unL, float3 invHalfDim)
+{
+    // Transform the light vector so that we can work with
+    // with the ellipsoid as if it was a unit sphere.
+    unL *= invHalfDim;
+
+    float sqDist = dot(unL, unL);
+    return SmoothDistanceAttenuation(sqDist, 1.0);
+}
-    return SmoothDistanceAttenuation(dot(unL, unL), invSqrAttenuationRadius);
+// Applies SmoothDistanceAttenuation() after mapping the axis-aligned box to a sphere.
+// If the diagonal of the box is 'd', invHalfDim = rcp(0.5 * d).
+// Both the box and 'unL' should be in the same coordinate system.
+// 'unL' should be computed from the center of the box.
+float GetBoxDistanceAttenuation(float3 unL, float3 invHalfDim)
+{
+    // Transform the light vector so that we can work with
+    // with the box as if it was a [-1, 1]^2 cube.
+    unL *= invHalfDim;
+
+    // Our algorithm expects the input vector to be within the cube.
+    if (Max3(abs(unL.x), abs(unL.y), abs(unL.z)) > 1.0) return 0.0;
+
+    float sqDist = ComputeCubeToSphereMapSqMagnitude(unL);
+    return SmoothDistanceAttenuation(sqDist, 1.0);
 }
 
 //-----------------------------------------------------------------------------
     tangentY    = float3(b, 1.0f - N.y * N.y * a, -N.y);
 }
 */
-
-//-----------------------------------------------------------------------------
-// various helper
-//-----------------------------------------------------------------------------
-
-// Performs the mapping of the vector 'v' located within the cube of dimensions [-r, r]^3
-// to a vector within the sphere of radius 'r', where r = sqrt(r2).
-// Modified version of http://mathproofs.blogspot.com/2005/07/mapping-cube-to-sphere.html
-float3 MapCubeToSphere(float3 v, float r2)
-{
-    float3 v2 = v * v;
-    float2 vr3 = v2.xy * rcp(3.0 * r2);
-    return v * sqrt((float3)r2 - 0.5 * v2.yzx - 0.5 * v2.zxy + vr3.yxx * v2.zzy);
-}
-
-// Computes the squared magnitude of the vector computed by MapCubeToSphere().
-float ComputeCubeToSphereMapSqMagnitude(float3 v, float r2)
-{
-    float3 v2 = v * v;
-    // Note: dot(v, v) is often computed before this function is called,
-    // so the compiler should optimize and use the precomputed result here.
-    return r2 * dot(v, v) - v2.x * v2.y - v2.y * v2.z - v2.z * v2.x + v2.x * v2.y * v2.z * rcp(r2);
-}
 
 #endif // UNITY_COMMON_LIGHTING_INCLUDED

Assets/ScriptableRenderLoop/common/ShaderBase.h

 
 float FetchDepth(Texture2D depthTexture, uint2 pixCoord)
 {
-    return 1 - depthTexture.Load(uint3(pixCoord.xy, 0)).x;
+	float zdpth = depthTexture.Load(uint3(pixCoord.xy, 0)).x;
+#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+	zdpth = 1.0 - zdpth;
+#endif
+    return zdpth;
-    return 1 - depthTexture.Load(uint3(pixCoord.xy, 0), sampleIdx).x;
+	float zdpth = depthTexture.Load(uint3(pixCoord.xy, 0), sampleIdx).x;
+#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+	zdpth = 1.0 - zdpth;
+#endif
+    return zdpth;
 }
 
 #endif

Assets/ScriptableRenderLoop/common/TextureSettings.cs

-[System.Serializable]
-public struct TextureSettings
+namespace UnityEngine.Experimental.ScriptableRenderLoop
-    public uint spotCookieSize;
-    public uint pointCookieSize;
-    public uint reflectionCubemapSize;
+    [System.Serializable]
+    public class TextureSettings
+    {
+        public int spotCookieSize;
+        public int pointCookieSize;
+        public int reflectionCubemapSize;
-    public static TextureSettings Default
-    {
-        get
+        public static TextureSettings Default
-            TextureSettings settings;
-            settings.spotCookieSize = 128;
-            settings.pointCookieSize = 512;
-            settings.reflectionCubemapSize = 128;
-            return settings;
+            get
+            {
+                TextureSettings settings = new TextureSettings();
+                settings.spotCookieSize = 128;
+                settings.pointCookieSize = 512;
+                settings.reflectionCubemapSize = 128;
+                return settings;
+            }
         }
     }
 }

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

             m_CookieTexArray = new TextureCache2D();
             m_CubeCookieTexArray = new TextureCacheCubemap();
             m_CubeReflTexArray = new TextureCacheCubemap();
-            m_CookieTexArray.AllocTextureArray(8, (int)m_TextureSettings.spotCookieSize, (int)m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
-            m_CubeCookieTexArray.AllocTextureArray(4, (int)m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
-            m_CubeReflTexArray.AllocTextureArray(64, (int)m_TextureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
+            m_CookieTexArray.AllocTextureArray(8, m_TextureSettings.spotCookieSize, m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
+            m_CubeCookieTexArray.AllocTextureArray(4, m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
+            m_CubeReflTexArray.AllocTextureArray(64, m_TextureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
 
             //m_DeferredMaterial.SetTexture("_spotCookieTextures", m_cookieTexArray.GetTexCache());
             //m_DeferredMaterial.SetTexture("_pointCookieTextures", m_cubeCookieTexArray.GetTexCache());
             // render opaque objects using Deferred pass
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("Deferred"))
             {
-                sorting = {sortOptions = SortOptions.SortByMaterialThenMesh},
+                sorting = { flags = SortFlags.CommonOpaque },
                 rendererConfiguration = RendererConfiguration.PerObjectLightmaps
             };
 
             // render opaque objects using Deferred pass
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("ForwardSinglePass"))
             {
-                sorting = { sortOptions = SortOptions.SortByMaterialThenMesh }
+                sorting = { flags = SortFlags.CommonOpaque }
             };
             settings.rendererConfiguration = RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
             if (opaquesOnly) settings.inputFilter.SetQueuesOpaque();
             // render opaque objects using Deferred pass
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("DepthOnly"))
             {
-                sorting = { sortOptions = SortOptions.SortByMaterialThenMesh }
+                sorting = { flags = SortFlags.CommonOpaque }
             };
             settings.inputFilter.SetQueuesOpaque();
             loop.DrawRenderers(ref settings);
 
         void DoTiledDeferredLighting(Camera camera, RenderLoop loop, int numLights, int numDirLights)
         {
-            var bUseClusteredForDeferred = !usingFptl;       // doesn't work on reflections yet but will soon
+            var bUseClusteredForDeferred = !usingFptl;
             var cmd = new CommandBuffer();
 
             m_DeferredMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
 
             return numLightsOut + numProbesOut;
         }
+
+#if UNITY_EDITOR
+        public override void RenderSceneView(Camera camera, RenderLoop renderLoop)
+        {
+            base.RenderSceneView(camera, renderLoop);
+            renderLoop.PrepareForEditorRendering(camera, new RenderTargetIdentifier(s_CameraDepthTexture));
+            renderLoop.Submit();
+        }
+#endif
 
         public override void Render(Camera[] cameras, RenderLoop renderLoop)
         {

Assets/ScriptableRenderLoop/fptl/LightingTemplate.hlsl

 StructuredBuffer<DirectionalLight> g_dirLightData;
 
 
-#define VALVE_DECLARE_SHADOWMAP( tex ) Texture2D tex; SamplerComparisonState sampler##tex
-#define VALVE_SAMPLE_SHADOW( tex, coord ) tex.SampleCmpLevelZero( sampler##tex, (coord).xy, (coord).z )
+#define DECLARE_SHADOWMAP( tex ) Texture2D tex; SamplerComparisonState sampler##tex
+#define SAMPLE_SHADOW( tex, coord ) tex.SampleCmpLevelZero( sampler##tex, (coord).xy, (coord).z )
-VALVE_DECLARE_SHADOWMAP(g_tShadowBuffer);
+DECLARE_SHADOWMAP(g_tShadowBuffer);
 
 float ComputeShadow_PCF_3x3_Gaussian(float3 vPositionWs, float4x4 matWorldToShadow)
 {
     float objDepth = saturate(257.0 / 256.0 - vPositionTextureSpace.z);
 
     float4 v20Taps;
-    v20Taps.x = VALVE_SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.xy, objDepth)).x; //  1  1
-    v20Taps.y = VALVE_SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.zy, objDepth)).x; // -1  1
-    v20Taps.z = VALVE_SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.xw, objDepth)).x; //  1 -1
-    v20Taps.w = VALVE_SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.zw, objDepth)).x; // -1 -1
+    v20Taps.x = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.xy, objDepth)).x; //  1  1
+    v20Taps.y = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.zy, objDepth)).x; // -1  1
+    v20Taps.z = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.xw, objDepth)).x; //  1 -1
+    v20Taps.w = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms1.zw, objDepth)).x; // -1 -1
     float flSum = dot(v20Taps.xyzw, float4(0.25, 0.25, 0.25, 0.25));
     if ((flSum == 0.0) || (flSum == 1.0))
         return flSum;
-    v33Taps.x = VALVE_SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms2.xz, objDepth)).x; //  1  0
-    v33Taps.y = VALVE_SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms3.xz, objDepth)).x; // -1  0
-    v33Taps.z = VALVE_SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms3.zy, objDepth)).x; //  0 -1
-    v33Taps.w = VALVE_SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms2.zy, objDepth)).x; //  0  1
+    v33Taps.x = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms2.xz, objDepth)).x; //  1  0
+    v33Taps.y = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms3.xz, objDepth)).x; // -1  0
+    v33Taps.z = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms3.zy, objDepth)).x; //  0 -1
+    v33Taps.w = SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy + g_vShadow3x3PCFTerms2.zy, objDepth)).x; //  0  1
-    flSum += VALVE_SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy, objDepth)).x * g_vShadow3x3PCFTerms0.z;
+    flSum += SAMPLE_SHADOW(g_tShadowBuffer, float3(shadowMapCenter.xy, objDepth)).x * g_vShadow3x3PCFTerms0.z;
 
     return flSum;
 }

Assets/ScriptableRenderLoop/fptl/StandardTest.shader

             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile_fog
+			#pragma multi_compile TILED_FORWARD REGULAR_FORWARD
 
             #pragma vertex vertForward
             #pragma fragment fragForward
             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile_fog
-			#pragma multi_compile TILED_FORWARD REGULAR_FORWARD
 
             #pragma vertex vertForward
             #pragma fragment fragNoLight

Assets/ScriptableRenderLoop/fptl/lightlistbuild-bigtile.compute

 	int offs = tileIDX.y*nrBigTilesX + tileIDX.x;
 
 	for(int i=t; i<(iNrCoarseLights+1); i+=NR_THREADS)
-		g_vLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*offs + i] = t==0 ? iNrCoarseLights : lightsListLDS[i-1];
+		g_vLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*offs + i] = i==0 ? iNrCoarseLights : lightsListLDS[i-1];
 }
 
 

Assets/ScriptableRenderLoop/fptl/lightlistbuild.compute

 	
 	for(int l=threadID; l<iNrCoarseLights; l+=NR_THREADS)
 	{
-		SFiniteLightBound lightData = g_data[coarseList[l]];
+		SFiniteLightBound lightData = g_data[prunedList[l]];
 	
 		if( DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lightData.center.xyz, lightData.radius) )
 		{

Assets/TestScenes/HDTest/GlobalIlluminationTest.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.5456174, g: 0.39782104, b: 0.24038851, a: 1}
+  m_IndirectSpecularColor: {r: 0.6238628, g: 0.56322443, b: 0.5425187, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
   m_Component:
   - component: {fileID: 565152815}
   - component: {fileID: 565152816}
+  - component: {fileID: 565152817}
   m_Layer: 0
   m_Name: Spotlight
   m_TagString: Untagged
   m_BounceIntensity: 1
   m_ShadowRadius: 0
   m_ShadowAngle: 0
+--- !u!114 &565152817
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 565152814}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  archetype: 0
+  isDoubleSided: 0
+  areaLightLength: 0
+  areaLightWidth: 0
 --- !u!1 &841702834
 GameObject:
   m_ObjectHideFlags: 0
   shadowDimmer: 1
   affectDiffuse: 1
   affectSpecular: 1
-  treatAsAreaLight: 0
+  archetype: 0
   isDoubleSided: 0
   areaLightLength: 0
   areaLightWidth: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1543726725}
   m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
-  m_LocalPosition: {x: -6.33, y: 0.428, z: -5.0499997}
+  m_LocalPosition: {x: -6.33, y: 0.428, z: -4.84}
   m_LocalScale: {x: 1.6119599, y: 1.6119599, z: 1.6119599}
   m_Children: []
   m_Father: {fileID: 1027688891}

Assets/TestScenes/HDTest/HDRenderLoopTest.unity

     minRegionArea: 2
     manualCellSize: 0
     cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
     accuratePlacement: 0
   m_NavMeshData: {fileID: 0}
 --- !u!1 &68487706
     m_RemovedComponents: []
   m_ParentPrefab: {fileID: 100100000, guid: 646b4ac0331f8e447bd20f06eba916a3, type: 3}
   m_IsPrefabParent: 0
+--- !u!1 &192903503
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 192903504}
+  - component: {fileID: 192903506}
+  - component: {fileID: 192903505}
+  m_Layer: 0
+  m_Name: Spot Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &192903504
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 192903503}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -0.05, y: -0.25, z: -2.0000005}
+  m_LocalScale: {x: 0, y: 0, z: 1.0000005}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 90, y: 0, z: 0}
+--- !u!114 &192903505
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 192903503}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  archetype: 0
+  isDoubleSided: 1
+  areaLightLength: 4
+  areaLightWidth: 2
+--- !u!108 &192903506
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 192903503}
+  m_Enabled: 1
+  serializedVersion: 7
+  m_Type: 0
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 50
+  m_Range: 6
+  m_SpotAngle: 60
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 2800000, guid: 32c4b9c8ddc1c5d49ac7d10122540447, type: 3}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
 --- !u!1 &209784732
 GameObject:
   m_ObjectHideFlags: 0
   m_Name: 
   m_EditorClassIdentifier: 
   worldRayleighColorRamp:
-    key0:
-      serializedVersion: 2
-      rgba: 4288243277
-    key1:
-      serializedVersion: 2
-      rgba: 4291598720
-    key2:
-      serializedVersion: 2
-      rgba: 0
-    key3:
-      serializedVersion: 2
-      rgba: 0
-    key4:
-      serializedVersion: 2
-      rgba: 0
-    key5:
-      serializedVersion: 2
-      rgba: 0
-    key6:
-      serializedVersion: 2
-      rgba: 0
-    key7:
-      serializedVersion: 2
-      rgba: 0
+    serializedVersion: 2
+    key0: {r: 0.3019608, g: 0.4, b: 0.6, a: 1}
+    key1: {r: 0.5019608, g: 0.6, b: 0.8, a: 1}
+    key2: {r: 0, g: 0, b: 0, a: 0}
+    key3: {r: 0, g: 0, b: 0, a: 0}
+    key4: {r: 0, g: 0, b: 0, a: 0}
+    key5: {r: 0, g: 0, b: 0, a: 0}
+    key6: {r: 0, g: 0, b: 0, a: 0}
+    key7: {r: 0, g: 0, b: 0, a: 0}
     ctime0: 0
     ctime1: 65535
     ctime2: 0
   worldRayleighExtinctionFactor: 1.1
   worldRayleighIndirectScatter: 0.33
   worldMieColorRamp:
-    key0:
-      serializedVersion: 2
-      rgba: 4286627826
-    key1:
-      serializedVersion: 2
-      rgba: 4294960895
-    key2:
-      serializedVersion: 2
-      rgba: 0
-    key3:
-      serializedVersion: 2
-      rgba: 0
-    key4:
-      serializedVersion: 2
-      rgba: 0
-    key5:
-      serializedVersion: 2
-      rgba: 0
-    key6:
-      serializedVersion: 2
-      rgba: 0
-    key7:
-      serializedVersion: 2
-      rgba: 0
+    serializedVersion: 2
+    key0: {r: 0.9490196, g: 0.7490196, b: 0.5019608, a: 1}
+    key1: {r: 1, g: 0.9019608, b: 1, a: 1}
+    key2: {r: 0, g: 0, b: 0, a: 0}
+    key3: {r: 0, g: 0, b: 0, a: 0}
+    key4: {r: 0, g: 0, b: 0, a: 0}
+    key5: {r: 0, g: 0, b: 0, a: 0}
+    key6: {r: 0, g: 0, b: 0, a: 0}
+    key7: {r: 0, g: 0, b: 0, a: 0}
     ctime0: 0
     ctime1: 65535
     ctime2: 0
   heightPlaneShift: {x: 0, y: 0, z: 0}
   heightNearScatterPush: 0
   heightNormalDistance: 1000
+  atmosphericShaderOverride: {fileID: 0}
-  atmosphericShader: {fileID: 0}
+  depthTexture: 0
   debugMode: 0
 --- !u!1 &609148480
 GameObject:
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 10
+  m_Range: 12
   m_SpotAngle: 30
   m_CookieSize: 10
   m_Shadows:
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 10
+  m_Range: 12
   m_SpotAngle: 30
   m_CookieSize: 10
   m_Shadows:
   m_Father: {fileID: 1586360512}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &858501138
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 858501139}
+  - component: {fileID: 858501141}
+  - component: {fileID: 858501140}
+  m_Layer: 0
+  m_Name: Point Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &858501139
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 858501138}
+  m_LocalRotation: {x: -0, y: 0, z: -0, w: 1}
+  m_LocalPosition: {x: 0.25, y: -0, z: -2.72}
+  m_LocalScale: {x: 0, y: 0, z: 1}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 90, y: 0, z: 0}
+--- !u!114 &858501140
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 858501138}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  archetype: 0
+  isDoubleSided: 1
+  areaLightLength: 4
+  areaLightWidth: 2
+--- !u!108 &858501141
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 858501138}
+  m_Enabled: 1
+  serializedVersion: 7
+  m_Type: 2
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 50
+  m_Range: 6
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 8900000, guid: 7daac0a2e2877f94fb9990a7e09d9691, type: 3}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
 --- !u!1 &891124079
 GameObject:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1072084077}
   m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &1085128921
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1085128922}
+  - component: {fileID: 1085128924}
+  - component: {fileID: 1085128923}
+  m_Layer: 0
+  m_Name: Directional light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1085128922
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1085128921}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -0.3, y: 0, z: -2.0000005}
+  m_LocalScale: {x: 1, y: 1, z: 1.0000005}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 90, y: 0, z: 0}
+--- !u!114 &1085128923
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1085128921}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  archetype: 0
+  isDoubleSided: 1
+  areaLightLength: 4
+  areaLightWidth: 2
+--- !u!108 &1085128924
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1085128921}
+  m_Enabled: 1
+  serializedVersion: 7
+  m_Type: 1
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 10
+  m_Range: 6
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 2800000, guid: 32c4b9c8ddc1c5d49ac7d10122540447, type: 3}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
 --- !u!1 &1124705054
 GameObject:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1269195139}
   m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &1279943772
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1279943773}
+  - component: {fileID: 1279943776}
+  - component: {fileID: 1279943775}
+  - component: {fileID: 1279943774}
+  m_Layer: 0
+  m_Name: Quad
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1279943773
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1279943772}
+  m_LocalRotation: {x: -0.7071068, y: 0, z: 0, w: 0.7071068}
+  m_LocalPosition: {x: 0.2515, y: 0.0954, z: -1.61}
+  m_LocalScale: {x: 0.3, y: 8, z: 1}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: -90, y: 0, z: 0}
+--- !u!23 &1279943774
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1279943772}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: f03665895dc89b84487310c5216b8458, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!64 &1279943775
+MeshCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1279943772}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Convex: 0
+  m_InflateMesh: 0
+  m_SkinWidth: 0.01
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!33 &1279943776
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1279943772}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!1001 &1314842926
 Prefab:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1989256444}
   m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &2015022933
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 2015022934}
+  - component: {fileID: 2015022936}
+  - component: {fileID: 2015022935}
+  m_Layer: 0
+  m_Name: Spot Light (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2015022934
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2015022933}
+  m_LocalRotation: {x: -0.258819, y: 0, z: 0, w: 0.9659259}
+  m_LocalPosition: {x: -0.05, y: 0, z: -2}
+  m_LocalScale: {x: 0, y: 0, z: 1.0000005}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: -30, y: 0, z: 0}
+--- !u!114 &2015022935
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2015022933}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  archetype: 0
+  isDoubleSided: 1
+  areaLightLength: 4
+  areaLightWidth: 2
+--- !u!108 &2015022936
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2015022933}
+  m_Enabled: 1
+  serializedVersion: 7
+  m_Type: 0
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 50
+  m_Range: 6
+  m_SpotAngle: 60
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 2800000, guid: 32c4b9c8ddc1c5d49ac7d10122540447, type: 3}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
 --- !u!1 &2018759379
 GameObject:
   m_ObjectHideFlags: 0
   m_Children: []
   m_Father: {fileID: 1269195140}
   m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2026378390
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 2026378394}
+  - component: {fileID: 2026378393}
+  - component: {fileID: 2026378392}
+  - component: {fileID: 2026378391}
+  m_Layer: 0
+  m_Name: Test - Light Cookies
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!23 &2026378391
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2026378390}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: f03665895dc89b84487310c5216b8458, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!64 &2026378392
+MeshCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2026378390}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Convex: 0
+  m_InflateMesh: 0
+  m_SkinWidth: 0.01
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!33 &2026378393
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2026378390}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &2026378394
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2026378390}
+  m_LocalRotation: {x: 0.7071068, y: -0, z: -0, w: 0.7071068}
+  m_LocalPosition: {x: -125, y: -0, z: 36}
+  m_LocalScale: {x: 20, y: 12, z: 1}
+  m_Children:
+  - {fileID: 858501139}
+  - {fileID: 192903504}
+  - {fileID: 2015022934}
+  - {fileID: 1085128922}
+  - {fileID: 1279943773}
+  m_Father: {fileID: 0}
+  m_RootOrder: 27
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &2028486192
 GameObject:

ProjectSettings/GraphicsSettings.asset

   m_PreloadedShaders: []
   m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000,
     type: 0}
-  m_ScriptableRenderLoop: {fileID: 11400000, guid: 9654ae26e66cbee45b8d2a4f8cac0ceb,
+  m_CustomRenderPipeline: {fileID: 11400000, guid: 2400b74f5ce370c4481e5dc417d03703,
     type: 2}
   m_TransparencySortMode: 0
   m_TransparencySortAxis: {x: 0, y: 0, z: 1}

ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 5.6.0a5
+m_EditorVersion: 5.6.0a6

Assets/BasicRenderLoopTutorial/BasicRenderLoop.asset

   m_Enabled: 1
   m_EditorHideFlags: 0
   m_Script: {fileID: 11500000, guid: 22228a1bd982b864ea6c84db2fc11dd1, type: 3}
-  m_Name: basicrenderloop
+  m_Name: BasicRenderLoop
   m_EditorClassIdentifier: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Detail_Checker.tga.meta

 fileFormatVersion: 2
-guid: ded78b6c0a9afd94a8d528c2ec647f8f
-timeCreated: 1475674763
+guid: 21bed8c058c65f84e92fd4e28dd6ec51
+timeCreated: 1480611216
 licenseType: Pro
 TextureImporter:
   fileIDToRecycleName: {}
   - buildTarget: DefaultTexturePlatform
     maxTextureSize: 2048
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

Assets/TestScenes/HDTest/LayeredLitTest/Material/UVMap.tga.meta

 fileFormatVersion: 2
-guid: eddc784b66d317641bd2c3b078a694b1
-timeCreated: 1475675441
+guid: 0e413f4460470044d93a7c42e4275b09
+timeCreated: 1480085061
 licenseType: Pro
 TextureImporter:
   fileIDToRecycleName: {}
     enableMipMap: 1
-    sRGBTexture: 0
+    sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     borderMipMap: 0
   - buildTarget: DefaultTexturePlatform
     maxTextureSize: 2048
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0
     textureFormat: -1
-    textureCompression: 2
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

Assets/BasicRenderLoopTutorial/BasicRenderLoop.asset.meta

+fileFormatVersion: 2
+guid: b03c9b2b48c84914e93527b52d6044cb
+timeCreated: 1481014594
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightLoop.cs

+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
+using System;
+
+namespace UnityEngine.Experimental.ScriptableRenderLoop
+{
+    public class BaseLightLoop
+    {
+        // TODO: We should rather put the texture settings in LightLoop, but how do we serialize it ?
+        public virtual void Rebuild(TextureSettings textureSettings) {}
+
+        public virtual void Cleanup() {}
+
+        public virtual bool NeedResize() { return false;  }
+
+        public virtual void AllocResolutionDependentBuffers(int width, int height) { }
+
+        public virtual void ReleaseResolutionDependentBuffers() {}
+
+        public virtual void NewFrame() {}
+
+        public virtual void PrepareLightsForGPU(CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput) { }
+        
+        // TODO: this should not be aprt of the interface but for now make something working
+        public virtual void BuildGPULightLists(Camera camera, RenderLoop loop, RenderTargetIdentifier cameraDepthBufferRT) { }
+
+        public virtual void PushGlobalParams(Camera camera, RenderLoop loop) {}
+
+        public virtual void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderTargetIdentifier cameraColorBufferRT) {}
+
+        public virtual void RenderForward(Camera camera, RenderLoop renderLoop, bool renderOpaque) {}
+    }
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightLoop.cs.meta

+fileFormatVersion: 2
+guid: 1669ef5a164969c4c90cd3509b01123d
+timeCreated: 1481066258
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest.meta

+fileFormatVersion: 2
+guid: a543aea7ca333cc42be34cf8ed9d740f
+folderAsset: yes
+timeCreated: 1480078465
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material.meta

+fileFormatVersion: 2
+guid: 0f751bcc65cbd78419128d1bdfa3327d
+folderAsset: yes
+timeCreated: 1480078546
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_BlendColor.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: Layered_BlendColor
+  m_Shader: {fileID: 4800000, guid: 81d02e8644315b742b154842a3a2f98c, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _EMISSIVE_COLOR _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS
+    _LAYERMASKMAP _LAYER_MAPPING_PLANAR0 _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_PLANAR_1
+    _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_PLANAR_3 _LAYER_MASK_VERTEX_COLOR _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _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}
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _DiffuseLightingMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _EmissiveColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap3:
+        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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        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}
+    m_Floats:
+    - _AlphaCutoff: 0.122
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _EmissiveIntensity0: 0
+    - _EmissiveIntensity1: 0
+    - _EmissiveIntensity2: 0
+    - _EmissiveIntensity3: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 4
+    - _LayerMapping0: 2
+    - _LayerMapping1: 2
+    - _LayerMapping2: 2
+    - _LayerMapping3: 2
+    - _LayerMaskVertexColor: 1
+    - _LayerSize0: 4
+    - _LayerSize1: 4
+    - _LayerSize2: 2
+    - _LayerSize3: 2
+    - _LayerTiling0: 10
+    - _LayerTiling1: 10
+    - _LayerTiling2: 1
+    - _LayerTiling3: 1
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metalic0: 0
+    - _Metalic1: 0
+    - _Metalic2: 0
+    - _Metalic3: 0
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 0.5
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.2
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.4
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 0, b: 0, a: 1}
+    - _BaseColor2: {r: 0, g: 1, b: 0, a: 1}
+    - _BaseColor3: {r: 0, g: 0, b: 1, a: 1}
+    - _Color: {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}
+    - _EmissiveColor0: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor1: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor2: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor3: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, 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_BlendColor.mat.meta

+fileFormatVersion: 2
+guid: f5e011eaf3efd6a418f211803a5f7d74
+timeCreated: 1480943223
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["fbea672215bd9944f8d9f98d5437e3cb","b91619c97bb14b64b82c0cdeaac0cc68","be6f395f0458348419faf76aca4cf856","000d0f1d5b188ed43a674de93e854997"]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_BlendMask.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: Layered_BlendMask
+  m_Shader: {fileID: 4800000, guid: 81d02e8644315b742b154842a3a2f98c, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _EMISSIVE_COLOR _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS
+    _LAYERMASKMAP _LAYERMASKVERTEXCOLOR_OFF _LAYER_MAPPING_PLANAR0 _LAYER_MAPPING_PLANAR_0
+    _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_PLANAR_3 _NORMALMAP_TANGENT_SPACE
+    _REQUIRE_UV3
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _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}
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _DiffuseLightingMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _EmissiveColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap3:
+        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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        m_Texture: {fileID: 2800000, guid: 6b43fa9736beb354dba359b5d2ec3699, type: 3}
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        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}
+    m_Floats:
+    - _AlphaCutoff: 0.122
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _EmissiveIntensity0: 0
+    - _EmissiveIntensity1: 0
+    - _EmissiveIntensity2: 0
+    - _EmissiveIntensity3: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 4
+    - _LayerMapping0: 2
+    - _LayerMapping1: 2
+    - _LayerMapping2: 2
+    - _LayerMapping3: 2
+    - _LayerMaskVertexColor: 0
+    - _LayerSize0: 4
+    - _LayerSize1: 4
+    - _LayerSize2: 2
+    - _LayerSize3: 2
+    - _LayerTiling0: 10
+    - _LayerTiling1: 10
+    - _LayerTiling2: 1
+    - _LayerTiling3: 1
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metalic0: 0
+    - _Metalic1: 0
+    - _Metalic2: 0
+    - _Metalic3: 0
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 0.5
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 0, b: 0, a: 1}
+    - _BaseColor2: {r: 0, g: 1, b: 0, a: 1}
+    - _BaseColor3: {r: 0, g: 0, b: 1, a: 1}
+    - _Color: {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}
+    - _EmissiveColor0: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor1: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor2: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor3: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, 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_BlendMask.mat.meta

+fileFormatVersion: 2
+guid: 25d41ce4a1b7bae42a4bcf5fd62bda4c
+timeCreated: 1480682670
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["fbea672215bd9944f8d9f98d5437e3cb","b91619c97bb14b64b82c0cdeaac0cc68","be6f395f0458348419faf76aca4cf856","000d0f1d5b188ed43a674de93e854997"]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer0_Planar.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: Layered_Layer0_Planar
+  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
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 2, y: 2}
+        m_Offset: {x: 0.25, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 0.2
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 3
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 0, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 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: 0, a: 1}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, 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_Planar.mat.meta

+fileFormatVersion: 2
+guid: 91a8197de5f6d074c8dac4416c16cbb2
+timeCreated: 1480934271
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["a02ccd7b5946da643a654ccea743375b","686eb5593c0e94f4eb86ca1d3cfef7fa","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer0_Triplanar.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: Layered_Layer0_Triplanar
+  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_MAPPING_TRIPLANAR_0 _LAYER_MASK_VERTEX_COLOR
+    _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 2, y: 2}
+        m_Offset: {x: 0.25, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 0
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 0.2
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 4
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 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: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, 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_Triplanar.mat.meta

+fileFormatVersion: 2
+guid: b8805bd8838bdf34996bedcee9ebbf10
+timeCreated: 1480934285
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["a02ccd7b5946da643a654ccea743375b","686eb5593c0e94f4eb86ca1d3cfef7fa","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer0_UV0.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: Layered_Layer0_UV0
+  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
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 2, y: 2}
+        m_Offset: {x: 0.25, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, 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_UV0.mat.meta

+fileFormatVersion: 2
+guid: ea0f1f2983d72874084abf3a8d75bf04
+timeCreated: 1480933657
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["a02ccd7b5946da643a654ccea743375b","686eb5593c0e94f4eb86ca1d3cfef7fa","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer0_UV1.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: Layered_Layer0_UV1
+  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
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 2, y: 2}
+        m_Offset: {x: 0.25, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 1
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 1
+    - _UVDetail1: 1
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 0, g: 1, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 0, g: 1, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 0, g: 1, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, 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_UV1.mat.meta

+fileFormatVersion: 2
+guid: dde88fa6f8dc19a4eb2d828bf0f4d91c
+timeCreated: 1480934261
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["a02ccd7b5946da643a654ccea743375b","686eb5593c0e94f4eb86ca1d3cfef7fa","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer0_UV3.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: Layered_Layer0_UV3
+  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
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 2, y: 2}
+        m_Offset: {x: 0.25, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 2
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 2
+    - _UVDetail1: 2
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 0, g: 0, b: 1, a: 0}
+    - _UVDetailsMappingMask1: {r: 0, g: 0, b: 1, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 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}
+    - _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
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["a02ccd7b5946da643a654ccea743375b","686eb5593c0e94f4eb86ca1d3cfef7fa","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer1_Planar.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: Layered_Layer1_Planar
+  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: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 0.2
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 3
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 0.97058815, g: 0.51384073, b: 0.51384073, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 0, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 0, g: 0, b: 0, a: 1}
+    - _UVMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask3: {r: 1, g: 0, b: 0, a: 0}

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

+fileFormatVersion: 2
+guid: fd9a6b078b486c8408e9c7ed638a47ec
+timeCreated: 1480680901
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","609b27a9e3e537048b26ff65f31946e8","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer1_Triplanar.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: Layered_Layer1_Triplanar
+  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_MAPPING_TRIPLANAR_1 _LAYER_MASK_VERTEX_COLOR
+    _NORMALMAP_TANGENT_SPACE _REQUIRE_UV3
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 0
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 0.2
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 4
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 0.97058815, g: 0.51384073, b: 0.51384073, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 0, g: 0, b: 0, 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_Layer1_Triplanar.mat.meta

+fileFormatVersion: 2
+guid: 74b98b46b0cf6f4408b920728d5945eb
+timeCreated: 1480680915
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","609b27a9e3e537048b26ff65f31946e8","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer1_UV0.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: Layered_Layer1_UV0
+  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: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 0.97058815, g: 0.51384073, b: 0.51384073, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, 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_Layer1_UV0.mat.meta

+fileFormatVersion: 2
+guid: 46b0a67189ffdb441ac11d3a4761b331
+timeCreated: 1480680724
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","609b27a9e3e537048b26ff65f31946e8","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer1_UV1.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: Layered_Layer1_UV1
+  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: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 1
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 1
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 0.97058815, g: 0.51384073, b: 0.51384073, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 0, g: 1, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 0, g: 1, b: 0, 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_Layer1_UV1.mat.meta

+fileFormatVersion: 2
+guid: 516fda78ebad434419873a3e8b7621a3
+timeCreated: 1480680792
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","609b27a9e3e537048b26ff65f31946e8","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer1_UV3.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: Layered_Layer1_UV3
+  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: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 2
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 2
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 2
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 0.97058815, g: 0.51384073, b: 0.51384073, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 0, g: 0, b: 1, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {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_Layer1_UV3.mat.meta

+fileFormatVersion: 2
+guid: aa6171e055287cb4f9fea8ce6733e050
+timeCreated: 1480680809
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","609b27a9e3e537048b26ff65f31946e8","",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer2_Planar.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: Layered_Layer2_Planar
+  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 _LAYEREDLIT_3_LAYERS _LAYER_MASK_VERTEX_COLOR
+    _NORMALMAP_TANGENT_SPACE _REQUIRE_UV3
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 3
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 0.2
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 3
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 0.61764705, g: 1, b: 0.74685603, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 0, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask2: {r: 0, g: 0, b: 0, a: 1}
+    - _UVMappingMask3: {r: 1, g: 0, b: 0, a: 0}

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

+fileFormatVersion: 2
+guid: cd6fab12a4d34f841a5d2e59188f981c
+timeCreated: 1480680992
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","b1bac0266a49a1040a9365f40c7b6ddd",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer2_Triplanar.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: Layered_Layer2_Triplanar
+  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 _LAYEREDLIT_3_LAYERS _LAYER_MAPPING_TRIPLANAR_2
+    _LAYER_MASK_VERTEX_COLOR _NORMALMAP_TANGENT_SPACE _REQUIRE_UV3
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 0
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 3
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 0.2
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 4
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 0.61764705, g: 1, b: 0.74685603, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask2: {r: 0, g: 0, b: 0, a: 0}
+    - _UVMappingMask3: {r: 1, g: 0, b: 0, a: 0}

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

+fileFormatVersion: 2
+guid: 4e173a4bed5c8ba4b930247d61ca57ec
+timeCreated: 1480681000
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","b1bac0266a49a1040a9365f40c7b6ddd",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer2_UV0.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: Layered_Layer2_UV0
+  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 _LAYEREDLIT_3_LAYERS _LAYER_MASK_VERTEX_COLOR
+    _NORMALMAP_TANGENT_SPACE _REQUIRE_UV3
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 3
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 0.61764705, g: 1, b: 0.74685603, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, 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_Layer2_UV0.mat.meta

+fileFormatVersion: 2
+guid: bffe4a0d0044eb14c9ced7ec74de33b1
+timeCreated: 1480680957
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","b1bac0266a49a1040a9365f40c7b6ddd",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer2_UV1.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: Layered_Layer2_UV1
+  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 _LAYEREDLIT_3_LAYERS _LAYER_MASK_VERTEX_COLOR
+    _NORMALMAP_TANGENT_SPACE _REQUIRE_UV3
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 3
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 1
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 1
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 0.61764705, g: 1, b: 0.74685603, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 0, g: 1, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask2: {r: 0, g: 1, b: 0, a: 0}
+    - _UVMappingMask3: {r: 1, g: 0, b: 0, a: 0}

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

+fileFormatVersion: 2
+guid: f02163c5434d8754cb5ce54359c405b1
+timeCreated: 1480680976
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","b1bac0266a49a1040a9365f40c7b6ddd",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer2_UV3.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: Layered_Layer2_UV3
+  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 _LAYEREDLIT_3_LAYERS _LAYER_MASK_VERTEX_COLOR
+    _NORMALMAP_TANGENT_SPACE _REQUIRE_UV3
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 3
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 2
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 2
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 0.61764705, g: 1, b: 0.74685603, a: 1}
+    - _BaseColor3: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 0, g: 0, b: 1, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask2: {r: 0, g: 0, b: 1, a: 0}
+    - _UVMappingMask3: {r: 1, g: 0, b: 0, a: 0}

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

+fileFormatVersion: 2
+guid: ee3e0f05e742ad246855fc1151154c01
+timeCreated: 1480680986
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","b1bac0266a49a1040a9365f40c7b6ddd",""]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer3_Planar.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: Layered_Layer3_Planar
+  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 _LAYEREDLIT_4_LAYERS _LAYER_MASK_VERTEX_COLOR
+    _NORMALMAP_TANGENT_SPACE _REQUIRE_UV3
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 4
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 0.2
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 3
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 0.97058815, g: 0.51384073, b: 0.51384073, a: 1}
+    - _BaseColor2: {r: 0.61764705, g: 1, b: 0.74685603, a: 1}
+    - _BaseColor3: {r: 0.6602435, g: 0.63235295, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 0, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask3: {r: 0, g: 0, b: 0, a: 1}

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

+fileFormatVersion: 2
+guid: 32ddfc45781832a4f94eb0efa3b88571
+timeCreated: 1480682190
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","6c40a6ba55a62fc4c92fdc1cdee2f85a"]}'
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Material/Layered_Layer3_Triplanar.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: Layered_Layer3_Triplanar
+  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 _LAYEREDLIT_4_LAYERS _LAYER_MAPPING_TRIPLANAR_3
+    _LAYER_MASK_VERTEX_COLOR _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseColorMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap3:
+        m_Texture: {fileID: 2800000, guid: 0e413f4460470044d93a7c42e4275b09, type: 3}
+        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}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 2800000, guid: 21bed8c058c65f84e92fd4e28dd6ec51, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
+        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}
+    - _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}
+    - _HeightMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LayerMaskMap:
+        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}
+    - _MaskMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap3:
+        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}
+    - _NormalMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        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}
+    - _SpecularOcclusionMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 0
+    - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 0
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias0: 0
+    - _HeightBias1: 0
+    - _HeightBias2: 0
+    - _HeightBias3: 0
+    - _HeightMapMode: 0
+    - _HeightScale0: 1
+    - _HeightScale1: 1
+    - _HeightScale2: 1
+    - _HeightScale3: 1
+    - _LayerCount: 4
+    - _LayerMaskVertexColor: 1
+    - _Metallic: 0
+    - _Metallic0: 0
+    - _Metallic1: 0
+    - _Metallic2: 0
+    - _Metallic3: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness0: 0.5
+    - _Smoothness1: 0.5
+    - _Smoothness2: 0.5
+    - _Smoothness3: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 0.2
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 4
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor3: {r: 0.6602435, g: 0.63235295, b: 1, a: 1}
+    - _Color: {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}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVDetailsMappingMask3: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask3: {r: 0, g: 0, b: 0, a: 0}

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

+fileFormatVersion: 2
+guid: 0284c7765797bfe42b104f08550600a8
+timeCreated: 1480935617
+licenseType: Pro
+NativeFormatImporter:
+  userData: '{"GUIDArray":["686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","686eb5593c0e94f4eb86ca1d3cfef7fa","6c40a6ba55a62fc4c92fdc1cdee2f85a"]}'
+  assetBundleName: 
+  assetBundleVariant: