Merge remote-tracking branch 'origin/master' into scriptablerenderloop-materialgraph

Assets/Editor/Tests/RenderloopTests/CullResultsTest.cs

 using UnityEngine;
-using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
 using NUnit.Framework;
 
 [TestFixture]

Assets/Editor/Tests/RenderloopTests/RenderloopTestFixture.cs

 using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor;
-using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
 using NUnit.Framework;
 
 [ExecuteInEditMode]

Assets/Editor/Tests/ShaderGeneratorTests/ShaderGeneratorTests.cs

 using System.Reflection;
 using UnityEngine;
 using UnityEditor;
-using UnityEngine.Rendering;
-using UnityEngine.ScriptableRenderLoop;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.ScriptableRenderLoop;
 using NUnit.Framework;
 
 [TestFixture]

Assets/ScriptableRenderLoop/AdditionalLightData.cs

-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     //@TODO: We should continously move these values
     // into the engine when we can see them being generally useful

Assets/ScriptableRenderLoop/ForwardRenderLoop/ForwardRenderLoop.cs

-using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     public class ForwardRenderLoop : ScriptableRenderLoop
     {

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

 using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     [ExecuteInEditMode]
     // This HDRenderLoop assume linear lighting. Don't work with gamma.
         {
             Depth = 1,
             TexCoord0 = 2,
-            VertexNormalWS = 3,
-            VertexTangentWS = 4,
-            VertexBitangentWS = 5,
-            VertexColor = 6,
+            TexCoord1 = 3,
+            TexCoord2 = 4,
+            VertexTangentWS = 5,
+            VertexBitangentWS = 6,
+            VertexNormalWS = 7,
+            VertexColor = 8,
-            Depth = 7,
-            BakeDiffuseLighting = 8,
+            Depth = 9,
+            BakeDiffuseLighting = 10,
         }
 
         public class DebugParameters
 
                 Shader.SetGlobalInt("_DebugViewMaterial", (int)debugParameters.debugViewMaterial);
 
-                RenderOpaqueRenderList(cull, camera, renderLoop, "DebugView");
+                RenderOpaqueRenderList(cull, camera, renderLoop, "DebugViewMaterial");
             }
 
             // Render GBUffer opaque
 
             RenderTransparentRenderList(cullResults, camera, renderLoop, "Forward");
         }
+
+        void RenderForwardUnlit(CullResults cullResults, Camera camera, RenderLoop renderLoop)
+        {
+            // Bind material data
+            m_LitRenderLoop.Bind();
+
+            var cmd = new CommandBuffer { name = "Forward Unlit Pass" };
+            cmd.SetRenderTarget(new RenderTargetIdentifier(s_CameraColorBuffer), new RenderTargetIdentifier(s_CameraDepthBuffer));
+            renderLoop.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+
+            RenderOpaqueRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
+            RenderTransparentRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
+        }        
 
         void FinalPass(RenderLoop renderLoop)
         {
                     RenderDeferredLighting(camera, renderLoop);
 
                     RenderForward(cullResults, camera, renderLoop);
+                    RenderForwardUnlit(cullResults, camera, renderLoop);
 
                     FinalPass(renderLoop);
                 }

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoopInspector.cs

 
 //using EditorGUIUtility=UnityEditor.EditorGUIUtility;
 
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     [CustomEditor(typeof(HDRenderLoop))]
     public class HDRenderLoopInspector : Editor
                           + gbufferNames.Length
                           + typeof(Builtin.BuiltinData).GetFields().Length
                           + typeof(Lit.SurfaceData).GetFields().Length
-                          + typeof(Lit.BSDFData).GetFields().Length;
+                          + typeof(Lit.BSDFData).GetFields().Length
+                          + typeof(Unlit.SurfaceData).GetFields().Length
+                          + typeof(Unlit.BSDFData).GetFields().Length;
 
                 styles.debugViewMaterialStrings = new GUIContent[num];
                 styles.debugViewMaterialValues = new int[num];
                 FillWithPropertiesEnum(typeof(HDRenderLoop.DebugViewVaryingMode), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, ref index);
                 FillWithProperties(typeof(Builtin.BuiltinData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, ref index);
                 FillWithProperties(typeof(Lit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, ref index);
+                FillWithProperties(typeof(Unlit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, ref index);
+                FillWithProperties(typeof(Unlit.BSDFData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, true, ref index);
 
                 styles.isDebugViewMaterialInit = true;
             }

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Debug/DebugViewMaterial.hlsl

 // Must be in sync with DebugViewVaryingMode
 #define DEBUGVIEW_VARYING_DEPTH 1
 #define DEBUGVIEW_VARYING_TEXCOORD0 2
-#define DEBUGVIEW_VARYING_VERTEXNORMALWS 3
-#define DEBUGVIEW_VARYING_VERTEXTANGENTWS 4
-#define DEBUGVIEW_VARYING_VERTEXBITANGENTWS 5
-#define DEBUGVIEW_VARYING_VERTEXCOLOR 6
+#define DEBUGVIEW_VARYING_TEXCOORD1 3
+#define DEBUGVIEW_VARYING_TEXCOORD2 4
+#define DEBUGVIEW_VARYING_VERTEXTANGENTWS 5
+#define DEBUGVIEW_VARYING_VERTEXBITANGENTWS 6
+#define DEBUGVIEW_VARYING_VERTEXNORMALWS 7
+#define DEBUGVIEW_VARYING_VERTEXCOLOR 8
-#define DEBUGVIEW_GBUFFER_DEPTH 7
-#define DEBUGVIEW_GBUFFER_BAKEDIFFUSELIGHTING 8
+#define DEBUGVIEW_GBUFFER_DEPTH 9
+#define DEBUGVIEW_GBUFFER_BAKEDIFFUSELIGHTING 10

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

 //-----------------------------------------------------------------------------
 // structure definition
 //-----------------------------------------------------------------------------
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     // These structures share between C# and hlsl need to be align on float4, so we pad them.
     [GenerateHLSL]
     {
         public Vector3 positionWS;
     };
-} // namespace UnityEngine.ScriptableRenderLoop
+} // namespace UnityEngine.Experimental.ScriptableRenderLoop

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

 //
 
 //
-// UnityEngine.ScriptableRenderLoop.AreaShapeType:  static fields
+// UnityEngine.Experimental.ScriptableRenderLoop.AreaShapeType:  static fields
 //
 #define AREASHAPETYPE_RECTANGLE (0)
 #define AREASHAPETYPE_LINE (1)
 #define AREASHAPETYPE_CYLINDER (5)
 
 //
-// UnityEngine.ScriptableRenderLoop.EnvShapeType:  static fields
+// UnityEngine.Experimental.ScriptableRenderLoop.EnvShapeType:  static fields
-// Generated from UnityEngine.ScriptableRenderLoop.PunctualLightData
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.PunctualLightData
 // PackingRules = Exact
 struct PunctualLightData
 {
 	float2 unused2;
 };
 
-// Generated from UnityEngine.ScriptableRenderLoop.AreaLightData
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.AreaLightData
 // PackingRules = Exact
 struct AreaLightData
 {
 	float unused;
 };
 
-// Generated from UnityEngine.ScriptableRenderLoop.EnvLightData
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.EnvLightData
 // PackingRules = Exact
 struct EnvLightData
 {
 	float unused1;
 };
 
-// Generated from UnityEngine.ScriptableRenderLoop.PlanarLightData
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.PlanarLightData
 // PackingRules = Exact
 struct PlanarLightData
 {
 //
-// Accessors for UnityEngine.ScriptableRenderLoop.PunctualLightData
+// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.PunctualLightData
 //
 float3 GetPositionWS(PunctualLightData value)
 {
 }
 
 //
-// Accessors for UnityEngine.ScriptableRenderLoop.AreaLightData
+// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.AreaLightData
 //
 float3 GetPositionWS(AreaLightData value)
 {
 }
 
 //
-// Accessors for UnityEngine.ScriptableRenderLoop.EnvLightData
+// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.EnvLightData
 //
 float3 GetPositionWS(EnvLightData value)
 {
 }
 
 //
-// Accessors for UnityEngine.ScriptableRenderLoop.PlanarLightData
+// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.PlanarLightData
 //
 float3 GetPositionWS(PlanarLightData value)
 {

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Lighting/Lighting.hlsl

 // Like for material we have one define by architecture.
 // TODO: who setup the define for a given architecture ?
 
-// For now our loop looks use texture arrays (but we should support different define based on architecture).
-// NOTE: How do we support a pass with tiled forward and single forward in the same renderer  (i.e with tex array and single tex)
-#define UNITY_DECLARE_ENV(tex) UNITY_DECLARE_TEXCUBEARRAY(tex)
-#define UNITY_ARGS_ENV(tex) UNITY_ARGS_TEXCUBEARRAY(tex)
-#define UNITY_PASS_ENV(tex) UNITY_PASS_TEXCUBEARRAY(tex)
-#define UNITY_SAMPLE_ENV_LOD(tex, coord, lightData, lod) UNITY_SAMPLE_TEXCUBEARRAY_LOD(tex, float4(coord, lightData.sliceIndex), lod)
-
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Material.hlsl"
 
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Lighting/LightingForward/LightingForward.hlsl"

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Lighting/LightingForward/LightingForward.hlsl

 StructuredBuffer<PunctualLightData> _PunctualLightList;
 int _PunctualLightCount;
 
-UNITY_DECLARE_ENV(_EnvTextures);
+UNITY_DECLARE_TEXCUBEARRAY(_EnvTextures);
+
 StructuredBuffer<EnvLightData> _EnvLightList;
 int _EnvLightCount;
 
     {
         float4 localDiffuseLighting;
         float4 localSpecularLighting;
-        EvaluateBSDF_Env(V, positionWS, prelightData, _EnvLightList[j], bsdfData, UNITY_PASS_ENV(_EnvTextures), localDiffuseLighting, localSpecularLighting);
+        EvaluateBSDF_Env(V, positionWS, prelightData, _EnvLightList[j], bsdfData, UNITY_PASS_TEXCUBEARRAY(_EnvTextures), localDiffuseLighting, localSpecularLighting);
         iblDiffuseLighting.rgb = lerp(iblDiffuseLighting.rgb, localDiffuseLighting.rgb, localDiffuseLighting.a); // Should be remove by the compiler if it is smart as all is constant 0
         iblSpecularLighting.rgb = lerp(iblSpecularLighting.rgb, localSpecularLighting.rgb, localSpecularLighting.a);
     }

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Builtin/BuiltinData.cs

 //-----------------------------------------------------------------------------
 // structure definition
 //-----------------------------------------------------------------------------
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     namespace Builtin
     {
             public Vector2 distortion;
             [SurfaceDataAttributes("Distortion Blur")]
             public float distortionBlur;           // Define the color buffer mipmap level to use
+        };
+
+        //-----------------------------------------------------------------------------
+        // LighTransportData
+        // This struct is use to store information for Enlighten/Progressive light mapper. both at runtime or off line.
+        //-----------------------------------------------------------------------------
+        [GenerateHLSL(PackingRules.Exact, false, true, 120)]
+        public struct LighTransportData
+        {
+            public Vector3 diffuseColor;
+            public Vector3 emissiveColor;
         };
     }
 }

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Builtin/BuiltinData.cs.hlsl

 //
 
 //
-// UnityEngine.ScriptableRenderLoop.Builtin.BuiltinData:  static fields
+// UnityEngine.Experimental.ScriptableRenderLoop.Builtin.BuiltinData:  static fields
 //
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_OPACITY (100)
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING (101)
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION (105)
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR (106)
 
-// Generated from UnityEngine.ScriptableRenderLoop.Builtin.BuiltinData
+//
+// UnityEngine.Experimental.ScriptableRenderLoop.Builtin.LighTransportData:  static fields
+//
+#define DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_DIFFUSE_COLOR (120)
+#define DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_EMISSIVE_COLOR (121)
+
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.Builtin.BuiltinData
 // PackingRules = Exact
 struct BuiltinData
 {
 	float2 velocity;
 	float2 distortion;
 	float distortionBlur;
+};
+
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.Builtin.LighTransportData
+// PackingRules = Exact
+struct LighTransportData
+{
+	float3 diffuseColor;
+	float3 emissiveColor;
 };
 
 

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Builtin/BuiltinData.hlsl

         break;
     }
 }
+
+void GetLighTransportDataDebug(uint paramId, LighTransportData lightTransportData, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+    case DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_DIFFUSE_COLOR:
+        result = lightTransportData.diffuseColor; needLinearToSRGB = true;
+        break;
+    case DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_EMISSIVE_COLOR:
+        // TODO: Need a tonemap ?
+        result = lightTransportData.emissiveColor;
+        break;
+    }    
+}
+
 #endif // UNITY_BUILTIN_DATA_INCLUDED

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

         _BaseColorMap2("BaseColorMap2", 2D) = "white" {}
         _BaseColorMap3("BaseColorMap3", 2D) = "white" {}
 
-        _Metalic0("Metalic0", Range(0.0, 1.0)) = 0
-        _Metalic1("Metalic1", Range(0.0, 1.0)) = 0
-        _Metalic2("Metalic2", Range(0.0, 1.0)) = 0
-        _Metalic3("Metalic3", Range(0.0, 1.0)) = 0
+        _Metallic0("Metallic0", Range(0.0, 1.0)) = 0
+        _Metallic1("Metallic1", Range(0.0, 1.0)) = 0
+        _Metallic2("Metallic2", Range(0.0, 1.0)) = 0
+        _Metallic3("Metallic3", Range(0.0, 1.0)) = 0
 
         _Smoothness0("Smoothness0", Range(0.0, 1.0)) = 0.5
         _Smoothness1("Smoothness1", Range(0.0, 1.0)) = 0.5
     #pragma shader_feature _LAYERMASKMAP
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
 
-    #include "LayeredLitTemplate.hlsl"
+    //-------------------------------------------------------------------------------------
+    // Include
+    //-------------------------------------------------------------------------------------
+    #include "common.hlsl"
+    #include "../../ShaderPass/ShaderPass.cs.hlsl"
 
     ENDHLSL
 
             HLSLPROGRAM
 
             #pragma vertex VertDefault
-            #pragma fragment FragDeferred
+            #pragma fragment Frag
-            #if SHADER_STAGE_FRAGMENT
-
-            void FragDeferred(  PackedVaryings packedInput,
-                                OUTPUT_GBUFFER(outGBuffer)
-                                #ifdef VELOCITY_IN_GBUFFER
-                                , OUTPUT_GBUFFER_VELOCITY(outGBuffer)
-                                #endif
-                                , OUTPUT_GBUFFER_BAKE_LIGHTING(outGBuffer)
-                                )
-            {
-                Varyings input = UnpackVaryings(packedInput);
-                float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
-                float3 positionWS = input.positionWS;
-
-                SurfaceData surfaceData;
-                BuiltinData builtinData;
-                GetSurfaceAndBuiltinData(input, surfaceData, builtinData);
+            #ifdef SHADER_STAGE_FRAGMENT
-                BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
-                Coordinate coord = GetCoordinate(input.positionHS.xy, _ScreenSize.zw);
-                PreLightData preLightData = GetPreLightData(V, positionWS, coord, bsdfData);
+            #define SHADERPASS SHADERPASS_GBUFFER
+            #include "LayeredLitCommon.hlsl"
-                ENCODE_INTO_GBUFFER(surfaceData, outGBuffer);
-                #ifdef VELOCITY_IN_GBUFFER
-                ENCODE_VELOCITY_INTO_GBUFFER(builtinData.velocity, outGBuffer);
-                #endif
-                ENCODE_BAKE_LIGHTING_INTO_GBUFFER(GetBakedDiffuseLigthing(preLightData, surfaceData, builtinData, bsdfData), outGBuffer);
-            }
+            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
 
             #endif
 
         Pass
         {
             Name "Debug"
-            Tags{ "LightMode" = "DebugView" }
+            Tags{ "LightMode" = "DebugViewMaterial" }
 
             Cull[_CullMode]
 
-            #pragma fragment FragDebug
-
-            #include "Color.hlsl"
+            #pragma fragment Frag
-            int _DebugViewMaterial;
+            #define SHADERPASS SHADERPASS_DEBUG_VIEW_MATERIAL
+            #include "LayeredLitCommon.hlsl"
-            #if SHADER_STAGE_FRAGMENT
-
-            float4 FragDebug(PackedVaryings packedInput) : SV_Target
-            {
-                Varyings input = UnpackVaryings(packedInput);
-                SurfaceData surfaceData;
-                BuiltinData builtinData;
-                GetSurfaceAndBuiltinData(input, surfaceData, builtinData);
-
-                BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
-
-                float3 result = float3(1.0, 1.0, 0.0);
-                bool needLinearToSRGB = false;
-
-                GetVaryingsDataDebug(_DebugViewMaterial, input, result, needLinearToSRGB);
-                GetBuiltinDataDebug(_DebugViewMaterial, builtinData, result, needLinearToSRGB);
-                GetSurfaceDataDebug(_DebugViewMaterial, surfaceData, result, needLinearToSRGB);
-                GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB); // TODO: This required to initialize all field from BSDFData...
-
-                // TEMP!
-                // For now, the final blit in the backbuffer performs an sRGB write
-                // So in the meantime we apply the inverse transform to linear data to compensate.
-                if (!needLinearToSRGB)
-                    result = SRGBToLinear(max(0, result));
-
-                return float4(result, 0.0);
-            }
-
-            #endif
+            #include "../../ShaderPass/ShaderPassDebugViewMaterial.hlsl"
 
             ENDHLSL
         }
             HLSLPROGRAM
 
             #pragma vertex VertDefault
