Merge branch 'master' of https://github.com/Unity-Technologies/ScriptableRenderLoop into SkySystem

Assets/ScriptableRenderLoop/HDRenderLoop/Debug.meta

 fileFormatVersion: 2
-guid: ee4b12281385a0a4791e3128dd34eae4
+guid: 10d6f30f9ddaa5f47b910603925654fb
 folderAsset: yes
 timeCreated: 1475748186
 licenseType: Pro

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/HDRenderLoopInspector.cs

 
             public readonly GUIContent useForwardRenderingOnly = new GUIContent("Use Forward Rendering Only");
             public readonly GUIContent useDepthPrepass = new GUIContent("Use Depth Prepass");
+            public readonly GUIContent useSinglePassLightLoop = new GUIContent("Use single Pass light loop");
 
             public bool isDebugViewMaterialInit = false;
             public GUIContent[] debugViewMaterialStrings = null;
             public readonly GUIContent[] shadowsCascadeCounts = new GUIContent[] { new GUIContent("1"), new GUIContent("2"), new GUIContent("3"), new GUIContent("4") };
             public readonly int[] shadowsCascadeCountValues = new int[] { 1, 2, 3, 4 };
             public readonly GUIContent shadowsCascades = new GUIContent("Cascade values");
+
+            public readonly GUIContent tileLightLoopSettings = new GUIContent("Tile Light Loop settings");
+            public readonly GUIContent tileLightLoopDebugMode = new GUIContent("Enable Debug mode", "Toggle overheat map mode");
+            public readonly GUIContent directIndirectSinglePass = new GUIContent("Enable direct and indirect lighting in single pass", "Toggle");
+            public readonly GUIContent bigTilePrepass = new GUIContent("Enable big tile prepass", "Toggle");
+            public readonly GUIContent clustered = new GUIContent("Enable clusted", "Toggle");   
         }
 
         private static Styles s_Styles = null;
             debugParameters.displayOpaqueObjects = EditorGUILayout.Toggle(styles.displayOpaqueObjects, debugParameters.displayOpaqueObjects);
             debugParameters.displayTransparentObjects = EditorGUILayout.Toggle(styles.displayTransparentObjects, debugParameters.displayTransparentObjects);
 			debugParameters.useForwardRenderingOnly = EditorGUILayout.Toggle(styles.useForwardRenderingOnly, debugParameters.useForwardRenderingOnly);
-            debugParameters.useDepthPrepass = EditorGUILayout.Toggle(styles.useDepthPrepass, debugParameters.useDepthPrepass);            
+            debugParameters.useDepthPrepass = EditorGUILayout.Toggle(styles.useDepthPrepass, debugParameters.useDepthPrepass);
+            debugParameters.useSinglePassLightLoop = EditorGUILayout.Toggle(styles.useSinglePassLightLoop, debugParameters.useSinglePassLightLoop);     
 
             if (EditorGUI.EndChangeCheck())
             {
             EditorGUI.indentLevel++;
             EditorGUI.BeginChangeCheck();
 
+            /*
+            */
  
             if (EditorGUI.EndChangeCheck())
             {
             }
             EditorGUI.indentLevel--;
             
+            if (EditorGUI.EndChangeCheck())
+            {
+                EditorUtility.SetDirty(renderLoop); // Repaint
+            }
+            EditorGUI.indentLevel--;
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(styles.tileLightLoopSettings);
+            EditorGUI.indentLevel++;
+            EditorGUI.BeginChangeCheck();
+
+            renderLoop.tilePassLightLoop.debugViewTilesFlags = (TilePass.DebugViewTilesFlags)EditorGUILayout.EnumMaskField("DebugView Tiles", renderLoop.tilePassLightLoop.debugViewTilesFlags);
+            renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass = EditorGUILayout.Toggle(styles.directIndirectSinglePass, renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass);
+            renderLoop.tilePassLightLoop.enableBigTilePrepass = EditorGUILayout.Toggle(styles.bigTilePrepass, renderLoop.tilePassLightLoop.enableBigTilePrepass);
+            renderLoop.tilePassLightLoop.enableClustered = EditorGUILayout.Toggle(styles.clustered, renderLoop.tilePassLightLoop.enableClustered);
+
             if (EditorGUI.EndChangeCheck())
             {
                 EditorUtility.SetDirty(renderLoop); // Repaint

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset

   m_Script: {fileID: 11500000, guid: 558064ecdbf6b6742892d699acb39aed, type: 3}
   m_Name: HDRenderLoop
   m_EditorClassIdentifier: 
+  m_SkyParameters:
+    skyHDRI: {fileID: 0}
+    rotation: 0
+    exposure: 0
+    multiplier: 1
   m_ShadowSettings:
     enabled: 1
     shadowAtlasWidth: 4096

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset.meta

 fileFormatVersion: 2
 guid: 2400b74f5ce370c4481e5dc417d03703
-timeCreated: 1479691644
+timeCreated: 1480265826
 licenseType: Pro
 NativeFormatImporter:
   userData: 

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

 
             public bool enableTonemap = true;
             public float exposure = 0;
+
+            public bool useSinglePassLightLoop = true;
         }
 
         DebugParameters m_DebugParameters = new DebugParameters();
 
         // TODO: Find a way to automatically create/iterate through lightloop
         SinglePass.LightLoop m_SinglePassLightLoop;
-        TilePass.LightLoop m_TilePassLightLoop;
+        TilePass.LightLoop m_TilePassLightLoop = null;
+        public TilePass.LightLoop tilePassLightLoop
+        {
+            get { return m_TilePassLightLoop; }
+        }
 
         // TODO: Find a way to automatically create/iterate through deferred material
         Lit.RenderLoop m_LitRenderLoop;
             m_SinglePassLightLoop = new SinglePass.LightLoop();
             m_SinglePassLightLoop.Rebuild();
             m_TilePassLightLoop = new TilePass.LightLoop();
-            m_TilePassLightLoop.Rebuild();
+            tilePassLightLoop.Rebuild();
 
             m_lightList = new LightList();
             m_lightList.Allocate();
         {
             m_LitRenderLoop.OnDisable();
             m_SinglePassLightLoop.OnDisable();
-            m_TilePassLightLoop.OnDisable();
+            tilePassLightLoop.OnDisable();
 
             Utilities.Destroy(m_FinalPassMaterial);
             Utilities.Destroy(m_DebugViewMaterialGBuffer);
             {
                 // Bind material data
                 m_LitRenderLoop.Bind();
-                m_SinglePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
-                //  m_TilePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
+                if (debugParameters.useSinglePassLightLoop)
+                {
+                    m_SinglePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
+                }
+                else
+                {
+                    tilePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBufferRT);
+                }
             }
         }
 
                 lightList.envCullIndices.Add(probeIndex);
             }
 
-            // build per tile light lists           
-            m_SinglePassLightLoop.PrepareLightsForGPU(cullResults, camera, m_lightList);
-            //m_TilePassLightLoop.PrepareLightsForGPU(cullResults, camera, m_lightList);
+            // build per tile light lists
+            if (debugParameters.useSinglePassLightLoop)
+            {
+                m_SinglePassLightLoop.PrepareLightsForGPU(cullResults, camera, m_lightList);
+            }
+            else
+            {
+                tilePassLightLoop.PrepareLightsForGPU(cullResults, camera, m_lightList);
+            }            
-            if (camera.pixelWidth != m_WidthOnRecord || camera.pixelHeight != m_HeightOnRecord || m_TilePassLightLoop.NeedResize())
+            if (camera.pixelWidth != m_WidthOnRecord || camera.pixelHeight != m_HeightOnRecord || tilePassLightLoop.NeedResize())
-                    m_TilePassLightLoop.ReleaseResolutionDependentBuffers();
+                    tilePassLightLoop.ReleaseResolutionDependentBuffers();
-                m_TilePassLightLoop.AllocResolutionDependentBuffers(camera.pixelWidth, camera.pixelHeight);
+                tilePassLightLoop.AllocResolutionDependentBuffers(camera.pixelWidth, camera.pixelHeight);
 
                 // update recorded window resolution
                 m_WidthOnRecord = camera.pixelWidth;
             //Shader.SetGlobalTexture("_CubeCookieTextures", m_CubeCookieTexArray.GetTexCache());
             Shader.SetGlobalTexture("_EnvTextures", m_CubeReflTexArray.GetTexCache());
 