-            #pragma fragment FragForward
+            #pragma fragment Frag
-            #if SHADER_STAGE_FRAGMENT
-
-            float4 FragForward(PackedVaryings packedInput) : SV_Target
-            {
-                Varyings input = UnpackVaryings(packedInput);
-                float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
-                float3 positionWS = input.positionWS;
-
-                SurfaceData surfaceData;
-                BuiltinData builtinData;
-                GetSurfaceAndBuiltinData(input, surfaceData, builtinData);
-
-                BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
-                Coordinate coord = GetCoordinate(input.positionHS.xy, _ScreenSize.zw);
-                PreLightData preLightData = GetPreLightData(V, positionWS, coord, bsdfData);
-
-                float4 diffuseLighting;
-                float4 specularLighting;
-                ForwardLighting(V, positionWS, preLightData, bsdfData, diffuseLighting, specularLighting);
-
-                diffuseLighting.rgb += GetBakedDiffuseLigthing(preLightData, surfaceData, builtinData, bsdfData);
+            #define SHADERPASS SHADERPASS_FORWARD
+            #include "LayeredLitCommon.hlsl"
-                return float4(diffuseLighting.rgb + specularLighting.rgb, builtinData.opacity);
-            }
-
-            #endif
+            #include "../../ShaderPass/ShaderPassForward.hlsl"
 
             ENDHLSL
         }

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/LayeredLit/LayeredLitCommon.hlsl

 // Set of users variables
 PROP_DECL(float4, _BaseColor);
 PROP_DECL_TEX2D(_BaseColorMap);
-PROP_DECL(float, _Metalic);
+PROP_DECL(float, _Metallic);
 PROP_DECL(float, _Smoothness);
 PROP_DECL_TEX2D(_MaskMap);
 PROP_DECL_TEX2D(_SpecularOcclusionMap);
     float4 positionHS;
     float3 positionWS;
     float2 texCoord0;
-    float4 tangentToWorld[3]; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
+    float3 tangentToWorld[3];
     float4 vertexColor;
 
 #ifdef SHADER_STAGE_FRAGMENT
     output.positionHS = input.positionHS;
     output.interpolators[0].xyz = input.positionWS.xyz;
     output.interpolators[0].w = input.texCoord0.x;
-    output.interpolators[1] = input.tangentToWorld[0];
-    output.interpolators[2] = input.tangentToWorld[1];
-    output.interpolators[3] = input.tangentToWorld[2];
+    output.interpolators[1].xyz = input.tangentToWorld[0];
+    output.interpolators[2].xyz = input.tangentToWorld[1];
+    output.interpolators[3].xyz = input.tangentToWorld[2];
     output.interpolators[4].x = input.texCoord0.y;
     output.interpolators[4].yzw = float3(0.0, 0.0, 0.0);
     output.interpolators[5] = input.vertexColor;
     output.positionWS.xyz = input.interpolators[0].xyz;
     output.texCoord0.x = input.interpolators[0].w;
     output.texCoord0.y = input.interpolators[4].x;
-    output.tangentToWorld[0] = input.interpolators[1];
-    output.tangentToWorld[1] = input.interpolators[2];
-    output.tangentToWorld[2] = input.interpolators[3];
+    output.tangentToWorld[0] = input.interpolators[1].xyz;
+    output.tangentToWorld[1] = input.interpolators[2].xyz;
+    output.tangentToWorld[2] = input.interpolators[3].xyz;
     output.vertexColor = input.interpolators[5];
 
 #ifdef SHADER_STAGE_FRAGMENT
     output.tangentToWorld[1].xyz = tangentToWorld[1];
     output.tangentToWorld[2].xyz = tangentToWorld[2];
 
-    output.tangentToWorld[0].w = 0;
-    output.tangentToWorld[1].w = 0;
-    output.tangentToWorld[2].w = 0;
-
     output.vertexColor = input.color;
 
     return PackVaryings(output);
 //-------------------------------------------------------------------------------------
 // Fill SurfaceData/Lighting data function
 //-------------------------------------------------------------------------------------
-
-float3 TransformTangentToWorld(float3 normalTS, float4 tangentToWorld[3])
-{
-    // TODO check: do we need to normalize ?
-    return normalize(mul(normalTS, float3x3(tangentToWorld[0].xyz, tangentToWorld[1].xyz, tangentToWorld[2].xyz)));
-}
 
 #if SHADER_STAGE_FRAGMENT
 
 
     surfaceData.materialId = 0;
 
-    // MaskMap is Metalic, Ambient Occlusion, (Optional) - emissive Mask, Optional - Smoothness (in alpha)
-    PROP_DECL(float, metalic);
+    // MaskMap is Metallic, Ambient Occlusion, (Optional) - emissive Mask, Optional - Smoothness (in alpha)
+    PROP_DECL(float, metallic);
-    PROP_SAMPLE(metalic, _MaskMap, input.texCoord0, a);
+    PROP_SAMPLE(metallic, _MaskMap, input.texCoord0, a);
-    PROP_ASSIGN_VALUE(metalic, 1.0);
+    PROP_ASSIGN_VALUE(metallic, 1.0);
-    PROP_MUL(metalic, _Metalic, r);
+    PROP_MUL(metallic, _Metallic, r);
-    PROP_BLEND_SCALAR(metalic, weights);
+    PROP_BLEND_SCALAR(metallic, weights);
-    surfaceData.metalic = metalic;
+    surfaceData.metallic = metallic;
     surfaceData.ambientOcclusion = ambientOcclusion;
 
     surfaceData.tangentWS = float3(1.0, 0.0, 0.0);

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

 //-----------------------------------------------------------------------------
 // structure definition
 //-----------------------------------------------------------------------------
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     namespace Lit
     {
             public Vector3 tangentWS;
             [SurfaceDataAttributes("Anisotropy")]
             public float anisotropy; // anisotropic ratio(0->no isotropic; 1->full anisotropy in tangent direction)
-            [SurfaceDataAttributes("Metalic")]
-            public float metalic;
+            [SurfaceDataAttributes("Metallic")]
+            public float metallic;
             [SurfaceDataAttributes("Specular")]
             public float specular; // 0.02, 0.04, 0.16, 0.2
 
                 isInit = false;
             }
 