-            m_SinglePassLightLoop.PushGlobalParams(camera, renderLoop, lightList);
-            m_TilePassLightLoop.PushGlobalParams(camera, renderLoop, lightList);
+            if (debugParameters.useSinglePassLightLoop)
+            {
+                m_SinglePassLightLoop.PushGlobalParams(camera, renderLoop, lightList);
+            }
+            else
+            {
+                tilePassLightLoop.PushGlobalParams(camera, renderLoop, lightList);
+            }            
         }
 
         public override void Render(Camera[] cameras, RenderLoop renderLoop)
                     using (new Utilities.ProfilingSample("Build Light list", renderLoop))
                     {
                         PrepareLightsForGPU(cullResults, camera, ref shadows, ref m_lightList);
-                        //m_TilePassLightLoop.BuildGPULightLists(camera, renderLoop, m_lightList, m_CameraDepthBuffer);
+                        if (!debugParameters.useSinglePassLightLoop)
+                            tilePassLightLoop.BuildGPULightLists(camera, renderLoop, m_lightList, m_CameraDepthBufferRT);
 
                         PushGlobalParams(camera, renderLoop, m_lightList);
                     }

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting.meta

 fileFormatVersion: 2
-guid: b8bec6e2ba5850349bc2827fbe25b071
+guid: 7dc18395c5211d44bbe417b8b8b2e81a
 folderAsset: yes
 timeCreated: 1474297943
 licenseType: Pro

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Forward.hlsl

 // If only one keyword is present it mean that only one type of forward lighting architecture is supported.
 
 // Must match name in GetKeyword() method of forward lighting architecture .cs file
-// #pragma multi_compile LIGHTLOOP_SINGLE_PASS  -> can't use a pragma from include... (for now)
+// #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS -> can't use a pragma from include... (for now)
 // #pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF  -> can't use a pragma from include... (for now)

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

 #define ENVSHAPETYPE_BOX (1)
 #define ENVSHAPETYPE_SPHERE (2)
 
+//
+// UnityEngine.Experimental.ScriptableRenderLoop.EnvConstants:  static fields
+//
+#define ENVCONSTANTS_SPEC_CUBE_LOD_STEP (6)
+
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.LightData
 // PackingRules = Exact
 struct LightData

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Lighting.hlsl

 
 #ifdef LIGHTLOOP_SINGLE_PASS
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.hlsl"
-#elif  LIGHTLOOP_TILED_PASS
+#elif defined(LIGHTLOOP_TILE_PASS)
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.hlsl"
 #endif
 
 // LightLoop use evaluation BSDF function for light type define in Material.hlsl
 #ifdef LIGHTLOOP_SINGLE_PASS 
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePassLoop.hlsl"
-#elif  LIGHTLOOP_TILED_PASS
+#elif defined(LIGHTLOOP_TILE_PASS)
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePassLoop.hlsl"
 #endif
 

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

 Shader "Hidden/HDRenderLoop/Deferred"
 {
+    Properties
+    {
+        // We need to be able to control the blend mode for deferred shader in case we do multiple pass
+        _SrcBlend("", Float) = 1
+        _DstBlend("", Float) = 1
+    }
+
     SubShader
     {
 
             Blend Off
+            Blend[_SrcBlend][_DstBlend]
 
             HLSLPROGRAM
             #pragma target 5.0
             // TODO: Workflow problem here, I would like to only generate variant for the LIGHTLOOP_TILE_PASS case, not the LIGHTLOOP_SINGLE_PASS case. This must be on lightloop side and include here.... (Can we codition
             #pragma multi_compile LIGHTLOOP_TILE_DIRECT LIGHTLOOP_TILE_INDIRECT LIGHTLOOP_TILE_ALL
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-            #pragma multi_compile _ ENABLE_DEBUG
 
             //-------------------------------------------------------------------------------------
             // Include

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass.meta

 fileFormatVersion: 2
-guid: 16efe1cc514ae594993f6705dacbf97d
+guid: dfb6e7f2aee22e147834de3e01b7c03c
 folderAsset: yes
 timeCreated: 1477266406
 licenseType: Pro

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.cs

                 Shader.SetGlobalVectorArray("_DirShadowSplitSpheres", lightList.directionalShadowSplitSphereSqr);      
             }
 
-            public void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderTargetIdentifier colorBuffer)
+            public void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderTargetIdentifier cameraColorBufferRT)
             {
                 var invViewProj = Utilities.GetViewProjectionMatrix(camera).inverse;
                 m_DeferredMaterial.SetMatrix("_InvViewProjMatrix", invViewProj);
 
+                m_DeferredMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                m_DeferredMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+
-                cmd.Blit(null, colorBuffer, m_DeferredMaterial, 0);
+                cmd.Blit(null, cameraColorBufferRT, m_DeferredMaterial, 0);
                 renderLoop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             }

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.hlsl

 SAMPLERCUBE(sampler_SkyTexture); // NOTE: Sampler could be share here with _EnvTextures. Don't know if the shader compiler will complain...
 
 CBUFFER_START(UnityPerLightLoop)
-    int _DirectionalLightCount;
-    int _PunctualLightCount;
-    int _AreaLightCount;
-    int _EnvLightCount;
+    uint _DirectionalLightCount;
+    uint _PunctualLightCount;
+    uint _AreaLightCount;
+    uint _EnvLightCount;
     EnvLightData _EnvLightSky;
 	float4 _ShadowMapSize;
     float4 _DirShadowSplitSpheres[4]; // TODO share this max between C# and hlsl

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePassLoop.hlsl

     diffuseLighting  = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
 
-    int i = 0; // Declare once to avoid the D3D11 compiler warning.
+    uint i = 0; // Declare once to avoid the D3D11 compiler warning.
 
     for (i = 0; i < _DirectionalLightCount; ++i)
     {

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

 float GetScaleFromBase(float base)
 {
     const float C = (float)(1 << g_iLog2NumClusters);
-    const float geomSeries = (1.0 - pow(base, C)) / (1 - base);     // geometric series: sum_k=0^{C-1} base^k
+    const float geomSeries = (1.0 - pow(abs(base), C)) / (1 - base);     // geometric series: sum_k=0^{C-1} base^k
     return geomSeries / (g_fFarPlane - g_fNearPlane);
 }
 

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

 
 	lightOffs = 0;
 	GroupMemoryBarrierWithGroupSync();
-	for(int i=t; i<iNrCoarseLights; i+=NR_THREADS) if(lightsListLDS[i]<g_iNrVisibLights) InterlockedAdd(lightOffs, 1);
+    int i;
+	for(i=t; i<iNrCoarseLights; i+=NR_THREADS) if(lightsListLDS[i]<g_iNrVisibLights) InterlockedAdd(lightOffs, 1);
-	for(int i=t; i<(iNrCoarseLights+1); i+=NR_THREADS)
+	for(i=t; i<(iNrCoarseLights+1); i+=NR_THREADS)
 		g_vLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*offs + i] = t==0 ? iNrCoarseLights : lightsListLDS[i-1];
 }
 
 	const int totNrEdgePairs = 12*nrFrustEdges;
 	for(int l=0; l<iNrCoarseLights; l++)
 	{
-		const int idxCoarse = lightsListLDS[l];
+		const uint idxCoarse = lightsListLDS[l];
 		[branch]if(idxCoarse<(uint) g_iNrVisibLights && g_vLightData[idxCoarse].lightType!=SPHERE_LIGHT)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
 		GroupMemoryBarrierWithGroupSync();
 #endif
 }