-            public void RenderInit(UnityEngine.Rendering.RenderLoop renderLoop)
+            public void RenderInit(UnityEngine.Experimental.Rendering.RenderLoop renderLoop)
             {
                 var cmd = new CommandBuffer();
                 cmd.name = "Init PreFGD";

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

 //
 
 //
-// UnityEngine.ScriptableRenderLoop.Lit.MaterialId:  static fields
+// UnityEngine.Experimental.ScriptableRenderLoop.Lit.MaterialId:  static fields
 //
 #define MATERIALID_LIT_STANDARD (0)
 #define MATERIALID_LIT_SSS (1)
 
 //
-// UnityEngine.ScriptableRenderLoop.Lit.SurfaceData:  static fields
+// UnityEngine.Experimental.ScriptableRenderLoop.Lit.SurfaceData:  static fields
 //
 #define DEBUGVIEW_LIT_SURFACEDATA_BASE_COLOR (1000)
 #define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_OCCLUSION (1001)
 #define DEBUGVIEW_LIT_SURFACEDATA_AMBIENT_OCCLUSION (1005)
 #define DEBUGVIEW_LIT_SURFACEDATA_TANGENT_WS (1006)
 #define DEBUGVIEW_LIT_SURFACEDATA_ANISOTROPY (1007)
-#define DEBUGVIEW_LIT_SURFACEDATA_METALIC (1008)
+#define DEBUGVIEW_LIT_SURFACEDATA_METALLIC (1008)
 #define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR (1009)
 #define DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_RADIUS (1010)
 #define DEBUGVIEW_LIT_SURFACEDATA_THICKNESS (1011)
 #define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR (1015)
 
 //
-// UnityEngine.ScriptableRenderLoop.Lit.BSDFData:  static fields
+// UnityEngine.Experimental.ScriptableRenderLoop.Lit.BSDFData:  static fields
 //
 #define DEBUGVIEW_LIT_BSDFDATA_DIFFUSE_COLOR (1030)
 #define DEBUGVIEW_LIT_BSDFDATA_FRESNEL0 (1031)
 #define DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS (1046)
 
 //
-// UnityEngine.ScriptableRenderLoop.Lit.GBufferMaterial:  static fields
+// UnityEngine.Experimental.ScriptableRenderLoop.Lit.GBufferMaterial:  static fields
-// Generated from UnityEngine.ScriptableRenderLoop.Lit.SurfaceData
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.Lit.SurfaceData
 // PackingRules = Exact
 struct SurfaceData
 {
 	float ambientOcclusion;
 	float3 tangentWS;
 	float anisotropy;
-	float metalic;
+	float metallic;
 	float specular;
 	float subSurfaceRadius;
 	float thickness;
 	float3 specularColor;
 };
 
-// Generated from UnityEngine.ScriptableRenderLoop.Lit.BSDFData
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.Lit.BSDFData
 // PackingRules = Exact
 struct BSDFData
 {

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

 
 BSDFData ConvertSurfaceDataToBSDFData(SurfaceData surfaceData)
 {
-    BSDFData bsdfData = (BSDFData)0;
+    BSDFData bsdfData;
+    ZERO_INITIALIZE(BSDFData, bsdfData);
 
     bsdfData.specularOcclusion = surfaceData.specularOcclusion;
     bsdfData.normalWS = surfaceData.normalWS;
 
     if (bsdfData.materialId == MATERIALID_LIT_STANDARD)
     {
-        bsdfData.diffuseColor = surfaceData.baseColor * (1.0 - surfaceData.metalic);
-        bsdfData.fresnel0 = lerp(float3(surfaceData.specular, surfaceData.specular, surfaceData.specular), surfaceData.baseColor, surfaceData.metalic);
+        bsdfData.diffuseColor = surfaceData.baseColor * (1.0 - surfaceData.metallic);
+        bsdfData.fresnel0 = lerp(float3(surfaceData.specular, surfaceData.specular, surfaceData.specular), surfaceData.baseColor, surfaceData.metallic);
 
         bsdfData.tangentWS = surfaceData.tangentWS;
         bsdfData.bitangentWS = cross(surfaceData.normalWS, surfaceData.tangentWS);        
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
-        bsdfData.diffuseColor = surfaceData.baseColor * (1.0 - surfaceData.metalic);
-        bsdfData.fresnel0 = lerp(float3(surfaceData.specular, surfaceData.specular, surfaceData.specular), surfaceData.baseColor, surfaceData.metalic);
+        bsdfData.diffuseColor = surfaceData.baseColor * (1.0 - surfaceData.metallic);
+        bsdfData.fresnel0 = lerp(float3(surfaceData.specular, surfaceData.specular, surfaceData.specular), surfaceData.baseColor, surfaceData.metallic);
         bsdfData.coatNormalWS = surfaceData.coatNormalWS;
         bsdfData.coatRoughness = PerceptualSmoothnessToRoughness(surfaceData.coatPerceptualSmoothness);
     }
         // Encode tangent on 16bit with oct compression
         float2 octTangentWS = PackNormalOctEncode(surfaceData.tangentWS);
         // TODO: store metal and specular together, specular should be an enum (fixed value)
-        outGBuffer2 = float4(octTangentWS * 0.5 + 0.5, surfaceData.anisotropy, surfaceData.metalic);
+        outGBuffer2 = float4(octTangentWS * 0.5 + 0.5, surfaceData.anisotropy, surfaceData.metallic);
     }
     else if (surfaceData.materialId == MATERIALID_LIT_SSS)
     {
         // Encode coat normal on 16bit with oct compression
         float2 octCoatNormalWS = PackNormalOctEncode(surfaceData.coatNormalWS);
         // TODO: store metal and specular together, specular should be an enum (fixed value)
-        outGBuffer2 = float4(octCoatNormalWS * 0.5 + 0.5, PerceptualSmoothnessToRoughness(surfaceData.coatPerceptualSmoothness), surfaceData.metalic);
+        outGBuffer2 = float4(octCoatNormalWS * 0.5 + 0.5, PerceptualSmoothnessToRoughness(surfaceData.coatPerceptualSmoothness), surfaceData.metallic);
     }
     else if (surfaceData.materialId == MATERIALID_LIT_SPECULAR)
     {
                             float4 inGBuffer1,
                             float4 inGBuffer2)
 {
-    BSDFData bsdfData = (BSDFData)0;
+    BSDFData bsdfData;
+    ZERO_INITIALIZE(BSDFData, bsdfData);
 
     float3 baseColor = inGBuffer0.rgb;
     bsdfData.specularOcclusion = inGBuffer0.a;
 
     if (bsdfData.materialId == MATERIALID_LIT_STANDARD)
     {
-        float metalic = inGBuffer2.a;
+        float metallic = inGBuffer2.a;
-        bsdfData.diffuseColor = baseColor * (1.0 - metalic);
-        bsdfData.fresnel0 = lerp(float3(specular, specular, specular), baseColor, metalic);
+        bsdfData.diffuseColor = baseColor * (1.0 - metallic);
+        bsdfData.fresnel0 = lerp(float3(specular, specular, specular), baseColor, metallic);
 
         bsdfData.tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
         bsdfData.bitangentWS = cross(bsdfData.normalWS, bsdfData.tangentWS);
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
-        float metalic = inGBuffer2.a;
+        float metallic = inGBuffer2.a;
-        bsdfData.diffuseColor = baseColor * (1.0 - metalic);
-        bsdfData.fresnel0 = lerp(float3(specular, specular, specular), baseColor, metalic);
+        bsdfData.diffuseColor = baseColor * (1.0 - metallic);
+        bsdfData.fresnel0 = lerp(float3(specular, specular, specular), baseColor, metallic);
         bsdfData.coatNormalWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
         bsdfData.coatRoughness = inGBuffer2.b;
     }
         case DEBUGVIEW_LIT_SURFACEDATA_ANISOTROPY:
             result = surfaceData.anisotropy.xxx;
             break;
-        case DEBUGVIEW_LIT_SURFACEDATA_METALIC:
-            result = surfaceData.metalic.xxx;
+        case DEBUGVIEW_LIT_SURFACEDATA_METALLIC:
+            result = surfaceData.metallic.xxx;
             break;
         // TODO: Remap here!
         case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR:
 }
 
 //-----------------------------------------------------------------------------
+// light transport functions
+//-----------------------------------------------------------------------------
+
+LighTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
+{
+    LighTransportData lightTransportData;
+
+    // diffuseColor for lightmapping should basically be diffuse color.
+    // But rough metals (black diffuse) still scatter quite a lot of light around, so
+    // we want to take some of that into account too.
+
+    lightTransportData.diffuseColor = bsdfData.diffuseColor + bsdfData.fresnel0 * bsdfData.roughness * 0.5 * surfaceData.metallic;
+    lightTransportData.emissiveColor = builtinData.emissiveColor * builtinData.emissiveIntensity;
+
+    return lightTransportData;
+}
+
+//-----------------------------------------------------------------------------
 // BSDF share between area light (reference) and punctual light
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
-// EvaluateBSDF_Env - Reference
-// ----------------------------------------------------------------------------
-
-// Ref: Moving Frostbite to PBR (Appendix A)
-float3 IntegrateLambertIBLRef(  EnvLightData lightData, BSDFData bsdfData,
-                                UNITY_ARGS_ENV(_EnvTextures),
-                                uint sampleCount = 2048)
-{
-    float3 N        = bsdfData.normalWS;
-    float3 acc      = float3(0.0, 0.0, 0.0);
-    // Add some jittering on Hammersley2d
-    float2 randNum  = InitRandom(N.xy * 0.5 + 0.5);
-
-    float3 tangentX, tangentY;
-    GetLocalFrame(N, tangentX, tangentY);
-
-    for (uint i = 0; i < sampleCount; ++i)
-    {
-        float2 u    = Hammersley2d(i, sampleCount);
-        u           = frac(u + randNum + 0.5);
-
-        float3 L;
-        float NdotL;
-        float weightOverPdf;
-        ImportanceSampleLambert(u, N, tangentX, tangentY, L, NdotL, weightOverPdf);
-
-        if (NdotL > 0.0)
-        {
-            float4 val = UNITY_SAMPLE_ENV_LOD(_EnvTextures, L, lightData, 0);
-
-            // diffuse Albedo is apply here as describe in ImportanceSampleLambert function
-            acc += bsdfData.diffuseColor * Lambert() * weightOverPdf * val.rgb;
-        }
-    }
-
-    return acc / sampleCount;
-}
-
-float3 IntegrateDisneyDiffuseIBLRef(float3 V, EnvLightData lightData, BSDFData bsdfData,
-                                    UNITY_ARGS_ENV(_EnvTextures),
-                                    uint sampleCount = 2048)
-{
-    float3 N = bsdfData.normalWS;
-    float NdotV = dot(N, V);
-    float3 acc  = float3(0.0, 0.0, 0.0);
-    // Add some jittering on Hammersley2d
-    float2 randNum  = InitRandom(N.xy * 0.5 + 0.5);
-
-    float3 tangentX, tangentY;
-    GetLocalFrame(N, tangentX, tangentY);
-
-    for (uint i = 0; i < sampleCount; ++i)
-    {
-        float2 u    = Hammersley2d(i, sampleCount);
-        u           = frac(u + randNum + 0.5);
-
-        float3 L;
-        float NdotL;
-        float weightOverPdf;
-        // for Disney we still use a Cosine importance sampling, true Disney importance sampling imply a look up table
-        ImportanceSampleLambert(u, N, tangentX, tangentY, L, NdotL, weightOverPdf);
-
-        if (NdotL > 0.0)
-        {            
-            float3 H = normalize(L + V);
-            float LdotH = dot(L, H);
-            // Note: we call DisneyDiffuse that require to multiply by Albedo / PI. Divide by PI is already taken into account
-            // in weightOverPdf of ImportanceSampleLambert call.
-            float disneyDiffuse = DisneyDiffuse(NdotV, NdotL, LdotH, bsdfData.perceptualRoughness);
-
-            // diffuse Albedo is apply here as describe in ImportanceSampleLambert function
-            float4 val = UNITY_SAMPLE_ENV_LOD(_EnvTextures, L, lightData, 0);
-            acc += bsdfData.diffuseColor * disneyDiffuse * weightOverPdf * val.rgb;
-        }
-    }
-
-    return acc / sampleCount;
-}
-
-// Ref: Moving Frostbite to PBR (Appendix A)
-float3 IntegrateSpecularGGXIBLRef(  float3 V, EnvLightData lightData, BSDFData bsdfData,
-                                    UNITY_ARGS_ENV(_EnvTextures),
-                                    uint sampleCount = 2048)
-{
-    float3 N        = bsdfData.normalWS;
-    float NdotV     = saturate(dot(N, V));
-    float3 acc      = float3(0.0, 0.0, 0.0);
-
-    // Add some jittering on Hammersley2d
-    float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
-
-    float3 tangentX, tangentY;
-    GetLocalFrame(N, tangentX, tangentY);
-
-    for (uint i = 0; i < sampleCount; ++i)
-    {
-        float2 u    = Hammersley2d(i, sampleCount);
-        u           = frac(u + randNum + 0.5);
-
-        float VdotH;
-        float NdotL;
-        float3 L;
-        float weightOverPdf;
-
-        // GGX BRDF
-        ImportanceSampleGGX(u, V, N, tangentX, tangentY, bsdfData.roughness, NdotV,
-                            L, VdotH, NdotL, weightOverPdf);
-
-        if (NdotL > 0.0)
-        {
-            // Fresnel component is apply here as describe in ImportanceSampleGGX function
-            float3 FweightOverPdf = F_Schlick(bsdfData.fresnel0, VdotH) * weightOverPdf;
-
-            float4 val = UNITY_SAMPLE_ENV_LOD(_EnvTextures, L, lightData, 0);
-
-            acc += FweightOverPdf * val.rgb;
-        }
-    }
-
-    return acc / sampleCount;
-}
-
-//-----------------------------------------------------------------------------
-// _preIntegratedFGD and _CubemapLD are unique for each BRDF
-void EvaluateBSDF_Env(  float3 V, float3 positionWS, PreLightData prelightData, EnvLightData lightData, BSDFData bsdfData,
-                        UNITY_ARGS_ENV(_EnvTextures),
-                        out float4 diffuseLighting,
-                        out float4 specularLighting)
-{
-#ifdef LIT_DISPLAY_REFERENCE
-
-    specularLighting.rgb = IntegrateSpecularGGXIBLRef(V, lightData, bsdfData, UNITY_PASS_ENV(_EnvTextures));
-    specularLighting.a = 1.0;
+// We must implement EvaluateBSDF_Env for various environment map case. For now just cube array and cube (but could add latlong later).
+// As a loop can call several version inside the same lighting architecture (think about sky and reflection probes, one isolated uncompressed, the others compressed BC6H in a textures array)
+// we need to implemnt various version here. To factor code we play with macro to generate the various varient.
+#define UNITY_ARGS_ENV(tex) UNITY_ARGS_TEXCUBEARRAY(tex)
+#define UNITY_SAMPLE_ENV_LOD(tex, coord, lightData, lod) UNITY_SAMPLE_TEXCUBEARRAY_LOD(tex, float4(coord, lightData.sliceIndex), lod)
+#include "LitEnvTemplate.hlsl"
+#undef UNITY_ARGS_ENV
+#undef UNITY_SAMPLE_ENV_LOD
-/*
-    #ifdef DIFFUSE_LAMBERT_BRDF
-    diffuseLighting.rgb = IntegrateLambertIBLRef(lightData, bsdfData, UNITY_PASS_ENV(_EnvTextures));
-    #else
-    diffuseLighting.rgb = IntegrateDisneyDiffuseIBLRef(V, lightData, bsdfData, UNITY_PASS_ENV(_EnvTextures));
-    #endif
-    diffuseLighting.a = 1.0;
-*/
-    diffuseLighting = float4(0.0, 0.0, 0.0, 0.0);
-
-#else
-    // TODO: factor this code in common, so other material authoring don't require to rewrite everything, 
-    // also think about how such a loop can handle 2 cubemap at the same time as old unity. Macro can allow to do that
-    // but we need to have UNITY_SAMPLE_ENV_LOD replace by a true function instead that is define by the lighting arcitecture.
-    // Also not sure how to deal with 2 intersection....
-    // Box and sphere are related to light property (but we have also distance based roughness etc...)
-
-    // 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;
-    float weight = 1.0;
-
-    // In this code we redefine a bit the behavior of the reflcetion proble. We separate the projection volume (the proxy of the scene) form the influence volume (what pixel on the screen is affected)
-
-    // 1. First determine the projection volume
-    
-    // In Unity the cubemaps are capture with the localToWorld transform of the component. 
-    // This mean that location and oritention matter. So after intersection of proxy volume we need to convert back to world.
-    
-    // CAUTION: localToWorld is the transform use to convert the cubemap capture point to world space (mean it include the offset)
-    // the center of the bounding box is thus in locals space: positionLS - offsetLS
-    // We use this formulation as it is the one of legacy unity that was using only AABB box.
-
-    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.
-
-    if (lightData.envShapeType == ENVSHAPETYPE_BOX)
-    {
-        float3 rayLS = mul(rayWS, worldToLocal);
-        float3 boxOuterDistance = lightData.innerDistance + float3(lightData.blendDistance, lightData.blendDistance, lightData.blendDistance);
-        float dist = BoxRayIntersectSimple(positionLS, rayLS, -boxOuterDistance, boxOuterDistance);
-
-        // No need to normalize for fetching cubemap
-        // We can reuse dist calculate in LS directly in WS as there is no scaling. Also the offset is already include in lightData.positionWS
-        R = (positionWS + dist * rayWS) - lightData.positionWS;
-        
-        // TODO: add distance based roughness
-    } 
-    else if (lightData.envShapeType == ENVSHAPETYPE_SPHERE)
-    {
-        float3 rayLS = mul(rayWS, worldToLocal);
-        float sphereOuterDistance = lightData.innerDistance.x + lightData.blendDistance;
-        float dist = SphereRayIntersectSimple(positionLS, rayLS, sphereOuterDistance);
-
-        R = (positionWS + dist * rayWS) - lightData.positionWS;
-    }
-
-    // 2. Apply the influence volume (Box volume is used for culling whatever the influence shape)
-    // TODO: In the future we could have an influence volume inside the projection volume (so with a different transform, in this case we will need another transform)
-    if (lightData.envShapeType == ENVSHAPETYPE_SPHERE)
-    {
-        float distFade = max(length(positionLS) - lightData.innerDistance.x, 0.0);
-        weight = saturate(1.0 - distFade / max(lightData.blendDistance, 0.0001)); // avoid divide by zero
-    }
-    else // ENVSHAPETYPE_BOX or ENVSHAPETYPE_NONE 
-    {
-        // Calculate falloff value, so reflections on the edges of the volume would gradually blend to previous reflection.
-        float distFade = DistancePointBox(positionLS, -lightData.innerDistance, lightData.innerDistance);
-        weight = saturate(1.0 - distFade / max(lightData.blendDistance, 0.0001)); // avoid divide by zero
-    }
-
-    // Smooth weighting
-    weight = smoothstep01(weight);
-
-    // TODO: we must always perform a weight calculation as due to tiled rendering we need to smooth out cubemap at boundaries.
-    // So goal is to split into two category and have an option to say if we parallax correct or not.
-
-    // TODO: compare current Morten version: offline cubemap with a particular remap + the bias in perceptualRoughnessToMipmapLevel
-    // to classic remap like unreal/Frobiste. The function GetSpecularDominantDir can result in a better matching in this case
-    // We let GetSpecularDominantDir currently as it still an improvement but not as good as it could be
-    float mip = perceptualRoughnessToMipmapLevel(bsdfData.perceptualRoughness);
-    float4 preLD = UNITY_SAMPLE_ENV_LOD(_EnvTextures, R, lightData, mip);
-    specularLighting.rgb = preLD.rgb * prelightData.specularFGD;
-
-    // Apply specular occlusion on it
-    specularLighting.rgb *= bsdfData.specularOcclusion;
-    specularLighting.a = weight;
-
-    diffuseLighting = float4(0.0, 0.0, 0.0, 0.0);
-
-#endif    
-}
+#define UNITY_ARGS_ENV(tex) UNITY_ARGS_TEXCUBE(tex)
+#define UNITY_SAMPLE_ENV_LOD(tex, coord, lightData, lod) UNITY_SAMPLE_TEXCUBE_LOD(tex, float3(coord), lod)
+#include "LitEnvTemplate.hlsl"
+#undef UNITY_ARGS_ENV
+#undef UNITY_SAMPLE_ENV_LOD
 
 #endif // UNITY_MATERIAL_LIT_INCLUDED

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

             public static GUIContent baseColorText = new GUIContent("Base Color + Opacity", "Albedo (RGB) and Opacity (A)");
             public static GUIContent baseColorSmoothnessText = new GUIContent("Base Color + Smoothness", "Albedo (RGB) and Smoothness (A)");
 
-            public static GUIContent metalicText = new GUIContent("Metalic", "Metalic scale factor");
+            public static GUIContent metallicText = new GUIContent("Metallic", "Metallic scale factor");
             public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness scale factor");
             public static GUIContent maskMapESText = new GUIContent("Mask Map - M(R), AO(G), E(B), S(A)", "Mask map");
             public static GUIContent maskMapEText = new GUIContent("Mask Map - M(R), AO(G), E(B)", "Mask map");
 
         MaterialProperty baseColor = null;
         MaterialProperty baseColorMap = null;
-        MaterialProperty metalic = null;
+        MaterialProperty metallic = null;
         MaterialProperty smoothness = null;
         MaterialProperty maskMap = null;
         MaterialProperty specularOcclusionMap = null;
         {
             baseColor = FindProperty("_BaseColor", props);
             baseColorMap = FindProperty("_BaseColorMap", props);
-            metalic = FindProperty("_Metalic", props);
+            metallic = FindProperty("_Metallic", props);
             smoothness = FindProperty("_Smoothness", props);
             maskMap = FindProperty(kMaskMap, props);
             specularOcclusionMap = FindProperty(kspecularOcclusionMap, props);
 
             GUILayout.Label(Styles.InputsText, EditorStyles.boldLabel);
             m_MaterialEditor.TexturePropertySingleLine(smoothnessInAlbedoAlpha ? Styles.baseColorSmoothnessText : Styles.baseColorText, baseColorMap, baseColor);
-            m_MaterialEditor.ShaderProperty(metalic, Styles.metalicText);
+            m_MaterialEditor.ShaderProperty(metallic, Styles.metallicText);
             m_MaterialEditor.ShaderProperty(smoothness, Styles.smoothnessText);
 
             if (smoothnessInAlbedoAlpha && useEmissiveMask)

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Unlit/Unlit.hlsl

 #ifndef UNITY_UNLIT_INCLUDED
 #define UNITY_UNLIT_INCLUDED
 
-struct SurfaceData
-{
-    float3 color;
-};
+//-----------------------------------------------------------------------------
+// SurfaceData and BSDFData
+//-----------------------------------------------------------------------------
-struct BSDFData
-{
-    float3 color;
-};
+// SurfaceData is define in Lit.cs which generate Lit.cs.hlsl
+#include "Unlit.cs.hlsl"
 
 //-----------------------------------------------------------------------------
 // conversion function for forward
 // No light evaluation, this is unlit
 //-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
+// Debug method (use to display values)
+//-----------------------------------------------------------------------------
+
+void GetSurfaceDataDebug(uint paramId, SurfaceData surfaceData, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+    case DEBUGVIEW_UNLIT_SURFACEDATA_COLOR:
+        result = surfaceData.color; needLinearToSRGB = true;
+        break;
+    }
+}
+
+void GetBSDFDataDebug(uint paramId, BSDFData bsdfData, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+    case DEBUGVIEW_UNLIT_SURFACEDATA_COLOR:
+        result = bsdfData.color; needLinearToSRGB = true;
+        break;
+    }
+}
 
 #endif // UNITY_UNLIT_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderPass/ShaderPassDebugViewMaterial.hlsl

-#if SHADER_STAGE_FRAGMENT
+#if SHADERPASS != SHADERPASS_DEBUG_VIEW_MATERIAL
+#error SHADERPASS_is_not_correctly_define
+#endif
 
 #include "Color.hlsl"
 int _DebugViewMaterial;
-	Varyings input = UnpackVaryings(packedInput);
+    FragInput input = UnpackVaryings(packedInput);
+
 	SurfaceData surfaceData;
 	BuiltinData builtinData;
 	GetSurfaceAndBuiltinData(input, surfaceData, builtinData);
 	return float4(result, 0.0);
 }
 
-#endif

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderPass/ShaderPassForward.hlsl

-#if SHADER_STAGE_FRAGMENT
+#if SHADERPASS != SHADERPASS_FORWARD
+#error SHADERPASS_is_not_correctly_define
+#endif
-	Varyings input = UnpackVaryings(packedInput);
+    FragInput input = UnpackVaryings(packedInput);
 	float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
 	float3 positionWS = input.positionWS;
 
 	return float4(diffuseLighting.rgb + specularLighting.rgb, builtinData.opacity);
 }
 
-#endif

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderPass/ShaderPassGBuffer.hlsl

-#if SHADER_STAGE_FRAGMENT
+#if SHADERPASS != SHADERPASS_GBUFFER
+#error SHADERPASS_is_not_correctly_define
+#endif
 
 void Frag(  PackedVaryings packedInput,
 			OUTPUT_GBUFFER(outGBuffer)
 			, OUTPUT_GBUFFER_BAKE_LIGHTING(outGBuffer)
 			)
 {
-	Varyings input = UnpackVaryings(packedInput);
+    FragInput input = UnpackVaryings(packedInput);
 	float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
 	float3 positionWS = input.positionWS;
 
 	#endif
 	ENCODE_BAKE_LIGHTING_INTO_GBUFFER(GetBakedDiffuseLigthing(preLightData, surfaceData, builtinData, bsdfData), outGBuffer);
 }
-
-#endif

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderVariables.hlsl

 
 CBUFFER_END
 
+CBUFFER_START(UnityLightmaps)
+float4 unity_LightmapST;
+float4 unity_DynamicLightmapST;
+CBUFFER_END
+
 // ----------------------------------------------------------------------------
 
 // TODO: move this to constant buffer by Pass
 float3 GetWorldSpaceNormalizeViewDir(float3 positionWS)
 {
     return normalize(_WorldSpaceCameraPos.xyz - positionWS);
+}
+
+float3 TransformTangentToWorld(float3 dirTS, float3 tangentToWorld[3])
+{
+    // TODO check: do we need to normalize ?
+    return normalize(mul(dirTS, float3x3(tangentToWorld[0].xyz, tangentToWorld[1].xyz, tangentToWorld[2].xyz)));
+}
+
+// Assume TBN is orthonormal.
+float3 TransformWorldToTangent(float3 dirWS, float3 tangentToWorld[3])
+{
+    // TODO check: do we need to normalize ?
+    return normalize(mul(float3x3(tangentToWorld[0].xyz, tangentToWorld[1].xyz, tangentToWorld[2].xyz), dirWS));
 }
 
 #endif // UNITY_SHADER_VARIABLES_INCLUDED

Assets/ScriptableRenderLoop/RenderPasses/ShadowRenderPass.cs

 using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     [System.Serializable]
     public struct ShadowSettings

Assets/ScriptableRenderLoop/ScriptableRenderLoop.cs

-using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     public abstract class ScriptableRenderLoop : ScriptableObject
     {

Assets/ScriptableRenderLoop/ScriptableRenderLoopPicker.cs

-using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     //@TODO: This should be moved into GraphicsSettings
     [ExecuteInEditMode]

Assets/ScriptableRenderLoop/ShaderLibrary/API/D3D11.hlsl

 #define CBUFFER_START(name) cbuffer name {
 #define CBUFFER_END };
 
+// Initialize arbitrary structure with zero values.
+// Do not exist on some platform, in this case we need to have a standard name that call a function that will initialize all parameters to 0
+#define ZERO_INITIALIZE(type, name) name = (type)0;
+
 // Macros to declare textures and samplers, possibly separately. For platforms
 // that have separate samplers & textures (like DX11), and we'd want to conserve
 // the samplers.

Assets/ScriptableRenderLoop/ShaderLibrary/API/Validate.hlsl

 REQUIRE_DEFINED(CBUFFER_START)
 REQUIRE_DEFINED(CBUFFER_END)
 
+REQUIRE_DEFINED(INITIALIZE_OUTPUT)
+
 */

Assets/ScriptableRenderLoop/ShaderLibrary/Color.hlsl

     return max(vRGB, float3(0.0, 0.0, 0.0));
 }
 
-// TODO: check what is really use by the lightmap... should be hardcoded
-// This function must handle various crappy case of lightmap ?
-float4 UnityEncodeRGBM (float3 rgb, float maxRGBM)
+// TODO: This function is used with the LightTransport pass to encode lightmap or emissive
+float4 PackRGBM(float3 rgb, float maxRGBM)
 {
     float kOneOverRGBMMaxRange = 1.0 / maxRGBM;
     const float kMinMultiplier = 2.0 * 1e-2;
 
 // Alternative...
 #define RGBMRANGE (8.0)
-float4 packRGBM(float3 color)
+float4 PackRGBM(float3 color)
 {
     float4 rgbm;
     color *= (1.0 / RGBMRANGE);
     return rgbm;
 }
 
-float3 unpackRGBM(float4 rgbm)
+float3 UnpackRGBM(float4 rgbm)
 {
     return RGBMRANGE * rgbm.rgb * rgbm.a;
 }

Assets/ScriptableRenderLoop/ShaderLibrary/CommonLighting.hlsl

 }
 */
 
+// ----------------------------------------------------------------------------
+// Parallax mapping
+// ----------------------------------------------------------------------------
+
+float2 ParallaxOffset(float3 viewDirTS, float height)
+{
+    // Parallax mapping with offset limiting to reduce weird artifcat (i.e do not divide by z), also save performance
+    return viewDirTS.xy * height;
+}
+
+
 #endif // UNITY_COMMON_LIGHTING_INCLUDED

Assets/ScriptableRenderLoop/Tests/RenderLoopWrapper.cs

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
-using UnityEngine.ScriptableRenderLoop;
-using UnityEngine.Rendering;
+using UnityEngine.Experimental.ScriptableRenderLoop;
+using UnityEngine.Experimental.Rendering;
 
 [ExecuteInEditMode]
 public class RenderLoopWrapper : MonoBehaviour

Assets/ScriptableRenderLoop/common/SkyboxHelper.cs

 using System.Collections.Generic;
 using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
 using UnityEngine;
 
 public class SkyboxHelper

Assets/ScriptableRenderLoop/common/TextureCache.cs

 
 public class TextureCache2D : TextureCache
 {
-    private Texture2DArray cache;
+    private Texture2DArray m_Cache;
-        var mismatch = (cache.width != texture.width) || (cache.height != texture.height);
+        var mismatch = (m_Cache.width != texture.width) || (m_Cache.height != texture.height);
-            mismatch |= (cache.format != (texture as Texture2D).format);
+            mismatch |= (m_Cache.format != (texture as Texture2D).format);
-                texture.name, cache.width, cache.height, cache.format);
+                texture.name, m_Cache.width, m_Cache.height, m_Cache.format);
-        Graphics.CopyTexture(texture, 0, cache, sliceIndex);
+        Graphics.CopyTexture(texture, 0, m_Cache, sliceIndex);
-        return cache;
+        return m_Cache;
     }
 
     public bool AllocTextureArray(int numTextures, int width, int height, TextureFormat format, bool isMipMapped)
 
-        cache = new Texture2DArray(width, height, numTextures, format, isMipMapped)
+        m_Cache = new Texture2DArray(width, height, numTextures, format, isMipMapped)
         {
             hideFlags = HideFlags.HideAndDontSave,
             wrapMode = TextureWrapMode.Clamp
 
     public void Release()
     {
-        Texture.DestroyImmediate(cache);      // do I need this?
+        Texture.DestroyImmediate(m_Cache);      // do I need this?
     }
 }
 

Assets/ScriptableRenderLoop/fptl/Internal-DeferredShading.shader

-Shader "Hidden/Internal-Obscurity" {
-Properties {
-    _LightTexture0 ("", any) = "" {}
-    _ShadowMapTexture ("", any) = "" {}
-    _SrcBlend ("", Float) = 1
-    _DstBlend ("", Float) = 1
-}
-SubShader {
-
-
-
-
-Pass
-{
-    ZWrite Off
-    ZTest Always
-    Cull Off
-    Blend Off
-    //Blend [_SrcBlend] [_DstBlend]
-
-
-CGPROGRAM
-#pragma target 5.0
-#pragma vertex vert
-#pragma fragment frag
-
-#pragma multi_compile USE_FPTL_LIGHTLIST    USE_CLUSTERED_LIGHTLIST
-
-#include "UnityLightingCommon.cginc"
-
-float3 EvalMaterial(UnityLight light, UnityIndirect ind);
-
-// uses the optimized single layered light list for opaques only
-
-#ifdef USE_FPTL_LIGHTLIST
-    #define OPAQUES_ONLY
-#endif
-
-#include "TiledLightingTemplate.hlsl"
-
-
-Texture2D _CameraDepthTexture;
-Texture2D _CameraGBufferTexture0;
-Texture2D _CameraGBufferTexture1;
-Texture2D _CameraGBufferTexture2;
-Texture2D _CameraGBufferTexture3;
-
-
-struct v2f {
-    float4 vertex : SV_POSITION;
-    float2 texcoord : TEXCOORD0;
-};
-
-v2f vert (float4 vertex : POSITION, float2 texcoord : TEXCOORD0)
-{
-    v2f o;
-    o.vertex = UnityObjectToClipPos(vertex);
-    o.texcoord = texcoord.xy;
-    return o;
-}
-
-struct StandardData
-{
-    float3 specularColor;
-    float3 diffuseColor;
-    float3 normalWorld;
-    float smoothness;
-	float3 emission;
-};
-
-struct LocalDataBRDF
-{
-    StandardData gbuf;
-
-    // extras
-    float oneMinusReflectivity;
-    float3 Vworld;
-};
-
-static LocalDataBRDF g_localParams;
-
-StandardData UnityStandardDataFromGbuffer(float4 gbuffer0, float4 gbuffer1, float4 gbuffer2, float4 gbuffer3)
-{
-    StandardData data;
-
-    data.normalWorld = normalize(2*gbuffer2.xyz-1);
-    data.smoothness = gbuffer1.a;
-    data.diffuseColor = gbuffer0.xyz; data.specularColor = gbuffer1.xyz;
-    float ao = gbuffer0.a;
-	data.emission = gbuffer3.xyz;
-
-    return data;
-}
-
-
-float3 EvalMaterial(UnityLight light, UnityIndirect ind)
-{
-    StandardData data = g_localParams.gbuf;
-    return UNITY_BRDF_PBS(data.diffuseColor, data.specularColor, g_localParams.oneMinusReflectivity, data.smoothness, data.normalWorld, g_localParams.Vworld, light, ind);
-}
-
-
-half4 frag (v2f i) : SV_Target
-{
-    uint2 pixCoord = ((uint2) i.vertex.xy);
-
-    float zbufDpth = FetchDepth(_CameraDepthTexture, pixCoord.xy).x;
-    float linDepth = GetLinearDepth(zbufDpth);
-
-    float3 vP = GetViewPosFromLinDepth(i.vertex.xy, linDepth);
-    float3 vPw = mul(g_mViewToWorld, float4(vP, 1)).xyz;
-    float3 Vworld = normalize(mul((float3x3) g_mViewToWorld, -vP).xyz);     //unity_CameraToWorld
-
-    float4 gbuffer0 = _CameraGBufferTexture0.Load( uint3(pixCoord.xy, 0) );
-    float4 gbuffer1 = _CameraGBufferTexture1.Load( uint3(pixCoord.xy, 0) );
-    float4 gbuffer2 = _CameraGBufferTexture2.Load( uint3(pixCoord.xy, 0) );
-	float4 gbuffer3 = _CameraGBufferTexture3.Load( uint3(pixCoord.xy, 0) );
-
-    StandardData data = UnityStandardDataFromGbuffer(gbuffer0, gbuffer1, gbuffer2, gbuffer3);
-
-    g_localParams.gbuf = data;
-    g_localParams.oneMinusReflectivity = 1.0 - SpecularStrength(data.specularColor.rgb);
-    g_localParams.Vworld = Vworld;
-
-    uint numLightsProcessed = 0;
-    float3 c = data.emission + ExecuteLightList(numLightsProcessed, pixCoord, vP, vPw, Vworld);
-
-    //c = OverlayHeatMap(numLightsProcessed, c);
-    return float4(c,1.0);
-}
-
-ENDCG
-}
-
-}
-Fallback Off
-}
+Shader "Hidden/Internal-Obscurity" {
+Properties {
+    _LightTexture0 ("", any) = "" {}
+    _ShadowMapTexture ("", any) = "" {}
+    _SrcBlend ("", Float) = 1
+    _DstBlend ("", Float) = 1
+}
+SubShader {
+
+
+
+
+Pass
+{
+    ZWrite Off
+    ZTest Always
+    Cull Off
+    Blend Off
+    //Blend [_SrcBlend] [_DstBlend]
+
+
+CGPROGRAM
+#pragma target 5.0
+#pragma vertex vert
+#pragma fragment frag
+
+#pragma multi_compile USE_FPTL_LIGHTLIST    USE_CLUSTERED_LIGHTLIST
+#pragma multi_compile __ ENABLE_DEBUG
+
+#include "UnityLightingCommon.cginc"
+
+float3 EvalMaterial(UnityLight light, UnityIndirect ind);
+
+// uses the optimized single layered light list for opaques only
+
+#ifdef USE_FPTL_LIGHTLIST
+    #define OPAQUES_ONLY
+#endif
+
+#include "TiledLightingTemplate.hlsl"
+
+
+Texture2D _CameraDepthTexture;
+Texture2D _CameraGBufferTexture0;
+Texture2D _CameraGBufferTexture1;
+Texture2D _CameraGBufferTexture2;
+Texture2D _CameraGBufferTexture3;
+
+
+struct v2f {
+    float4 vertex : SV_POSITION;
+    float2 texcoord : TEXCOORD0;
+};
+
+v2f vert (float4 vertex : POSITION, float2 texcoord : TEXCOORD0)
+{
+    v2f o;
+    o.vertex = UnityObjectToClipPos(vertex);
+    o.texcoord = texcoord.xy;
+    return o;
+}
+
+struct StandardData
+{
+    float3 specularColor;
+    float3 diffuseColor;
+    float3 normalWorld;
+    float smoothness;
+	float3 emission;
+};
+
+struct LocalDataBRDF
+{
+    StandardData gbuf;
+
+    // extras
+    float oneMinusReflectivity;
+    float3 Vworld;
+};
+
+static LocalDataBRDF g_localParams;
+
+StandardData UnityStandardDataFromGbuffer(float4 gbuffer0, float4 gbuffer1, float4 gbuffer2, float4 gbuffer3)
+{
+    StandardData data;
+
+    data.normalWorld = normalize(2*gbuffer2.xyz-1);
+    data.smoothness = gbuffer1.a;
+    data.diffuseColor = gbuffer0.xyz; data.specularColor = gbuffer1.xyz;
+    float ao = gbuffer0.a;
+	data.emission = gbuffer3.xyz;
+
+    return data;
+}
+
+
+float3 EvalMaterial(UnityLight light, UnityIndirect ind)
+{
+    StandardData data = g_localParams.gbuf;
+    return UNITY_BRDF_PBS(data.diffuseColor, data.specularColor, g_localParams.oneMinusReflectivity, data.smoothness, data.normalWorld, g_localParams.Vworld, light, ind);
+}
+
+
+half4 frag (v2f i) : SV_Target
+{
+    uint2 pixCoord = ((uint2) i.vertex.xy);
+
+    float zbufDpth = FetchDepth(_CameraDepthTexture, pixCoord.xy).x;
+    float linDepth = GetLinearDepth(zbufDpth);
+
+    float3 vP = GetViewPosFromLinDepth(i.vertex.xy, linDepth);
+    float3 vPw = mul(g_mViewToWorld, float4(vP, 1)).xyz;
+    float3 Vworld = normalize(mul((float3x3) g_mViewToWorld, -vP).xyz);     //unity_CameraToWorld
+
+    float4 gbuffer0 = _CameraGBufferTexture0.Load( uint3(pixCoord.xy, 0) );
+    float4 gbuffer1 = _CameraGBufferTexture1.Load( uint3(pixCoord.xy, 0) );
+    float4 gbuffer2 = _CameraGBufferTexture2.Load( uint3(pixCoord.xy, 0) );
+	float4 gbuffer3 = _CameraGBufferTexture3.Load( uint3(pixCoord.xy, 0) );
+
+    StandardData data = UnityStandardDataFromGbuffer(gbuffer0, gbuffer1, gbuffer2, gbuffer3);
+
+    g_localParams.gbuf = data;
+    g_localParams.oneMinusReflectivity = 1.0 - SpecularStrength(data.specularColor.rgb);
+    g_localParams.Vworld = Vworld;
+
+    uint numLightsProcessed = 0;
+    float3 c = data.emission + ExecuteLightList(numLightsProcessed, pixCoord, vP, vPw, Vworld);
+
+#if ENABLE_DEBUG
+    c = OverlayHeatMap(pixCoord & 15, numLightsProcessed, c);
+#endif
+    return float4(c,1.0);
+}
+
+ENDCG
+}
+
+}
+Fallback Off
+}

Assets/ScriptableRenderLoop/fptl/LightDefinitions.cs

 using UnityEngine;
+using UnityEngine.Experimental.ScriptableRenderLoop;
-[UnityEngine.ScriptableRenderLoop.GenerateHLSL]
+[GenerateHLSL]
 public struct SFiniteLightData
 {
     // setup constant buffer
     public float probeBlendDistance;
 };
 
-[UnityEngine.ScriptableRenderLoop.GenerateHLSL]
+[GenerateHLSL]
 public struct SFiniteLightBound
 {
     public Vector3 boxAxisX;
     public float radius;
 };
 
-[UnityEngine.ScriptableRenderLoop.GenerateHLSL]
+[GenerateHLSL]
 public struct DirectionalLight
 {
     public Vector3 color;
     public float pad1;
 };
 
-[UnityEngine.ScriptableRenderLoop.GenerateHLSL]
+[GenerateHLSL]
 public class LightDefinitions
 {
     public static int MAX_NR_LIGHTS_PER_CAMERA = 1024;

Assets/ScriptableRenderLoop/fptl/LightingUtils.hlsl

 
 float GetLinearDepth(float zDptBufSpace)    // 0 is near 1 is far
 {
-    float3 vP = float3(0.0f,0.0f,zDptBufSpace);
-    float4 v4Pres = mul(g_mInvScrProjection, float4(vP,1.0));
-    return v4Pres.z / v4Pres.w;
-}
+    // 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;
+}
-float3 OverlayHeatMap(uint numLights, float3 c)
-{
-    /////////////////////////////////////////////////////////////////////
-    //
-    const float4 kRadarColors[12] =
-    {
-        float4(0.0,0.0,0.0,0.0),   // black
-        float4(0.0,0.0,0.6,0.5),   // dark blue
-        float4(0.0,0.0,0.9,0.5),   // blue
-        float4(0.0,0.6,0.9,0.5),   // light blue
-        float4(0.0,0.9,0.9,0.5),   // cyan
-        float4(0.0,0.9,0.6,0.5),   // blueish green
-        float4(0.0,0.9,0.0,0.5),   // green
-        float4(0.6,0.9,0.0,0.5),   // yellowish green
-        float4(0.9,0.9,0.0,0.5),   // yellow
-        float4(0.9,0.6,0.0,0.5),   // orange
-        float4(0.9,0.0,0.0,0.5),   // red
-        float4(1.0,0.0,0.0,0.9)    // strong red
-    };
-
-    float maxNrLightsPerTile = 31;
-
-
-
-    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];
-
-    return lerp(c, pow(col.xyz, 2.2), 0.3*col.w);
+bool SampleDebugFont(int2 pixCoord, uint digit)
+{
+    if (pixCoord.x < 0 || pixCoord.y < 0 || pixCoord.x >= 5 || pixCoord.y >= 9 || digit > 9)
+        return false;
+#define PACK_BITS25(_x0,_x1,_x2,_x3,_x4,_x5,_x6,_x7,_x8,_x9,_x10,_x11,_x12,_x13,_x14,_x15,_x16,_x17,_x18,_x19,_x20,_x21,_x22,_x23,_x24) (_x0|(_x1<<1)|(_x2<<2)|(_x3<<3)|(_x4<<4)|(_x5<<5)|(_x6<<6)|(_x7<<7)|(_x8<<8)|(_x9<<9)|(_x10<<10)|(_x11<<11)|(_x12<<12)|(_x13<<13)|(_x14<<14)|(_x15<<15)|(_x16<<16)|(_x17<<17)|(_x18<<18)|(_x19<<19)|(_x20<<20)|(_x21<<21)|(_x22<<22)|(_x23<<23)|(_x24<<24))
+#define _ 0
+#define x 1
+    uint fontData[9][2] = {
+        PACK_BITS25(_,_,x,_,_,		_,_,x,_,_,		_,x,x,x,_,		x,x,x,x,x,		_,_,_,x,_),	PACK_BITS25(x,x,x,x,x,		_,x,x,x,_,		x,x,x,x,x,		_,x,x,x,_,		_,x,x,x,_),
+        PACK_BITS25(_,x,_,x,_,		_,x,x,_,_,		x,_,_,_,x,		_,_,_,_,x,		_,_,_,x,_),	PACK_BITS25(x,_,_,_,_,		x,_,_,_,x,		_,_,_,_,x,		x,_,_,_,x,		x,_,_,_,x),
+        PACK_BITS25(x,_,_,_,x,		x,_,x,_,_,		x,_,_,_,x,		_,_,_,x,_,		_,_,x,x,_),	PACK_BITS25(x,_,_,_,_,		x,_,_,_,_,		_,_,_,x,_,		x,_,_,_,x,		x,_,_,_,x),
+        PACK_BITS25(x,_,_,_,x,		_,_,x,_,_,		_,_,_,_,x,		_,_,x,_,_,		_,x,_,x,_),	PACK_BITS25(x,_,x,x,_,		x,_,_,_,_,		_,_,_,x,_,		x,_,_,_,x,		x,_,_,_,x),
+        PACK_BITS25(x,_,_,_,x,		_,_,x,_,_,		_,_,_,x,_,		_,x,x,x,_,		_,x,_,x,_),	PACK_BITS25(x,x,_,_,x,		x,x,x,x,_,		_,_,x,_,_,		_,x,x,x,_,		_,x,x,x,x),
+        PACK_BITS25(x,_,_,_,x,		_,_,x,_,_,		_,_,x,_,_,		_,_,_,_,x,		x,_,_,x,_),	PACK_BITS25(_,_,_,_,x,		x,_,_,_,x,		_,_,x,_,_,		x,_,_,_,x,		_,_,_,_,x),
+        PACK_BITS25(x,_,_,_,x,		_,_,x,_,_,		_,x,_,_,_,		_,_,_,_,x,		x,x,x,x,x),	PACK_BITS25(_,_,_,_,x,		x,_,_,_,x,		_,x,_,_,_,		x,_,_,_,x,		_,_,_,_,x),
+        PACK_BITS25(_,x,_,x,_,		_,_,x,_,_,		x,_,_,_,_,		x,_,_,_,x,		_,_,_,x,_),	PACK_BITS25(x,_,_,_,x,		x,_,_,_,x,		_,x,_,_,_,		x,_,_,_,x,		x,_,_,_,x),
+        PACK_BITS25(_,_,x,_,_,		x,x,x,x,x,		x,x,x,x,x,		_,x,x,x,_,		_,_,_,x,_),	PACK_BITS25(_,x,x,x,_,		_,x,x,x,_,		_,x,_,_,_,		_,x,x,x,_,		_,x,x,x,_)
+    };
+#undef _
+#undef x
+#undef PACK_BITS25
+    return (fontData[8 - pixCoord.y][digit >= 5] >> ((digit % 5) * 5 + pixCoord.x)) & 1;
+}
+
+bool SampleDebugFontNumber(int2 coord, uint number)
+{
+    coord.y -= 4;
+    if (number <= 9)
+    {
+        return SampleDebugFont(coord - int2(6, 0), number);
+
+    }
+    else
+    {
+        return (SampleDebugFont(coord, number / 10) | SampleDebugFont(coord - int2(6, 0), number % 10));
+    }
+}
+
+
+float3 OverlayHeatMap(uint2 pixCoord, uint numLights, float3 c)
+{
+    /////////////////////////////////////////////////////////////////////
+    //
+    const float4 kRadarColors[12] =
+    {
+        float4(0.0,0.0,0.0,0.0),   // black
+        float4(0.0,0.0,0.6,0.5),   // dark blue
+        float4(0.0,0.0,0.9,0.5),   // blue
+        float4(0.0,0.6,0.9,0.5),   // light blue
+        float4(0.0,0.9,0.9,0.5),   // cyan
+        float4(0.0,0.9,0.6,0.5),   // blueish green
+        float4(0.0,0.9,0.0,0.5),   // green
+        float4(0.6,0.9,0.0,0.5),   // yellowish green
+        float4(0.9,0.9,0.0,0.5),   // yellow
+        float4(0.9,0.6,0.0,0.5),   // orange
+        float4(0.9,0.0,0.0,0.5),   // red
+        float4(1.0,0.0,0.0,0.9)    // strong red
+    };
+
+    float maxNrLightsPerTile = 31;
+
+    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];
+
+    int2 coord = pixCoord - int2(1, 1);
+
+    float3 color = lerp(c, pow(col.xyz, 2.2), 0.3*col.w);
+    if (SampleDebugFontNumber(coord, numLights))		// Shadow
+        color = 0.0f;
+    if (SampleDebugFontNumber(coord + 1, numLights))	// Text
+        color = 1.0f;
+
+    return color;
 }
 
 

Assets/ScriptableRenderLoop/fptl/ReflectionTemplate.hlsl

 
 
 UNITY_DECLARE_TEXCUBEARRAY(_reflCubeTextures);
+UNITY_DECLARE_TEXCUBE(_reflRootCubeTexture);
+//uniform int _reflRootSliceIndex;
+uniform float _reflRootHdrDecodeMult;
+uniform float _reflRootHdrDecodeExp;
+
 
 half3 Unity_GlossyEnvironment (UNITY_ARGS_TEXCUBEARRAY(tex), int sliceIndex, half4 hdr, Unity_GlossyEnvironmentData glossIn);
 
     light.dir = 0;
 
     float3 ints = 0;
+
+	// root ibl begin
+	{
+		Unity_GlossyEnvironmentData g;
+		g.roughness = percRoughness;
+		g.reflUVW = worldNormalRefl;
+
+		half3 env0 = Unity_GlossyEnvironment(UNITY_PASS_TEXCUBE(_reflRootCubeTexture), float4(_reflRootHdrDecodeMult, _reflRootHdrDecodeExp, 0.0, 0.0), g);
+		//half3 env0 = Unity_GlossyEnvironment(UNITY_PASS_TEXCUBEARRAY(_reflCubeTextures), _reflRootSliceIndex, float4(_reflRootHdrDecodeMult, _reflRootHdrDecodeExp, 0.0, 0.0), g);
+
+		UnityIndirect ind;
+		ind.diffuse = 0;
+		ind.specular = env0;// * data.occlusion;
+		ints = EvalIndirectSpecular(light, ind);
+	}
+	// root ibl end
 
     uint l=0;
 	// don't need the outer loop since the probes are sorted by volume type (currently one type in fact)

Assets/ScriptableRenderLoop/fptl/UnityStandardForwardNew.cginc

 #include "LightingUtils.hlsl"
 
 static FragmentCommonData gdata;