-#endif
+#endif

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

 	{
 		uint2 uPixCrd = min( uint2(viTilLL.x+(idx&0xf), viTilLL.y+(idx>>4)), uint2(iWidth-1, iHeight-1) );
 #ifdef MSAA_ENABLED
-		for(int i=0; i<iNumSamplesMSAA; i++)
+		for(uint i=0; i<iNumSamplesMSAA; i++)
 		{
 		const float fDpth = FetchDepthMSAA(g_depth_tex, uPixCrd, i);
 #else
 void ClearAtomic(uint threadID : SV_GroupIndex, uint3 u3GroupID : SV_GroupID)
 {
 	g_LayeredSingleIdxBuffer[0]=0;
-}
+}

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

 	lightOffsSph = 0;
 
 	// make a copy of coarseList in prunedList.
-	for(int l=threadID; l<iNrCoarseLights; l+=NR_THREADS)
+    int l;
+	for(l=threadID; l<iNrCoarseLights; l+=NR_THREADS)
 		prunedList[l]=coarseList[l];
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 	float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne();
 	float halfTileSizeAtZDistOne = 8*onePixDiagDist;		// scale by half a tile
 	
-	for(int l=threadID; l<iNrCoarseLights; l+=NR_THREADS)
+	for(l=threadID; l<iNrCoarseLights; l+=NR_THREADS)
 	{
 		SFiniteLightBound lightData = g_data[coarseList[l]];
 	
 		if(uIndex<MAX_NR_COARSE_ENTRIES) prunedList[uIndex] = coarseList[t];		// we allow up to 64 pruned lights while stored in LDS.
 	}
 }
-#endif
+#endif

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

         }
 
         [GenerateHLSL]
+        public enum DebugViewTilesFlags
+        {
+            DirectLighting = 1,
+            Reflection = 2
+        };
+
+        [GenerateHLSL]
         public struct SFiniteLightBound
         {
             public Vector3 boxAxisX;
             private static int s_GenListPerBigTileKernel;
 
             // clustered light list specific buffers and data begin
+            public DebugViewTilesFlags debugViewTilesFlags = 0;
-            public bool enableBigTilePrepass = false; // SebL - TODO: I get a crash when enabling this
+            public bool enableBigTilePrepass = true;
-            public bool enableDrawTileDebug = false;
+            public bool enableDirectIndirectSinglePass = false;
             public bool enableComputeLightEvaluation = false;
             const bool k_UseDepthBuffer = true;      // only has an impact when EnableClustered is true (requires a depth-prepass)
             const bool k_UseAsyncCompute = true;        // should not use on mobile
             static ComputeBuffer s_PunctualShadowList;
             static ComputeBuffer s_DirectionalShadowList;
 
-            Material m_DeferredMaterial;
-            Material m_DeferredReflectionMaterial;
+            Material m_DeferredDirectMaterial;
+            Material m_DeferredIndirectMaterial;
+            Material m_DeferredAllMaterial;
+            Material m_DebugViewTilesMaterial;
 
             const int k_TileSize = 16;
 
 
             int GetNumTileY(Camera camera)
             {
-                return (camera.pixelWidth + (k_TileSize - 1)) / k_TileSize;
+                return (camera.pixelHeight + (k_TileSize - 1)) / k_TileSize;
             }
 
             // Local function
                     buildPerBigTileLightListShader.SetBuffer(s_GenListPerBigTileKernel, "g_data", s_ConvexBoundsBuffer);
                 }
 
+                s_LightList = null;
                 m_boundData = new SFiniteLightBound[MaxNumLights];
                 m_lightData = new SFiniteLightData[MaxNumLights];
                 m_lightCount = 0;
                 s_EnvLightList = new ComputeBuffer(HDRenderLoop.k_MaxEnvLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
                 s_PunctualShadowList = new ComputeBuffer(HDRenderLoop.k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(PunctualShadowData)));
 
-                m_DeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
-                m_DeferredMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredMaterial.EnableKeyword("LIGHTLOOP_TILE_DIRECT");
-                
-                m_DeferredReflectionMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
-                m_DeferredReflectionMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredReflectionMaterial.EnableKeyword("LIGHTLOOP_TILE_INDIRECT");
+                m_DeferredDirectMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_DeferredDirectMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredDirectMaterial.EnableKeyword("LIGHTLOOP_TILE_DIRECT");
+                m_DeferredDirectMaterial.DisableKeyword("LIGHTLOOP_TILE_INDIRECT");
+                m_DeferredDirectMaterial.DisableKeyword("LIGHTLOOP_TILE_ALL");
+
+                m_DeferredIndirectMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_DeferredIndirectMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredIndirectMaterial.DisableKeyword("LIGHTLOOP_TILE_DIRECT");
+                m_DeferredIndirectMaterial.EnableKeyword("LIGHTLOOP_TILE_INDIRECT");
+                m_DeferredIndirectMaterial.DisableKeyword("LIGHTLOOP_TILE_ALL");
+
+                m_DeferredAllMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_DeferredAllMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredAllMaterial.DisableKeyword("LIGHTLOOP_TILE_DIRECT");
+                m_DeferredAllMaterial.DisableKeyword("LIGHTLOOP_TILE_INDIRECT");
+                m_DeferredAllMaterial.EnableKeyword("LIGHTLOOP_TILE_ALL");
+
+
+                m_DebugViewTilesMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/DebugViewTiles");
+
             }
 
             public void OnDisable()
                 s_PunctualShadowList.Release();
                 s_PunctualShadowList = null;
 
-                Utilities.Destroy(m_DeferredMaterial);
-                Utilities.Destroy(m_DeferredReflectionMaterial);
+                Utilities.Destroy(m_DeferredDirectMaterial);
+                Utilities.Destroy(m_DeferredIndirectMaterial);
+                Utilities.Destroy(m_DeferredAllMaterial);
+                Utilities.Destroy(m_DebugViewTilesMaterial);
             }
 
             public bool NeedResize()
                     lightData.boxInnerDist = e;
                     lightData.boxInvRange.Set(1.0f / delta.x, 1.0f / delta.y, 1.0f / delta.z);
 
+                    lightData.lightType = (uint)LightDefinitions.BOX_LIGHT;
+                    lightData.lightModel = (uint)LightDefinitions.REFLECTION_LIGHT;
+
+                    m_lightData[index] = lightData;
                 }
 
                 // Sanity check
 
                 m_lightCount = lightList.punctualLights.Count + lightList.envLights.Count;
                 s_ConvexBoundsBuffer.SetData(m_boundData); // TODO: check with Vlad what is happening here, do we copy 1024 element always ? Could we setup the size we want to copy ?
+                s_LightDataBuffer.SetData(m_lightData);
-            void VoxelLightListGeneration(CommandBuffer cmd, Camera camera, Matrix4x4 projscr, Matrix4x4 invProjscr, int cameraDepthBuffer)
+            void VoxelLightListGeneration(CommandBuffer cmd, Camera camera, Matrix4x4 projscr, Matrix4x4 invProjscr, RenderTargetIdentifier cameraDepthBufferRT)
             {
                 // clear atomic offset index
                 cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_ClearVoxelAtomicKernel, "g_LayeredSingleIdxBuffer", s_GlobalLightListAtomic);
                 cmd.SetComputeFloatParam(buildPerVoxelLightListShader, "g_fClustScale", m_ClustScale);
                 cmd.SetComputeFloatParam(buildPerVoxelLightListShader, "g_fClustBase", k_ClustLogBase);
 
-                cmd.SetComputeTextureParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_depth_tex", new RenderTargetIdentifier(cameraDepthBuffer));
+                cmd.SetComputeTextureParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_depth_tex", cameraDepthBufferRT);
-                if (enableBigTilePrepass) cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_vBigTileLightList", s_BigTileLightList);
+                if (enableBigTilePrepass) 
+                    cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_vBigTileLightList", s_BigTileLightList);
 
                 if (k_UseDepthBuffer)
                 {
                 cmd.DispatchCompute(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, numTilesX, numTilesY, 1);
             }
 
-            public void BuildGPULightLists(Camera camera, RenderLoop loop, HDRenderLoop.LightList lightList, int cameraDepthBuffer)
+            public void BuildGPULightLists(Camera camera, RenderLoop loop, HDRenderLoop.LightList lightList, RenderTargetIdentifier cameraDepthBufferRT)
             {
                 var w = camera.pixelWidth;
                 var h = camera.pixelHeight;
                     cmd.SetComputeIntParam(buildPerTileLightListShader, "g_iNrVisibLights", m_lightCount);
                     Utilities.SetMatrixCS(cmd, buildPerTileLightListShader, "g_mScrProjection", projscr);
                     Utilities.SetMatrixCS(cmd, buildPerTileLightListShader, "g_mInvScrProjection", invProjscr);
-                    cmd.SetComputeTextureParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_depth_tex", new RenderTargetIdentifier(cameraDepthBuffer));
+                    cmd.SetComputeTextureParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_depth_tex", cameraDepthBufferRT);
-                    if (enableBigTilePrepass) cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_vBigTileLightList", s_BigTileLightList);
+                    if (enableBigTilePrepass)
+                        cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_vBigTileLightList", s_BigTileLightList);
-                    VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBuffer);
+                    VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBufferRT);
                 }
 
                 loop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             }
 
-            public void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderTargetIdentifier colorBuffer)
+            public void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderTargetIdentifier cameraColorBufferRT)
-                var cmd = new CommandBuffer();
-                m_DeferredMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                m_DeferredReflectionMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                if (enableDrawTileDebug)
-                    m_DeferredMaterial.EnableKeyword("ENABLE_DEBUG");
-                else
-                    m_DeferredMaterial.DisableKeyword("ENABLE_DEBUG");
+                var invViewProj = Utilities.GetViewProjectionMatrix(camera).inverse;
+                var screenSize = Utilities.ComputeScreenSize(camera);
+                m_DeferredDirectMaterial.SetMatrix("_InvViewProjMatrix", invViewProj);
+                m_DeferredDirectMaterial.SetVector("_ScreenSize", screenSize);
+                m_DeferredDirectMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                m_DeferredDirectMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                m_DeferredDirectMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                m_DeferredDirectMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                
+                m_DeferredIndirectMaterial.SetMatrix("_InvViewProjMatrix", invViewProj);
+                m_DeferredIndirectMaterial.SetVector("_ScreenSize", screenSize);
+                m_DeferredIndirectMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                m_DeferredIndirectMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One); // Additive
+                m_DeferredIndirectMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                m_DeferredIndirectMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                
+                m_DeferredAllMaterial.SetMatrix("_InvViewProjMatrix", invViewProj);
+                m_DeferredAllMaterial.SetVector("_ScreenSize", screenSize);
+                m_DeferredAllMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                m_DeferredAllMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                m_DeferredAllMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                m_DeferredAllMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                
+                m_DebugViewTilesMaterial.SetVector("_ScreenSize", screenSize);
+                m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)debugViewTilesFlags);
+                
+
+                var cmd = new CommandBuffer();
                 cmd.SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
 
                 // In case of bUseClusteredForDeferred disable toggle option since we're using m_perVoxelLightLists as opposed to lightList
                 }
                 else
                 {*/
-                    cmd.Blit(0, colorBuffer, m_DeferredMaterial, 0);
-                    cmd.Blit(0, colorBuffer, m_DeferredReflectionMaterial, 0);
+                    if (enableDirectIndirectSinglePass)
+                    {
+                        cmd.Blit(null, cameraColorBufferRT, m_DeferredAllMaterial, 0);
+                    }
+                    else
+                    {
+                        cmd.Blit(null, cameraColorBufferRT, m_DeferredDirectMaterial, 0);
+                        cmd.Blit(null, cameraColorBufferRT, m_DeferredIndirectMaterial, 0);
+                    }
+
+                if(debugViewTilesFlags != 0)
+                {
+                    cmd.Blit(null, cameraColorBufferRT, m_DebugViewTilesMaterial, 0);
+                }
 
                 renderLoop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();

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

 #define DIRECT_LIGHT (0)
 #define REFLECTION_LIGHT (1)
 
+//
+// UnityEngine.Experimental.ScriptableRenderLoop.TilePass.DebugViewTilesFlags:  static fields
+//
+#define DEBUGVIEWTILESFLAGS_DIRECT_LIGHTING (1)
+#define DEBUGVIEWTILESFLAGS_REFLECTION (2)
+
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.TilePass.SFiniteLightBound
 // PackingRules = Exact
 struct SFiniteLightBound

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

 #define PROCESS_ENV_LIGHT
 #endif
 
+#include "TilePass.cs.hlsl"
+
+Buffer<uint> g_vLightListGlobal;
 
 #define TILE_SIZE 16 // This is fixed
 #define DWORD_PER_TILE 16 // See dwordsPerTile in TilePass.cs, we have roomm for 31 lights and a number of light value all store on 16 bit (ushort)

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

     const int tileOffset = GetTileOffset(coord, lightCategory);
 
     // The first entry inside a tile is the number of light for lightCategory (thus the +0)
-    lightCount = g_vLightListGlobal[DWORD_PER_TILE * tileOffs + 0] & 0xffff;
+    lightCount = g_vLightListGlobal[DWORD_PER_TILE * tileOffset + 0] & 0xffff;
     start = tileOffset;
 }
 
 
 uint FetchIndex(uint tileOffset, uint lightIndex)
 {
-    return FetchIndexOpaque(tileOffs, lightIndex);
+    return FetchIndexOpaque(tileOffset, lightIndex);
 }
 
 #else
     diffuseLighting = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
 
-    int i = 0; // Declare once to avoid the D3D11 compiler warning.
+    uint i = 0; // Declare once to avoid the D3D11 compiler warning.
 
 #ifdef PROCESS_DIRECTIONAL_LIGHT
     for (i = 0; i < _DirectionalLightCount; ++i)
         iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
         iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
     }
+
+    diffuseLighting += iblDiffuseLighting;
+    specularLighting += iblSpecularLighting;
-    // TODO
-#if ENABLE_DEBUG
-//    c = OverlayHeatMap(pixCoord & 15, numLightsProcessed, c);
+    // Currently do lightmap with indirect specula
+    // TODO: test what is the most appropriate here...
+#ifdef PROCESS_ENV_LIGHT
+    // Add indirect diffuse + emissive (if any)
+    diffuseLighting += bakeDiffuseLighting;
 #endif
 }

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Builtin.meta

 fileFormatVersion: 2
-guid: af4ee1f6f88b039449ba02003b0f332d
+guid: d67cc60b4fdba994cb837067ccdc352a
 folderAsset: yes
 timeCreated: 1476653183
 licenseType: Pro

Assets/ScriptableRenderLoop/HDRenderLoop/Material/LayeredLit.meta

 fileFormatVersion: 2
-guid: cebd0ba54432759488065d1592e05692
+guid: d43c06a2afd9f2f4ab88a7a94c43e1a6
 folderAsset: yes
 timeCreated: 1476653183
 licenseType: Pro

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

 using UnityEngine;
 using UnityEngine.Rendering;
 