-
+static float occlusion;
 
 half4 fragNoLight(VertexOutputForwardNew i) : SV_Target
 {
 
 float3 EvalIndirectSpecular(UnityLight light, UnityIndirect ind)
 {
-    float occlusion = 1.0;      // have none for now
     return occlusion * UNITY_BRDF_PBS(gdata.diffColor, gdata.specColor, gdata.oneMinusReflectivity, gdata.smoothness, gdata.normalWorld, -gdata.eyeVec, light, ind);
 }
 
 
     uint2 pixCoord = ((uint2) i.pos.xy);
 
-    //float atten = 0.0;
-    //half occlusion = Occlusion(i.tex.xy);
-    //UnityGI gi = FragmentGI (gdata, occlusion, i.ambientOrLightmapUV, atten, mainLight);
-
+    float atten = 1.0;
+	occlusion = Occlusion(i.tex.xy);
+    UnityGI gi = FragmentGI (gdata, occlusion, i.ambientOrLightmapUV, atten, DummyLight(), false);
+	
+
+	// direct light contributions
-    res += ExecuteReflectionList(numReflectionsProcessed, pixCoord, vP, gdata.normalWorld, Vworld, gdata.smoothness);
-    // don't really have a handle on this yet
-    //UnityLight mainLight = MainLight ();
-    //res += UNITY_BRDF_GI (gdata.diffColor, gdata.specColor, gdata.oneMinusReflectivity, gdata.smoothness, gdata.normalWorld, -gdata.eyeVec, occlusion, gi);
-    res += Emission(i.tex.xy);
+	// specular GI
+    res += ExecuteReflectionList(numReflectionsProcessed, pixCoord, vP, gdata.normalWorld, Vworld, gdata.smoothness);
+    // diffuse GI
+	res += UNITY_BRDF_PBS (gdata.diffColor, gdata.specColor, gdata.oneMinusReflectivity, gdata.smoothness, gdata.normalWorld, -gdata.eyeVec, gi.light, gi.indirect).xyz;
+    res += UNITY_BRDF_GI (gdata.diffColor, gdata.specColor, gdata.oneMinusReflectivity, gdata.smoothness, gdata.normalWorld, -gdata.eyeVec, occlusion, gi);
+	
     //res = OverlayHeatMap(numLightsProcessed, res);
 
     //UNITY_APPLY_FOG(i.fogCoord, res);

Assets/ScriptableRenderLoop/fptl/lightlistbuild-clustered.compute

 	const int N = (const int) LimitPow2AndClamp((unsigned int) length, MAX_NR_COARSE_ENTRIES);			// N is 1 when length is zero but will still not enter first for-loop
 
 	// bitonic sort can only handle arrays with a power of two length. Fill remaining entries with greater than possible index.
-	for(int t=length+localThreadID; t<N; t+=NR_THREADS) { coarseList[t]=MAX_NR_COARSE_ENTRIES; }		// impossible index
+	for(int t=length+localThreadID; t<N; t+=NR_THREADS) { coarseList[t]=0xffffffff; }		// impossible index
 	GroupMemoryBarrierWithGroupSync();
 
 	for(int k=2; k<=N; k=2*k)

Assets/ScriptableRenderLoop/fptl/lightlistbuild.compute

 	const int N = (const int) LimitPow2AndClamp((unsigned int) length, MAX_NR_COARSE_ENTRIES);			// N is 1 when length is zero but will still not enter first for-loop
 
 	// bitonic sort can only handle arrays with a power of two length. Fill remaining entries with greater than possible index.
-	for(int t=length+localThreadID; t<N; t+=NR_THREADS) { prunedList[t]=MAX_NR_COARSE_ENTRIES; }		// impossible index
+	for(int t=length+localThreadID; t<N; t+=NR_THREADS) { prunedList[t]=0xffffffff; }		// impossible index
 	GroupMemoryBarrierWithGroupSync();
 
 	for(int k=2; k<=N; k=2*k)

Assets/ScriptableRenderLoop/fptl/renderloopfptl.asset

   deferredReflectionShader: {fileID: 4800000, guid: 3899e06d641c2cb4cbff794df0da536b,
     type: 3}
   finalPassShader: {fileID: 4800000, guid: 5590f54ad211f594da4e687b698f2258, type: 3}
+  debugLightBoundsShader: {fileID: 4800000, guid: 33f2a444e9120d34396d41e40795d712,
+    type: 3}
   buildScreenAABBShader: {fileID: 7200000, guid: e7a739144e735934b89a42a4b9d9e23c,
     type: 3}
   buildPerTileLightListShader: {fileID: 7200000, guid: f54ef7cb596a714488693ef9cdaf63fb,
-  EnableClustered: 0
+  enableClustered: 0
+  enableDrawLightBoundsDebug: 1

Assets/ShaderGenerator/CSharpToHLSL.cs

 using System.Reflection;
 using UnityEditor;
 
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     public class CSharpToHLSL
     {

Assets/ShaderGenerator/ShaderGeneratorMenu.cs

-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     public class ShaderGeneratorMenu
     {

Assets/ShaderGenerator/ShaderTypeGeneration.cs

 using System.Collections.Generic;
 using System.Reflection;
 
-namespace UnityEngine.ScriptableRenderLoop
+namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     public enum PackingRules
     {

Assets/TestScenes/HDTest/Leaf/GroundLeaf/Materials/GroundLeaf_Albedo.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: GroundLeaf_Albedo
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _DOUBLESIDED_LIGHTING_FLIP _EMISSION _MASKMAP _METALLICGLOSSMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Blue_Alpha.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Blue_Alpha
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_CustomRenderQueue: -1
-  stringTagMap: {}
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
   m_SavedProperties:
     serializedVersion: 2
     m_TexEnvs:

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/CubeTransparent.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: CubeTransparent
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Gray.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Gray
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Green.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Green
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Ground/Ground_01_2x2.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Ground_01_2x2
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Ground/Needle_Moss_1x1.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Needle_Moss_1x1
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Ground/Sand_02_2x2_02.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Sand_02_2x2_02
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Layered.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Layered
-  m_Shader: {fileID: 4800000, guid: 81d02e8644315b742b154842a3a2f98c, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS _LAYERMASKMAP _MASKMAP _NORMALMAP
     _NORMALMAP_TANGENT_SPACE
   m_SavedProperties:
     serializedVersion: 2
     m_TexEnvs:
+    - first:
+        name: _BaseColorMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - first:
         name: _BaseColorMap0
       second:
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - first:
+        name: _DiffuseLightingMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
         name: _EmissionMap
       second:
         m_Texture: {fileID: 0}
+        name: _EmissiveColorMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
         name: _EmissiveColorMap0
       second:
         m_Texture: {fileID: 0}
         m_Offset: {x: 0, y: 0}
     - first:
         name: _EmissiveColorMap3
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _HeightMap
       second:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - first:
+        name: _MaskMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
         name: _MaskMap0
       second:
         m_Texture: {fileID: 2800000, guid: eddc784b66d317641bd2c3b078a694b1, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - first:
+        name: _NormalMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
         name: _NormalMap0
       second:
         m_Texture: {fileID: 2800000, guid: d896c388b98bb614ebe6bb48e0f56dcf, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - first:
+        name: _SpecularOcclusionMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
         name: _SpecularOcclusionMap0
       second:
         m_Texture: {fileID: 0}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - first:
+        name: _SubSurfaceRadiusMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     m_Floats:
     - first:
         name: _AlphaCutoff
         name: _EmissiveColorMode
       second: 1
     - first:
+        name: _EmissiveIntensity
+      second: 0
+    - first:
         name: _EmissiveIntensity0
       second: 0
     - first:
     - first:
         name: _GlossyReflections
       second: 1
+    - first:
+        name: _HeightBias
+      second: 0
     - first:
         name: _HeightBias0
       second: 0
         name: _HeightMapMode
       second: 0
     - first:
+        name: _HeightScale
+      second: 1
+    - first:
         name: _HeightScale0
       second: 1
     - first:
       second: 4
     - first:
         name: _MaterialId
+      second: 0
+    - first:
+        name: _Metalic
       second: 0
     - first:
         name: _Metalic0
     - first:
         name: _Parallax
       second: 0.02
+    - first:
+        name: _Smoothness
+      second: 0.5
     - first:
         name: _Smoothness0
       second: 1
         name: _SrcBlend
       second: 1
     - first:
+        name: _SubSurfaceRadius
+      second: 0
+    - first:
         name: _SurfaceType
       second: 0
     - first:
       second: 1
     m_Colors:
     - first:
+        name: _BaseColor
+      second: {r: 1, g: 1, b: 1, a: 1}
+    - first:
         name: _BaseColor0
       second: {r: 1, g: 1, b: 1, a: 1}
     - first:
       second: {r: 1, g: 1, b: 1, a: 1}
     - first:
         name: _EmissionColor
+      second: {r: 0, g: 0, b: 0, a: 1}
+    - first:
+        name: _EmissiveColor
       second: {r: 0, g: 0, b: 0, a: 1}
     - first:
         name: _EmissiveColor0

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Red.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Red
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Terrain.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Terrain
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/test-alpha.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: test-alpha
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_CustomRenderQueue: -1
-  stringTagMap: {}
+  m_CustomRenderQueue: 2450
+  stringTagMap:
+    RenderType: TransparentCutout
   m_SavedProperties:
     serializedVersion: 2
     m_TexEnvs:

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/test-transparent.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: test-transparent
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/test-twosidedLighting.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: test-twosidedLighting
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _DOUBLESIDED_LIGHTING_FLIP _EMISSION _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

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

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: test
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Rock/rcgRock012/Materials/rcgRock012Material.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: rcgRock012Material
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _DOUBLESIDEDLIGTHING_OFF _DOUBLESIDED_OFF _EMISSION _METALLICGLOSSMAP _NORMALMAP
     _NORMALMAP_TANGENT_SPACE

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_0.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_0
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_1.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_1
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_2.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_2
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_3.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_3
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_4.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_4
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_5.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_5
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_6.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_6
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_7.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_7
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_8.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_8
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth0_9.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth0_9
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smooth1_1.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smooth1_1
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_0.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_0
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_1.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_1
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_2.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_2
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_3.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_3
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_4.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_4
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_5.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_5
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_6.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_6
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_7.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_7
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_8.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_8
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric0_9.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric0_9
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/TestScenes/HDTest/Spheres/Mat_smoothdielectric1_0.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_smoothdielectric1_0
-  m_Shader: {fileID: 4800000, guid: ef966ed93e262964781047eaf96991db, type: 3}
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/LayeredLit/LayeredLitCommon.hlsl.meta

+fileFormatVersion: 2
+guid: 4475f12491047e54d9ddd0a61e36ead2
+timeCreated: 1476924487
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+// No guard header!
+
+//-------------------------------------------------------------------------------------
+// FragInput
+// This structure gather all possible varying/interpolator for this shader.
+//-------------------------------------------------------------------------------------
+
+struct FragInput
+{
+    float4 positionHS;
+    float3 positionWS;
+    float2 texCoord0;
+    float2 texCoord1;
+    float2 texCoord2;
+    float3 tangentToWorld[3];
+    bool isFrontFace;
+};
+
+//-------------------------------------------------------------------------------------
+// Fill SurfaceData/Builtin data function
+//-------------------------------------------------------------------------------------
+
+void GetSurfaceAndBuiltinData(FragInput input, out SurfaceData surfaceData, out BuiltinData builtinData)
+{    
+#ifdef _HEIGHTMAP
+    // TODO: in case of shader graph, a node like parallax must be nullify if use to generate code for Meta pass
+    #ifndef _HEIGHTMAP_AS_DISPLACEMENT
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS); // This should be remove by the compiler as we usually cal it before.
+    float height = UNITY_SAMPLE_TEX2D(_HeightMap, input.texCoord0).r * _HeightScale + _HeightBias;
+    // Transform view vector in tangent space
+    TransformWorldToTangent(V, input.tangentToWorld);
+    float2 offset = ParallaxOffset(viewDirTS, height);
+    input.texCoord0 += offset;
+    input.texCoord1 += offset;
+    #endif
+#endif
+
+    surfaceData.baseColor = UNITY_SAMPLE_TEX2D(_BaseColorMap, input.texCoord0).rgb * _BaseColor.rgb;
+#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    float alpha = _BaseColor.a;
+#else
+    float alpha = UNITY_SAMPLE_TEX2D(_BaseColorMap, input.texCoord0).a * _BaseColor.a;
+#endif
+
+#ifdef _ALPHATEST_ON
+    clip(alpha - _AlphaCutoff);
+#endif
+
+#ifdef _SPECULAROCCLUSIONMAP
+    // TODO: Do something. For now just take alpha channel
+    surfaceData.specularOcclusion = UNITY_SAMPLE_TEX2D(_SpecularOcclusionMap, input.texCoord0).a;
+#else
+    // Horizon Occlusion for Normal Mapped Reflections: http://marmosetco.tumblr.com/post/81245981087
+    //surfaceData.specularOcclusion = saturate(1.0 + horizonFade * dot(r, input.tangentToWorld[2].xyz);
+    // smooth it
+    //surfaceData.specularOcclusion *= surfaceData.specularOcclusion;
+    surfaceData.specularOcclusion = 1.0;
+#endif
+
+    // TODO: think about using BC5
+    float3 vertexNormalWS = input.tangentToWorld[2].xyz;
+
+#ifdef _NORMALMAP
+    #ifdef _NORMALMAP_TANGENT_SPACE
+    float3 normalTS = UnpackNormalAG(UNITY_SAMPLE_TEX2D(_NormalMap, input.texCoord0));
+    surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
+    #else // Object space (TODO: We need to apply the world rotation here! - Require to pass world transform)
+    surfaceData.normalWS = UNITY_SAMPLE_TEX2D(_NormalMap, input.texCoord0).rgb;
+    #endif
+#else
+    surfaceData.normalWS = vertexNormalWS;
+#endif
+
+#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
+    #ifdef _DOUBLESIDED_LIGHTING_FLIP
+    float3 oppositeNormalWS = -surfaceData.normalWS;
+    #else
+    // Mirror the normal with the plane define by vertex normal
+    float3 oppositeNormalWS = reflect(surfaceData.normalWS, vertexNormalWS);
+#endif
+    // TODO : Test if GetOdddNegativeScale() is necessary here in case of normal map, as GetOdddNegativeScale is take into account in CreateTangentToWorld();
+    surfaceData.normalWS =  input.isFrontFace ? 
+                                (GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS) :
+                                (-GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS);
+#endif
+
+#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    surfaceData.perceptualSmoothness = UNITY_SAMPLE_TEX2D(_BaseColorMap, input.texCoord0).a;
+#elif defined(_MASKMAP)
+    surfaceData.perceptualSmoothness = UNITY_SAMPLE_TEX2D(_MaskMap, input.texCoord0).a;
+#else
+    surfaceData.perceptualSmoothness = 1.0;
+#endif
+    surfaceData.perceptualSmoothness *= _Smoothness;
+
+    surfaceData.materialId = 0;
+
+    // MaskMap is Metallic, Ambient Occlusion, (Optional) - emissive Mask, Optional - Smoothness (in alpha)
+#ifdef _MASKMAP
+    surfaceData.metallic = UNITY_SAMPLE_TEX2D(_MaskMap, input.texCoord0).r;
+    surfaceData.ambientOcclusion = UNITY_SAMPLE_TEX2D(_MaskMap, input.texCoord0).g;
+#else
+    surfaceData.metallic = 1.0;
+    surfaceData.ambientOcclusion = 1.0;
+#endif
+    surfaceData.metallic *= _Metallic;
+
+
+    surfaceData.tangentWS = input.tangentToWorld[0].xyz; // TODO: do with tangent same as with normal, sample into texture etc...
+    surfaceData.anisotropy = 0;
+    surfaceData.specular = 0.04;
+
+    surfaceData.subSurfaceRadius = 1.0;
+    surfaceData.thickness = 0.0;
+    surfaceData.subSurfaceProfile = 0;
+
+    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
+    surfaceData.coatPerceptualSmoothness = 1.0;
+    surfaceData.specularColor = float3(0.0, 0.0, 0.0);
+
+
+    // Builtin Data
+    builtinData.opacity = alpha;
+
+    // TODO: Sample lightmap/lightprobe/volume proxy
+    // This should also handle projective lightmap
+    // Note that data input above can be use to sample into lightmap (like normal)
+    builtinData.bakeDiffuseLighting = UNITY_SAMPLE_TEX2D(_DiffuseLightingMap, input.texCoord1).rgb;
+
+    // If we chose an emissive color, we have a dedicated texture for it and don't use MaskMap
+#ifdef _EMISSIVE_COLOR
+    #ifdef _EMISSIVE_COLOR_MAP
+    builtinData.emissiveColor = UNITY_SAMPLE_TEX2D(_EmissiveColorMap, input.texCoord0).rgb * _EmissiveColor;
+    #else
+    builtinData.emissiveColor = _EmissiveColor;
+    #endif
+#elif defined(_MASKMAP) // If we have a MaskMap, use emissive slot as a mask on baseColor
+    builtinData.emissiveColor = surfaceData.baseColor * UNITY_SAMPLE_TEX2D(_MaskMap, input.texCoord0).bbb;
+#else
+    builtinData.emissiveColor = float3(0.0, 0.0, 0.0);
+#endif
+
+    builtinData.emissiveIntensity = _EmissiveIntensity;
+
+    builtinData.velocity = float2(0.0, 0.0);
+
+    builtinData.distortion = float2(0.0, 0.0);
+    builtinData.distortionBlur = 0.0;
+}

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

+fileFormatVersion: 2
+guid: c4a6d6f92d4f44d47b369e7a13250e0a
+timeCreated: 1477003836
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+Shader "Unity/Lit"
+{
+    Properties
+    {
+        // Following set of parameters represent the parameters node inside the MaterialGraph.
+        // They are use to fill a SurfaceData. With a MaterialGraph this should not exist.
+
+        // Reminder. Color here are in linear but the UI (color picker) do the conversion sRGB to linear
+        _BaseColor("BaseColor", Color) = (1,1,1,1)
+        _BaseColorMap("BaseColorMap", 2D) = "white" {}
+
+        _Metallic("_Metallic", Range(0.0, 1.0)) = 0
+        _Smoothness("Smoothness", Range(0.0, 1.0)) = 0.5
+        _MaskMap("MaskMap", 2D) = "white" {}
+
+        _SpecularOcclusionMap("SpecularOcclusion", 2D) = "white" {}
+
+        _NormalMap("NormalMap", 2D) = "bump" {}
+        [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
+
+        _HeightMap("HeightMap", 2D) = "black" {}
+        _HeightScale("Height Scale", Float) = 1
+        _HeightBias("Height Bias", Float) = 0
+        [Enum(Parallax, 0, Displacement, 1)] _HeightMapMode("Heightmap usage", Float) = 0
+
+        _SubSurfaceRadius("SubSurfaceRadius", Range(0.0, 1.0)) = 0
+        _SubSurfaceRadiusMap("SubSurfaceRadiusMap", 2D) = "white" {}
+        //_Thickness("Thickness", Range(0.0, 1.0)) = 0
+        //_ThicknessMap("ThicknessMap", 2D) = "white" {}
+        //_SubSurfaceProfile("SubSurfaceProfile", Float) = 0
+
+        //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
+        //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
+
+        //_CoatRoughness("CoatRoughness", Range(0.0, 1.0)) = 0
+        //_CoatRoughnessMap("CoatRoughnessMap", 2D) = "white" {}
+
+        // _DistortionVectorMap("DistortionVectorMap", 2D) = "white" {}
+        // _DistortionBlur("DistortionBlur", Range(0.0, 1.0)) = 0
+
+        // Following options are for the GUI inspector and different from the input parameters above
+        // These option below will cause different compilation flag.
+
+        _DiffuseLightingMap("DiffuseLightingMap", 2D) = "black" {}
+        _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
+        _EmissiveColorMap("EmissiveColorMap", 2D) = "white" {}
+        _EmissiveIntensity("EmissiveIntensity", Float) = 0
+
+        [ToggleOff]     _DistortionOnly("Distortion Only", Float) = 0.0
+        [ToggleOff]     _DistortionDepthTest("Distortion Only", Float) = 0.0
+
+        [ToggleOff]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
+        _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+
+        // Blending state
+        [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
+        [HideInInspector] _BlendMode ("__blendmode", Float) = 0.0
+        [HideInInspector] _SrcBlend ("__src", Float) = 1.0
+        [HideInInspector] _DstBlend ("__dst", Float) = 0.0
+        [HideInInspector] _ZWrite ("__zw", Float) = 1.0
+        [HideInInspector] _CullMode("__cullmode", Float) = 2.0
+        // Material Id
+        [HideInInspector] _MaterialId("_MaterialId", FLoat) = 0
+
+        [Enum(Mask Alpha, 0, BaseColor Alpha, 1)] _SmoothnessTextureChannel("Smoothness texture channel", Float) = 1
+        [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
+        [Enum(None, 0, DoubleSided, 1, DoubleSidedLigthingFlip, 2, DoubleSidedLigthingMirror, 3)] _DoubleSidedMode("Double sided mode", Float) = 0
+    }
+
+    HLSLINCLUDE
+
+    #pragma target 5.0
+    #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
+
+    //-------------------------------------------------------------------------------------
+    // Variant
+    //-------------------------------------------------------------------------------------
+
+    #pragma shader_feature _ALPHATEST_ON
+    #pragma shader_feature _ _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
+    #pragma shader_feature _NORMALMAP
+    #pragma shader_feature _NORMALMAP_TANGENT_SPACE
+    #pragma shader_feature _MASKMAP
+    #pragma shader_feature _SPECULAROCCLUSIONMAP
+    #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    #pragma shader_feature _EMISSIVE_COLOR
+    #pragma shader_feature _EMISSIVE_COLOR_MAP
+    #pragma shader_feature _HEIGHTMAP
+    #pragma shader_feature _HEIGHTMAP_AS_DISPLACEMENT
+
+    #pragma multi_compile _ LIGHTMAP_ON
+    #pragma multi_compile _ DIRLIGHTMAP_COMBINED
+    #pragma multi_compile _ DYNAMICLIGHTMAP_ON
+
+    //-------------------------------------------------------------------------------------
+    // Define
+    //-------------------------------------------------------------------------------------
+
+    #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
+
+    //-------------------------------------------------------------------------------------
+    // Include
+    //-------------------------------------------------------------------------------------
+
+    #include "common.hlsl"
+    #include "../../ShaderPass/ShaderPass.cs.hlsl"
+    #include "../../ShaderVariables.hlsl"
+    #include "../../Debug/DebugViewMaterial.hlsl"
+
+    //-------------------------------------------------------------------------------------
+    // variable declaration
+    //-------------------------------------------------------------------------------------
+
+    // Set of users variables
+    float4 _BaseColor;
+    UNITY_DECLARE_TEX2D(_BaseColorMap);
+
+    float _Metallic;
+    float _Smoothness;
+    UNITY_DECLARE_TEX2D(_MaskMap);
+    UNITY_DECLARE_TEX2D(_SpecularOcclusionMap);
+
+    UNITY_DECLARE_TEX2D(_NormalMap);
+    UNITY_DECLARE_TEX2D(_Heightmap);
+    float _HeightScale;
+    float _HeightBias;
+
+    UNITY_DECLARE_TEX2D(_DiffuseLightingMap);
+    float4 _EmissiveColor;
+    UNITY_DECLARE_TEX2D(_EmissiveColorMap);
+    float _EmissiveIntensity;
+
+    float _SubSurfaceRadius;
+    UNITY_DECLARE_TEX2D(_SubSurfaceRadiusMap);
+    // float _Thickness;
+    // UNITY_DECLARE_TEX2D(_ThicknessMap);
+
+    // float _CoatCoverage;
+    // UNITY_DECLARE_TEX2D(_CoatCoverageMap);
+
+    // float _CoatRoughness;
+    // UNITY_DECLARE_TEX2D(_CoatRoughnessMap);
+
+    float _AlphaCutoff;
+
+    ENDHLSL
+
+    SubShader
+    {
+        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
+        LOD 300
+
+        // ------------------------------------------------------------------
+        //  Deferred pass
+        Pass
+        {
+            Name "GBuffer"  // Name is not used
+            Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
+
+            Cull  [_CullMode]
+
+            HLSLPROGRAM
+
+            #pragma vertex VertDefault
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_GBUFFER
+            #include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
+            #include "LitData.hlsl"
+            #include "LitShare.hlsl"            
+
+            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
+
+            ENDHLSL
+        }
+
+        // ------------------------------------------------------------------
+        //  Debug pass
+        Pass
+        {
+            Name "Debug"
+            Tags { "LightMode" = "DebugViewMaterial" }
+
+            Cull[_CullMode]
+
+            HLSLPROGRAM
+
+            #pragma vertex VertDefault
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_DEBUG_VIEW_MATERIAL
+            #include "../../Material/Material.hlsl"
+            #include "LitData.hlsl"
+            #include "LitShare.hlsl"
+
+            void GetVaryingsDataDebug(uint paramId, FragInput input, inout float3 result, inout bool needLinearToSRGB)
+            {
+                switch (paramId)
+                {
+                case DEBUGVIEW_VARYING_DEPTH:
+                    // TODO: provide a customize parameter (like a slider)
+                    float linearDepth = frac(LinearEyeDepth(input.positionHS.z, _ZBufferParams) * 0.1);
+                    result = linearDepth.xxx;
+                    break;
+                case DEBUGVIEW_VARYING_TEXCOORD0:
+                    result = float3(input.texCoord0 * 0.5 + 0.5, 0.0);
+                    break;
+                case DEBUGVIEW_VARYING_TEXCOORD1:
+                    result = float3(input.texCoord1 * 0.5 + 0.5, 0.0);
+                    break;
+                case DEBUGVIEW_VARYING_TEXCOORD2:
+                    result = float3(input.texCoord2 * 0.5 + 0.5, 0.0);
+                    break;
+                case DEBUGVIEW_VARYING_VERTEXTANGENTWS:
+                    result = input.tangentToWorld[0].xyz * 0.5 + 0.5;
+                    break;
+                case DEBUGVIEW_VARYING_VERTEXBITANGENTWS:
+                    result = input.tangentToWorld[1].xyz * 0.5 + 0.5;
+                    break;
+                case DEBUGVIEW_VARYING_VERTEXNORMALWS:
+                    result = input.tangentToWorld[2].xyz * 0.5 + 0.5;
+                    break;
+                }
+            }
+            
+            #include "../../ShaderPass/ShaderPassDebugViewMaterial.hlsl"
+
+            ENDHLSL
+        }
+
+        // ------------------------------------------------------------------
+        // Extracts information for lightmapping, GI (emission, albedo, ...)
+        // This pass it not used during regular rendering.
+        Pass
+        {
+            Name "META"
+            Tags{ "LightMode" = "Meta" }
+
+            Cull Off
+
+            HLSLPROGRAM
+
+            // Lightmap memo
+            // DYNAMICLIGHTMAP_ON is used when we have an "enlighten lightmap" ie a lightmap updated at runtime by enlighten.This lightmap contain indirect lighting from realtime lights and realtime emissive material.Offline baked lighting(from baked material / light, 
+            // both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON.
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
+            #include "../../Material/Material.hlsl"
+            #include "LitData.hlsl"
+
+            CBUFFER_START(UnityMetaPass)
+            // x = use uv1 as raster position
+            // y = use uv2 as raster position
+            bool4 unity_MetaVertexControl;
+
+            // x = return albedo
+            // y = return normal
+            bool4 unity_MetaFragmentControl;
+
+            CBUFFER_END
+
+            // This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
+            float unity_OneOverOutputBoost;
+            float unity_MaxOutputValue;
+
+            struct Attributes
+            {
+                float3 positionOS : POSITION;
+                float3 normalOS : NORMAL;
+                float2 uv0 : TEXCOORD0;
+                float2 uv1 : TEXCOORD1;
+                float2 uv2 : TEXCOORD2;
+                float4 tangentOS : TANGENT;
+            };
+
+            struct Varyings
+            {
+                float4 positionHS;
+                float2 texCoord0;
+                float2 texCoord1;
+            };
+
+            struct PackedVaryings
+            {
+                float4 positionHS : SV_Position;
+                float4 interpolators[1] : TEXCOORD0;
+            };
+
+            // Function to pack data to use as few interpolator as possible, the ShaderGraph should generate these functions
+            PackedVaryings PackVaryings(Varyings input)
+            {
+                PackedVaryings output;
+                output.positionHS = input.positionHS;
+                output.interpolators[0].xy = input.texCoord0;
+                output.interpolators[0].zw = input.texCoord1;
+
+                return output;
+            }
+
+            FragInput UnpackVaryings(PackedVaryings input)
+            {
+                FragInput output;
+                ZERO_INITIALIZE(FragInput, output);
+
+                output.positionHS = input.positionHS;
+                output.texCoord0 = input.interpolators[0].xy;
+                output.texCoord1 = input.interpolators[0].zw;
+
+                return output;
+            }
+
+            PackedVaryings Vert(Attributes input)
+            {
+                Varyings output;
+
+                // Output UV coordinate in vertex shader
+                if (unity_MetaVertexControl.x)
+                {
+                    input.positionOS.xy = input.uv1 * unity_LightmapST.xy + unity_LightmapST.zw;
+                    // OpenGL right now needs to actually use incoming vertex position,
+                    // so use it in a very dummy way
+                    //v.positionOS.z = vertex.z > 0 ? 1.0e-4f : 0.0f;
+                }
+                if (unity_MetaVertexControl.y)
+                {
+                    input.positionOS.xy = input.uv2 * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
+                    // OpenGL right now needs to actually use incoming vertex position,
+                    // so use it in a very dummy way
+                    //v.positionOS.z = vertex.z > 0 ? 1.0e-4f : 0.0f;
+                }
+
+                float3 positionWS = TransformObjectToWorld(input.positionOS);
+                output.positionHS = TransformWorldToHClip(positionWS);
+                output.texCoord0 = input.uv0;
+                output.texCoord1 = input.uv1;
+
+                return PackVaryings(output);
+            }
+
+            #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
+
+            ENDHLSL
+        }
+
+        // ------------------------------------------------------------------
+        //  Depth only
+        Pass
+        {
+            Name "DepthOnly" // Name is not used
+            Tags { "LightMode" = "DepthOnly" } // This will be only for transparent object based on the RenderQueue index
+
+            Blend [_SrcBlend] [_DstBlend]
+            ZWrite [_ZWrite]
+            Cull [_CullMode]
+
+            HLSLPROGRAM
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "../../Material/Material.hlsl"            
+            #include "LitData.hlsl"
+
+            struct Attributes
+            {
+                float3 positionOS : POSITION;
+                float2 uv0 : TEXCOORD0;
+                #if defined(_HEIGHTMAP) && !defined (_HEIGHTMAP_AS_DISPLACEMENT)
+                float4 tangentOS : TANGENT;
+                #endif
+            };
+
+            struct Varyings
+            {
+                float4 positionHS;
+                float2 texCoord0;
+                #if defined(_HEIGHTMAP) && !defined (_HEIGHTMAP_AS_DISPLACEMENT)
+                float3 positionWS;                
+                float3 tangentToWorld[3];
+                #endif
+            };
+
+            struct PackedVaryings
+            {
+                float4 positionHS : SV_Position;
+                #if defined(_HEIGHTMAP) && !defined (_HEIGHTMAP_AS_DISPLACEMENT)
+                float4 interpolators[4] : TEXCOORD0;
+                #else
+                float4 interpolators[1] : TEXCOORD0;
+                #endif
+            };
+
+            // Function to pack data to use as few interpolator as possible, the ShaderGraph should generate these functions
+            PackedVaryings PackVaryings(Varyings input)
+            {
+                PackedVaryings output;
+                output.positionHS = input.positionHS;
+                #if defined(_HEIGHTMAP) && !defined (_HEIGHTMAP_AS_DISPLACEMENT)
+                output.interpolators[0].xyz = input.positionWS.xyz;
+                output.interpolators[1].xyz = input.tangentToWorld[0];
+                output.interpolators[2].xyz = input.tangentToWorld[1];
+                output.interpolators[3].xyz = input.tangentToWorld[2];
+
+                output.interpolators[0].w = input.texCoord0.x;
+                output.interpolators[1].w = input.texCoord0.y;                
+                #else
+                output.interpolators[0] = float4(input.texCoord0, 0.0, 0.0);
+                #endif
+
+                return output;
+            }
+
+            FragInput UnpackVaryings(PackedVaryings input)
+            {
+                FragInput output;
+                ZERO_INITIALIZE(FragInput, output);
+
+                output.positionHS = input.positionHS;
+                #if defined(_HEIGHTMAP) && !defined (_HEIGHTMAP_AS_DISPLACEMENT)
+                output.positionWS.xyz = input.interpolators[0].xyz;
+                output.tangentToWorld[0] = input.interpolators[1].xyz;
+                output.tangentToWorld[1] = input.interpolators[2].xyz;
+                output.tangentToWorld[2] = input.interpolators[3].xyz;
+
+                output.texCoord0.xy = float2(input.interpolators[0].w, input.interpolators[1].w);
+                #else
+                output.texCoord0.xy = input.interpolators[0].xy;
+                #endif
+
+                return output;
+            }
+
+            PackedVaryings Vert(Attributes input)
+            {
+                Varyings output;
+
+                float3 positionWS = TransformObjectToWorld(input.positionOS);
+                output.positionHS = TransformWorldToHClip(positionWS);                
+
+                output.texCoord0 = input.uv0;
+
+                #if defined(_HEIGHTMAP) && !defined (_HEIGHTMAP_AS_DISPLACEMENT)
+                output.positionWS = positionWS;
+
+                float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
+                float4 tangentWS = float4(TransformObjectToWorldDir(input.tangentOS.xyz), input.tangentOS.w);
+
+                float3x3 tangentToWorld = CreateTangentToWorld(normalWS, tangentWS.xyz, tangentWS.w);
+                output.tangentToWorld[0] = tangentToWorld[0];
+                output.tangentToWorld[1] = tangentToWorld[1];
+                output.tangentToWorld[2] = tangentToWorld[2];
+                #endif
+
+                return PackVaryings(output);
+            }
+
+            #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
+
+            ENDHLSL
+        }
+
+        // ------------------------------------------------------------------
+        //  forward pass
+        Pass
+        {
+            Name "Forward" // Name is not used
+            Tags { "LightMode" = "Forward" } // This will be only for transparent object based on the RenderQueue index
+
+            Blend [_SrcBlend] [_DstBlend]
+            ZWrite [_ZWrite]
+            Cull [_CullMode]
+
+            HLSLPROGRAM
+
+            #pragma vertex VertDefault
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../Lighting/Lighting.hlsl"
+            #include "LitData.hlsl"
+            #include "LitShare.hlsl"
+
+            #include "../../ShaderPass/ShaderPassForward.hlsl"
+
+            ENDHLSL
+        }
+    }
+
+    CustomEditor "LitGUI"
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Lit/LitDefault.shader.meta

+fileFormatVersion: 2
+guid: 6e4ae4064600d784cac1e41a9e6f2e59
+timeCreated: 1477003836
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+// No guard header!
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Env - Reference
+// ----------------------------------------------------------------------------
+
+// Ref: Moving Frostbite to PBR (Appendix A)
+float3 IntegrateLambertIBLRef(  EnvLightData lightData, BSDFData bsdfData,
+                                UNITY_ARGS_ENV(_EnvTextures),
+                                uint sampleCount = 2048)
+{
+    float3 N        = bsdfData.normalWS;
+    float3 acc      = float3(0.0, 0.0, 0.0);
+    // Add some jittering on Hammersley2d
+    float2 randNum  = InitRandom(N.xy * 0.5 + 0.5);
+
+    float3 tangentX, tangentY;
+    GetLocalFrame(N, tangentX, tangentY);
+
+    for (uint i = 0; i < sampleCount; ++i)
+    {
+        float2 u    = Hammersley2d(i, sampleCount);
+        u           = frac(u + randNum + 0.5);
+
+        float3 L;
+        float NdotL;
+        float weightOverPdf;
+        ImportanceSampleLambert(u, N, tangentX, tangentY, L, NdotL, weightOverPdf);
+
+        if (NdotL > 0.0)
+        {
+            float4 val = UNITY_SAMPLE_ENV_LOD(_EnvTextures, L, lightData, 0);
+
+            // diffuse Albedo is apply here as describe in ImportanceSampleLambert function
+            acc += bsdfData.diffuseColor * Lambert() * weightOverPdf * val.rgb;
+        }
+    }
+
+    return acc / sampleCount;
+}
+
+float3 IntegrateDisneyDiffuseIBLRef(float3 V, EnvLightData lightData, BSDFData bsdfData,
+                                    UNITY_ARGS_ENV(_EnvTextures),
+                                    uint sampleCount = 2048)
+{
+    float3 N = bsdfData.normalWS;
+    float NdotV = dot(N, V);
+    float3 acc  = float3(0.0, 0.0, 0.0);
+    // Add some jittering on Hammersley2d
+    float2 randNum  = InitRandom(N.xy * 0.5 + 0.5);
+
+    float3 tangentX, tangentY;
+    GetLocalFrame(N, tangentX, tangentY);
+
+    for (uint i = 0; i < sampleCount; ++i)
+    {
+        float2 u    = Hammersley2d(i, sampleCount);
+        u           = frac(u + randNum + 0.5);
+
+        float3 L;
+        float NdotL;
+        float weightOverPdf;
+        // for Disney we still use a Cosine importance sampling, true Disney importance sampling imply a look up table
+        ImportanceSampleLambert(u, N, tangentX, tangentY, L, NdotL, weightOverPdf);
+
+        if (NdotL > 0.0)
+        {            
+            float3 H = normalize(L + V);
+            float LdotH = dot(L, H);
+            // Note: we call DisneyDiffuse that require to multiply by Albedo / PI. Divide by PI is already taken into account
+            // in weightOverPdf of ImportanceSampleLambert call.
+            float disneyDiffuse = DisneyDiffuse(NdotV, NdotL, LdotH, bsdfData.perceptualRoughness);
+
+            // diffuse Albedo is apply here as describe in ImportanceSampleLambert function
+            float4 val = UNITY_SAMPLE_ENV_LOD(_EnvTextures, L, lightData, 0);
+            acc += bsdfData.diffuseColor * disneyDiffuse * weightOverPdf * val.rgb;
+        }
+    }
+
+    return acc / sampleCount;
+}
+
+// Ref: Moving Frostbite to PBR (Appendix A)
+float3 IntegrateSpecularGGXIBLRef(  float3 V, EnvLightData lightData, BSDFData bsdfData,
+                                    UNITY_ARGS_ENV(_EnvTextures),
+                                    uint sampleCount = 2048)
+{
+    float3 N        = bsdfData.normalWS;
+    float NdotV     = saturate(dot(N, V));
+    float3 acc      = float3(0.0, 0.0, 0.0);
+
+    // Add some jittering on Hammersley2d
+    float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
+
+    float3 tangentX, tangentY;
+    GetLocalFrame(N, tangentX, tangentY);
+
+    for (uint i = 0; i < sampleCount; ++i)
+    {
+        float2 u    = Hammersley2d(i, sampleCount);
+        u           = frac(u + randNum + 0.5);
+
+        float VdotH;
+        float NdotL;
+        float3 L;
+        float weightOverPdf;
+
+        // GGX BRDF
+        ImportanceSampleGGX(u, V, N, tangentX, tangentY, bsdfData.roughness, NdotV,
+                            L, VdotH, NdotL, weightOverPdf);
+
+        if (NdotL > 0.0)
+        {
+            // Fresnel component is apply here as describe in ImportanceSampleGGX function
+            float3 FweightOverPdf = F_Schlick(bsdfData.fresnel0, VdotH) * weightOverPdf;
+
+            float4 val = UNITY_SAMPLE_ENV_LOD(_EnvTextures, L, lightData, 0);
+
+            acc += FweightOverPdf * val.rgb;
+        }
+    }
+
+    return acc / sampleCount;
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Env
+// ----------------------------------------------------------------------------
+
+// _preIntegratedFGD and _CubemapLD are unique for each BRDF
+void EvaluateBSDF_Env(  float3 V, float3 positionWS, PreLightData prelightData, EnvLightData lightData, BSDFData bsdfData,
+                        UNITY_ARGS_ENV(_EnvTextures),
+                        out float4 diffuseLighting,
+                        out float4 specularLighting)
+{
+#ifdef LIT_DISPLAY_REFERENCE
+
+    specularLighting.rgb = IntegrateSpecularGGXIBLRef(V, lightData, bsdfData, UNITY_PASS_ENV(_EnvTextures));
+    specularLighting.a = 1.0;
+
+/*
+    #ifdef DIFFUSE_LAMBERT_BRDF
+    diffuseLighting.rgb = IntegrateLambertIBLRef(lightData, bsdfData, UNITY_PASS_ENV(_EnvTextures));
+    #else
+    diffuseLighting.rgb = IntegrateDisneyDiffuseIBLRef(V, lightData, bsdfData, UNITY_PASS_ENV(_EnvTextures));
+    #endif
+    diffuseLighting.a = 1.0;
+*/
+    diffuseLighting = float4(0.0, 0.0, 0.0, 0.0);
+
+#else
+    // TODO: factor this code in common, so other material authoring don't require to rewrite everything, 
+    // also think about how such a loop can handle 2 cubemap at the same time as old unity. Macro can allow to do that
+    // but we need to have UNITY_SAMPLE_ENV_LOD replace by a true function instead that is define by the lighting arcitecture.
+    // Also not sure how to deal with 2 intersection....
+    // Box and sphere are related to light property (but we have also distance based roughness etc...)
+
+    // 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;
+    float weight = 1.0;
+
+    // In this code we redefine a bit the behavior of the reflcetion proble. We separate the projection volume (the proxy of the scene) form the influence volume (what pixel on the screen is affected)
+
+    // 1. First determine the projection volume
+    
+    // In Unity the cubemaps are capture with the localToWorld transform of the component. 
+    // This mean that location and oritention matter. So after intersection of proxy volume we need to convert back to world.
+    
+    // CAUTION: localToWorld is the transform use to convert the cubemap capture point to world space (mean it include the offset)
+    // the center of the bounding box is thus in locals space: positionLS - offsetLS
+    // We use this formulation as it is the one of legacy unity that was using only AABB box.
+
+    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.
+
+    if (lightData.envShapeType == ENVSHAPETYPE_BOX)
+    {
+        float3 rayLS = mul(rayWS, worldToLocal);
+        float3 boxOuterDistance = lightData.innerDistance + float3(lightData.blendDistance, lightData.blendDistance, lightData.blendDistance);
+        float dist = BoxRayIntersectSimple(positionLS, rayLS, -boxOuterDistance, boxOuterDistance);
+
+        // No need to normalize for fetching cubemap
+        // We can reuse dist calculate in LS directly in WS as there is no scaling. Also the offset is already include in lightData.positionWS
+        R = (positionWS + dist * rayWS) - lightData.positionWS;
+        
+        // TODO: add distance based roughness
+    } 
+    else if (lightData.envShapeType == ENVSHAPETYPE_SPHERE)
+    {
+        float3 rayLS = mul(rayWS, worldToLocal);
+        float sphereOuterDistance = lightData.innerDistance.x + lightData.blendDistance;
+        float dist = SphereRayIntersectSimple(positionLS, rayLS, sphereOuterDistance);
+
+        R = (positionWS + dist * rayWS) - lightData.positionWS;
+    }
+
+    // 2. Apply the influence volume (Box volume is used for culling whatever the influence shape)
+    // TODO: In the future we could have an influence volume inside the projection volume (so with a different transform, in this case we will need another transform)
+    if (lightData.envShapeType == ENVSHAPETYPE_SPHERE)
+    {
+        float distFade = max(length(positionLS) - lightData.innerDistance.x, 0.0);
+        weight = saturate(1.0 - distFade / max(lightData.blendDistance, 0.0001)); // avoid divide by zero
+    }
+    else // ENVSHAPETYPE_BOX or ENVSHAPETYPE_NONE 
+    {
+        // Calculate falloff value, so reflections on the edges of the volume would gradually blend to previous reflection.
+        float distFade = DistancePointBox(positionLS, -lightData.innerDistance, lightData.innerDistance);
+        weight = saturate(1.0 - distFade / max(lightData.blendDistance, 0.0001)); // avoid divide by zero
+    }
+
+    // Smooth weighting
+    weight = smoothstep01(weight);
+
+    // TODO: we must always perform a weight calculation as due to tiled rendering we need to smooth out cubemap at boundaries.
+    // So goal is to split into two category and have an option to say if we parallax correct or not.
+
+    // TODO: compare current Morten version: offline cubemap with a particular remap + the bias in perceptualRoughnessToMipmapLevel
+    // to classic remap like unreal/Frobiste. The function GetSpecularDominantDir can result in a better matching in this case
+    // We let GetSpecularDominantDir currently as it still an improvement but not as good as it could be
+    float mip = perceptualRoughnessToMipmapLevel(bsdfData.perceptualRoughness);
+    float4 preLD = UNITY_SAMPLE_ENV_LOD(_EnvTextures, R, lightData, mip);
+    specularLighting.rgb = preLD.rgb * prelightData.specularFGD;
+
+    // Apply specular occlusion on it
+    specularLighting.rgb *= bsdfData.specularOcclusion;
+    specularLighting.a = weight;
+
+    diffuseLighting = float4(0.0, 0.0, 0.0, 0.0);
+
+#endif    
+}
+

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Lit/LitEnvTemplate.hlsl.meta

+fileFormatVersion: 2
+guid: 22c20a34a48ade04daa95ffdc51ac052
+timeCreated: 1476997917
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+// No guard header!
+
+#ifndef SHADERPASS
+#error Undefine_SHADERPASS
+#endif
+
+//-------------------------------------------------------------------------------------
+// Attribute/Varying
+//-------------------------------------------------------------------------------------
+
+struct Attributes
+{
+    float3 positionOS   : POSITION;
+    float3 normalOS     : NORMAL;
+    float2 uv0          : TEXCOORD0;
+    float2 uv1		    : TEXCOORD1;
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+    float2 uv2		    : TEXCOORD2;
+#endif    
+    float4 tangentOS    : TANGENT;  // Always present as we require it also in case of anisotropic lighting
+
+    // UNITY_INSTANCE_ID
+};
+
+struct Varyings
+{
+    float4 positionHS;
+    float3 positionWS;
+    float2 texCoord0;
+    float2 texCoord1;
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+    float2 texCoord2;
+#endif
+    float3 tangentToWorld[3];
+};
+
+struct PackedVaryings
+{
+    float4 positionHS : SV_Position;
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+    float4 interpolators[5] : TEXCOORD0;
+#else
+    float4 interpolators[4] : TEXCOORD0;
+#endif
+
+#if SHADER_STAGE_FRAGMENT
+    #if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
+    FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMATIC;
+    #endif
+#endif
+};
+
+// Function to pack data to use as few interpolator as possible, the ShaderGraph should generate these functions
+PackedVaryings PackVaryings(Varyings input)
+{
+    PackedVaryings output;
+    output.positionHS = input.positionHS;
+    output.interpolators[0].xyz = input.positionWS.xyz;
+    output.interpolators[1].xyz = input.tangentToWorld[0];
+    output.interpolators[2].xyz = input.tangentToWorld[1];
+    output.interpolators[3].xyz = input.tangentToWorld[2];
+
+    output.interpolators[0].w = input.texCoord0.x;
+    output.interpolators[1].w = input.texCoord0.y;
+    output.interpolators[2].w = input.texCoord1.x;
+    output.interpolators[3].w = input.texCoord1.y;
+
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+    output.interpolators[4] = float4(input.texCoord2.xy, 0.0, 0.0);
+#endif
+
+    return output;
+}
+
+FragInput UnpackVaryings(PackedVaryings input)
+{
+    FragInput output;
+    ZERO_INITIALIZE(FragInput, output);
+
+    output.positionHS = input.positionHS;
+    output.positionWS.xyz = input.interpolators[0].xyz;
+    output.tangentToWorld[0] = input.interpolators[1].xyz;
+    output.tangentToWorld[1] = input.interpolators[2].xyz;
+    output.tangentToWorld[2] = input.interpolators[3].xyz;
+
+    output.texCoord0.xy = float2(input.interpolators[0].w, input.interpolators[1].w);
+    output.texCoord1.xy = float2(input.interpolators[2].w, input.interpolators[3].w);
+
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+    output.texCoord2 = input.interpolators[4].xy;
+#endif
+
+#if SHADER_STAGE_FRAGMENT
+    #if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
+    output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false);
+    #endif
+#endif
+
+    return output;
+}
+
+//-------------------------------------------------------------------------------------
+// Vertex shader
+//-------------------------------------------------------------------------------------
+
+// TODO: Here we will also have all the vertex deformation (GPU skinning, vertex animation, morph target...) or we will need to generate a compute shaders instead (better! but require work to deal with unpacking like fp16)
+PackedVaryings VertDefault(Attributes input)
+{
+    Varyings output;
+
+    output.positionWS = TransformObjectToWorld(input.positionOS);
+    // TODO deal with camera center rendering and instancing (This is the reason why we always perform tow steps transform to clip space + instancing matrix)
+    output.positionHS = TransformWorldToHClip(output.positionWS);
+
+    float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
+
+    output.texCoord0 = input.uv0;
+    output.texCoord1 = input.uv1;
+#if (DYNAMICLIGHTMAP_ON) || (SHADERPASS == SHADERPASS_DEBUG_VIEW_MATERIAL)
+    output.texCoord2 = input.uv2;
+#endif
+
+    float4 tangentWS = float4(TransformObjectToWorldDir(input.tangentOS.xyz), input.tangentOS.w);
+
+    float3x3 tangentToWorld = CreateTangentToWorld(normalWS, tangentWS.xyz, tangentWS.w);
+    output.tangentToWorld[0] = tangentToWorld[0];
+    output.tangentToWorld[1] = tangentToWorld[1];
+    output.tangentToWorld[2] = tangentToWorld[2];
+
+    return PackVaryings(output);
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Lit/LitShare.hlsl.meta

+fileFormatVersion: 2
+guid: 9e1065b7612f2bd4c918d79e8a7ea8a3
+timeCreated: 1477003836
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Unlit/Unlit.cs

+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using System;
+
+//-----------------------------------------------------------------------------
+// structure definition
+//-----------------------------------------------------------------------------
+namespace UnityEngine.Experimental.ScriptableRenderLoop
+{
+    namespace Unlit
+    {
+        //-----------------------------------------------------------------------------
+        // SurfaceData
+        //-----------------------------------------------------------------------------
+
+        // Main structure that store the user data (i.e user input of master node in material graph)
+        [GenerateHLSL(PackingRules.Exact, false, true, 1100)]
+        public struct SurfaceData
+        {
+            [SurfaceDataAttributes("Color")]
+            public Vector3 color;
+        };
+
+        //-----------------------------------------------------------------------------
+        // BSDFData
+        //-----------------------------------------------------------------------------
+
+        [GenerateHLSL(PackingRules.Exact, false, true, 1130)]
+        public struct BSDFData
+        {
+            public Vector3 color;
+        };
+    }
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Unlit/Unlit.cs.hlsl

+//
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Unlit/Unlit.cs.  Please don't edit by hand.
+//
+
+//
+// UnityEngine.Experimental.ScriptableRenderLoop.Unlit.SurfaceData:  static fields
+//
+#define DEBUGVIEW_UNLIT_SURFACEDATA_COLOR (1100)
+
+//
+// UnityEngine.Experimental.ScriptableRenderLoop.Unlit.BSDFData:  static fields
+//
+#define DEBUGVIEW_UNLIT_BSDFDATA_COLOR (1130)
+
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.Unlit.SurfaceData
+// PackingRules = Exact
+struct SurfaceData
+{
+	float3 color;
+};
+
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.Unlit.BSDFData
+// PackingRules = Exact
+struct BSDFData
+{
+	float3 color;
+};
+
+

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Unlit/Unlit.cs.hlsl.meta

+fileFormatVersion: 2
+guid: 69c83587055c7b1488151841534b03e1
+timeCreated: 1476887739
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Unlit/Unlit.cs.meta

+fileFormatVersion: 2
+guid: 442f2692415eb6d4ab434b389a186d4a
+timeCreated: 1476887639
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Unlit/UnlitData.hlsl

+// No guard header!
+
+//-------------------------------------------------------------------------------------
+// FragInput
+// This structure gather all possible varying/interpolator for this shader.
+//-------------------------------------------------------------------------------------
+
+struct FragInput
+{
+    float4 positionHS;
+    float2 texCoord0;
+};
+
+//-------------------------------------------------------------------------------------
+// Fill SurfaceData/Builtin data function
+//-------------------------------------------------------------------------------------
+
+void GetSurfaceAndBuiltinData(FragInput input, out SurfaceData surfaceData, out BuiltinData builtinData)
+{
+    surfaceData.color = UNITY_SAMPLE_TEX2D(_ColorMap, input.texCoord0).rgb * _Color.rgb;
+    float alpha = UNITY_SAMPLE_TEX2D(_ColorMap, input.texCoord0).a * _Color.a;
+
+#ifdef _ALPHATEST_ON
+    clip(alpha - _AlphaCutoff);
+#endif
+
+    // Builtin Data
+    builtinData.opacity = alpha;
+
+    builtinData.bakeDiffuseLighting = float3(0.0, 0.0, 0.0);
+
+#ifdef _EMISSIVE_COLOR_MAP
+    builtinData.emissiveColor = UNITY_SAMPLE_TEX2D(_EmissiveColorMap, input.texCoord0).rgb * _EmissiveColor;
+#else
+    builtinData.emissiveColor = _EmissiveColor;
+#endif
+
+    builtinData.emissiveIntensity = _EmissiveIntensity;
+
+    builtinData.velocity = float2(0.0, 0.0);
+
+    builtinData.distortion = float2(0.0, 0.0);
+    builtinData.distortionBlur = 0.0;
+}
+