-namespace UnityEditor
+namespace UnityEditor.Experimental.ScriptableRenderLoop
 {
     internal class LayeredLitGUI : LitGUI
     {

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

     #pragma shader_feature _EMISSIVE_COLOR_MAP
     #pragma shader_feature _HEIGHTMAP
     #pragma shader_feature _DETAIL_MAP
-    #pragma shader_feature _LAYER_VERTEX_COLOR
+    #pragma shader_feature _LAYER_MASK_VERTEX_COLOR
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
         }
     }
 
-    CustomEditor "LayeredLitGUI"
+	CustomEditor "UnityEditor.Experimental.ScriptableRenderLoop.LayeredLitGUI"
 }

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

 using UnityEngine;
 using UnityEngine.Rendering;
 
-namespace UnityEditor
+namespace UnityEditor.Experimental.ScriptableRenderLoop
 {
     public abstract class BaseLitGUI : ShaderGUI
     {

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

             #define SHADERPASS SHADERPASS_FORWARD
             // TEMP until pragma work in include
             // #include "../../Lighting/Forward.hlsl"
+            // LIGHTLOOP_TILE_PASS
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS
             //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF
 
         }
     }
 
-    CustomEditor "LitGUI"
+    CustomEditor "UnityEditor.Experimental.ScriptableRenderLoop.LitGUI"
 }

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Unlit.meta

 fileFormatVersion: 2
-guid: 355ba1f7a06cc7a4abe51689715bb1e7
+guid: 5ebb7166783e16a42807309c93c63fad
 folderAsset: yes
 timeCreated: 1476653182
 licenseType: Pro

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

 using UnityEngine;
 using UnityEngine.Rendering;
 
-namespace UnityEditor
+namespace UnityEditor.Experimental.ScriptableRenderLoop
 {
     internal class UnlitGUI : ShaderGUI
     {

Assets/ScriptableRenderLoop/HDRenderLoop/PostProcess.meta

 fileFormatVersion: 2
-guid: 8a352e0cb2a42fd4ba968b628ec4bc10
+guid: 838933a8561a8704e9d537270132e500
 folderAsset: yes
 timeCreated: 1474641822
 licenseType: Pro

Assets/ScriptableRenderLoop/HDRenderLoop/ShaderPass.meta

 fileFormatVersion: 2
-guid: 86e1905991f44ab49baa68fc4d0570e4
+guid: e3b3ad4462341ec4b86566ec1fd82c7c
 folderAsset: yes
 timeCreated: 1476885561
 licenseType: Pro

Assets/ScriptableRenderLoop/HDRenderLoop/Shadow.meta

 fileFormatVersion: 2
-guid: 90ecdcec65552154d89b8e03c90039d4
+guid: 74dbe7f252951f340bb1038a738db89e
 folderAsset: yes
 timeCreated: 1477395055
 licenseType: Pro

Assets/ScriptableRenderLoop/HDRenderLoop/Shadow/FixedSizePCF.meta

 fileFormatVersion: 2
-guid: bf62af062defe384f9e1e45ef3cb4169
+guid: b7ba3daf73a727d4a851bd2c904c04dd
 folderAsset: yes
 timeCreated: 1477395055
 licenseType: Pro

Assets/ScriptableRenderLoop/HDRenderLoop/Utilities.cs

 
             cmd.SetComputeFloatParams(shadercs, name, data);
         }
+
+        public static void SetKeyword(Material m, string keyword, bool state)
+        {
+            if (state)
+                m.EnableKeyword(keyword);
+            else
+                m.DisableKeyword(keyword);
+        }
     }
 }

Assets/ScriptableRenderLoop/ScriptableRenderLoopPicker.cs

         [SerializeField]
         private ScriptableRenderLoop m_RenderLoop;
 
+        // TEMPORARY
+        public int legacyRenderLoopMaxShaderLOD = int.MaxValue;
+
         void OnEnable()
         {
             RenderLoop.renderLoopDelegate += Render;
 
         void SyncRenderingFeatures()
         {
+            if (m_RenderLoop != null && isActiveAndEnabled)
+                Shader.globalMaximumLOD = int.MaxValue; 
+
 #if UNITY_EDITOR
             if (m_RenderLoop != null && isActiveAndEnabled)
                 UnityEditor.SupportedRenderingFeatures.active = m_RenderLoop.GetSupportedRenderingFeatures();
         void OnDisable()
         {
             RenderLoop.renderLoopDelegate -= Render;
+            Shader.globalMaximumLOD = legacyRenderLoopMaxShaderLOD;
-            #if UNITY_EDITOR
+#if UNITY_EDITOR
             UnityEditor.SupportedRenderingFeatures.active = UnityEditor.SupportedRenderingFeatures.Default;
             #endif
         }

Assets/ScriptableRenderLoop/ShaderLibrary/API/D3D11.hlsl

 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Gather(samplerName, float3(coord2, index))
 #define GATHER_TEXTURECUBE(textureName, samplerName, coord3) textureName.Gather(samplerName, coord3)
 #define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Gather(samplerName, float4(coord3, index))
-#define GATHER_TEXTURE3D(textureName, samplerName, coord3) textureName.Gather(samplerName, coord3)

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

                                 0.0, 0.0, 1.0, 0.0,
                                 0.0, 0.0, 0.0, 1.0 };
 
+// Using pow often result to a warning like this
+// "pow(f, e) will not work for negative f, use abs(f) or conditionally handle negative values if you expect them"
+// PositivePow remove this warning when you know the value is positive and avoid inf/NAN.
+float PositivePow(float base, float power)
+{
+    return pow(max(abs(base), float(FLT_EPSILON)), power);
+}
+
+float2 PositivePow(float2 base, float2 power)
+{
+    return pow(max(abs(base), float2(FLT_EPSILON, FLT_EPSILON)), power);
+}
+
+float3 PositivePow(float3 base, float3 power)
+{
+    return pow(max(abs(base), float3(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
+}
+
+float4 PositivePow(float4 base, float4 power)
+{
+    return pow(max(abs(base), float4(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
+}
+
 // ----------------------------------------------------------------------------
 // World position reconstruction / transformation
 // ----------------------------------------------------------------------------

Assets/ScriptableRenderLoop/ShaderLibrary/CommonMaterial.hlsl

     return blendWeights;
 }
 
+float LerpWhiteTo(float b, float t)
+{
+    float oneMinusT = 1.0 - t;
+    return oneMinusT + b * t;
+}
+
 float3 LerpWhiteTo(float3 b, float t)
 {
     float oneMinusT = 1.0 - t;

Assets/ScriptableRenderLoop/ShaderLibrary/Debug.hlsl

     return outColor;
 }
 
+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 pixCoord, uint number)
+{
+    pixCoord.y -= 4;
+    if (number <= 9)
+    {
+        return SampleDebugFont(pixCoord - int2(6, 0), number);
+
+    }
+    else
+    {
+        return (SampleDebugFont(pixCoord, number / 10) | SampleDebugFont(pixCoord - int2(6, 0), number % 10));
+    }
+}
+
 #endif // UNITY_DEBUG_INCLUDED

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

                 var bnds = rl.bounds;
                 var boxOffset = rl.center;                  // reflection volume offset relative to cube map capture point
                 var blendDistance = rl.blendDistance;
-                float imp = rl.importance;
-                //Matrix4x4 mat = rl.transform.localToWorldMatrix;
-                Vector3 cubeCapturePos = mat.GetColumn(3);      // cube map capture position in world space
-
 
                 // implicit in CalculateHDRDecodeValues() --> float ints = rl.intensity;
                 var boxProj = (rl.boxProjection != 0);
                 //Vector3 C = bnds.center;        // P + boxOffset;
                 var C = mat.MultiplyPoint(boxOffset);       // same as commented out line above when rot is identity
 
-                //Vector3 posForShaderParam = bnds.center - boxOffset;    // gives same as rl.GetComponent<Transform>().position;
-                var posForShaderParam = cubeCapturePos;        // same as commented out line above when rot is identity
                 var combinedExtent = e + new Vector3(blendDistance, blendDistance, blendDistance);
 
                 Vector3 vx = mat.GetColumn(0);

Assets/ScriptableRenderLoop/fptl/LightingUtils.hlsl

     //return v4Pres.z / v4Pres.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(numLights > 0)
-    {
-        if (SampleDebugFontNumber(coord, numLights))		// Shadow
-            color = 0.0f;
-        if (SampleDebugFontNumber(coord + 1, numLights))	// Text
-            color = 1.0f;
-    }
-    return color;
+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(numLights > 0)
+    {
+        if (SampleDebugFontNumber(coord, numLights))		// Shadow
+            color = 0.0f;
+        if (SampleDebugFontNumber(coord + 1, numLights))	// Text
+            color = 1.0f;
+    }
+    return color;
 }
 
 

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

   m_PrefabInternal: {fileID: 0}
   m_Name: Layered
   m_Shader: {fileID: 4800000, guid: 81d02e8644315b742b154842a3a2f98c, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS _LAYERMASKMAP _LAYER_MAPPING_PLANAR0
-    _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_PLANAR_3
-    _LAYER_MASK_VERTEX_COLOR _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _EMISSIVE_COLOR _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS
+    _LAYERMASKMAP _LAYER_MAPPING_PLANAR0 _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_PLANAR_1
+    _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_PLANAR_3 _LAYER_MASK_VERTEX_COLOR _MASKMAP
+    _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_CustomRenderQueue: -1
   stringTagMap: {}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _DetailMap0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap3:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask1:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask2:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask3:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _BumpScale: 1
     - _CullMode: 2
     - _Cutoff: 0.5
+    - _DetailAOScale0: 1
+    - _DetailAOScale1: 1
+    - _DetailAOScale2: 1
+    - _DetailAOScale3: 1
+    - _DetailAlbedoScale0: 1
+    - _DetailAlbedoScale1: 1
+    - _DetailAlbedoScale2: 1
+    - _DetailAlbedoScale3: 1
+    - _DetailHeightScale0: 1
+    - _DetailHeightScale1: 1
+    - _DetailHeightScale2: 1
+    - _DetailHeightScale3: 1
+    - _DetailMapMode: 0
+    - _DetailNormalScale0: 1
+    - _DetailNormalScale1: 1
+    - _DetailNormalScale2: 1
+    - _DetailNormalScale3: 1
+    - _DetailSmoothnessScale0: 1
+    - _DetailSmoothnessScale1: 1
+    - _DetailSmoothnessScale2: 1
+    - _DetailSmoothnessScale3: 1
-    - _EmissiveColorMode: 1
+    - _EmissiveColorMode: 0
     - _EmissiveIntensity: 0
     - _EmissiveIntensity0: 0
     - _EmissiveIntensity1: 0
     - _SrcBlend: 1
     - _SubSurfaceRadius: 0
     - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScale0: 1
+    - _TexWorldScale1: 1
+    - _TexWorldScale2: 1
+    - _TexWorldScale3: 1
+    - _UVBase: 0
+    - _UVBase0: 0
+    - _UVBase1: 0
+    - _UVBase2: 0
+    - _UVBase3: 0
+    - _UVDetail: 0
+    - _UVDetail0: 0
+    - _UVDetail1: 0
+    - _UVDetail2: 0
+    - _UVDetail3: 0
+    - _UVDetailsMappingMask0: 0
+    - _UVDetailsMappingMask1: 0
+    - _UVDetailsMappingMask2: 0
+    - _UVDetailsMappingMask3: 0
     - _UVSec: 0
     - _ZWrite: 1
     m_Colors:
     - _EmissiveColor1: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor2: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor3: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask0: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask1: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask2: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask3: {r: 1, g: 0, b: 0, a: 0}

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

 fileFormatVersion: 2
 guid: 6e7fa39a7d1b15c4184c9f51d86eba22
-timeCreated: 1479379836
+timeCreated: 1480070650
 licenseType: Pro
 NativeFormatImporter:
   userData: '{"GUIDArray":["01fa3be727161d249a81ad7065c15459","3acf8f156d29e494e8cd196462d1a17c","62b3c923bc540b94a803550e9927936a","c569253e641dc934db7c3595b31890da"]}'

Assets/ScriptableRenderLoop/Editor.meta

+fileFormatVersion: 2
+guid: 74ae8146f4a01491ba1306f3db78139d
+folderAsset: yes
+timeCreated: 1479851675
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+Shader "Hidden/HDRenderLoop/DebugViewTiles"
+{
+	SubShader
+	{
+
+		Pass
+	    {
+		    ZWrite Off
+		    Blend SrcAlpha OneMinusSrcAlpha
+
+		    HLSLPROGRAM
+            #pragma target 5.0
+            #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
+
+            #pragma vertex VertViewTiles
+            #pragma fragment FragViewTiles
+
+            #define LIGHTLOOP_TILE_PASS 1
+            #define USE_FPTL_LIGHTLIST	1		//TODO: make it also work with clustered
+            #define LIGHTLOOP_TILE_ALL	1
+
+
+		    //-------------------------------------------------------------------------------------
+		    // Include
+		    //-------------------------------------------------------------------------------------
+
+            #include "Common.hlsl"
+
+		    // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
+		    // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
+		    // the deferred shader will require to use multicompile.
+            #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderConfig.cs.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Lighting.hlsl" // This include Material.hlsl
+
+		    //-------------------------------------------------------------------------------------
+		    // variable declaration
+		    //-------------------------------------------------------------------------------------
+
+	        uint _ViewTilesFlags;
+
+	        TEXTURE2D(_CameraDepthTexture);
+	        SAMPLER2D(sampler_CameraDepthTexture);
+
+	        float4 VertViewTiles(float3 positionOS : POSITION): SV_POSITION
+	        {
+		        return TransformWorldToHClip(TransformObjectToWorld(positionOS));
+	        }
+
+            float4 OverlayHeatMap(uint2 pixCoord, uint numLights)
+            {
+                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);
+
+                float4 color = float4(pow(col.xyz, 2.2), 0.3*col.w);
+                if (numLights > 0)
+                {
+                    if (SampleDebugFontNumber(coord, numLights))		// Shadow
+                        color = float4(0, 0, 0, 1);
+                    if (SampleDebugFontNumber(coord + 1, numLights))	// Text
+                        color = float4(1, 1, 1, 1);
+                }
+                return color;
+            }
+
+	        float4 FragViewTiles(float4 positionCS : SV_POSITION) : SV_Target
+	        {
+		        Coordinate coord = GetCoordinate(positionCS.xy, _ScreenSize.zw);
+
+                #if USE_FPTL_LIGHTLIST
+		        float linearDepth = 0.0;
+                #else
+		        float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
+		        float linearDepth = GetLinearDepth(depth);
+                #endif
+
+		        int n = 0;
+		        if (_ViewTilesFlags & DEBUGVIEWTILESFLAGS_DIRECT_LIGHTING)
+		        {
+			        uint punctualLightStart;
+			        uint punctualLightCount;
+			        GetCountAndStart(coord, DIRECT_LIGHT, linearDepth, punctualLightStart, punctualLightCount);
+			        n += punctualLightCount;
+		        }
+
+		        if (_ViewTilesFlags & DEBUGVIEWTILESFLAGS_REFLECTION)
+		        {
+			        uint envLightStart;
+			        uint envLightCount;
+			        GetCountAndStart(coord, REFLECTION_LIGHT, linearDepth, envLightStart, envLightCount);
+			        n += envLightCount;
+		        }
+
+		        if (n > 0)
+		        {
+			        return OverlayHeatMap(int2(coord.unPositionSS.xy) & 15, n);
+		        }
+		        else
+		        {
+			        return 0.0;
+		        }
+	        }
+
+		    ENDHLSL
+	    }
+	}
+	Fallback Off
+}

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

+fileFormatVersion: 2
+guid: c7c2bd17b06ceb4468e14081aaf1b96f
+timeCreated: 1480329456
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/UpgradeStandardShaderMaterials.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using System;
+using NUnit.Framework;
+
+namespace UnityEditor.Experimental.ScriptableRenderLoop
+{
+    public class UpgradeStandardShaderMaterials
+    {
+        static List<MaterialUpgrader> GetHDUpgraders()
+        {
+            var upgraders = new List<MaterialUpgrader>();
+            upgraders.Add(new StandardToHDLitMaterialUpgrader());
+            upgraders.Add(new StandardSpecularToHDLitMaterialUpgrader());
+            return upgraders;
+        }
+
+        [MenuItem("HDRenderLoop/Upgrade Materials - Project")]
+        static void UpgradeMaterialsProject()
+        {
+            MaterialUpgrader.UpgradeProjectFolder(GetHDUpgraders(), "Upgrade to HD Material");
+        }
+
+        [MenuItem("HDRenderLoop/Upgrade Materials - Selection")]
+        static void UpgradeMaterialsSelection()
+        {
+            MaterialUpgrader.UpgradeSelection(GetHDUpgraders(), "Upgrade to HD Material");
+        }
+
+        [MenuItem("HDRenderLoop/Modify Light Intensity for Upgrade - Scene Only")]
+        static void UpgradeLights()
+        {
+            Light[] lights = Light.GetLights(LightType.Directional, 0);
+            foreach (var l in lights)
+            {
+                l.intensity *= Mathf.PI;
+            }
+        }
+    }
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/UpgradeStandardShaderMaterials.cs.meta

+fileFormatVersion: 2
+guid: 9384735d0665f47539990919bf72504e
+timeCreated: 1479839793
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace UnityEditor.Experimental.ScriptableRenderLoop
+{
+    class StandardSpecularToHDLitMaterialUpgrader : MaterialUpgrader
+    {
+        public StandardSpecularToHDLitMaterialUpgrader()
+        {
+            RenameShader("Standard (Specular setup)", "HDRenderLoop/LitLegacySupport");
+
+            RenameTexture("_MainTex", "_BaseColorMap");
+            RenameColor("_Color", "_BaseColor");
+            RenameFloat("_Glossiness", "_Smoothness");
+            RenameTexture("_BumpMap", "_NormalMap");
+            RenameColor("_EmissionColor", "_EmissiveColor");
+            RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
+            RenameTexture("_DetailNormalMap", "_DetailMap");
+
+            //@Seb: Bumpmap scale doesn't exist in new shader
+            //_BumpScale("Scale", Float) = 1.0
+
+            // Anything reasonable that can be done here?
+            //RenameFloat("_SpecColor", ...);
+
+            //@TODO: Seb. Why do we multiply color by intensity
+            //       in shader when we can just store a color?
+            // builtinData.emissiveColor * builtinData.emissiveIntensity
+        }
+
+        public override void Convert(Material srcMaterial, Material dstMaterial)
+        {
+            base.Convert(srcMaterial, dstMaterial);
+            //@TODO: Find a good way of setting up keywords etc from properties. 
+            // Code should be shared with material UI code.
+        }
+
+        [Test]
+        public void UpgradeMaterial()
+        {
+            var newShader = Shader.Find("HDRenderLoop/LitLegacySupport");
+            var mat = new Material(Shader.Find("Standard (Specular setup)"));
+            var albedo = new Texture2D(1, 1);
+            var normals = new Texture2D(1, 1);
+            var baseScale = new Vector2(1, 1);
+            var color = Color.red;
+            mat.mainTexture = albedo;
+            mat.SetTexture("_BumpMap", normals);
+            mat.color = color;
+            mat.SetTextureScale("_MainTex", baseScale);
+
+            MaterialUpgrader.Upgrade(mat, new StandardSpecularToHDLitMaterialUpgrader(), MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
+
+            Assert.AreEqual(newShader, mat.shader);
+            Assert.AreEqual(albedo, mat.GetTexture("_BaseColorMap"));
+            Assert.AreEqual(color, mat.GetColor("_BaseColor"));
+            Assert.AreEqual(baseScale, mat.GetTextureScale("_BaseColorMap"));
+            Assert.AreEqual(normals, mat.GetTexture("_NormalMap"));
+        }
+    }
+}
+

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Editor/StandardSpecularToHDLitMaterialUpgrader.cs.meta

+fileFormatVersion: 2
+guid: 775bef174b1e2ed47972a143845e1191
+timeCreated: 1479911618
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace UnityEditor.Experimental.ScriptableRenderLoop
+{
+    class StandardToHDLitMaterialUpgrader : MaterialUpgrader
+    {
+        public StandardToHDLitMaterialUpgrader()
+        {
+            RenameShader("Standard", "HDRenderLoop/LitLegacySupport");
+
+            RenameTexture("_MainTex", "_BaseColorMap");
+            RenameColor("_Color", "_BaseColor");
+            RenameFloat("_Glossiness", "_Smoothness");
+            RenameTexture("_BumpMap", "_NormalMap");
+            RenameColor("_EmissionColor", "_EmissiveColor");
+            RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
+
+            // the HD renderloop packs detail albedo and detail normals into a single texture.
+            // mapping the detail normal map, if any, to the detail map, should do the right thing if
+            // there is no detail albedo.
+            RenameTexture("_DetailNormalMap", "_DetailMap");
+
+            //@Seb: Bumpmap scale doesn't exist in new shader
+            //_BumpScale("Scale", Float) = 1.0
+
+            // Metallic uses [Gamma] attribute in standard shader but not in Lit. 
+            // @Seb: Should we convert?
+            RenameFloat("_Metallic", "_Metallic");
+
+            //@TODO: Seb. Why do we multiply color by intensity
+            //       in shader when we can just store a color?
+            // builtinData.emissiveColor * builtinData.emissiveIntensity
+        }
+
+        public override void Convert(Material srcMaterial, Material dstMaterial)
+        {
+            base.Convert(srcMaterial, dstMaterial);
+            //@TODO: Find a good way of setting up keywords etc from properties. 
+            // Code should be shared with material UI code.
+        }
+
+        [Test]
+        public void UpgradeMaterial()
+        {
+            var newShader = Shader.Find("HDRenderLoop/LitLegacySupport");
+            var mat = new Material(Shader.Find("Standard"));
+            var albedo = new Texture2D(1, 1);
+            var normals = new Texture2D(1, 1);
+            var baseScale = new Vector2(1, 1);
+            var color = Color.red;
+            mat.mainTexture = albedo;
+            mat.SetTexture("_BumpMap", normals);
+            mat.color = color;
+            mat.SetTextureScale("_MainTex", baseScale);
+
+
+            MaterialUpgrader.Upgrade(mat, new StandardToHDLitMaterialUpgrader(), MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
+
+            Assert.AreEqual(newShader, mat.shader);
+            Assert.AreEqual(albedo, mat.GetTexture("_BaseColorMap"));
+            Assert.AreEqual(color, mat.GetColor("_BaseColor"));
+            Assert.AreEqual(baseScale, mat.GetTextureScale("_BaseColorMap"));
+            Assert.AreEqual(normals, mat.GetTexture("_NormalMap"));
+        }
+    }
+}
+

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Editor/StandardToHDLitMaterialUpgrader.cs.meta

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

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/PatchStandardShaderToNewNamingConvention.cginc

+// NOTE: For performing a project upgrade where you temporarily support both old and new renderloops
+//       in the same sahder
+// 
+// The basic approach is:
+// Upgrade all your shaders to the new naming convention, using a SubShader that also contains the legacy // renderloop code.
+//             
+// 1. Copy HDRenderloop Lit.shader into your project
+// 2. Add a SubShader and copy old Standard shader passes into it.
+// 2. Set LOD on subshader to make Unity pick at runtime to use new renderloop shaders or 
+// legacy standard shaders based on if SRL is enabled or not.
+// In the legacy standard shader section add
+// #include "PatchStandardShaderToNewNamingConvention.cginc"
+
+// List of name remaps
+#define _MainTex _BaseColorMap 
+#define _MainTex_ST _BaseColorMap_ST
+#define _BumpMap _NormalMap
+#define _ParallaxMap _HeightMap
+#define _Parallax _HeightScale
+#define _Glossiness _Smoothness

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/PatchStandardShaderToNewNamingConvention.cginc.meta

+fileFormatVersion: 2
+guid: a9b4e2b7ef9a45f49834b052e7722acb
+timeCreated: 1480085057
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/Editor/MaterialUpgrader.cs.meta

+fileFormatVersion: 2
+guid: 67b996d0727a74b029aff1545143be17
+timeCreated: 1479851694
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/Editor/MaterialUpgrader.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEditor.Experimental.ScriptableRenderLoop
+{
+    public class MaterialUpgrader
+    {
+        string m_OldShader;
+        string m_NewShader;
+
+        Dictionary<string, string> m_TextureRename = new Dictionary<string, string>();
+        Dictionary<string, string> m_FloatRename = new Dictionary<string, string>();
+        Dictionary<string, string> m_ColorRename = new Dictionary<string, string>();
+
+        [Flags]
+        public enum UpgradeFlags
+        {
+            None = 0,
+            LogErrorOnNonExistingProperty = 1,
+            CleanupNonUpgradedProperties = 2,
+        }
+
+        public void Upgrade(Material material, UpgradeFlags flags)
+        {
+            Material newMaterial;
+            if ((flags & UpgradeFlags.CleanupNonUpgradedProperties) != 0)
+            {
+                newMaterial = new Material(Shader.Find(m_NewShader));
+            }
+            else
+            {
+                newMaterial = UnityEngine.Object.Instantiate(material) as Material;
+                newMaterial.shader = Shader.Find(m_NewShader);
+            }
+
+            Convert(material, newMaterial);
+
+            material.shader = Shader.Find(m_NewShader);
+            material.CopyPropertiesFromMaterial(newMaterial);
+            UnityEngine.Object.DestroyImmediate(newMaterial);
+        }
+
+        // Overridable function to implement custom material upgrading functionality
+        public virtual void Convert(Material srcMaterial, Material dstMaterial)
+        {
+            foreach (var t in m_TextureRename)
+            {
+                dstMaterial.SetTextureScale(t.Value, srcMaterial.GetTextureScale(t.Key));
+                dstMaterial.SetTextureOffset(t.Value, srcMaterial.GetTextureOffset(t.Key));
+                dstMaterial.SetTexture(t.Value, srcMaterial.GetTexture(t.Key));
+            }
+
+            foreach (var t in m_FloatRename)
+                dstMaterial.SetFloat(t.Value, srcMaterial.GetFloat(t.Key));
+
+            foreach (var t in m_ColorRename)
+                dstMaterial.SetColor(t.Value, srcMaterial.GetColor(t.Key));
+        }
+
+        public void RenameShader(string oldName, string newName)
+        {
+            m_OldShader = oldName;
+            m_NewShader = newName;
+        }
+
+        public void RenameTexture(string oldName, string newName)
+        {
+            m_TextureRename[oldName] = newName;
+        }
+
+        public void RenameFloat(string oldName, string newName)
+        {
+            m_FloatRename[oldName] = newName;
+        }
+
+        public void RenameColor(string oldName, string newName)
+        {
+            m_ColorRename[oldName] = newName;
+        }
+
+        static bool IsMaterialPath(string path)
+        {
+            return path.EndsWith(".mat", StringComparison.OrdinalIgnoreCase);
+        }
+
+        static MaterialUpgrader GetUpgrader(List<MaterialUpgrader> upgraders, Material material)
+        {
+            if (material == null || material.shader == null)
+                return null;
+
+            string shaderName = material.shader.name;
+            for (int i = 0; i != upgraders.Count; i++)
+            {
+                if (upgraders[i].m_OldShader == shaderName)
+                    return upgraders[i];
+            }
+
+            return null;
+        }
+
+        //@TODO: Only do this when it exceeds memory consumption...
+        static void SaveAssetsAndFreeMemory()
+        {
+            AssetDatabase.SaveAssets();
+            GC.Collect();
+            EditorUtility.UnloadUnusedAssetsImmediate();
+            AssetDatabase.Refresh();
+        }
+
+        public static void UpgradeProjectFolder(List<MaterialUpgrader> upgraders, string progressBarName)
+        {
+            int totalMaterialCount = 0;
+            foreach (string s in UnityEditor.AssetDatabase.GetAllAssetPaths())
+            {
+                if (IsMaterialPath(s))
+                    totalMaterialCount++;
+            }
+
+            int materialIndex = 0;
+            foreach (string path in UnityEditor.AssetDatabase.GetAllAssetPaths())
+            {
+                if (IsMaterialPath(path))
+                {
+                    materialIndex++;
+                    if (UnityEditor.EditorUtility.DisplayCancelableProgressBar(progressBarName, string.Format("({0} of {1}) {2}", materialIndex, totalMaterialCount, path), (float)materialIndex / (float)totalMaterialCount))
+                        break;
+
+                    Material m = UnityEditor.AssetDatabase.LoadMainAssetAtPath(path) as Material;
+                    Upgrade(m, upgraders, UpgradeFlags.None);
+
+                    //SaveAssetsAndFreeMemory();
+                }
+            }
+
+            UnityEditor.EditorUtility.ClearProgressBar();
+        }
+
+        public static void Upgrade(Material material, MaterialUpgrader upgrader, UpgradeFlags flags)
+        {
+            var upgraders = new List<MaterialUpgrader>();
+            upgraders.Add(upgrader);
+            Upgrade(material, upgraders, flags);
+        }
+
+        public static void Upgrade(Material material, List<MaterialUpgrader> upgraders, UpgradeFlags flags)
+        {
+            var upgrader = GetUpgrader(upgraders, material);
+            if (upgrader != null)
+                upgrader.Upgrade(material, flags);
+        }
+
+        public static void UpgradeSelection(List<MaterialUpgrader> upgraders, string progressBarName)
+        {
+            string lastMaterialName = "";
+            var selection = Selection.objects;
+            for (int i = 0; i < selection.Length; i++)
+            {
+
+                if (UnityEditor.EditorUtility.DisplayCancelableProgressBar(progressBarName, string.Format("({0} of {1}) {2}", i, selection.Length, lastMaterialName), (float)i / (float)selection.Length))
+                    break;
+
+                var material = selection[i] as Material;
+                Upgrade(material, upgraders, UpgradeFlags.None);
+                if (material != null)
+                    lastMaterialName = material.name;
+            }
+
+            UnityEditor.EditorUtility.ClearProgressBar();
+        }
+    }
+}

Assets/forwardrenderloop.asset

-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!114 &11400000
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 98fe12104b04e43dd9a963f3f7b26e8e, type: 3}
-  m_Name: forwardrenderloop
-  m_EditorClassIdentifier: 
-  m_ShadowSettings:
-    enabled: 1
-    shadowAtlasWidth: 4096
-    shadowAtlasHeight: 4096
-    maxShadowDistance: 1000
-    directionalLightCascadeCount: 4
-    directionalLightCascades: {x: 0.05, y: 0.2, z: 0.3}

Assets/forwardrenderloop.asset.meta

-fileFormatVersion: 2
-guid: bfc231f294556ca4799e7f7feddee50d
-timeCreated: 1475076344
-licenseType: Pro
-NativeFormatImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: