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

# Conflicts:
#	Assets/ScriptableRenderLoop/HDRenderLoop/Material/LayeredLit/Editor/LayeredLitUI.cs

Assets/BasicRenderLoopTutorial/BasicRenderLoop.cs

 // - This loop also does not setup lightmaps, light probes, reflection probes or light cookies
 
 [ExecuteInEditMode]
-public class BasicRenderLoop : MonoBehaviour
+public class BasicRenderLoop : RenderPipeline
-    private ShaderPassName shaderPassBasic;
-    public void OnEnable ()
+#if UNITY_EDITOR
+    [UnityEditor.MenuItem("Renderloop/CreateBasicRenderLoop")]
+    static void CreateBasicRenderLoop()
-        shaderPassBasic = new ShaderPassName ("BasicPass");
-        RenderLoop.renderLoopDelegate += Render;
+        var instance = ScriptableObject.CreateInstance<BasicRenderLoop>();
+        UnityEditor.AssetDatabase.CreateAsset(instance, "Assets/basicrenderloop.asset");
+#endif
-    public void OnDisable ()
+    private ShaderPassName shaderPassBasic;
+
+    public void OnEnable()
-        RenderLoop.renderLoopDelegate -= Render;
+        Rebuild();
+    public override void Initialize()
+    {
+        shaderPassBasic = new ShaderPassName("BasicPass");
+    }
-    bool Render (Camera[] cameras, RenderLoop loop)
+    public override void Render(Camera[] cameras, RenderLoop loop)
     {
         foreach (var camera in cameras)
         {
 
             loop.Submit ();
         }
-
-        return true;
     }
 
 

Assets/BasicRenderLoopTutorial/BasicRenderLoopScene.unity

   m_ReflectionIntensity: 0.5
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.090675384, g: 0.11147798, b: 0.14205901, a: 0.5}
+  m_IndirectSpecularColor: {r: 0.09067501, g: 0.11147752, b: 0.14205909, a: 0.5}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &261580744
 SphereCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!136 &531853422
 CapsuleCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &1280249097
 MeshCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1405931299
 SphereCollider:
   - component: {fileID: 1447851828}
   - component: {fileID: 1447851827}
   - component: {fileID: 1447851826}
-  - component: {fileID: 1447851831}
   m_Layer: 0
   m_Name: Main Camera
   m_TagString: MainCamera
   m_Father: {fileID: 0}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!114 &1447851831
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 1447851825}
-  m_Enabled: 0
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 22228a1bd982b864ea6c84db2fc11dd1, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
 --- !u!1 &1485985477
 GameObject:
   m_ObjectHideFlags: 0
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!136 &1485985479
 CapsuleCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1596459101
 SphereCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!136 &1714697414
 CapsuleCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1749252041
 SphereCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &2031315347
 SphereCollider:

Assets/Editor/Tests/RenderloopTests/CullResultsTest.cs

     public void TestReflectionProbes()
     {
         UnityEditor.SceneManagement.EditorSceneManager.OpenScene("Assets/Editor/Tests/TestScene.unity");
-
-        // Asserts.ExpectLogError("Boing");
-
         RenderLoopTestFixture.Run(InspectCullResults);
     }
 }

Assets/Editor/Tests/RenderloopTests/RenderloopTestFixture.cs

 using UnityEditor;
 using UnityEngine.Experimental.Rendering;
 using NUnit.Framework;
+using UnityEngine.Experimental.ScriptableRenderLoop;
+using UnityEngine.Rendering;
-public class RenderLoopTestFixture : MonoBehaviour
+public class RenderLoopTestFixture : RenderPipeline
-    public static void Render(RenderLoopWrapper wrapper, Camera[] cameras, RenderLoop renderLoop)
+    private static RenderLoopTestFixture m_Instance;
+
+    public override void Render(Camera[] cameras, RenderLoop renderLoop)
     {
         foreach (var camera in cameras)
         {
 
             CullResults cullResults = CullResults.Cull(ref cullingParams, renderLoop);
 
-            s_Callback(camera, cullResults, renderLoop);
+            if (s_Callback != null)
+                s_Callback(camera, cullResults, renderLoop);
         }
 
         renderLoop.Submit();
     {
+        if (m_Instance == null)
+        {
+            m_Instance = ScriptableObject.CreateInstance<RenderLoopTestFixture>();
+        }
+
-        var instance = camObject.AddComponent<RenderLoopWrapper>();
-        instance.callback = Render;
+        GraphicsSettings.SetRenderPipeline(m_Instance);
-        instance.enabled = true;
-
         Transform t = camObject.transform;
 
         // Can't use AlignViewToObject because it animates over time, and we want the first frame
         SceneView.lastActiveSceneView.LookAtDirect(t.position + t.forward * camDist, t.rotation, size);
 
-        // Invoke renderer
-        try
-        {
-            sceneCamera.Render();
-        }
-        finally
-        {
-            Object.DestroyImmediate(instance);
-        }
+        sceneCamera.Render();
+        GraphicsSettings.SetRenderPipeline(null);
     }
 }

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 skyResolution = new GUIContent("Sky Resolution");
             public readonly GUIContent skyExposure = new GUIContent("Sky Exposure");
             public readonly GUIContent skyRotation = new GUIContent("Sky Rotation");
             public readonly GUIContent skyMultiplier = new GUIContent("Sky Multiplier");
             public readonly GUIContent[] 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();
 
-            skyParameters.skyHDRI = (Cubemap)EditorGUILayout.ObjectField("Cubemap", skyParameters.skyHDRI, typeof(Cubemap), false);
+            skyParameters.skyHDRI = (Texture)EditorGUILayout.ObjectField("Cubemap", skyParameters.skyHDRI, typeof(Cubemap), false);
+
+            skyParameters.skyResolution = (SkyResolution)EditorGUILayout.EnumPopup(styles.skyResolution, skyParameters.skyResolution);
- 
+
             if (EditorGUI.EndChangeCheck())
             {
                 EditorUtility.SetDirty(renderLoop); // Repaint
             }
             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: 1480436907
 licenseType: Pro
 NativeFormatImporter:
   userData: 

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

 {
     [ExecuteInEditMode]
     // This HDRenderLoop assume linear lighting. Don't work with gamma.
-    public partial class HDRenderLoop : ScriptableRenderLoop
+    public partial class HDRenderLoop : RenderPipeline
     {
         const string k_HDRenderLoopPath = "Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset";
 
 
             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;
         TextureCacheCubemap m_CubeCookieTexArray;
 
-        void OnEnable()
-        {
-            Rebuild();
-        }
-
-        void OnValidate()
+        private void OnValidate()
         {
             m_Dirty = true;
         }
             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();
 
-        void OnDisable()
+        public override void Initialize()
+        {
+#if UNITY_EDITOR
+            UnityEditor.SupportedRenderingFeatures.active = new UnityEditor.SupportedRenderingFeatures
+            {
+                reflectionProbe = UnityEditor.SupportedRenderingFeatures.ReflectionProbe.Rotation
+            };
+#endif
+
+            Rebuild();
+        }
+
+        public override void Cleanup()
-            m_TilePassLightLoop.OnDisable();
+            tilePassLightLoop.OnDisable();
 
             Utilities.Destroy(m_FinalPassMaterial);
             Utilities.Destroy(m_DebugViewMaterialGBuffer);
             m_CubeCookieTexArray.Release();
 
             m_SkyRenderer.OnDisable();
+
+#if UNITY_EDITOR
+            UnityEditor.SupportedRenderingFeatures.active = UnityEditor.SupportedRenderingFeatures.Default;
+#endif
         }
 
         void NewFrame()
                 return ;
             }
 
-            using (new Utilities.ProfilingSample("Single Pass - Deferred Lighting Pass", renderLoop))
+            // Bind material data
+            m_LitRenderLoop.Bind();
+            if (debugParameters.useSinglePassLightLoop)
-                // Bind material data
-                m_LitRenderLoop.Bind();
-                //  m_TilePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
+            }
+            else
+            {
+                tilePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBufferRT);
             }
         }
 
             }
         }
 
+#if UNITY_EDITOR
+        public override void RenderSceneView(Camera camera, RenderLoop renderLoop)
+        {
+            base.RenderSceneView(camera, renderLoop);
+            renderLoop.PrepareForEditorRendering(camera, m_CameraDepthBufferRT);
+            renderLoop.Submit();
+        }
+#endif
 
         void FinalPass(RenderLoop renderLoop)
         {
                 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())
+            // TODO: Detect if renderdoc just load and force a resize in this case, as often renderdoc require to realloc resource.
+
+            // TODO: This is the wrong way to handle resize/allocation. We can have several different camera here, mean that the loop on camera will allocate and deallocate
+            // the below buffer which is bad. Best is to have a set of buffer for each camera that is persistent and reallocate resource if need
+            // For now consider we have only one camera that go to this code, the main one.
+            m_SkyRenderer.Resize(m_SkyParameters); // TODO: Also a bad naming, here we just want to realloc texture if skyparameters change (usefull for lookdev)
+            
+            if (camera.pixelWidth != m_WidthOnRecord || camera.pixelHeight != m_HeightOnRecord || 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 (m_SkyRenderer.IsSkyValid(m_SkyParameters))
+            {
+                m_SkyRenderer.SetGlobalSkyTexture();
+                Shader.SetGlobalInt("_EnvLightSkyEnabled", 1);
+            }
+            else
+            {
+                Shader.SetGlobalInt("_EnvLightSkyEnabled", 0);
+            }
+
+            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);
                     }
 
             // Post effects
         }
-
-        #if UNITY_EDITOR
-        public override UnityEditor.SupportedRenderingFeatures GetSupportedRenderingFeatures()
-        {
-            var features = new UnityEditor.SupportedRenderingFeatures
-            {
-                reflectionProbe = UnityEditor.SupportedRenderingFeatures.ReflectionProbe.Rotation
-            };
-
-            return features;
-        }
-        #endif
     }
 }

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

     [GenerateHLSL]
     public enum EnvShapeType
     {
-        None, 
-        Box, 
-        Sphere
+        None,
+        Box,
+        Sphere,
+        Sky
     };
 
     [GenerateHLSL]
         public EnvShapeType envShapeType;
 
         public Vector3 forward;
-        public float envIndex;
+        public int envIndex;
 
         public Vector3 up;
         public float blendDistance;     // blend transition outside the volume

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

 #define ENVSHAPETYPE_NONE (0)
 #define ENVSHAPETYPE_BOX (1)
 #define ENVSHAPETYPE_SPHERE (2)
+#define ENVSHAPETYPE_SKY (3)
+
+//
+// UnityEngine.Experimental.ScriptableRenderLoop.EnvConstants:  static fields
+//
+#define ENVCONSTANTS_SPEC_CUBE_LOD_STEP (6)
 
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.LightData
 // PackingRules = Exact
 	float3 positionWS;
 	int envShapeType;
 	float3 forward;
-	float envIndex;
+	int envIndex;
 	float3 up;
 	float blendDistance;
 	float3 right;
 {
 	return value.forward;
 }
-float GetEnvIndex(EnvLightData value)
+int GetEnvIndex(EnvLightData value)
 {
 	return value.envIndex;
 }

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Lighting.hlsl

 
 #ifdef LIGHTLOOP_SINGLE_PASS
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.hlsl"
-#elif  LIGHTLOOP_TILED_PASS
+#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightUtilities.hlsl"
+#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);
-                var cmd = new CommandBuffer { name = "" };
-                cmd.Blit(null, colorBuffer, m_DeferredMaterial, 0);
-                renderLoop.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
+
+                using (new Utilities.ProfilingSample("SinglePass - Deferred Lighting Pass", renderLoop))
+                {
+                    var cmd = new CommandBuffer { name = "" };
+                    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;
-    EnvLightData _EnvLightSky;
+    uint _DirectionalLightCount;
+    uint _PunctualLightCount;
+    uint _AreaLightCount;
+    uint _EnvLightCount;
+    int  _EnvLightSkyEnabled;         // TODO: make it a bool
-    float4 _DirShadowSplitSpheres[4]; // TODO share this max between C# and hlsl
+    float4 _DirShadowSplitSpheres[4]; // TODO: share this max between C# and hlsl
 CBUFFER_END
 
 struct LightLoopContext
     // This code will be inlined as lightLoopContext is hardcoded in the light loop
     if (lightLoopContext.sampleReflection == SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES)
     {
-        return SAMPLE_TEXTURECUBE_ARRAY_LOD(_EnvTextures, sampler_EnvTextures, float4(texCoord, index), lod);
+        return SAMPLE_TEXTURECUBE_ARRAY_LOD(_EnvTextures, sampler_EnvTextures, texCoord, index, lod);
     }
     else // SINGLE_PASS_SAMPLE_SKY
     {

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)
     {
         specularLighting += localSpecularLighting;
     }
 
+    // TODO: Check the reflection hierarchy, for the current system (matching legacy unity) we must sort from bigger solid angle to lower (lower override bigger). So begging by sky
+    // TODO: Change the way it is done by reversing the order, from smaller solid angle to bigger, so we can early out when the weight is 1.
-    for (i = 0; i < _EnvLightCount; ++i)
+    // Only apply sky IBL if the sky texture is available.
+    if (_EnvLightSkyEnabled)
-        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
-        EvaluateBSDF_Env(context, V, positionWS, prelightData, _EnvLightList[i], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-        iblDiffuseLighting  = lerp(iblDiffuseLighting,  localDiffuseLighting,  weight.x); // Should be remove by the compiler if it is smart as all is constant 0
+        // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
+        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
+        EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
+        EvaluateBSDF_Env(context, V, positionWS, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+        iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
-    /*
-    // Sky Ibl
+    for (i = 0; i < _EnvLightCount; ++i)
-        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
-        EvaluateBSDF_Env(context, V, positionWS, prelightData, _EnvLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
+        EvaluateBSDF_Env(context, V, positionWS, prelightData, _EnvLightList[i], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-    */
 
     diffuseLighting  += iblDiffuseLighting;
     specularLighting += iblSpecularLighting;

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

 uniform float g_fFarPlane;
 
 StructuredBuffer<float3> g_vBoundsBuffer : register( t1 );
-StructuredBuffer<SFiniteLightData> g_vLightData : register( t2 );
+StructuredBuffer<LightShapeData> _LightShapeData : register(t2);
 StructuredBuffer<SFiniteLightBound> g_data : register( t3 );
 
 
 
 	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];
-		[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.
+		const uint idxCoarse = lightsListLDS[l];
+        [branch]if (idxCoarse<(uint)g_iNrVisibLights && _LightShapeData[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

 Texture2D g_depth_tex : register( t0 );
 #endif
 StructuredBuffer<float3> g_vBoundsBuffer : register( t1 );
-StructuredBuffer<SFiniteLightData> g_vLightData : register( t2 );
+StructuredBuffer<LightShapeData> _LightShapeData : register(t2);
 StructuredBuffer<SFiniteLightBound> g_data : register( t3 );
 
 #ifdef USE_TWO_PASS_TILED_LIGHTING
 	{
 		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
 		{
 			if(offs<(start+iSpaceAvail) && i<nrClusters && CheckIntersection(l, i, viTilLL.xy, viTilUR.xy, suggestedBase) )
 			{
-				uint lightModel = g_vLightData[ coarseList[l] ].lightModel;
-				++modelListCount[ lightModel==REFLECTION_LIGHT ? 1 : 0];
+                uint lightCategory = _LightShapeData[coarseList[l]].lightCategory;
+                ++modelListCount[lightCategory == REFLECTION_LIGHT ? 1 : 0];
 				g_vLayeredLightList[offs++] = coarseList[l];			// reflection lights will be last since we sorted
 			}
 		}
 		GroupMemoryBarrierWithGroupSync();
 #endif
 		const int idxCoarse = coarseList[l];
-		[branch]if(g_vLightData[idxCoarse].lightType!=SPHERE_LIGHT)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+        [branch]if (_LightShapeData[idxCoarse].lightType != SPHERE_LIGHT)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
 	
 void ClearAtomic(uint threadID : SV_GroupIndex, uint3 u3GroupID : SV_GroupID)
 {
 	g_LayeredSingleIdxBuffer[0]=0;
-}
+}

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

 
 Texture2D g_depth_tex : register( t0 );
 StructuredBuffer<float3> g_vBoundsBuffer : register( t1 );
-StructuredBuffer<SFiniteLightData> g_vLightData : register( t2 );
+StructuredBuffer<LightShapeData> _LightShapeData : register(t2);
 StructuredBuffer<SFiniteLightBound> g_data : register( t3 );
 
 #ifdef USE_TWO_PASS_TILED_LIGHTING
 	int nrLightsCombinedList = min(ldsNrLightsFinal,MAX_NR_COARSE_ENTRIES);
 	for(int i=t; i<nrLightsCombinedList; i+=NR_THREADS) 
 	{
-		InterlockedAdd(ldsModelListCount[ g_vLightData[ prunedList[i] ].lightModel ], 1);
+        InterlockedAdd(ldsModelListCount[_LightShapeData[prunedList[i]].lightCategory], 1);
 	}
 
 
 	// write lights to global buffers
 	int localOffs=0;
 	int offs = tileIDX.y*nrTilesX + tileIDX.x;
+
 	for(int m=0; m<NR_LIGHT_MODELS; m++)
 	{
 		int nrLightsFinal = ldsModelListCount[ m ];
 		const int nrDWords = ((nrLightsFinalClamped+1)+1)>>1;
 		for(int l=(int) t; l<(int) nrDWords; l += NR_THREADS)
 		{
-			uint uLow = l==0 ? nrLightsFinalClamped : prunedList[2*l-1+localOffs];
-			uint uHigh = prunedList[2*l+0+localOffs];
+            // We remap the prunedList index to the original LightData / EnvLightData indices
+			uint uLow = l==0 ? nrLightsFinalClamped : _LightShapeData[prunedList[2*l-1+localOffs]].lightIndex;
+            uint uHigh = _LightShapeData[prunedList[2 * l + 0 + localOffs]].lightIndex;
 
 			g_vLightList[16*offs + l] = (uLow&0xffff) | (uHigh<<16);
 		}
 	}
-
 }
 
 
 	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]];
 	
 	{
 		// fetch light
 		int idxCoarse = l<iNrCoarseLights ? coarseList[l] : 0;
-		uint uLgtType = l<iNrCoarseLights ? g_vLightData[idxCoarse].lightType : 0;
+        uint uLgtType = l<iNrCoarseLights ? _LightShapeData[idxCoarse].lightType : 0;
-			SFiniteLightData lightData = g_vLightData[idxCoarse];
+            LightShapeData lightData = _LightShapeData[idxCoarse];
             // TODO: Change by SebL
             const bool bIsSpotDisc = true; // (lightData.flags&IS_CIRCULAR_SPOT_SHAPE) != 0;
 				
 
 			uLightsFlags[l<32 ? 0 : 1] |= (uVal<<(l&31));
 			++l; idxCoarse = l<iNrCoarseLights ? coarseList[l] : 0;
-			uLgtType = l<iNrCoarseLights ? g_vLightData[idxCoarse].lightType : 0;
+            uLgtType = l<iNrCoarseLights ? _LightShapeData[idxCoarse].lightType : 0;
-			SFiniteLightData lightData = g_vLightData[idxCoarse];
+            LightShapeData lightData = _LightShapeData[idxCoarse];
 
 			// serially check 4 pixels
 			uint uVal = 0;
 
 			uLightsFlags[l<32 ? 0 : 1] |= (uVal<<(l&31));
 			++l; idxCoarse = l<iNrCoarseLights ? coarseList[l] : 0;
-			uLgtType = l<iNrCoarseLights ? g_vLightData[idxCoarse].lightType : 0;
+            uLgtType = l<iNrCoarseLights ? _LightShapeData[idxCoarse].lightType : 0;
-			SFiniteLightData lightData = g_vLightData[idxCoarse];
+            LightShapeData lightData = _LightShapeData[idxCoarse];
 
 			// serially check 4 pixels
 			uint uVal = 0;
 
 			uLightsFlags[l<32 ? 0 : 1] |= (uVal<<(l&31));
 			++l; idxCoarse = l<iNrCoarseLights ? coarseList[l] : 0;
-			uLgtType = l<iNrCoarseLights ? g_vLightData[idxCoarse].lightType : 0;
+            uLgtType = l<iNrCoarseLights ? _LightShapeData[idxCoarse].lightType : 0;
 		}
 
 		// in case we have some corrupt data make sure we terminate
 		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;
         };
 
         [GenerateHLSL]
-        public struct SFiniteLightData
+        public struct LightShapeData
+            public uint lightIndex; // Index in light tabs like LightData / EnvLightData
 
             public Vector3 lightAxisX;
             public uint lightType;
             public float cotan;
  
             public Vector3 boxInnerDist;
-            public uint lightModel;        // DIRECT_LIGHT=0, REFLECTION_LIGHT=1
+            public uint lightCategory;        // DIRECT_LIGHT=0, REFLECTION_LIGHT=1
 
             public Vector3 boxInvRange;
             public float unused2;
             private static int s_GenListPerTileKernel;
             private static int s_GenListPerVoxelKernel;
             private static int s_ClearVoxelAtomicKernel;
-            private static ComputeBuffer s_LightDataBuffer;
+            private static ComputeBuffer s_LightShapeDataBuffer;
             private static ComputeBuffer s_ConvexBoundsBuffer;
             private static ComputeBuffer s_AABBBoundsBuffer;
             private static ComputeBuffer s_LightList;
 
             // 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
             // clustered light list specific buffers and data end
 
             SFiniteLightBound[] m_boundData;
-            SFiniteLightData[] m_lightData;
+            LightShapeData[] m_lightShapeData;
             int m_lightCount;
 
             bool usingFptl
             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
                 if (s_ConvexBoundsBuffer != null)
                     s_ConvexBoundsBuffer.Release();
 
-                if (s_LightDataBuffer != null)
-                    s_LightDataBuffer.Release();
+                if (s_LightShapeDataBuffer != null)
+                    s_LightShapeDataBuffer.Release();
 
                 if (enableClustered)
                 {
                 s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(enableBigTilePrepass ? "TileLightListGen_SrcBigTile" : "TileLightListGen");
                 s_AABBBoundsBuffer = new ComputeBuffer(2 * MaxNumLights, 3 * sizeof(float));
                 s_ConvexBoundsBuffer = new ComputeBuffer(MaxNumLights, System.Runtime.InteropServices.Marshal.SizeOf(typeof(SFiniteLightBound)));
-                s_LightDataBuffer = new ComputeBuffer(MaxNumLights, System.Runtime.InteropServices.Marshal.SizeOf(typeof(SFiniteLightData)));
+                s_LightShapeDataBuffer = new ComputeBuffer(MaxNumLights, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightShapeData)));
-                buildPerTileLightListShader.SetBuffer(s_GenListPerTileKernel, "g_vLightData", s_LightDataBuffer);
+                buildPerTileLightListShader.SetBuffer(s_GenListPerTileKernel, "_LightShapeData", s_LightShapeDataBuffer);
                 buildPerTileLightListShader.SetBuffer(s_GenListPerTileKernel, "g_data", s_ConvexBoundsBuffer);
 
                 if (enableClustered)
                     s_ClearVoxelAtomicKernel = buildPerVoxelLightListShader.FindKernel("ClearAtomic");
                     buildPerVoxelLightListShader.SetBuffer(s_GenListPerVoxelKernel, "g_vBoundsBuffer", s_AABBBoundsBuffer);
-                    buildPerVoxelLightListShader.SetBuffer(s_GenListPerVoxelKernel, "g_vLightData", s_LightDataBuffer);
+                    buildPerVoxelLightListShader.SetBuffer(s_GenListPerVoxelKernel, "_LightShapeData", s_LightShapeDataBuffer);
                     buildPerVoxelLightListShader.SetBuffer(s_GenListPerVoxelKernel, "g_data", s_ConvexBoundsBuffer);
 
                     s_GlobalLightListAtomic = new ComputeBuffer(1, sizeof(uint));
                 {
                     s_GenListPerBigTileKernel = buildPerBigTileLightListShader.FindKernel("BigTileLightListGen");
                     buildPerBigTileLightListShader.SetBuffer(s_GenListPerBigTileKernel, "g_vBoundsBuffer", s_AABBBoundsBuffer);
-                    buildPerBigTileLightListShader.SetBuffer(s_GenListPerBigTileKernel, "g_vLightData", s_LightDataBuffer);
+                    buildPerBigTileLightListShader.SetBuffer(s_GenListPerBigTileKernel, "_LightShapeData", s_LightShapeDataBuffer);
+                s_LightList = null;
-                m_lightData = new SFiniteLightData[MaxNumLights];
+                m_lightShapeData = new LightShapeData[MaxNumLights];
                 m_lightCount = 0;
 
                 s_DirectionalLights = new ComputeBuffer(HDRenderLoop.k_MaxDirectionalLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));
                 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_AABBBoundsBuffer.Release();
                 s_ConvexBoundsBuffer.Release();
-                s_LightDataBuffer.Release();
+                s_LightShapeDataBuffer.Release();
                 ReleaseResolutionDependentBuffers();
 
                 if (enableClustered)
                 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()
                 // add decals here too similar to the above
 
                 // establish offsets
-                for (var m = 0; m < numModels; m++)
+                for (int m = 0; m < numModels; m++)
-                    for (var v = 1; v < numVolTypes; v++)
+                    for (int v = 1; v < numVolTypes; v++)
                     {
                         offsets[m, v] = numEntries[m, v - 1] + offsets[m, v - 1];
                     }
 
                     // Fill bounds
                     var bound = new SFiniteLightBound();
-                    var lightData = new SFiniteLightData();
+                    var lightShapeData = new LightShapeData();
-                    lightData.lightModel = (uint)LightDefinitions.DIRECT_LIGHT;
+                    lightShapeData.lightCategory = (uint)LightDefinitions.DIRECT_LIGHT;
+                    lightShapeData.lightIndex = (uint)lightIndex;
 
                     if (punctualLightData.lightType == GPULightType.Spot || punctualLightData.lightType == GPULightType.ProjectorPyramid)
                     {
                         bound.scaleXY = squeeze ? new Vector2(0.01f, 0.01f) : new Vector2(1.0f, 1.0f);
 
 
-                        lightData.lightAxisX = vx;
-                        lightData.lightAxisY = vy;
-                        lightData.lightAxisZ = vz;
-                        lightData.lightType = (uint)LightDefinitions.SPOT_LIGHT;
-                        lightData.lightPos = worldToView.MultiplyPoint(lightPos);
-                        lightData.radiusSq = range * range;
-                        lightData.cotan = cota;
+                        lightShapeData.lightAxisX = vx;
+                        lightShapeData.lightAxisY = vy;
+                        lightShapeData.lightAxisZ = vz;
+                        lightShapeData.lightType = (uint)LightDefinitions.SPOT_LIGHT;
+                        lightShapeData.lightPos = worldToView.MultiplyPoint(lightPos);
+                        lightShapeData.radiusSq = range * range;
+                        lightShapeData.cotan = cota;
 
                         int i = LightDefinitions.DIRECT_LIGHT, j = LightDefinitions.SPOT_LIGHT;
                         index = numEntries2nd[i, j] + offsets[i, j]; ++numEntries2nd[i, j];
                         Vector3 vz = lightToView.GetColumn(2);
 
                         // fill up ldata
-                        lightData.lightAxisX = vx;
-                        lightData.lightAxisY = vy;
-                        lightData.lightAxisZ = vz;
-                        lightData.lightType = (uint)LightDefinitions.SPHERE_LIGHT;
-                        lightData.lightPos = bound.center;
-                        lightData.radiusSq = range * range;
+                        lightShapeData.lightAxisX = vx;
+                        lightShapeData.lightAxisY = vy;
+                        lightShapeData.lightAxisZ = vz;
+                        lightShapeData.lightType = (uint)LightDefinitions.SPHERE_LIGHT;
+                        lightShapeData.lightPos = bound.center;
+                        lightShapeData.radiusSq = range * range;
 
                         int i = LightDefinitions.DIRECT_LIGHT, j = LightDefinitions.SPHERE_LIGHT;
                         index = numEntries2nd[i, j] + offsets[i, j]; ++numEntries2nd[i, j];
-                    m_lightData[index] = lightData;
+                    m_lightShapeData[index] = lightShapeData;
                 }
 
                 for (int envIndex = 0; envIndex < lightList.envLights.Count; envIndex++)
 
-                    var bound = new SFiniteLightBound();
-                    var lightData = new SFiniteLightData();
+                    var bound = new SFiniteLightBound();                    
 
                     var bnds = probe.bounds;
                     var boxOffset = probe.center;                  // reflection volume offset relative to cube map capture point
                     bound.scaleXY.Set(1.0f, 1.0f);
                     bound.radius = combinedExtent.magnitude;
 
-                    lightData.lightPos = Cw;
-                    lightData.lightAxisX = vx;
-                    lightData.lightAxisY = vy;
-                    lightData.lightAxisZ = vz;
+                    var lightShapeData = new LightShapeData();
+                    lightShapeData.lightType = (uint)LightDefinitions.BOX_LIGHT;
+                    lightShapeData.lightCategory = (uint)LightDefinitions.REFLECTION_LIGHT;
+                    lightShapeData.lightIndex = (uint)envIndex;
+
+                    lightShapeData.lightPos = Cw;
+                    lightShapeData.lightAxisX = vx;
+                    lightShapeData.lightAxisY = vy;
+                    lightShapeData.lightAxisZ = vz;
-                    lightData.boxInnerDist = e;
-                    lightData.boxInvRange.Set(1.0f / delta.x, 1.0f / delta.y, 1.0f / delta.z);
+                    lightShapeData.boxInnerDist = e;
+                    lightShapeData.boxInvRange.Set(1.0f / delta.x, 1.0f / delta.y, 1.0f / delta.z);
+                    m_lightShapeData[index] = lightShapeData;
                 }
 
                 // 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_LightShapeDataBuffer.SetData(m_lightShapeData);
-            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 bUseClusteredForDeferred = !usingFptl;       // doesn't work on reflections yet but will soon
-                var cmd = new CommandBuffer();
+                var bUseClusteredForDeferred = !usingFptl;
-                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);
-                cmd.SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
+                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);
+                m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                // In case of bUseClusteredForDeferred disable toggle option since we're using m_perVoxelLightLists as opposed to lightList
-                if (bUseClusteredForDeferred)
+                using (new Utilities.ProfilingSample("TilePass - Deferred Lighting Pass", renderLoop))
-                    cmd.SetGlobalFloat("g_isOpaquesOnlyEnabled", 0);
-                }
-                cmd.name = "DoTiledDeferredLighting";
+                    var cmd = new CommandBuffer();
+                    cmd.SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
-                /*
-                if (enableComputeLightEvaluation)  //TODO: temporary workaround for "All kernels must use same constant buffer layouts"
-                {
-                    var w = camera.pixelWidth;
-                    var h = camera.pixelHeight;
-                    var numTilesX = (w + 7) / 8;
-                    var numTilesY = (h + 7) / 8;
+                    // In case of bUseClusteredForDeferred disable toggle option since we're using m_perVoxelLightLists as opposed to lightList
+                    if (bUseClusteredForDeferred)
+                    {
+                        cmd.SetGlobalFloat("_UseTileLightList", 0);
+                    }
-                    string kernelName = "ShadeDeferred" + (bUseClusteredForDeferred ? "_Clustered" : "_Fptl") + (enableDrawTileDebug ? "_Debug" : "");
-                    int kernel = deferredComputeShader.FindKernel(kernelName);
+                    /*
+                    if (enableComputeLightEvaluation)  //TODO: temporary workaround for "All kernels must use same constant buffer layouts"
+                    {
+                        var w = camera.pixelWidth;
+                        var h = camera.pixelHeight;
+                        var numTilesX = (w + 7) / 8;
+                        var numTilesY = (h + 7) / 8;
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraDepthTexture", new RenderTargetIdentifier(s_CameraDepthTexture));
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture0", new RenderTargetIdentifier(s_GBufferAlbedo));
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture1", new RenderTargetIdentifier(s_GBufferSpecRough));
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture2", new RenderTargetIdentifier(s_GBufferNormal));
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture3", new RenderTargetIdentifier(s_GBufferEmission));
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_spotCookieTextures", m_CookieTexArray.GetTexCache());
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_pointCookieTextures", m_CubeCookieTexArray.GetTexCache());
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_reflCubeTextures", m_CubeReflTexArray.GetTexCache());
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_reflRootCubeTexture", ReflectionProbe.GetDefaultTexture());
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "g_tShadowBuffer", new RenderTargetIdentifier(m_shadowBufferID));
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "unity_NHxRoughness", m_NHxRoughnessTexture);
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_LightTextureB0", m_LightAttentuationTexture);
+                        string kernelName = "ShadeDeferred" + (bUseClusteredForDeferred ? "_Clustered" : "_Fptl") + (enableDrawTileDebug ? "_Debug" : "");
+                        int kernel = deferredComputeShader.FindKernel(kernelName);
-                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
-                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLightData", s_LightDataBuffer);
-                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_dirLightData", s_DirLightList);
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraDepthTexture", new RenderTargetIdentifier(s_CameraDepthTexture));
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture0", new RenderTargetIdentifier(s_GBufferAlbedo));
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture1", new RenderTargetIdentifier(s_GBufferSpecRough));
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture2", new RenderTargetIdentifier(s_GBufferNormal));
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture3", new RenderTargetIdentifier(s_GBufferEmission));
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_spotCookieTextures", m_CookieTexArray.GetTexCache());
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_pointCookieTextures", m_CubeCookieTexArray.GetTexCache());
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_reflCubeTextures", m_CubeReflTexArray.GetTexCache());
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_reflRootCubeTexture", ReflectionProbe.GetDefaultTexture());
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "g_tShadowBuffer", new RenderTargetIdentifier(m_shadowBufferID));
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "unity_NHxRoughness", m_NHxRoughnessTexture);
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_LightTextureB0", m_LightAttentuationTexture);
-                    var defdecode = ReflectionProbe.GetDefaultTextureHDRDecodeValues();
-                    cmd.SetComputeFloatParam(deferredComputeShader, "_reflRootHdrDecodeMult", defdecode.x);
-                    cmd.SetComputeFloatParam(deferredComputeShader, "_reflRootHdrDecodeExp", defdecode.y);
+                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
+                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "_LightShapeData", s_LightShapeDataBuffer);
+                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_dirLightData", s_DirLightList);
-                    cmd.SetComputeFloatParam(deferredComputeShader, "g_fClustScale", m_ClustScale);
-                    cmd.SetComputeFloatParam(deferredComputeShader, "g_fClustBase", k_ClustLogBase);
-                    cmd.SetComputeFloatParam(deferredComputeShader, "g_fNearPlane", camera.nearClipPlane);
-                    cmd.SetComputeFloatParam(deferredComputeShader, "g_fFarPlane", camera.farClipPlane);
-                    cmd.SetComputeIntParam(deferredComputeShader, "g_iLog2NumClusters", k_Log2NumClusters);
-                    cmd.SetComputeIntParam(deferredComputeShader, "g_isLogBaseBufferEnabled", k_UseDepthBuffer ? 1 : 0);
-                    cmd.SetComputeIntParam(deferredComputeShader, "g_isOpaquesOnlyEnabled", 0);
+                        var defdecode = ReflectionProbe.GetDefaultTextureHDRDecodeValues();
+                        cmd.SetComputeFloatParam(deferredComputeShader, "_reflRootHdrDecodeMult", defdecode.x);
+                        cmd.SetComputeFloatParam(deferredComputeShader, "_reflRootHdrDecodeExp", defdecode.y);
+                        cmd.SetComputeFloatParam(deferredComputeShader, "g_fClustScale", m_ClustScale);
+                        cmd.SetComputeFloatParam(deferredComputeShader, "g_fClustBase", k_ClustLogBase);
+                        cmd.SetComputeFloatParam(deferredComputeShader, "g_fNearPlane", camera.nearClipPlane);
+                        cmd.SetComputeFloatParam(deferredComputeShader, "g_fFarPlane", camera.farClipPlane);
+                        cmd.SetComputeIntParam(deferredComputeShader, "g_iLog2NumClusters", k_Log2NumClusters);
+                        cmd.SetComputeIntParam(deferredComputeShader, "g_isLogBaseBufferEnabled", k_UseDepthBuffer ? 1 : 0);
+                        cmd.SetComputeIntParam(deferredComputeShader, "_UseTileLightList", 0);
-                    //
-                    var proj = camera.projectionMatrix;
-                    var temp = new Matrix4x4();
-                    temp.SetRow(0, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
-                    temp.SetRow(1, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
-                    temp.SetRow(2, new Vector4(0.0f, 0.0f, 0.5f, 0.5f));
-                    temp.SetRow(3, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
-                    var projh = temp * proj;
-                    var invProjh = projh.inverse;
-                    temp.SetRow(0, new Vector4(0.5f * w, 0.0f, 0.0f, 0.5f * w));
-                    temp.SetRow(1, new Vector4(0.0f, 0.5f * h, 0.0f, 0.5f * h));
-                    temp.SetRow(2, new Vector4(0.0f, 0.0f, 0.5f, 0.5f));
-                    temp.SetRow(3, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
-                    var projscr = temp * proj;
-                    var invProjscr = projscr.inverse;
+                        //
+                        var proj = camera.projectionMatrix;
+                        var temp = new Matrix4x4();
+                        temp.SetRow(0, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
+                        temp.SetRow(1, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
+                        temp.SetRow(2, new Vector4(0.0f, 0.0f, 0.5f, 0.5f));
+                        temp.SetRow(3, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+                        var projh = temp * proj;
+                        var invProjh = projh.inverse;
-                    cmd.SetComputeIntParam(deferredComputeShader, "g_iNrVisibLights", numLights);
-                    SetMatrixCS(cmd, deferredComputeShader, "g_mScrProjection", projscr);
-                    SetMatrixCS(cmd, deferredComputeShader, "g_mInvScrProjection", invProjscr);
-                    SetMatrixCS(cmd, deferredComputeShader, "g_mViewToWorld", camera.cameraToWorldMatrix);
+                        temp.SetRow(0, new Vector4(0.5f * w, 0.0f, 0.0f, 0.5f * w));
+                        temp.SetRow(1, new Vector4(0.0f, 0.5f * h, 0.0f, 0.5f * h));
+                        temp.SetRow(2, new Vector4(0.0f, 0.0f, 0.5f, 0.5f));
+                        temp.SetRow(3, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+                        var projscr = temp * proj;
+                        var invProjscr = projscr.inverse;
+                        cmd.SetComputeIntParam(deferredComputeShader, "g_iNrVisibLights", numLights);
+                        SetMatrixCS(cmd, deferredComputeShader, "g_mScrProjection", projscr);
+                        SetMatrixCS(cmd, deferredComputeShader, "g_mInvScrProjection", invProjscr);
+                        SetMatrixCS(cmd, deferredComputeShader, "g_mViewToWorld", camera.cameraToWorldMatrix);
-                    if (bUseClusteredForDeferred)
-                    {
-                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLayeredOffsetsBuffer", s_PerVoxelOffset);
-                        if (k_UseDepthBuffer)
+
+                        if (bUseClusteredForDeferred)
-                            cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_logBaseBuffer", s_PerTileLogBaseTweak);
+                            cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLayeredOffsetsBuffer", s_PerVoxelOffset);
+                            if (k_UseDepthBuffer)
+                            {
+                                cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_logBaseBuffer", s_PerTileLogBaseTweak);
+                            }
+
+                        cmd.SetComputeIntParam(deferredComputeShader, "g_widthRT", w);
+                        cmd.SetComputeIntParam(deferredComputeShader, "g_heightRT", h);
+                        cmd.SetComputeIntParam(deferredComputeShader, "g_nNumDirLights", numDirLights);
+                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_dirLightData", s_DirLightList);
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "uavOutput", new RenderTargetIdentifier(s_CameraTarget));
+
+                        SetMatrixArrayCS(cmd, deferredComputeShader, "g_matWorldToShadow", m_MatWorldToShadow);
+                        SetVectorArrayCS(cmd, deferredComputeShader, "g_vDirShadowSplitSpheres", m_DirShadowSplitSpheres);
+                        cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms0", m_Shadow3X3PCFTerms[0]);
+                        cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms1", m_Shadow3X3PCFTerms[1]);
+                        cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms2", m_Shadow3X3PCFTerms[2]);
+                        cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms3", m_Shadow3X3PCFTerms[3]);
+
+                        cmd.DispatchCompute(deferredComputeShader, kernel, numTilesX, numTilesY, 1);
+                    else
+                    {*/
+                    if (enableDirectIndirectSinglePass)
+                    {
+                        cmd.Blit(null, cameraColorBufferRT, m_DeferredAllMaterial, 0);
+                    }
+                    else
+                    {
+                        cmd.Blit(null, cameraColorBufferRT, m_DeferredDirectMaterial, 0);
+                        cmd.Blit(null, cameraColorBufferRT, m_DeferredIndirectMaterial, 0);
+                    }
+                    //}
-                    cmd.SetComputeIntParam(deferredComputeShader, "g_widthRT", w);
-                    cmd.SetComputeIntParam(deferredComputeShader, "g_heightRT", h);
-                    cmd.SetComputeIntParam(deferredComputeShader, "g_nNumDirLights", numDirLights);
-                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_dirLightData", s_DirLightList);
-                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "uavOutput", new RenderTargetIdentifier(s_CameraTarget));
+                    if (debugViewTilesFlags != 0)
+                    {
+                        cmd.Blit(null, cameraColorBufferRT, m_DebugViewTilesMaterial, 0);
+                    }
-                    SetMatrixArrayCS(cmd, deferredComputeShader, "g_matWorldToShadow", m_MatWorldToShadow);
-                    SetVectorArrayCS(cmd, deferredComputeShader, "g_vDirShadowSplitSpheres", m_DirShadowSplitSpheres);
-                    cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms0", m_Shadow3X3PCFTerms[0]);
-                    cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms1", m_Shadow3X3PCFTerms[1]);
-                    cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms2", m_Shadow3X3PCFTerms[2]);
-                    cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms3", m_Shadow3X3PCFTerms[3]);
+                    renderLoop.ExecuteCommandBuffer(cmd);
+                    cmd.Dispose();
+                } // TilePass - Deferred Lighting Pass
-                    cmd.DispatchCompute(deferredComputeShader, kernel, numTilesX, numTilesY, 1);
-                }
-                else
-                {*/
-                    cmd.Blit(0, colorBuffer, m_DeferredMaterial, 0);
-                    cmd.Blit(0, colorBuffer, m_DeferredReflectionMaterial, 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
 	float radius;
 };
 
-// Generated from UnityEngine.Experimental.ScriptableRenderLoop.TilePass.SFiniteLightData
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.TilePass.LightShapeData
-struct SFiniteLightData
+struct LightShapeData
+	uint lightIndex;
 	float3 lightAxisX;
 	uint lightType;
 	float3 lightAxisY;
 	float3 boxInnerDist;
-	uint lightModel;
+	uint lightCategory;
 	float3 boxInvRange;
 	float unused2;
 };
 }
 
 //
-// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.TilePass.SFiniteLightData
+// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.TilePass.LightShapeData
-float3 GetLightPos(SFiniteLightData value)
+float3 GetLightPos(LightShapeData value)
-float3 GetLightAxisX(SFiniteLightData value)
+uint GetLightIndex(LightShapeData value)
+{
+	return value.lightIndex;
+}
+float3 GetLightAxisX(LightShapeData value)
-uint GetLightType(SFiniteLightData value)
+uint GetLightType(LightShapeData value)
-float3 GetLightAxisY(SFiniteLightData value)
+float3 GetLightAxisY(LightShapeData value)
-float GetRadiusSq(SFiniteLightData value)
+float GetRadiusSq(LightShapeData value)
-float3 GetLightAxisZ(SFiniteLightData value)
+float3 GetLightAxisZ(LightShapeData value)
-float GetCotan(SFiniteLightData value)
+float GetCotan(LightShapeData value)
-float3 GetBoxInnerDist(SFiniteLightData value)
+float3 GetBoxInnerDist(LightShapeData value)
-uint GetLightModel(SFiniteLightData value)
+uint GetLightCategory(LightShapeData value)
-	return value.lightModel;
+	return value.lightCategory;
-float3 GetBoxInvRange(SFiniteLightData value)
+float3 GetBoxInvRange(LightShapeData value)
-float GetUnused2(SFiniteLightData value)
+float GetUnused2(LightShapeData value)
 {
 	return value.unused2;
 }

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)
 int g_iLog2NumClusters;	// We need to always define these to keep constant buffer layouts compatible
 
 uint g_isLogBaseBufferEnabled;
-uint g_isOpaquesOnlyEnabled;
+uint _UseTileLightList;
 //#endif
 
 #ifdef USE_CLUSTERED_LIGHTLIST
 
 // TODO: Need to correctly define the shadow framework, WIP
-#include "../SinglePass/SinglePass.hlsl"
+#include "../SinglePass/SinglePass.hlsl"

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

     return (tileIndex.y + lightCategory * _NumTileY) * _NumTileX + tileIndex.x;
 }
 
-void GetCountAndStartOpaque(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
+void GetCountAndStartTile(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
-    lightCount = g_vLightListGlobal[DWORD_PER_TILE * tileOffs + 0] & 0xffff;
+    lightCount = g_vLightListGlobal[DWORD_PER_TILE * tileOffset + 0] & 0xffff;
-uint FetchIndexOpaque(uint tileOffset, uint lightIndex)
+uint FetchIndexTile(uint tileOffset, uint lightIndex)
+
-    GetCountAndStartOpaque(coord, lightCategory, linearDepth, start, lightCount);
+    GetCountAndStartTile(coord, lightCategory, linearDepth, start, lightCount);
-    return FetchIndexOpaque(tileOffs, lightIndex);
+    return FetchIndexTile(tileOffset, lightIndex);
 }
 
 #else
-void GetCountAndStart(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
+void GetCountAndStartCluster(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
-    if(g_isOpaquesOnlyEnabled)
+    uint2 tileIndex = coord.unPositionSS / TILE_SIZE;
+
+    float logBase = g_fClustBase;
+    if (g_isLogBaseBufferEnabled)
-        GetCountAndStartOpaque(coord, lightCategory, linearDepth, start, lightCount);
+        logBase = g_logBaseBuffer[tileIndex.y * _NumTileX + tileIndex.x];
-    else
-    {
-        uint2 tileIndex = coord.unPositionSS / TILE_SIZE;
-        float logBase = g_fClustBase;
-        if (g_isLogBaseBufferEnabled)
-        {
-            logBase = g_logBaseBuffer[tileIndex.y * _NumTileX + tileIndex.x];
-        }
+    int clustIdx = SnapToClusterIdxFlex(linearDepth, logBase, g_isLogBaseBufferEnabled != 0);
-        int clustIdx = SnapToClusterIdxFlex(linearDepth, logBase, g_isLogBaseBufferEnabled != 0);
+    int nrClusters = (1 << g_iLog2NumClusters);
+    const int idx = ((lightCategory * nrClusters + clustIdx) * _NumTileY + tileIndex.y) * _NumTileX + tileIndex.x;
+    uint dataPair = g_vLayeredOffsetsBuffer[idx];
+    start = dataPair & 0x7ffffff;
+    lightCount = (dataPair >> 27) & 31;
+}
-        int nrClusters = (1 << g_iLog2NumClusters);
-        const int idx = ((model * nrClusters + clustIdx) * _NumTileY + tileIndex.y) * _NumTileX + tileIndex.x;
-        uint dataPair = g_vLayeredOffsetsBuffer[idx];
-        start = dataPair & 0x7ffffff;
-        lightCount = (dataPair >> 27) & 31;
-    }
+uint FetchIndexCluster(uint tileOffset, uint lightIndex)
+{
+    return g_vLightListGlobal[tileOffset + lightIndex];
+}
+
+void GetCountAndStart(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
+{
+    if (_UseTileLightList)
+        GetCountAndStartTile(coord, lightCategory, linearDepth, start, lightCount);
+    else
+        GetCountAndStartCluster(coord, lightCategory, linearDepth, start, lightCount);
-    if(g_isOpaquesOnlyEnabled)
-        return FetchIndexOpaque(tileOffset, lightIndex);
+    if (_UseTileLightList)
+        return FetchIndexTile(tileOffset, lightIndex);
-        return g_vLightListGlobal[tileOffset + lightIndex];
+        return FetchIndexCluster(tileOffset, lightIndex);
 }
 
 float GetLinearDepth(float zDptBufSpace)    // 0 is near 1 is far
                 out float3 diffuseLighting,
                 out float3 specularLighting)
 {
-#if USE_CLUSTERED_LIGHTLIST
-    // TODO: Think more about the design, it is ok to do that ? hope the compiler could optimize it out as we do it before LightLoop call, else need to pass it as argument...
+#ifdef USE_CLUSTERED_LIGHTLIST
+    // TODO: Think more about the design, it is ok to do that ? hope the compiler could optimize it out as we already depth before LightLoop call, else need to pass it as argument...
-    float linearDepth = 0.0; // unsued
+    float linearDepth = 0.0; // unused
 #endif
 
     LightLoopContext context;
     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 System.Linq;
 
-namespace UnityEditor
+namespace UnityEditor.Experimental.ScriptableRenderLoop
 {
     internal class LayeredLitGUI : LitGUI
     {
 
 					if(!exclusionList.Contains(propertyName))
 					{
-						if (material.HasProperty(layerPropertyName))
-						{
-							ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(layerShader, i);
-							switch (type)
-							{
-								case ShaderUtil.ShaderPropertyType.Color:
-									{
-										material.SetColor(layerPropertyName, layerMaterial.GetColor(propertyName));
-										break;
-									}
-								case ShaderUtil.ShaderPropertyType.Float:
-								case ShaderUtil.ShaderPropertyType.Range:
-									{
-										material.SetFloat(layerPropertyName, layerMaterial.GetFloat(propertyName));
-										break;
-									}
-								case ShaderUtil.ShaderPropertyType.Vector:
-									{
-										material.SetVector(layerPropertyName, layerMaterial.GetVector(propertyName));
-										break;
-									}
-								case ShaderUtil.ShaderPropertyType.TexEnv:
-									{
-										material.SetTexture(layerPropertyName, layerMaterial.GetTexture(propertyName));
-										break;
-									}
-							}
-						}
-					}
+                    if (material.HasProperty(layerPropertyName))
+                    {
+                        ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(layerShader, i);
+                        switch (type)
+                        {
+                            case ShaderUtil.ShaderPropertyType.Color:
+                            {
+                                material.SetColor(layerPropertyName, layerMaterial.GetColor(propertyName));
+                                break;
+                            }
+                            case ShaderUtil.ShaderPropertyType.Float:
+                            case ShaderUtil.ShaderPropertyType.Range:
+                            {
+                                material.SetFloat(layerPropertyName, layerMaterial.GetFloat(propertyName));
+                                break;
+                            }
+                            case ShaderUtil.ShaderPropertyType.Vector:
+                            {
+                                material.SetVector(layerPropertyName, layerMaterial.GetVector(propertyName));
+                                break;
+                            }
+                            case ShaderUtil.ShaderPropertyType.TexEnv:
+                            {
+                                material.SetTexture(layerPropertyName, layerMaterial.GetTexture(propertyName));
+                                break;
+                            }
+                        }
+                    }
+        }
         }
 
         void InitializeMaterialLayers(AssetImporter materialImporter)

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

         }
     }
 
-    CustomEditor "LayeredLitGUI"
+	CustomEditor "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
-    {
-        protected static class Styles
-        {
-            public static string OptionText = "Options";
-            public static string SurfaceTypeText = "Surface Type";
-            public static string BlendModeText = "Blend Mode";
-            public static string detailText = "Inputs Detail";
-            public static string lightingText = "Inputs Lighting";
-
-            public static GUIContent alphaCutoffEnableText = new GUIContent("Alpha Cutoff Enable", "Threshold for alpha cutoff");
-            public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
-            public static GUIContent doubleSidedModeText = new GUIContent("Double Sided", "This will render the two face of the objects (disable backface culling)");
-
-            public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
-            public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
-
-            public static string InputsOptionsText = "Inputs options";
-
-            public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel");
-            public static GUIContent UVBaseMappingText = new GUIContent("UV set for Base", "");
-            public static GUIContent texWorldScaleText = new GUIContent("Scale to apply on world coordinate in case of Planar/Triplanar", "");
-            public static GUIContent UVBaseDetailMappingText = new GUIContent("UV set for Base and Detail", "");
-            public static GUIContent normalMapSpaceText = new GUIContent("Normal/Tangent Map space", "");
-            public static GUIContent heightMapModeText = new GUIContent("Height Map Mode", "");
-            public static GUIContent detailMapModeText = new GUIContent("Detail Map with Normal", "Detail Map with AO / Height");
-            public static GUIContent UVDetailMappingText = new GUIContent("UV set for Detail", "");
-            public static GUIContent emissiveColorModeText = new GUIContent("Emissive Color Usage", "Use emissive color or emissive mask");
-
-            public static string InputsText = "Inputs";
-
-            public static string InputsMapText = "";
-
-            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 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");
-            public static GUIContent maskMapText = new GUIContent("Mask Map - M(R), AO(G)", "Mask map");
-            public static GUIContent maskMapSText = new GUIContent("Mask Map - M(R), AO(G), S(A)", "Mask map");
-
-            public static GUIContent specularOcclusionMapText = new GUIContent("Specular Occlusion Map (RGBA)", "Specular Occlusion Map");
-
-            public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (DXT5) - Need to implement BC5");
- 
-            public static GUIContent heightMapText = new GUIContent("Height Map (R)", "Height Map");
-
-            public static GUIContent tangentMapText = new GUIContent("Tangent Map", "Tangent Map (BC5) - DXT5 for test");
-            public static GUIContent anisotropyText = new GUIContent("Anisotropy", "Anisotropy scale factor");
-            public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map (G)", "Anisotropy");
-
-            public static GUIContent detailMapNormalText = new GUIContent("Detail Map A(R) Ny(G) S(B) Nx(A)", "Detail Map");
-            public static GUIContent detailMapAOHeightText = new GUIContent("Detail Map  A(R) AO(G) S(B) H(A)", "Detail Map");
-            public static GUIContent detailMaskText = new GUIContent("Detail Mask (B)", "Mask for detailMap");
-            public static GUIContent detailAlbedoScaleText = new GUIContent("Detail AlbedoScale", "Detail Albedo Scale factor");
-            public static GUIContent detailNormalScaleText = new GUIContent("Detail NormalScale", "Normal Scale factor");
-            public static GUIContent detailSmoothnessScaleText = new GUIContent("Detail SmoothnessScale", "Smoothness Scale factor");
-            public static GUIContent detailHeightScaleText = new GUIContent("Detail HeightScale", "Height Scale factor");
-            public static GUIContent detailAOScaleText = new GUIContent("Detail AOScale", "AO Scale factor");
-
-            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
-            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
-
-            public static GUIContent emissiveWarning = new GUIContent("Emissive value is animated but the material has not been configured to support emissive. Please make sure the material itself has some amount of emissive.");
-            public static GUIContent emissiveColorWarning = new GUIContent("Ensure emissive color is non-black for emission to have effect.");
-        }
-
-        public enum SurfaceType
-        {
-            Opaque,
-            Transparent
-        }
-        public enum BlendMode
-        {
-            Lerp,
-            Add,
-            SoftAdd,
-            Multiply,
-            Premultiply
-        }
-        public enum DoubleSidedMode
-        {
-            None,
-            DoubleSided,
-            DoubleSidedLightingFlip,
-            DoubleSidedLightingMirror,
-        }
-
-        void SurfaceTypePopup()
-        {
-            EditorGUI.showMixedValue = surfaceType.hasMixedValue;
-            var mode = (SurfaceType)surfaceType.floatValue;
-
-            EditorGUI.BeginChangeCheck();
-            mode = (SurfaceType)EditorGUILayout.Popup(Styles.SurfaceTypeText, (int)mode, Styles.surfaceTypeNames);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
-                surfaceType.floatValue = (float)mode;
-            }
-
-            EditorGUI.showMixedValue = false;
-        }
-
-        protected void ShaderOptionsGUI()
-        {
-            EditorGUI.indentLevel++;
-            GUILayout.Label(Styles.OptionText, EditorStyles.boldLabel);
-            SurfaceTypePopup();
-            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
-            {
-                BlendModePopup();
-            }
-            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, Styles.alphaCutoffEnableText.text);
-            if (alphaCutoffEnable.floatValue == 1.0)
-            {
-                m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
-            }
-            m_MaterialEditor.ShaderProperty(doubleSidedMode, Styles.doubleSidedModeText.text);
-
-            EditorGUI.indentLevel--;
-        }
-
-        private void BlendModePopup()
-        {
-            EditorGUI.showMixedValue = blendMode.hasMixedValue;
-            var mode = (BlendMode)blendMode.floatValue;
-
-            EditorGUI.BeginChangeCheck();
-            mode = (BlendMode)EditorGUILayout.Popup(Styles.BlendModeText, (int)mode, Styles.blendModeNames);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
-                blendMode.floatValue = (float)mode;
-            }
-
-            EditorGUI.showMixedValue = false;
-        }
-
-        protected void FindOptionProperties(MaterialProperty[] props)
-        {
-            surfaceType = FindProperty(kSurfaceType, props);
-            blendMode = FindProperty(kBlendMode, props);
-            alphaCutoff = FindProperty(kAlphaCutoff, props);
-            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
-            doubleSidedMode = FindProperty(kDoubleSidedMode, props);
-            FindInputOptionProperties(props);
-        }
-
-        protected void SetupMaterial(Material material)
-        {
-            bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
-            SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
-            BlendMode blendMode = (BlendMode)material.GetFloat(kBlendMode);
-            DoubleSidedMode doubleSidedMode = (DoubleSidedMode)material.GetFloat(kDoubleSidedMode);
-
-            if (surfaceType == SurfaceType.Opaque)
-            {
-                material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : "");
-                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                material.SetInt("_ZWrite", 1);
-                material.renderQueue = alphaTestEnable ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : -1;
-            }
-            else
-            {
-                material.SetOverrideTag("RenderType", "Transparent");
-                material.SetInt("_ZWrite", 0);
-                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
-
-                switch (blendMode)
-                {
-                    case BlendMode.Lerp:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
-                        break;
-
-                    case BlendMode.Add:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        break;
-
-                    case BlendMode.SoftAdd:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        break;
-
-                    case BlendMode.Multiply:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                        break;
-
-                    case BlendMode.Premultiply:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
-                        break;
-                }
-            }
-
-            if (doubleSidedMode == DoubleSidedMode.None)
-            {
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back);
-            }
-            else
-            {
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Off);
-            }
-
-            if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingFlip)
-            {
-                material.EnableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-            else if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingMirror)
-            {
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.EnableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-            else
-            {
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-
-            SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
-            SetupInputMaterial(material);
-        }
-
-        protected void SetKeyword(Material m, string keyword, bool state)
-        {
-            if (state)
-                m.EnableKeyword(keyword);
-            else
-                m.DisableKeyword(keyword);
-        }
-
-        public void ShaderPropertiesGUI(Material material)
-        {
-            // Use default labelWidth
-            EditorGUIUtility.labelWidth = 0f;
-
-            // Detect any changes to the material
-            EditorGUI.BeginChangeCheck();
-            {
-                ShaderOptionsGUI();
-                EditorGUILayout.Space();
-
-                ShaderInputOptionsGUI();
-
-                EditorGUILayout.Space();
-                ShaderInputGUI();
-            }
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                foreach (var obj in m_MaterialEditor.targets)
-                    SetupMaterial((Material)obj);
-            }
-        }
-
-        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
-        {
-            FindOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
-            FindInputProperties(props);
-
-            m_MaterialEditor = materialEditor;
-            Material material = materialEditor.target as Material;
-            ShaderPropertiesGUI(material);
-        }
-
-        protected MaterialEditor m_MaterialEditor;
-
-        MaterialProperty surfaceType = null;
-        MaterialProperty alphaCutoffEnable = null;
-        MaterialProperty blendMode = null;
-        MaterialProperty alphaCutoff = null;
-        MaterialProperty doubleSidedMode = null;
- 
-        const string kSurfaceType = "_SurfaceType";
-        const string kBlendMode = "_BlendMode";
-        const string kAlphaCutoff = "_AlphaCutoff";
-        const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
-        const string kDoubleSidedMode = "_DoubleSidedMode";
-        protected static string[] reservedProperties = new string[] { kSurfaceType, kBlendMode, kAlphaCutoff, kAlphaCutoffEnabled, kDoubleSidedMode };
-
-        protected abstract void FindInputProperties(MaterialProperty[] props);
-        protected abstract void ShaderInputGUI();
-        protected abstract void ShaderInputOptionsGUI();
-        protected abstract void FindInputOptionProperties(MaterialProperty[] props);
-        protected abstract void SetupInputMaterial(Material material);
-    }
-
     class LitGUI : BaseLitGUI
     {
         public enum SmoothnessMapChannel
             SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
         }
 
-        public static bool ShouldEmissionBeEnabled(Material mat)
+        protected override bool ShouldEmissionBeEnabled(Material mat)
         {
             float emissiveIntensity = mat.GetFloat(kEmissiveIntensity);
             var realtimeEmission = (mat.globalIlluminationFlags & MaterialGlobalIlluminationFlags.RealtimeEmissive) > 0;
-        protected virtual void SetupEmissionGIFlags(Material material)
-        {
-            // Setup lightmap emissive flags
-            MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
-            if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
-            {
-                if (ShouldEmissionBeEnabled(material))
-                    flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
-                else
-                    flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
-
-                material.globalIlluminationFlags = flags;
-            }
-        }
-
         override protected void SetupInputMaterial(Material material)
         {
             // Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation
             SetKeyword(material, "_EMISSIVE_COLOR", ((EmissiveColorMode)material.GetFloat(kEmissiveColorMode)) == EmissiveColorMode.UseEmissiveColor);
  
             SetupKeywordsForInputMaps(material);
-            SetupEmissionGIFlags(material);
-        }
-
-        // TODO: ? or remove
-        bool HasValidEmissiveKeyword(Material material)
-        {
-            /*
-            // Material animation might be out of sync with the material keyword.
-            // So if the emission support is disabled on the material, but the property blocks have a value that requires it, then we need to show a warning.
-            // (note: (Renderer MaterialPropertyBlock applies its values to emissionColorForRendering))
-            bool hasEmissionKeyword = material.IsKeywordEnabled ("_EMISSION");
-            if (!hasEmissionKeyword && ShouldEmissionBeEnabled (material, emissionColorForRendering.colorValue))
-                return false;
-            else
-                return true;
-            */
-
-            return true;
         }
     }
 } // namespace UnityEditor

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

     // Aniso
     float TdotV;
     float BdotV;
-    
+
-    // image based lighting
-    // These variables aim to be use with EvaluateBSDF_Env 
-    float3 iblNormalWS; // Normal to be use with image based lighting
-    float3 iblR;        // Reflection vector, same as above.
+    float3 iblDirWS;    // Dominant specular direction, used for IBL in EvaluateBSDF_Env()
 
     float3 specularFGD; // Store preconvole BRDF for both specular and diffuse
     float diffuseFGD;
 
     preLightData.ggxLambdaV = GetSmithJointGGXLambdaV(preLightData.NdotV, bsdfData.roughness);
 
-    float iblNdotV = preLightData.NdotV;
+    float  iblNdotV    = preLightData.NdotV;
     float3 iblNormalWS = bsdfData.normalWS;
 
     // Check if we precompute anisotropy too
         preLightData.anisoGGXLambdaV = GetSmithJointGGXAnisoLambdaV(preLightData.TdotV, preLightData.BdotV, preLightData.NdotV, bsdfData.roughnessT, bsdfData.roughnessB);
         // Tangent = highlight stretch (anisotropy) direction. Bitangent = grain (brush) direction.
         iblNormalWS = GetAnisotropicModifiedNormal(bsdfData.bitangentWS, bsdfData.normalWS, V, bsdfData.anisotropy);
-        
+
         // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NDotV) and use iblNormalWS
         // into function like GetSpecularDominantDir(). However modified normal is just a hack. The goal is just to stretch a cubemap, no accuracy here.
         // With this in mind and for performance reasons we chose to only use modified normal to calculate R.
-    // We need to take into account the modified normal for faking anisotropic here.
-    preLightData.iblR = reflect(-V, iblNormalWS);
+
+    // We need to take into account the modified normal for faking anisotropic here.
+    float3 iblR = reflect(-V, iblNormalWS);
+    preLightData.iblDirWS = GetSpecularDominantDir(bsdfData.normalWS, iblR, bsdfData.roughness);
 
     // #if SHADERPASS == SHADERPASS_GBUFFER
     // preLightData.ambientOcclusion = LOAD_TEXTURE2D(_AmbientOcclusion, coord.unPositionSS).x;
 
     float3 unL = positionWS - lightData.positionWS;
 
-    // Pick the axis along which to expand the fade-out sphere into an ellipsoid.
+    // Pick the major axis of the ellipsoid.
-    // We define the ellipsoid s.t. r1 = r, r2 = (r + len / 2).
+    // We define the ellipsoid s.t. r1 = (r + len / 2), r2 = r3 = r.
     // TODO: This could be precomputed.
     float radius         = rsqrt(lightData.invSqrAttenuationRadius);
     float invAspectRatio = radius / (radius + (0.5 * len));
         ltcValue *= lightData.specularScale;
         specularLighting = fresnelTerm * lightData.color * ltcValue;
     }
-#endif
+#endif // LIT_DISPLAY_REFERENCE_AREA
 }
 
 //-----------------------------------------------------------------------------
 // EvaluateBSDF_Area - Approximation with Linearly Transformed Cosines
 //-----------------------------------------------------------------------------
 
+// #define ELLIPSOIDAL_ATTENUATION
+
 void EvaluateBSDF_Area(LightLoopContext lightLoopContext,
                        float3 V, float3 positionWS,
                        PreLightData preLightData, LightData lightData, BSDFData bsdfData,
 
     float3 unL = positionWS - lightData.positionWS;
 
-    // Pick the axis along which to expand the fade-out sphere into an ellipsoid.
-    float3 axis = (halfWidth >= halfHeight) ? lightData.right : lightData.up;
+    // Rotate the light direction into the light space.
+    float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
+    unL = mul(unL, transpose(lightToWorld));
-    // We define the ellipsoid s.t. r1 = r, r2 = (r + |w - h| / 2).
+    // Define the dimensions of the attenuation volume.
-    float radius         = rsqrt(lightData.invSqrAttenuationRadius);
-    float invAspectRatio = radius / (radius + abs(halfWidth - halfHeight));
+    float  radius     = rsqrt(lightData.invSqrAttenuationRadius);
+    float3 invHalfDim = rcp(float3(radius + halfWidth,
+                                   radius + halfHeight,
+                                   radius));
-    float intensity = GetEllipsoidalDistanceAttenuation(unL,  lightData.invSqrAttenuationRadius,
-                                                        axis, invAspectRatio);
+#ifdef ELLIPSOIDAL_ATTENUATION
+    // The attenuation volume is an axis-aligned ellipsoid s.t.
+    // r1 = (r + w / 2), r2 = (r + h / 2), r3 = r.
+    float intensity = GetEllipsoidalDistanceAttenuation(unL, invHalfDim);
+#else
+    // The attenuation volume is an axis-aligned box s.t.
+    // hX = (r + w / 2), hY = (r + h / 2), hZ = r.
+    float intensity = GetBoxDistanceAttenuation(unL, invHalfDim);
+#endif
 
     // Terminate if the shaded point is too far away.
     if (intensity == 0.0) return;
         ltcValue *= lightData.specularScale;
         specularLighting = fresnelTerm * lightData.color * ltcValue;
     }
-#endif
+#endif // LIT_DISPLAY_REFERENCE_AREA
 }
 
 //-----------------------------------------------------------------------------
 
     // TODO: test the strech from Tomasz
     // float shrinkedRoughness = AnisotropicStrechAtGrazingAngle(bsdfData.roughness, bsdfData.perceptualRoughness, NdotV);
-    
-    // Note: As explain in GetPreLightData we use normalWS and not iblNormalWS here (in case of anisotropy)
-    float3 rayWS = GetSpecularDominantDir(bsdfData.normalWS, preLightData.iblR, bsdfData.roughness);
-
-    float3 R = rayWS;
-    weight = float2(1.0, 1.0);
-    
-    // In Unity the cubemaps are capture with the localToWorld transform of the component. 
+
+    // In Unity the cubemaps are capture with the localToWorld transform of the component.
-    
+
+    float3 R = preLightData.iblDirWS;
     float3x3 worldToLocal = transpose(float3x3(lightData.right, lightData.up, lightData.forward)); // worldToLocal assume no scaling
     float3 positionLS = positionWS - lightData.positionWS;
     positionLS = mul(positionLS, worldToLocal).xyz - lightData.offsetLS; // We want to calculate the intersection from the center of the bounding box.
-        float3 rayLS = mul(rayWS, worldToLocal);
+        float3 dirLS = mul(R, worldToLocal);
-        float dist = BoxRayIntersectSimple(positionLS, rayLS, -boxOuterDistance, boxOuterDistance);
+        float dist = BoxRayIntersectSimple(positionLS, dirLS, -boxOuterDistance, boxOuterDistance);
-        R = (positionWS + dist * rayWS) - lightData.positionWS;
-        
+        R = (positionWS + dist * R) - lightData.positionWS;
+
-    } 
+    }
-        float3 rayLS = mul(rayWS, worldToLocal);
+        float3 dirLS = mul(R, worldToLocal);
-        float dist = SphereRayIntersectSimple(positionLS, rayLS, sphereOuterDistance);
+        float dist = SphereRayIntersectSimple(positionLS, dirLS, sphereOuterDistance);
-        R = (positionWS + dist * rayWS) - lightData.positionWS;
+        R = (positionWS + dist * R) - lightData.positionWS;
+    weight.y = 1.0;
+
-    else // ENVSHAPETYPE_BOX or ENVSHAPETYPE_NONE 
+    else if (lightData.envShapeType == ENVSHAPETYPE_BOX ||
+             lightData.envShapeType == 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);

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 "Experimental.ScriptableRenderLoop.LitGUI"
 }

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

     // TODO: think about using BC5
 #ifdef _TANGENTMAP
 #ifdef _NORMALMAP_TANGENT_SPACE // Normal and tangent use same space
-    float3 tangentTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base)));
+    float3 tangentTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base));
     surfaceData.tangentWS = TransformTangentToWorld(tangentTS, input.tangentToWorld);
 #else // Object space (TODO: We need to apply the world rotation here! - Require to pass world transform)
     surfaceData.tangentWS = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base)).rgb;

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Material.hlsl

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

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
+    class UnlitGUI : BaseUnlitGUI
-        public enum SurfaceType
-        {
-            Opaque,
-            Transparent
-        }
-        public enum BlendMode
-        {
-            Lerp,
-            Add,
-            SoftAdd,
-            Multiply,
-            Premultiply
-        }
-
-        public enum DoubleSidedMode
-        {
-            None,
-            DoubleSided
-        }
-
-        private static class Styles
-        {
-            public static string OptionText = "Options";
-            public static string SurfaceTypeText = "Surface Type";
-            public static string BlendModeText = "Blend Mode";
-
-            public static GUIContent alphaCutoffEnableText = new GUIContent("Alpha Cutoff Enable", "Threshold for alpha cutoff");
-            public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
-            public static GUIContent doubleSidedModeText = new GUIContent("Double Sided", "This will render the two face of the objects (disable backface culling)");
-
-            public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
-            public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
-
-            public static string InputsOptionsText = "Inputs options";
-
-            public static string InputsText = "Inputs";
-
-            public static string InputsMapText = "";
-
-            public static GUIContent colorText = new GUIContent("Color + Opacity", "Albedo (RGB) and Opacity (A)");
-
-            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
-            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
-        }
-
-        MaterialProperty surfaceType = null;
-        MaterialProperty blendMode = null;
-        MaterialProperty alphaCutoff = null;
-        MaterialProperty alphaCutoffEnable = null;
-        MaterialProperty doubleSidedMode = null;
-
-
-        protected MaterialEditor m_MaterialEditor;
-
-        protected const string kSurfaceType = "_SurfaceType";
-        protected const string kBlendMode = "_BlendMode";
-        protected const string kAlphaCutoff = "_AlphaCutoff";
-        protected const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
-        protected const string kDoubleSidedMode = "_DoubleSidedMode";
- 
- 
-        public void FindOptionProperties(MaterialProperty[] props)
-        {
-            surfaceType = FindProperty(kSurfaceType, props);
-            blendMode = FindProperty(kBlendMode, props);
-            alphaCutoff = FindProperty(kAlphaCutoff, props);
-            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
-            doubleSidedMode = FindProperty(kDoubleSidedMode, props);
-        }
+        protected const string kEmissiveIntensity = "_EmissiveIntensity";
-        public void FindInputProperties(MaterialProperty[] props)
+        override protected void FindInputProperties(MaterialProperty[] props)
         {
             color = FindProperty("_Color", props);
             colorMap = FindProperty("_ColorMap", props);
         }
 
-        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
-        {
-            FindOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
-            FindInputProperties(props);
-
-            m_MaterialEditor = materialEditor;
-            Material material = materialEditor.target as Material;
-            ShaderPropertiesGUI(material);
-        }
-
-        protected void ShaderOptionsGUI()
-        {
-            EditorGUI.indentLevel++;
-            GUILayout.Label(Styles.OptionText, EditorStyles.boldLabel);
-            SurfaceTypePopup();
-            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
-            {
-                BlendModePopup();
-            }
-            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, Styles.alphaCutoffEnableText.text);
-            if (alphaCutoffEnable.floatValue == 1.0)
-            {
-                m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
-            }
-            m_MaterialEditor.ShaderProperty(doubleSidedMode, Styles.doubleSidedModeText.text);
-
-            EditorGUI.indentLevel--;
-        }
-
-        protected void ShaderInputOptionsGUI()
-        {
-            EditorGUI.indentLevel++;
-            EditorGUI.indentLevel--;
-        }
-
-        protected void ShaderInputGUI()
+        override protected void ShaderInputGUI()
         {
             EditorGUI.indentLevel++;
 
             EditorGUI.indentLevel--;
         }
 
-        public void ShaderPropertiesGUI(Material material)
-        {
-            // Use default labelWidth
-            EditorGUIUtility.labelWidth = 0f;
-
-            // Detect any changes to the material
-            EditorGUI.BeginChangeCheck();
-            {
-                ShaderOptionsGUI();
-                EditorGUILayout.Space();
-
-                ShaderInputOptionsGUI();
-
-                EditorGUILayout.Space();
-                ShaderInputGUI();
-            }
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                foreach (var obj in m_MaterialEditor.targets)
-                    SetupMaterial((Material)obj);
-            }
-        }
-
-        // TODO: try to setup minimun value to fall back to standard shaders and reverse
-        public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
+        override protected void ShaderInputOptionsGUI()
-            base.AssignNewShaderToMaterial(material, oldShader, newShader);
-        void SurfaceTypePopup()
+        protected override void FindInputOptionProperties(MaterialProperty[] props)
-            EditorGUI.showMixedValue = surfaceType.hasMixedValue;
-            var mode = (SurfaceType)surfaceType.floatValue;
-
-            EditorGUI.BeginChangeCheck();
-            mode = (SurfaceType)EditorGUILayout.Popup(Styles.SurfaceTypeText, (int)mode, Styles.surfaceTypeNames);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
-                surfaceType.floatValue = (float)mode;
-            }
-
-            EditorGUI.showMixedValue = false;
-        void BlendModePopup()
-        {
-            EditorGUI.showMixedValue = blendMode.hasMixedValue;
-            var mode = (BlendMode)blendMode.floatValue;
-
-            EditorGUI.BeginChangeCheck();
-            mode = (BlendMode)EditorGUILayout.Popup(Styles.BlendModeText, (int)mode, Styles.blendModeNames);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
-                blendMode.floatValue = (float)mode;
-            }
-
-            EditorGUI.showMixedValue = false;
-        }
-
-        protected virtual void SetupKeywordsForInputMaps(Material material)
+        protected override void SetupInputMaterial(Material material)
-        protected void SetupMaterial(Material material)
+        protected override bool ShouldEmissionBeEnabled(Material mat)
-            // Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation
-            // (MaterialProperty value might come from renderer material property block)
-
-            bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
-            SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
-            BlendMode blendMode = (BlendMode)material.GetFloat(kBlendMode);
-            DoubleSidedMode doubleSidedMode = (DoubleSidedMode)material.GetFloat(kDoubleSidedMode);
-
-            if (surfaceType == SurfaceType.Opaque)
-            {
-                material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : "");
-                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                material.SetInt("_ZWrite", 1);
-                material.renderQueue = alphaTestEnable ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : -1;
-            }
-            else
-            {
-                material.SetOverrideTag("RenderType", "Transparent");
-                material.SetInt("_ZWrite", 0);
-                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
-
-                switch (blendMode)
-                {
-                    case BlendMode.Lerp:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
-                        break;
-
-                    case BlendMode.Add:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        break;
-
-                    case BlendMode.SoftAdd:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        break;
-
-                    case BlendMode.Multiply:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                        break;
-
-                    case BlendMode.Premultiply:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
-                        break;
-                }
-            }
-
-            if (doubleSidedMode == DoubleSidedMode.None)
-            {
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back);
-            }
-            else
-            {
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Off);
-            }
-
-            SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
-
-            SetupKeywordsForInputMaps(material);
-
-            // Setup lightmap emissive flags
-
-            MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
-            if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
-            {
-                if (LitGUI.ShouldEmissionBeEnabled(material))
-                    flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
-                else
-                    flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
-
-                material.globalIlluminationFlags = flags;
-            }
+            float emissiveIntensity = mat.GetFloat(kEmissiveIntensity);
+            var realtimeEmission = (mat.globalIlluminationFlags & MaterialGlobalIlluminationFlags.RealtimeEmissive) > 0;
+            return emissiveIntensity > 0.0f || realtimeEmission;
-        bool HasValidEmissiveKeyword(Material material)
-        {
-            /*
-            // Material animation might be out of sync with the material keyword.
-            // So if the emission support is disabled on the material, but the property blocks have a value that requires it, then we need to show a warning.
-            // (note: (Renderer MaterialPropertyBlock applies its values to emissionColorForRendering))
-            bool hasEmissionKeyword = material.IsKeywordEnabled ("_EMISSION");
-            if (!hasEmissionKeyword && ShouldEmissionBeEnabled (material, emissionColorForRendering.colorValue))
-                return false;
-            else
-                return true;
-            */
-
-            return true;
-        }
+    }
-        protected void SetKeyword(Material m, string keyword, bool state)
-        {
-            if (state)
-                m.EnableKeyword(keyword);
-            else
-                m.DisableKeyword(keyword);
-        }
-    }
 } // namespace UnityEditor

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Unlit/Unlit.shader

         }
     }
 
-    CustomEditor "UnlitGUI"
+    CustomEditor "Experimental.ScriptableRenderLoop.UnlitGUI"
 }

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/Sky/Resources/GGXConvolve.shader

 
             half4 Frag(Varyings input) : SV_Target
             {
-                float3 N = input.eyeVector;
+                // Vector interpolation is not magnitude-preserving.
+                float3 N = normalize(input.eyeVector);
                 float3 V = N;
 
                 float perceptualRoughness = mipmapLevelToPerceptualRoughness(_Level);
                                             PerceptualRoughnessToRoughness(perceptualRoughness),
                                             _MipMapCount,
                                             _InvOmegaP,
-                                            2048,
-                                            false);
+                                            64,
+                                            true);
 
                 return val;
             }

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

             #pragma vertex Vert
             #pragma fragment Frag
 
+            #pragma multi_compile _ ATMOSPHERICS_DEBUG
+            #pragma multi_compile _ ATMOSPHERICS_OCCLUSION_FULLSKY
+            #pragma multi_compile _ PERFORM_SKY_OCCLUSION_TEST
+
+            #ifndef PERFORM_SKY_OCCLUSION_TEST
+                #define IS_RENDERING_SKY
+            #endif
+
+            #include "Color.hlsl"
-        
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
+            #include "AtmosphericScattering.hlsl"
+
-            float4 _SkyParam; // x exposure, y multiplier, z rotation
+
+            float4x4 _InvViewProjMatrix;
+            float4   _SkyParam; // x exposure, y multiplier, z rotation
 
             struct Attributes
             {
             {
                 // TODO: implement SV_vertexID full screen quad
                 Varyings output;
-                output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE
-                    , 1.0);
-                output.eyeVector = input.eyeVector;
+                output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
+                output.eyeVector  = input.eyeVector;
 
                 return output;
             }
                 float3 rotDirY = float3(sinPhi, 0, cosPhi);
                 dir = float3(dot(rotDirX, dir), dir.y, dot(rotDirY, dir));
 
-                return ClampToFloat16Max(SAMPLE_TEXTURECUBE_LOD(_Cubemap, sampler_Cubemap, dir, 0) * exp2(_SkyParam.x) * _SkyParam.y);
+                /*
+                Coordinate coord = GetCoordinate(input.positionCS.xy, _ScreenSize.zw);
+
+                // If the sky box is too far away (depth set to 0), the resulting look is too foggy.
+                const float skyDepth = 0.01;
+
+                #ifdef PERFORM_SKY_OCCLUSION_TEST
+                    // Determine whether the sky is occluded by the scene geometry.
+                    // Do not perform blending with the environment map if the sky is occluded.
+                    float rawDepth     = max(skyDepth, LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).r);
+                    float skyTexWeight = (rawDepth > skyDepth) ? 0.0 : 1.0;
+                #else
+                    float rawDepth     = skyDepth;
+                    float skyTexWeight = 1.0;
+                #endif
+
+                float3 positionWS = UnprojectToWorld(rawDepth, coord.positionSS, _InvViewProjMatrix);
+
+                float4 c1, c2, c3;
+                VolundTransferScatter(positionWS, c1, c2, c3);
+
+                float4 coord1 = float4(c1.rgb + c3.rgb, max(0.f, 1.f - c1.a - c3.a));
+                float3 coord2 = c2.rgb;
+
+                float sunCos = dot(normalize(dir), _SunDirection);
+                float miePh  = MiePhase(sunCos, _MiePhaseAnisotropy);
+
+                float2 occlusion  = float2(1.0, 1.0); // TODO.
+                float  extinction = coord1.a;
+                float3 scatter    = coord1.rgb * occlusion.x + coord2 * miePh * occlusion.y;
+
+                #ifdef ATMOSPHERICS_DEBUG
+                    switch (_AtmosphericsDebugMode)
+                    {
+                        case ATMOSPHERICS_DBG_RAYLEIGH:           return c1;
+                        case ATMOSPHERICS_DBG_MIE:                return c2 * miePh;
+                        case ATMOSPHERICS_DBG_HEIGHT:             return c3;
+                        case ATMOSPHERICS_DBG_SCATTERING:         return float4(scatter, 0.0);
+                        case ATMOSPHERICS_DBG_OCCLUSION:          return float4(occlusion.xy, 0.0, 0.0);
+                        case ATMOSPHERICS_DBG_OCCLUDEDSCATTERING: return float4(scatter, 0.0);
+                    }
+                #endif
+
+                */
+
+                float3 skyColor = ClampToFloat16Max(SAMPLE_TEXTURECUBE_LOD(_Cubemap, sampler_Cubemap, dir, 0).rgb * exp2(_SkyParam.x) * _SkyParam.y);
+                return float4(skyColor, 1.0);
+
+                // Apply extinction to the scene color when performing alpha-blending.
+                //return float4(skyColor * (skyTexWeight * extinction) + scatter, extinction);
             }
 
             ENDHLSL

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/SkyRenderer.cs

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

Assets/ScriptableRenderLoop/HDRenderLoop/Utilities.cs

 
             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/ShaderLibrary/API/D3D11.hlsl

 
 #define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) textureName.Sample(samplerName, coord2)
 #define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Sample(samplerName, float3((coord2).xy, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod) textureName.SampleLevel(samplerName, float3((coord2).xy, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod) textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3) textureName.Sample(samplerName, float4((coord3).xyz, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, lod) textureName.SampleLevel(samplerName, float4((coord3).xyz, index), lod)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod) textureName.SampleLevel(samplerName, float4(coord3, index), lod)
 #define SAMPLE_TEXTURE3D(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define LOAD_TEXTURE2D(textureName, unCoord2) textureName.Load(int3(unCoord2, 0))
 #define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex) textureName.Load(unCoord2, sampleIndex)
 
+#define GATHER_TEXTURE2D(textureName, samplerName, coord2) textureName.Gather(samplerName, coord2)
+#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))

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/CommonLighting.hlsl

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

Assets/ScriptableRenderLoop/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

 namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     [ExecuteInEditMode]
-    public class FptlLighting : ScriptableRenderLoop
+    public class FptlLighting : RenderPipeline
     {
 #if UNITY_EDITOR
         [UnityEditor.MenuItem("Renderloop/CreateRenderLoopFPTL")]
         private Texture2D m_LightAttentuationTexture;
         private int m_shadowBufferID;
 
-        void OnEnable()
+        private void OnValidate()
-        void OnValidate()
+        public override void Initialize()
+        public override void Cleanup()
+        {
+            // RenderLoop.renderLoopDelegate -= ExecuteRenderLoop;
+            if (m_DeferredMaterial) DestroyImmediate(m_DeferredMaterial);
+            if (m_DeferredReflectionMaterial) DestroyImmediate(m_DeferredReflectionMaterial);
+            if (m_BlitMaterial) DestroyImmediate(m_BlitMaterial);
+            if (m_DebugLightBoundsMaterial) DestroyImmediate(m_DebugLightBoundsMaterial);
+            if (m_NHxRoughnessTexture) DestroyImmediate(m_NHxRoughnessTexture);
+            if (m_LightAttentuationTexture) DestroyImmediate(m_LightAttentuationTexture);
+
+            m_CookieTexArray.Release();
+            m_CubeCookieTexArray.Release();
+            m_CubeReflTexArray.Release();
+
+            s_AABBBoundsBuffer.Release();
+            s_ConvexBoundsBuffer.Release();
+            s_LightDataBuffer.Release();
+            ReleaseResolutionDependentBuffers();
+            s_DirLightList.Release();
+
+            if (enableClustered)
+            {
+                s_GlobalLightListAtomic.Release();
+            }
+
+            ClearComputeBuffers();
+        }
+
         void ClearComputeBuffers()
         {
             if (s_AABBBoundsBuffer != null)
             m_shadowBufferID = Shader.PropertyToID("g_tShadowBuffer");
         }
 
-        void OnDisable()
-        {
-            // RenderLoop.renderLoopDelegate -= ExecuteRenderLoop;
-            if (m_DeferredMaterial) DestroyImmediate(m_DeferredMaterial);
-            if (m_DeferredReflectionMaterial) DestroyImmediate(m_DeferredReflectionMaterial);
-            if (m_BlitMaterial) DestroyImmediate(m_BlitMaterial);
-            if (m_DebugLightBoundsMaterial) DestroyImmediate(m_DebugLightBoundsMaterial);
-            if (m_NHxRoughnessTexture) DestroyImmediate(m_NHxRoughnessTexture);
-            if (m_LightAttentuationTexture) DestroyImmediate(m_LightAttentuationTexture);
-
-            m_CookieTexArray.Release();
-            m_CubeCookieTexArray.Release();
-            m_CubeReflTexArray.Release();
-
-            s_AABBBoundsBuffer.Release();
-            s_ConvexBoundsBuffer.Release();
-            s_LightDataBuffer.Release();
-            ReleaseResolutionDependentBuffers();
-            s_DirLightList.Release();
-
-
-
-            if (enableClustered)
-            {
-                s_GlobalLightListAtomic.Release();
-            }
-        }
-
         static void SetupGBuffer(int width, int height, CommandBuffer cmd)
         {
             var format10 = RenderTextureFormat.ARGB32;
 
         void DoTiledDeferredLighting(Camera camera, RenderLoop loop, int numLights, int numDirLights)
         {
-            var bUseClusteredForDeferred = !usingFptl;       // doesn't work on reflections yet but will soon
+            var bUseClusteredForDeferred = !usingFptl;
             var cmd = new CommandBuffer();
 
             m_DeferredMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                 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);
 
             return numLightsOut + numProbesOut;
         }
+
+#if UNITY_EDITOR
+        public override void RenderSceneView(Camera camera, RenderLoop renderLoop)
+        {
+            base.RenderSceneView(camera, renderLoop);
+            renderLoop.PrepareForEditorRendering(camera, new RenderTargetIdentifier(s_CameraDepthTexture));
+            renderLoop.Submit();
+        }
+#endif
 
         public override void Render(Camera[] cameras, RenderLoop renderLoop)
         {

Assets/ScriptableRenderLoop/fptl/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/HDRenderLoopTest.unity

       objectReference: {fileID: 0}
     - target: {fileID: 485392, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_RootOrder
-      value: 3
+      value: 4
       objectReference: {fileID: 0}
     - target: {fileID: 115764, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_Name
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: 646b4ac0331f8e447bd20f06eba916a3, type: 3}
       propertyPath: m_RootOrder
-      value: 1
+      value: 2
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: 646b4ac0331f8e447bd20f06eba916a3, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 9
+  m_RootOrder: 10
   m_LocalEulerAnglesHint: {x: 37.039, y: 0, z: 0}
 --- !u!114 &580932148
 MonoBehaviour:
   - component: {fileID: 605581071}
   - component: {fileID: 605581070}
   - component: {fileID: 605581072}
+  - component: {fileID: 605581073}
-  m_Name: Directional light
+  m_Name: Sun (directional light)
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 11
+  m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 142.28, y: 106.256996, z: -160.70999}
 --- !u!114 &605581072
 MonoBehaviour:
   isDoubleSided: 0
   areaLightLength: 0
   areaLightWidth: 0
+--- !u!114 &605581073
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 605581069}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 97f65a78ace4fbf4187144e9fe724009, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  worldRayleighColorRamp:
+    key0:
+      serializedVersion: 2
+      rgba: 4288243277
+    key1:
+      serializedVersion: 2
+      rgba: 4291598720
+    key2:
+      serializedVersion: 2
+      rgba: 0
+    key3:
+      serializedVersion: 2
+      rgba: 0
+    key4:
+      serializedVersion: 2
+      rgba: 0
+    key5:
+      serializedVersion: 2
+      rgba: 0
+    key6:
+      serializedVersion: 2
+      rgba: 0
+    key7:
+      serializedVersion: 2
+      rgba: 0
+    ctime0: 0
+    ctime1: 65535
+    ctime2: 0
+    ctime3: 0
+    ctime4: 0
+    ctime5: 0
+    ctime6: 0
+    ctime7: 0
+    atime0: 0
+    atime1: 65535
+    atime2: 0
+    atime3: 0
+    atime4: 0
+    atime5: 0
+    atime6: 0
+    atime7: 0
+    m_Mode: 0
+    m_NumColorKeys: 2
+    m_NumAlphaKeys: 2
+  worldRayleighColorIntensity: 1
+  worldRayleighDensity: 10
+  worldRayleighExtinctionFactor: 1.1
+  worldRayleighIndirectScatter: 0.33
+  worldMieColorRamp:
+    key0:
+      serializedVersion: 2
+      rgba: 4286627826
+    key1:
+      serializedVersion: 2
+      rgba: 4294960895
+    key2:
+      serializedVersion: 2
+      rgba: 0
+    key3:
+      serializedVersion: 2
+      rgba: 0
+    key4:
+      serializedVersion: 2
+      rgba: 0
+    key5:
+      serializedVersion: 2
+      rgba: 0
+    key6:
+      serializedVersion: 2
+      rgba: 0
+    key7:
+      serializedVersion: 2
+      rgba: 0
+    ctime0: 0
+    ctime1: 65535
+    ctime2: 0
+    ctime3: 0
+    ctime4: 0
+    ctime5: 0
+    ctime6: 0
+    ctime7: 0
+    atime0: 0
+    atime1: 65535
+    atime2: 0
+    atime3: 0
+    atime4: 0
+    atime5: 0
+    atime6: 0
+    atime7: 0
+    m_Mode: 0
+    m_NumColorKeys: 2
+    m_NumAlphaKeys: 2
+  worldMieColorIntensity: 1
+  worldMieDensity: 15
+  worldMieExtinctionFactor: 0
+  worldMiePhaseAnisotropy: 0.9
+  worldNearScatterPush: 0
+  worldNormalDistance: 1000
+  heightRayleighColor: {r: 1, g: 1, b: 1, a: 1}
+  heightRayleighIntensity: 1
+  heightRayleighDensity: 10
+  heightMieDensity: 0
+  heightExtinctionFactor: 1.1
+  heightSeaLevel: 0
+  heightDistance: 50
+  heightPlaneShift: {x: 0, y: 0, z: 0}
+  heightNearScatterPush: 0
+  heightNormalDistance: 1000
+  worldScaleExponent: 1
+  atmosphericShader: {fileID: 0}
+  debugMode: 0
 --- !u!1 &609148480
 GameObject:
   m_ObjectHideFlags: 0
       objectReference: {fileID: 0}
     - target: {fileID: 485392, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_RootOrder
-      value: 2
+      value: 3
       objectReference: {fileID: 0}
     - target: {fileID: 115764, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_Name
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 10
+  m_RootOrder: 11
   m_LocalEulerAnglesHint: {x: 37.039, y: 0, z: 0}
 --- !u!114 &970745598
 MonoBehaviour:
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 7
+  m_RootOrder: 8
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1175446862
 GameObject:
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 8
+  m_RootOrder: 9
   m_LocalEulerAnglesHint: {x: -0.39200002, y: 1.033, z: -0.92}
 --- !u!114 &1220024536
 MonoBehaviour:
       objectReference: {fileID: 0}
     - target: {fileID: 485392, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_RootOrder
-      value: 5
+      value: 6
       objectReference: {fileID: 0}
     - target: {fileID: 115764, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_Name
       objectReference: {fileID: 0}
     - target: {fileID: 485392, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_RootOrder
-      value: 6
+      value: 7
       objectReference: {fileID: 0}
     - target: {fileID: 2374582, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_Materials.Array.data[0]
       objectReference: {fileID: 0}
     - target: {fileID: 485392, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_RootOrder
-      value: 4
+      value: 5
       objectReference: {fileID: 0}
     - target: {fileID: 115764, guid: e641a36bceddbf24a89656e94dafb3e5, type: 2}
       propertyPath: m_Name

ProjectSettings/GraphicsSettings.asset

   m_PreloadedShaders: []
   m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000,
     type: 0}
-  m_TierSettings_Tier1:
-    renderingPath: 1
-    useCascadedShadowMaps: 1
-    useHDR: 0
-    hdrMode: 0
-  m_TierSettings_Tier2:
-    renderingPath: 1
-    useCascadedShadowMaps: 1
-    useHDR: 0
-    hdrMode: 0
-  m_TierSettings_Tier3:
-    renderingPath: 1
-    useCascadedShadowMaps: 1
-    useHDR: 0
-    hdrMode: 0
+  m_CustomRenderPipeline: {fileID: 11400000, guid: 2400b74f5ce370c4481e5dc417d03703,
+    type: 2}
+  m_TransparencySortMode: 0
+  m_TransparencySortAxis: {x: 0, y: 0, z: 1}
-  - serializedVersion: 2
+  - serializedVersion: 3
-      hdrMode: 0
+      hdrMode: 1
-      useHDR: 0
+      useHDR: 1
-  - serializedVersion: 2
+  - serializedVersion: 3
-      hdrMode: 0
+      hdrMode: 1
-      useHDR: 0
+      useHDR: 1
-  - serializedVersion: 2
+  - serializedVersion: 3
-      hdrMode: 0
+      hdrMode: 1
-      useHDR: 0
+      useHDR: 1
       useDetailNormalMap: 1
       useCascadedShadowMaps: 1
       useDitherMaskForAlphaBlendedShadows: 1
   m_FogKeepLinear: 1
   m_FogKeepExp: 1
   m_FogKeepExp2: 1
+  m_AlbedoSwatchInfos: []

ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 5.6.0a5
+m_EditorVersion: 5.6.0a6

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 LIGHTLOOP_TILE_ALL	1
+
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
+
+		    //-------------------------------------------------------------------------------------
+		    // 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);
+
+                #ifdef USE_CLUSTERED_LIGHTLIST
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
+                float linearDepth = GetLinearDepth(depth); // View space linear depth
+                #else
+                float linearDepth = 0.0; // unused
+                #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/Lighting/LightUtilities.hlsl

+#ifndef UNITY_LIGHT_UTILITIES_INCLUDED
+#define UNITY_LIGHT_UTILITIES_INCLUDED
+
+#include "LightDefinition.cs.hlsl"
+
+// The EnvLightData of the sky light contains a bunch of compile-time constants.
+// This function sets them directly to allow the compiler to propagate them and optimize the code.
+EnvLightData InitSkyEnvLightData(int envIndex)
+{
+    EnvLightData output;
+    output.envShapeType  = ENVSHAPETYPE_SKY;
+    output.envIndex      = envIndex;
+    output.forward       = float3(0.0, 0.0, 1.0);
+    output.up            = float3(0.0, 1.0, 0.0);
+    output.right         = float3(1.0, 0.0, 0.0);
+    output.positionWS    = float3(0.0, 0.0, 0.0);
+    output.offsetLS      = float3(0.0, 0.0, 0.0);
+    output.innerDistance = float3(0.0, 0.0, 0.0);
+    output.blendDistance = 1.0;
+
+    return output;
+}
+
+#endif // UNITY_LIGHT_UTILITIES_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightUtilities.hlsl.meta

+fileFormatVersion: 2
+guid: be2a44d9e57c5b943ab80fa5fc334d99
+timeCreated: 1480423337
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityEditor.Experimental.ScriptableRenderLoop
+{
+    public abstract class BaseLitGUI : ShaderGUI
+    {
+        protected static class Styles
+        {
+            public static string OptionText = "Options";
+            public static string SurfaceTypeText = "Surface Type";
+            public static string BlendModeText = "Blend Mode";
+            public static string detailText = "Inputs Detail";
+            public static string lightingText = "Inputs Lighting";
+
+            public static GUIContent alphaCutoffEnableText = new GUIContent("Alpha Cutoff Enable", "Threshold for alpha cutoff");
+            public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
+            public static GUIContent doubleSidedModeText = new GUIContent("Double Sided", "This will render the two face of the objects (disable backface culling)");
+
+            public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
+            public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
+
+            public static string InputsOptionsText = "Inputs options";
+
+            public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel");
+            public static GUIContent UVBaseMappingText = new GUIContent("UV set for Base", "");
+            public static GUIContent texWorldScaleText = new GUIContent("Scale to apply on world coordinate in case of Planar/Triplanar", "");
+            public static GUIContent UVBaseDetailMappingText = new GUIContent("UV set for Base and Detail", "");
+            public static GUIContent normalMapSpaceText = new GUIContent("Normal/Tangent Map space", "");
+            public static GUIContent heightMapModeText = new GUIContent("Height Map Mode", "");
+            public static GUIContent detailMapModeText = new GUIContent("Detail Map with Normal", "Detail Map with AO / Height");
+            public static GUIContent UVDetailMappingText = new GUIContent("UV set for Detail", "");
+            public static GUIContent emissiveColorModeText = new GUIContent("Emissive Color Usage", "Use emissive color or emissive mask");
+
+            public static string InputsText = "Inputs";
+
+            public static string InputsMapText = "";
+
+            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 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");
+            public static GUIContent maskMapText = new GUIContent("Mask Map - M(R), AO(G)", "Mask map");
+            public static GUIContent maskMapSText = new GUIContent("Mask Map - M(R), AO(G), S(A)", "Mask map");
+
+            public static GUIContent specularOcclusionMapText = new GUIContent("Specular Occlusion Map (RGBA)", "Specular Occlusion Map");
+
+            public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (DXT5) - Need to implement BC5");
+ 
+            public static GUIContent heightMapText = new GUIContent("Height Map (R)", "Height Map");
+
+            public static GUIContent tangentMapText = new GUIContent("Tangent Map", "Tangent Map (BC5) - DXT5 for test");
+            public static GUIContent anisotropyText = new GUIContent("Anisotropy", "Anisotropy scale factor");
+            public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map (G)", "Anisotropy");
+
+            public static GUIContent detailMapNormalText = new GUIContent("Detail Map A(R) Ny(G) S(B) Nx(A)", "Detail Map");
+            public static GUIContent detailMapAOHeightText = new GUIContent("Detail Map  A(R) AO(G) S(B) H(A)", "Detail Map");
+            public static GUIContent detailMaskText = new GUIContent("Detail Mask (B)", "Mask for detailMap");
+            public static GUIContent detailAlbedoScaleText = new GUIContent("Detail AlbedoScale", "Detail Albedo Scale factor");
+            public static GUIContent detailNormalScaleText = new GUIContent("Detail NormalScale", "Normal Scale factor");
+            public static GUIContent detailSmoothnessScaleText = new GUIContent("Detail SmoothnessScale", "Smoothness Scale factor");
+            public static GUIContent detailHeightScaleText = new GUIContent("Detail HeightScale", "Height Scale factor");
+            public static GUIContent detailAOScaleText = new GUIContent("Detail AOScale", "AO Scale factor");
+
+            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
+            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
+
+            public static GUIContent emissiveWarning = new GUIContent("Emissive value is animated but the material has not been configured to support emissive. Please make sure the material itself has some amount of emissive.");
+            public static GUIContent emissiveColorWarning = new GUIContent("Ensure emissive color is non-black for emission to have effect.");
+        }
+
+        public enum SurfaceType
+        {
+            Opaque,
+            Transparent
+        }
+        public enum BlendMode
+        {
+            Lerp,
+            Add,
+            SoftAdd,
+            Multiply,
+            Premultiply
+        }
+        public enum DoubleSidedMode
+        {
+            None,
+            DoubleSided,
+            DoubleSidedLightingFlip,
+            DoubleSidedLightingMirror,
+        }
+
+        void SurfaceTypePopup()
+        {
+            EditorGUI.showMixedValue = surfaceType.hasMixedValue;
+            var mode = (SurfaceType)surfaceType.floatValue;
+
+            EditorGUI.BeginChangeCheck();
+            mode = (SurfaceType)EditorGUILayout.Popup(Styles.SurfaceTypeText, (int)mode, Styles.surfaceTypeNames);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
+                surfaceType.floatValue = (float)mode;
+            }
+
+            EditorGUI.showMixedValue = false;
+        }
+
+        protected void ShaderOptionsGUI()
+        {
+            EditorGUI.indentLevel++;
+            GUILayout.Label(Styles.OptionText, EditorStyles.boldLabel);
+            SurfaceTypePopup();
+            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
+            {
+                BlendModePopup();
+            }
+            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, Styles.alphaCutoffEnableText.text);
+            if (alphaCutoffEnable.floatValue == 1.0)
+            {
+                m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
+            }
+            m_MaterialEditor.ShaderProperty(doubleSidedMode, Styles.doubleSidedModeText.text);
+
+            EditorGUI.indentLevel--;
+        }
+
+        private void BlendModePopup()
+        {
+            EditorGUI.showMixedValue = blendMode.hasMixedValue;
+            var mode = (BlendMode)blendMode.floatValue;
+
+            EditorGUI.BeginChangeCheck();
+            mode = (BlendMode)EditorGUILayout.Popup(Styles.BlendModeText, (int)mode, Styles.blendModeNames);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
+                blendMode.floatValue = (float)mode;
+            }
+
+            EditorGUI.showMixedValue = false;
+        }
+
+        protected void FindOptionProperties(MaterialProperty[] props)
+        {
+            surfaceType = FindProperty(kSurfaceType, props);
+            blendMode = FindProperty(kBlendMode, props);
+            alphaCutoff = FindProperty(kAlphaCutoff, props);
+            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
+            doubleSidedMode = FindProperty(kDoubleSidedMode, props);
+            FindInputOptionProperties(props);
+        }
+
+        protected void SetupMaterial(Material material)
+        {
+            bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
+            SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
+            BlendMode blendMode = (BlendMode)material.GetFloat(kBlendMode);
+            DoubleSidedMode doubleSidedMode = (DoubleSidedMode)material.GetFloat(kDoubleSidedMode);
+
+            if (surfaceType == SurfaceType.Opaque)
+            {
+                material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : "");
+                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                material.SetInt("_ZWrite", 1);
+                material.renderQueue = alphaTestEnable ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : -1;
+            }
+            else
+            {
+                material.SetOverrideTag("RenderType", "Transparent");
+                material.SetInt("_ZWrite", 0);
+                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+
+                switch (blendMode)
+                {
+                    case BlendMode.Lerp:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                        break;
+
+                    case BlendMode.Add:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        break;
+
+                    case BlendMode.SoftAdd:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        break;
+
+                    case BlendMode.Multiply:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                        break;
+
+                    case BlendMode.Premultiply:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                        break;
+                }
+            }
+
+            if (doubleSidedMode == DoubleSidedMode.None)
+            {
+                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back);
+            }
+            else
+            {
+                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Off);
+            }
+
+            if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingFlip)
+            {
+                material.EnableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
+                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
+            }
+            else if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingMirror)
+            {
+                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
+                material.EnableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
+            }
+            else
+            {
+                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
+                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
+            }
+
+            SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
+            SetupInputMaterial(material);
+            SetupEmissionGIFlags(material);
+        }
+
+        protected void SetKeyword(Material m, string keyword, bool state)
+        {
+            if (state)
+                m.EnableKeyword(keyword);
+            else
+                m.DisableKeyword(keyword);
+        }
+
+        public void ShaderPropertiesGUI(Material material)
+        {
+            // Use default labelWidth
+            EditorGUIUtility.labelWidth = 0f;
+
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            {
+                ShaderOptionsGUI();
+                EditorGUILayout.Space();
+
+                ShaderInputOptionsGUI();
+
+                EditorGUILayout.Space();
+                ShaderInputGUI();
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in m_MaterialEditor.targets)
+                    SetupMaterial((Material)obj);
+            }
+        }
+
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        {
+            FindOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
+            FindInputProperties(props);
+
+            m_MaterialEditor = materialEditor;
+            Material material = materialEditor.target as Material;
+            ShaderPropertiesGUI(material);
+        }
+
+        // TODO: ? or remove
+        bool HasValidEmissiveKeyword(Material material)
+        {
+            /*
+            // Material animation might be out of sync with the material keyword.
+            // So if the emission support is disabled on the material, but the property blocks have a value that requires it, then we need to show a warning.
+            // (note: (Renderer MaterialPropertyBlock applies its values to emissionColorForRendering))
+            bool hasEmissionKeyword = material.IsKeywordEnabled ("_EMISSION");
+            if (!hasEmissionKeyword && ShouldEmissionBeEnabled (material, emissionColorForRendering.colorValue))
+                return false;
+            else
+                return true;
+            */
+
+            return true;
+        }
+
+        protected virtual void SetupEmissionGIFlags(Material material)
+        {
+            // Setup lightmap emissive flags
+            MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
+            if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
+            {
+                if (ShouldEmissionBeEnabled(material))
+                    flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
+                else
+                    flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
+
+                material.globalIlluminationFlags = flags;
+            }
+        }
+
+        protected MaterialEditor m_MaterialEditor;
+
+        MaterialProperty surfaceType = null;
+        MaterialProperty alphaCutoffEnable = null;
+        MaterialProperty blendMode = null;
+        MaterialProperty alphaCutoff = null;
+        MaterialProperty doubleSidedMode = null;
+ 
+        const string kSurfaceType = "_SurfaceType";
+        const string kBlendMode = "_BlendMode";
+        const string kAlphaCutoff = "_AlphaCutoff";
+        const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
+        const string kDoubleSidedMode = "_DoubleSidedMode";
+        protected static string[] reservedProperties = new string[] { kSurfaceType, kBlendMode, kAlphaCutoff, kAlphaCutoffEnabled, kDoubleSidedMode };
+
+        protected abstract void FindInputProperties(MaterialProperty[] props);
+        protected abstract void ShaderInputGUI();
+        protected abstract void ShaderInputOptionsGUI();
+        protected abstract void FindInputOptionProperties(MaterialProperty[] props);
+        protected abstract void SetupInputMaterial(Material material);
+        protected abstract bool ShouldEmissionBeEnabled(Material material);
+    }
+} // namespace UnityEditor

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

+fileFormatVersion: 2
+guid: d35c4b8ec5d49e4438d0b0ba2655c495
+timeCreated: 1480349253
+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/HDRenderLoop/Material/Unlit/Editor/BaseUnlitUI.cs

+using System;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityEditor.Experimental.ScriptableRenderLoop
+{
+    public abstract class BaseUnlitGUI : ShaderGUI
+    {
+        public enum SurfaceType
+        {
+            Opaque,
+            Transparent
+        }
+        public enum BlendMode
+        {
+            Lerp,
+            Add,
+            SoftAdd,
+            Multiply,
+            Premultiply
+        }
+
+        public enum DoubleSidedMode
+        {
+            None,
+            DoubleSided
+        }
+
+        protected static class Styles
+        {
+            public static string OptionText = "Options";
+            public static string SurfaceTypeText = "Surface Type";
+            public static string BlendModeText = "Blend Mode";
+
+            public static GUIContent alphaCutoffEnableText = new GUIContent("Alpha Cutoff Enable", "Threshold for alpha cutoff");
+            public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
+            public static GUIContent doubleSidedModeText = new GUIContent("Double Sided", "This will render the two face of the objects (disable backface culling)");
+
+            public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
+            public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
+
+            public static string InputsOptionsText = "Inputs options";
+
+            public static string InputsText = "Inputs";
+
+            public static string InputsMapText = "";
+
+            public static GUIContent colorText = new GUIContent("Color + Opacity", "Albedo (RGB) and Opacity (A)");
+
+            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
+            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
+        }
+
+        MaterialProperty surfaceType = null;
+        MaterialProperty blendMode = null;
+        MaterialProperty alphaCutoff = null;
+        MaterialProperty alphaCutoffEnable = null;
+        MaterialProperty doubleSidedMode = null;
+
+        protected const string kSurfaceType = "_SurfaceType";
+        protected const string kBlendMode = "_BlendMode";
+        protected const string kAlphaCutoff = "_AlphaCutoff";
+        protected const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
+        protected const string kDoubleSidedMode = "_DoubleSidedMode";
+
+        protected MaterialEditor m_MaterialEditor;
+
+        public void FindOptionProperties(MaterialProperty[] props)
+        {
+            surfaceType = FindProperty(kSurfaceType, props);
+            blendMode = FindProperty(kBlendMode, props);
+            alphaCutoff = FindProperty(kAlphaCutoff, props);
+            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
+            doubleSidedMode = FindProperty(kDoubleSidedMode, props);
+            FindInputOptionProperties(props);
+        }
+
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        {
+            FindOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
+            FindInputProperties(props);
+
+            m_MaterialEditor = materialEditor;
+            Material material = materialEditor.target as Material;
+            ShaderPropertiesGUI(material);
+        }
+
+        protected void ShaderOptionsGUI()
+        {
+            EditorGUI.indentLevel++;
+            GUILayout.Label(Styles.OptionText, EditorStyles.boldLabel);
+            SurfaceTypePopup();
+            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
+            {
+                BlendModePopup();
+            }
+            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, Styles.alphaCutoffEnableText.text);
+            if (alphaCutoffEnable.floatValue == 1.0)
+            {
+                m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
+            }
+            m_MaterialEditor.ShaderProperty(doubleSidedMode, Styles.doubleSidedModeText.text);
+
+            EditorGUI.indentLevel--;
+        }
+
+        public void ShaderPropertiesGUI(Material material)
+        {
+            // Use default labelWidth
+            EditorGUIUtility.labelWidth = 0f;
+
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            {
+                ShaderOptionsGUI();
+                EditorGUILayout.Space();
+
+                ShaderInputOptionsGUI();
+
+                EditorGUILayout.Space();
+                ShaderInputGUI();
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in m_MaterialEditor.targets)
+                    SetupMaterial((Material)obj);
+            }
+        }
+
+        // TODO: try to setup minimun value to fall back to standard shaders and reverse
+        public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
+        {
+            base.AssignNewShaderToMaterial(material, oldShader, newShader);
+        }
+
+        void SurfaceTypePopup()
+        {
+            EditorGUI.showMixedValue = surfaceType.hasMixedValue;
+            var mode = (SurfaceType)surfaceType.floatValue;
+
+            EditorGUI.BeginChangeCheck();
+            mode = (SurfaceType)EditorGUILayout.Popup(Styles.SurfaceTypeText, (int)mode, Styles.surfaceTypeNames);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
+                surfaceType.floatValue = (float)mode;
+            }
+
+            EditorGUI.showMixedValue = false;
+        }
+
+        void BlendModePopup()
+        {
+            EditorGUI.showMixedValue = blendMode.hasMixedValue;
+            var mode = (BlendMode)blendMode.floatValue;
+
+            EditorGUI.BeginChangeCheck();
+            mode = (BlendMode)EditorGUILayout.Popup(Styles.BlendModeText, (int)mode, Styles.blendModeNames);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
+                blendMode.floatValue = (float)mode;
+            }
+
+            EditorGUI.showMixedValue = false;
+        }
+
+        protected void SetupMaterial(Material material)
+        {
+            // Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation
+            // (MaterialProperty value might come from renderer material property block)
+
+            bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
+            SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
+            BlendMode blendMode = (BlendMode)material.GetFloat(kBlendMode);
+            DoubleSidedMode doubleSidedMode = (DoubleSidedMode)material.GetFloat(kDoubleSidedMode);
+
+            if (surfaceType == SurfaceType.Opaque)
+            {
+                material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : "");
+                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                material.SetInt("_ZWrite", 1);
+                material.renderQueue = alphaTestEnable ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : -1;
+            }
+            else
+            {
+                material.SetOverrideTag("RenderType", "Transparent");
+                material.SetInt("_ZWrite", 0);
+                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+
+                switch (blendMode)
+                {
+                    case BlendMode.Lerp:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                        break;
+
+                    case BlendMode.Add:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        break;
+
+                    case BlendMode.SoftAdd:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        break;
+
+                    case BlendMode.Multiply:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                        break;
+
+                    case BlendMode.Premultiply:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                        break;
+                }
+            }
+
+            if (doubleSidedMode == DoubleSidedMode.None)
+            {
+                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back);
+            }
+            else
+            {
+                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Off);
+            }
+
+            SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
+            SetupInputMaterial(material);
+
+            // Setup lightmap emissive flags
+            MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
+            if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
+            {
+                if (ShouldEmissionBeEnabled(material))
+                    flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
+                else
+                    flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
+
+                material.globalIlluminationFlags = flags;
+            }
+        }
+
+        bool HasValidEmissiveKeyword(Material material)
+        {
+            /*
+            // Material animation might be out of sync with the material keyword.
+            // So if the emission support is disabled on the material, but the property blocks have a value that requires it, then we need to show a warning.
+            // (note: (Renderer MaterialPropertyBlock applies its values to emissionColorForRendering))
+            bool hasEmissionKeyword = material.IsKeywordEnabled ("_EMISSION");
+            if (!hasEmissionKeyword && ShouldEmissionBeEnabled (material, emissionColorForRendering.colorValue))
+                return false;
+            else
+                return true;
+            */
+
+            return true;
+        }
+
+        protected void SetKeyword(Material m, string keyword, bool state)
+        {
+            if (state)
+                m.EnableKeyword(keyword);
+            else
+                m.DisableKeyword(keyword);
+        }
+
+        protected abstract void FindInputProperties(MaterialProperty[] props);
+        protected abstract void ShaderInputGUI();
+        protected abstract void ShaderInputOptionsGUI();
+        protected abstract void FindInputOptionProperties(MaterialProperty[] props);
+        protected abstract void SetupInputMaterial(Material material);
+        protected abstract bool ShouldEmissionBeEnabled(Material material);
+    }
+
+}

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

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

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/AtmosphericParameters.cs

+using UnityEngine;
+
+[ExecuteInEditMode]
+public class AtmosphericParameters : MonoBehaviour
+{
+    public enum OcclusionDownscale { x1 = 1, x2 = 2, x4 = 4 }
+    public enum OcclusionSamples   { x64 = 0, x164 = 1, x244 = 2 }
+    public enum DepthTexture       { Enable, Disable/*, Ignore*/ } // 'Ignore' appears to be currently unused.
+    public enum ScatterDebugMode   { None, Scattering, Occlusion, OccludedScattering, Rayleigh, Mie, Height }
+
+    [Header("Global Settings")]
+    public Gradient worldRayleighColorRamp              = null;
+    public float    worldRayleighColorIntensity         = 1f;
+    public float    worldRayleighDensity                = 10f;
+    public float    worldRayleighExtinctionFactor       = 1.1f;
+    public float    worldRayleighIndirectScatter        = 0.33f;
+    public Gradient worldMieColorRamp                   = null;
+    public float    worldMieColorIntensity              = 1f;
+    public float    worldMieDensity                     = 15f;
+    public float    worldMieExtinctionFactor            = 0f;
+    public float    worldMiePhaseAnisotropy             = 0.9f;
+    public float    worldNearScatterPush                = 0f;
+    public float    worldNormalDistance                 = 1000f;
+
+    [Header("Height Settings")]
+    public Color    heightRayleighColor                 = Color.white;
+    public float    heightRayleighIntensity             = 1f;
+    public float    heightRayleighDensity               = 10f;
+    public float    heightMieDensity                    = 0f;
+    public float    heightExtinctionFactor              = 1.1f;
+    public float    heightSeaLevel                      = 0f;
+    public float    heightDistance                      = 50f;
+    public Vector3  heightPlaneShift                    = Vector3.zero;
+    public float    heightNearScatterPush               = 0f;
+    public float    heightNormalDistance                = 1000f;
+
+    [Header("Sky Dome")]
+    /*public*/ Vector3        skyDomeScale              = new Vector3(1f, 1f, 1f);
+    /*public*/ Vector3        skyDomeRotation           = Vector3.zero;
+    /*public*/ Transform      skyDomeTrackedYawRotation = null;
+    /*public*/ bool           skyDomeVerticalFlip       = false;
+    /*public*/ Cubemap        skyDomeCube               = null;
+    /*public*/ float          skyDomeExposure           = 1f;
+    /*public*/ Color          skyDomeTint               = Color.white;
+    /*public*/ Vector3        skyDomeOffset             = Vector3.zero;
+
+    /*
+    [Header("Scatter Occlusion")]
+    public bool               useOcclusion              = false;
+    public float              occlusionBias             = 0f;
+    public float              occlusionBiasIndirect     = 0.6f;
+    public float              occlusionBiasClouds       = 0.3f;
+    public OcclusionDownscale occlusionDownscale        = OcclusionDownscale.x2;
+    public OcclusionSamples   occlusionSamples          = OcclusionSamples.x64;
+    public bool               occlusionDepthFixup       = true;
+    public float              occlusionDepthThreshold   = 25f;
+    public bool               occlusionFullSky          = false;
+    public float              occlusionBiasSkyRayleigh  = 0.2f;
+    public float              occlusionBiasSkyMie       = 0.4f;
+    */
+
+    [Header("Other")]
+    public Shader             atmosphericShaderOverride = null;
+    // public Shader             occlusionShaderOverride   = null;
+    public float              worldScaleExponent        = 1.0f;
+    // public bool            forcePerPixel             = true;
+    // public bool            forcePostEffect           = true;
+    [Tooltip("Soft clouds need depth values. Ignore means externally controlled.")]
+    public DepthTexture       depthTexture              = DepthTexture.Enable;
+    public ScatterDebugMode   debugMode                 = ScatterDebugMode.None;
+
+    // [HideInInspector] public Shader occlusionShaderOverride;
+
+    // Camera   m_currentCamera;
+
+    // UnityEngine.Rendering.CommandBuffer m_occlusionCmdAfterShadows, m_occlusionCmdBeforeScreen;
+
+    Material m_atmosphericMaterial = null;
+    // Material m_occlusionMaterial   = null;
+    bool     m_isAwake             = false;
+
+    public static AtmosphericParameters instance { get; private set; }
+
+    void Awake()
+    {
+        if (worldRayleighColorRamp == null)
+        {
+            worldRayleighColorRamp = new Gradient();
+            worldRayleighColorRamp.SetKeys(
+                new[] { new GradientColorKey(new Color(0.3f, 0.4f, 0.6f), 0f),
+                        new GradientColorKey(new Color(0.5f, 0.6f, 0.8f), 1f) },
+                new[] { new GradientAlphaKey(1f, 0f),
+                        new GradientAlphaKey(1f, 1f) }
+            );
+        }
+
+        if (worldMieColorRamp == null)
+        {
+            worldMieColorRamp = new Gradient();
+            worldMieColorRamp.SetKeys(
+                new[] { new GradientColorKey(new Color(0.95f, 0.75f, 0.5f), 0f),
+                        new GradientColorKey(new Color(1f, 0.9f, 8.0f), 1f) },
+                new[] { new GradientAlphaKey(1f, 0f),
+                        new GradientAlphaKey(1f, 1f) }
+            );
+        }
+
+        if (atmosphericShaderOverride != null)
+        {
+            // Override the default shader.
+            m_atmosphericMaterial           = new Material(atmosphericShaderOverride);
+            m_atmosphericMaterial.hideFlags = HideFlags.HideAndDontSave;
+        }
+
+        /*
+        if (occlusionShaderOverride != null)
+        {
+            // Override the default shader.
+            m_occlusionMaterial           = new Material(occlusionShaderOverride);
+            m_occlusionMaterial.hideFlags = HideFlags.HideAndDontSave;
+        }
+        */
+
+        m_isAwake = true;
+    }
+
+    public void OnValidate()
+    {
+        if (!m_isAwake) return;
+
+        Light light = gameObject.GetComponentInParent<Light>();
+
+        if (light == null || light.type != LightType.Directional)
+        {
+            Debug.LogErrorFormat("Unexpected: AtmosphericParameters is not attached to a directional light.");
+            return;
+        }
+
+        worldScaleExponent           = Mathf.Clamp(worldScaleExponent, 1f, 2f);
+        worldNormalDistance          = Mathf.Clamp(worldNormalDistance, 1f, 10000f);
+        worldNearScatterPush         = Mathf.Clamp(worldNearScatterPush, -200f, 300f);
+        worldRayleighDensity         = Mathf.Clamp(worldRayleighDensity, 0, 1000f);
+        worldMieDensity              = Mathf.Clamp(worldMieDensity, 0f, 1000f);
+        worldRayleighIndirectScatter = Mathf.Clamp(worldRayleighIndirectScatter, 0f, 1f);
+        worldMiePhaseAnisotropy      = Mathf.Clamp01(worldMiePhaseAnisotropy);
+
+        heightNormalDistance         = Mathf.Clamp(heightNormalDistance, 1f, 10000f);
+        heightNearScatterPush        = Mathf.Clamp(heightNearScatterPush, -200f, 300f);
+        heightRayleighDensity        = Mathf.Clamp(heightRayleighDensity, 0, 1000f);
+        heightMieDensity             = Mathf.Clamp(heightMieDensity, 0, 1000f);
+
+        /*
+        occlusionBias            = Mathf.Clamp01(occlusionBias);
+        occlusionBiasIndirect    = Mathf.Clamp01(occlusionBiasIndirect);
+        occlusionBiasClouds      = Mathf.Clamp01(occlusionBiasClouds);
+        occlusionBiasSkyRayleigh = Mathf.Clamp01(occlusionBiasSkyRayleigh);
+        occlusionBiasSkyMie      = Mathf.Clamp01(occlusionBiasSkyMie);
+        */
+
+        skyDomeExposure = Mathf.Clamp(skyDomeExposure, 0f, 8f);
+
+        if (instance == this)
+        {
+            // TODO: what's the point of doing this?
+            OnDisable();
+            OnEnable();
+        }
+
+        // TODO: why would I want to do that here?
+        // #if UNITY_EDITOR
+        //     UnityEditor.SceneView.RepaintAll();
+        // #endif
+    }
+
+    void OnEnable()
+    {
+        if (!m_isAwake) return;
+
+        // Define select preprocessor symbols.
+        UpdateKeywords(true);
+
+        if (depthTexture == DepthTexture.Disable)
+        {
+            // Disable depth texture rendering.
+            Camera.current.depthTextureMode = DepthTextureMode.None;
+        }
+
+        // Set shader constants.
+        UpdateStaticUniforms();
+        UpdateDynamicUniforms();
+
+        if (instance && instance != this)
+        {
+            Debug.LogErrorFormat("Unexpected: AtmosphericParameters.instance already set (to: {0}). Still overriding with: {1}.", instance.name, name);
+        }
+
+        instance = this;
+    }
+
+    void OnDisable()
+    {
+        // Undefine all preprocessor symbols.
+        UpdateKeywords(false);
+
+        if (instance && instance != this)
+        {
+            Debug.LogErrorFormat("Unexpected: AtmosphericParameters.instance set to: {0}, not to: {1}. Leaving alone.", instance.name, name);
+        }
+        else
+        {
+            instance = null;
+        }
+    }
+
+    void UpdateKeywords(bool enable)
+    {
+        Shader.DisableKeyword("ATMOSPHERICS_OCCLUSION");
+        Shader.DisableKeyword("ATMOSPHERICS_OCCLUSION_FULLSKY");
+        Shader.DisableKeyword("ATMOSPHERICS_OCCLUSION_EDGE_FIXUP");
+        Shader.DisableKeyword("ATMOSPHERICS_SUNRAYS");
+        Shader.DisableKeyword("ATMOSPHERICS_DEBUG");
+
+        if (enable)
+        {
+            /*
+            if (useOcclusion)
+            {
+                Shader.EnableKeyword("ATMOSPHERICS_OCCLUSION");
+
+                if(occlusionDepthFixup && occlusionDownscale != OcclusionDownscale.x1)
+                    Shader.EnableKeyword("ATMOSPHERICS_OCCLUSION_EDGE_FIXUP");
+
+                if(occlusionFullSky)
+                    Shader.EnableKeyword("ATMOSPHERICS_OCCLUSION_FULLSKY");
+            }
+            */
+
+            if (debugMode != ScatterDebugMode.None)
+            {
+                Shader.EnableKeyword("ATMOSPHERICS_DEBUG");
+            }
+        }
+    }
+
+    void UpdateStaticUniforms()
+    {
+        Shader.SetGlobalVector("_SkyDomeOffset", skyDomeOffset);
+        Shader.SetGlobalVector("_SkyDomeScale", skyDomeScale);
+        Shader.SetGlobalTexture("_SkyDomeCube", skyDomeCube);
+        Shader.SetGlobalFloat("_SkyDomeExposure", skyDomeExposure);
+        Shader.SetGlobalColor("_SkyDomeTint", skyDomeTint);
+
+        /*
+        Shader.SetGlobalFloat("_ShadowBias", useOcclusion ? occlusionBias : 1f);
+        Shader.SetGlobalFloat("_ShadowBiasIndirect", useOcclusion ? occlusionBiasIndirect : 1f);
+        Shader.SetGlobalFloat("_ShadowBiasClouds", useOcclusion ? occlusionBiasClouds : 1f);
+        Shader.SetGlobalVector("_ShadowBiasSkyRayleighMie", useOcclusion ? new Vector4(occlusionBiasSkyRayleigh, occlusionBiasSkyMie, 0f, 0f) : Vector4.zero);
+        Shader.SetGlobalFloat("_OcclusionDepthThreshold", occlusionDepthThreshold);
+        */
+
+        Shader.SetGlobalFloat("_WorldScaleExponent", worldScaleExponent);
+
+        Shader.SetGlobalFloat("_WorldNormalDistanceRcp", 1f/worldNormalDistance);
+        Shader.SetGlobalFloat("_WorldNearScatterPush", -Mathf.Pow(Mathf.Abs(worldNearScatterPush), worldScaleExponent) * Mathf.Sign(worldNearScatterPush));
+
+        Shader.SetGlobalFloat("_WorldRayleighDensity", -worldRayleighDensity / 100000f);
+        Shader.SetGlobalFloat("_MiePhaseAnisotropy", worldMiePhaseAnisotropy);
+        Shader.SetGlobalVector("_RayleighInScatterPct", new Vector4(1f - worldRayleighIndirectScatter, worldRayleighIndirectScatter, 0f, 0f));
+
+        Shader.SetGlobalFloat("_HeightNormalDistanceRcp", 1f/heightNormalDistance);
+        Shader.SetGlobalFloat("_HeightNearScatterPush", -Mathf.Pow(Mathf.Abs(heightNearScatterPush), worldScaleExponent) * Mathf.Sign(heightNearScatterPush));
+        Shader.SetGlobalFloat("_HeightRayleighDensity", -heightRayleighDensity / 100000f);
+
+        Shader.SetGlobalFloat("_HeightSeaLevel", heightSeaLevel);
+        Shader.SetGlobalFloat("_HeightDistanceRcp", 1f/heightDistance);
+        Shader.SetGlobalVector("_HeightPlaneShift", heightPlaneShift);
+        Shader.SetGlobalVector("_HeightRayleighColor", (Vector4)heightRayleighColor * heightRayleighIntensity);
+        Shader.SetGlobalFloat("_HeightExtinctionFactor", heightExtinctionFactor);
+        Shader.SetGlobalFloat("_RayleighExtinctionFactor", worldRayleighExtinctionFactor);
+        Shader.SetGlobalFloat("_MieExtinctionFactor", worldMieExtinctionFactor);
+
+        var rayleighColorM20 = worldRayleighColorRamp.Evaluate(0.00f);
+        var rayleighColorM10 = worldRayleighColorRamp.Evaluate(0.25f);
+        var rayleighColorO00 = worldRayleighColorRamp.Evaluate(0.50f);
+        var rayleighColorP10 = worldRayleighColorRamp.Evaluate(0.75f);
+        var rayleighColorP20 = worldRayleighColorRamp.Evaluate(1.00f);
+
+        var mieColorM20 = worldMieColorRamp.Evaluate(0.00f);
+        var mieColorO00 = worldMieColorRamp.Evaluate(0.50f);
+        var mieColorP20 = worldMieColorRamp.Evaluate(1.00f);
+
+        Shader.SetGlobalVector("_RayleighColorM20", (Vector4)rayleighColorM20 * worldRayleighColorIntensity);
+        Shader.SetGlobalVector("_RayleighColorM10", (Vector4)rayleighColorM10 * worldRayleighColorIntensity);
+        Shader.SetGlobalVector("_RayleighColorO00", (Vector4)rayleighColorO00 * worldRayleighColorIntensity);
+        Shader.SetGlobalVector("_RayleighColorP10", (Vector4)rayleighColorP10 * worldRayleighColorIntensity);
+        Shader.SetGlobalVector("_RayleighColorP20", (Vector4)rayleighColorP20 * worldRayleighColorIntensity);
+
+        Shader.SetGlobalVector("_MieColorM20", (Vector4)mieColorM20 * worldMieColorIntensity);
+        Shader.SetGlobalVector("_MieColorO00", (Vector4)mieColorO00 * worldMieColorIntensity);
+        Shader.SetGlobalVector("_MieColorP20", (Vector4)mieColorP20 * worldMieColorIntensity);
+
+        Shader.SetGlobalInt("_AtmosphericsDebugMode", (int)debugMode);
+    }
+
+    void OnWillRenderObject()
+    {
+        /*
+        if (!m_isAwake) return;
+
+        // For now, we only use the directional light we are attached to, and the current camera.
+
+        if (depthTexture == DepthTexture.Disable)
+        {
+            // Disable depth texture rendering.
+            Camera.current.depthTextureMode = DepthTextureMode.None;
+        }
+
+        // Set shader constants.
+        UpdateDynamicUniforms();
+
+
+        if (useOcclusion) {
+            var camRgt = m_currentCamera.transform.right;
+            var camUp = m_currentCamera.transform.up;
+            var camFwd = m_currentCamera.transform.forward;
+
+            var dy = Mathf.Tan(m_currentCamera.fieldOfView * 0.5f * Mathf.Deg2Rad);
+            var dx = dy * m_currentCamera.aspect;
+
+            var vpCenter = camFwd * m_currentCamera.farClipPlane;
+            var vpRight = camRgt * dx * m_currentCamera.farClipPlane;
+            var vpUp = camUp * dy * m_currentCamera.farClipPlane;
+
+            m_occlusionMaterial.SetVector("_CameraPosition", m_currentCamera.transform.position);
+            m_occlusionMaterial.SetVector("_ViewportCorner", vpCenter - vpRight - vpUp);
+            m_occlusionMaterial.SetVector("_ViewportRight", vpRight * 2f);
+            m_occlusionMaterial.SetVector("_ViewportUp", vpUp * 2f);
+            var farDist = m_currentCamera ? m_currentCamera.farClipPlane : 1000f;
+            var refDist = (Mathf.Min(farDist, QualitySettings.shadowDistance) - 1f) / farDist;
+            m_occlusionMaterial.SetFloat("_OcclusionSkyRefDistance", refDist);
+
+            var srcRect = m_currentCamera.pixelRect;
+            var downscale = 1f / (float)(int)occlusionDownscale;
+            var occWidth = Mathf.RoundToInt(srcRect.width * downscale);
+            var occHeight = Mathf.RoundToInt(srcRect.height * downscale);
+            var occlusionId = Shader.PropertyToID("_OcclusionTexture");
+
+            m_occlusionCmdBeforeScreen.Clear();
+            m_occlusionCmdBeforeScreen.GetTemporaryRT(occlusionId, occWidth, occHeight, 0, FilterMode.Bilinear, RenderTextureFormat.R8, RenderTextureReadWrite.sRGB);
+            m_occlusionCmdBeforeScreen.Blit(
+                null,
+                occlusionId,
+                m_occlusionMaterial,
+                (int)occlusionSamples
+            );
+            m_occlusionCmdBeforeScreen.SetGlobalTexture(occlusionId, occlusionId);
+        }
+        */
+    }
+
+    void UpdateDynamicUniforms()
+    {
+        /* For now, we only use the directional light we are attached to, and the current camera. */
+
+        var trackedYaw = skyDomeTrackedYawRotation ? skyDomeTrackedYawRotation.eulerAngles.y : 0f;
+        Shader.SetGlobalMatrix("_SkyDomeRotation",
+             Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(skyDomeRotation.x, 0f, 0f), Vector3.one)
+           * Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, skyDomeRotation.y - trackedYaw, 0f), Vector3.one)
+           * Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(1f, skyDomeVerticalFlip ? -1f : 1f, 1f))
+        );
+
+        Shader.SetGlobalVector("_SunDirection",    -transform.forward);
+        Shader.SetGlobalFloat("_WorldMieDensity",  -worldMieDensity / 100000f);
+        Shader.SetGlobalFloat("_HeightMieDensity", -heightMieDensity / 100000f);
+
+        var pixelRect = Camera.current ? Camera.current.pixelRect
+                                       : new Rect(0f, 0f, Screen.width, Screen.height);
+        var scale = 1.0f; //(float)(int)occlusionDownscale;
+        var depthTextureScaledTexelSize = new Vector4(scale / pixelRect.width,
+                                                      scale / pixelRect.height,
+                                                     -scale / pixelRect.width,
+                                                     -scale / pixelRect.height);
+        Shader.SetGlobalVector("_DepthTextureScaledTexelSize", depthTextureScaledTexelSize);
+    }
+
+    void OnRenderObject()
+    {
+        /* This component is not rendered directly. */
+    }
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/AtmosphericParameters.cs.meta

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

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/README.txt

+# Atmospheric Scattering
+
+Atmospheric scattering is a solution developed for nicer aerial perspective in The Blacksmith. It provides a model emulating atmospheric Rayleigh, Mie and height scattering (and also takes a lot of shortcuts in the name of performance and artistic control). Take a look at the blog post at this address http://blogs.unity3d.com/?p=27218 to get a high-level overview of the components making up the final composition.
+
+
+### Options description
+
+This component comes with quite a lot of options - but you normally don't have to tweak more than a handful of them to get good results - start with the densities and colors and that will get you started nicely.
+
+
+#### World Components
+
+**World Rayleigh Color Ramp**:  The color or colors used for rayleigh scattering. It's a ramp instead of a single color because you can have different scattering colors depending on the angle to the unit being shaded. Values to the left in the ramp are mapped to angles below horizon, whereas values to the right are mapped to angles above the horizon.
+
+**World Rayleigh Color Intensity**: An HDR color scale for the rayleigh color ramp.
+
+**World Rayleigh Density**: The density of the rayleigh component.
+
+**World Rayleigh Extinction Factor**: How much light is out-scattered or absorbed on its way to the eye. Basically how much to darken the shaded pixel.
+
+**World Rayleigh Indirect Scatter**: Which percentage of the rayleigh scattering should be considered 'indirect' scattering. (relevant for occlusion only)
+
+**World Mie Color Ramp**: The color or colors used for mie scattering. It's a ramp instead of a single color because you can have different scattering colors depending on the angle to the unit being shaded. Values to the left in the ramp are mapped to angles below horizon, whereas values to the right are mapped to angles above the horizon.
+
+**World Mie Color Intensity**: An HDR color scale for the mie color ramp.
+
+**World Mie Density**: The density of the mie component.
+
+**World Mie Extinction Factor**: How much light is out-scattered or absorbed on its way to the eye. Basically how much to darken the shaded pixel.
+
+**World Mie Phase Anisotropy**: How focused the forward directionality of the mie scattering is. Values close to 1 produce a small, very sharp mie component, whereas values below 0.5 creates a very large and unfocused mie component.
+
+**World Near Scatter Push**: Allows the scattering to be pushed out to have no scattering directly in front of the camera, or pulled in to have more scattering close to the camera.
+
+**World Normal Distance**: A measure of the scale of the scene. Essentially this desaturates the scattering near the camera, and interpolates into full color ramp at the edge of the specified distance.
+
+
+#### Height Components
+
+**Height Rayleigh Color**: The general global scattering color for height fog.
+
+**Height Rayleigh Intensity**: An HDR color scale for the height global fog color.
+
+**Height Rayleigh Density**: The density of the global height fog.
+
+**Height Mie Density**:  The density of the mie scattering being added to the global height fog.
+
+**Height Extinction Factor**: How much light is out-scattered or absorbed on its way to the eye. Basically how much to darken the shaded pixel.
+
+**Height Sea Level**: Sea level height offset from origin.
+
+**Height Distance**: Falloff distance from sea level
+
+**Height Plane Shift**: An optional plane vector for a tilted sea level.
+
+**Height Near Scatter Push**: Allows the scattering to be pushed out to have no scattering directly in front of the camera, or pulled in to have more scattering close to the camera.
+
+**Height Normal Distance**: A measure of the scale of the scene. Essentially this desaturates the scattering near the camera, and interpolates into full color at the edge of the specified distance.
+
+
+#### Sky Dome
+
+**Sky Dome Scale**: The scale of the skydome. We use this to virtually squash the sky sphere into behaving like a dome. The xz-dimensions affect how much scattering the horizon picks up, whereas the y-dimension dictates how far up on the sky the scattering is blended.
+
+**Sky Dome Rotation**: An optional rotation of the skydome. Usually, only Y-rotation makes sense.
+
+**Sky Dome Tracked Yaw Rotation**: Optionally have the skydome rotate to track a transform, typically a light source. Use in combination with rotation to perfectly align and track the sun to the skydome.
+
+**Sky Dome Vertical Flip**: We have the option of putting two skybox textures into the same cubemap. This flags flips the UV projection to show the bottom half instead of the top half.
+
+**Sky Dome Cube**: An HDR cubemap to use as sky dome.
+
+**Sky Dome Exposure**: The exposure of the sky cubemap.
+
+**Sky Dome Tint**: Tint color for the cubemap.
+
+
+#### Scatter Occlusion
+
+**Use Occlusion**: This flag enables scatter occlusion.
+
+**Occlusion Bias**: Controls how strongly occlusion affects direct scattering.
+
+**Occlusion BiasIndirect**: Controls how strongly occlusion affects indirect scattering.
+
+**Occlusion BiasClouds**: Controls how strongly occlusion affects placed clouds.
+
+**Occlusion Downscale**: Controls the downscale factor for occlusion gathering.
+
+**Occlusion Samples**: The number of samples to use in gathering.
+
+**Occlusion DepthFixup**: Whether to attempt to fix upsampling across depth discontinuities (currently d3d11 only).
+
+**Occlusion DepthThreshold**: The threshold defining discontinuous depth.
+
+**Occlusion FullSky**: Whether to gather occlusion even for skydome pixels.
+
+**Occlusion BiasSkyRayleigh **: Controls how strongly occlusion affects rayleigh scattering on the skydome.
+
+**Occlusion BiasSkyMie **: Controls how strongly occlusion affects mie scattering on the skydome.
+
+
+#### Other
+
+**World ScaleExponent**: An option to exponentially scale the world for scattering calculations (fake aerial perspective in small scenes).
+
+**Force Per Pixel**: Force all scatter calculations to run at per-pixel frequency.
+
+**Force Post Effect**: Force all scatter calculations to run in a post-process (requires the AtmosphericScatteringDeferred component on the camera, and doesn't apply to transparent object)
+
+**Depth Texture**: Whether to enable, disable or leave alone the camera depth texture settings. (required for depth fixup and soft cloud planes)
+
+**Debug Mode**: Various debug visualizations of the different rendering components.

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/README.txt.meta

+fileFormatVersion: 2
+guid: 4eead1bf6efbd0a4e852367accddc070
+timeCreated: 1480334378
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/AtmosphericScattering.hlsl

+#ifndef FILE_ATMOSPHERICSCATTERING
+#define FILE_ATMOSPHERICSCATTERING
+
+#define ATMOSPHERICS_DBG_NONE                   0
+#define ATMOSPHERICS_DBG_SCATTERING             1
+#define ATMOSPHERICS_DBG_OCCLUSION              2
+#define ATMOSPHERICS_DBG_OCCLUDEDSCATTERING     3
+#define ATMOSPHERICS_DBG_RAYLEIGH               4
+#define ATMOSPHERICS_DBG_MIE                    5
+#define ATMOSPHERICS_DBG_HEIGHT                 6
+
+uniform int         _AtmosphericsDebugMode;
+
+uniform float3      _SunDirection;
+
+uniform float       _ShadowBias;
+uniform float       _ShadowBiasIndirect;
+uniform float       _ShadowBiasClouds;
+uniform float       _OcclusionDepthThreshold;
+uniform float4      _OcclusionTexture_TexelSize;
+
+uniform float4      _DepthTextureScaledTexelSize;
+
+uniform float       _WorldScaleExponent;
+uniform float       _WorldNormalDistanceRcp;
+uniform float       _WorldNearScatterPush;
+uniform float       _WorldRayleighDensity;
+uniform float       _WorldMieDensity;
+
+uniform float3      _RayleighColorM20;
+uniform float3      _RayleighColorM10;
+uniform float3      _RayleighColorO00;
+uniform float3      _RayleighColorP10;
+uniform float3      _RayleighColorP20;
+uniform float3      _RayleighColorP45;
+
+uniform float3      _MieColorM20;
+uniform float3      _MieColorO00;
+uniform float3      _MieColorP20;
+uniform float3      _MieColorP45;
+
+uniform float       _HeightNormalDistanceRcp;
+uniform float       _HeightNearScatterPush;
+uniform float       _HeightRayleighDensity;
+uniform float       _HeightMieDensity;
+uniform float       _HeightSeaLevel;
+uniform float3      _HeightPlaneShift;
+uniform float       _HeightDistanceRcp;
+
+uniform float       _RayleighCoeffScale;
+uniform float3      _RayleighSunTintIntensity;
+uniform float2      _RayleighInScatterPct;
+
+uniform float       _MieCoeffScale;
+uniform float3      _MieSunTintIntensity;
+uniform float       _MiePhaseAnisotropy;
+
+uniform float       _HeightExtinctionFactor;
+uniform float       _RayleighExtinctionFactor;
+uniform float       _MieExtinctionFactor;
+
+uniform float4      _HeightRayleighColor;
+
+SAMPLER2D(sampler_CameraDepthTexture)
+#define SRL_BilinearSampler sampler_CameraDepthTexture // Used for all textures
+
+TEXTURE2D(_CameraDepthTexture);
+TEXTURE2D(_OcclusionTexture);
+
+float HenyeyGreensteinPhase(float g, float cosTheta) {
+    float gSqr = g * g;
+    float a1 = (1.f - gSqr);
+    float a2 = (2.f + gSqr);
+    float b1 = 1.f + cosTheta * cosTheta;
+    float b2 = pow(abs(1.f + gSqr - 2.f * g * cosTheta), 1.5f);
+    return (a1 / a2) * (b1 / b2);
+}
+
+float RayleighPhase(float cosTheta) {
+    const float f = 3.f / (16.f * PI);
+    return f + f * cosTheta * cosTheta;
+}
+
+float MiePhase(float cosTheta, float anisotropy) {
+    const float f = 3.f / (8.f * PI);
+    return f * HenyeyGreensteinPhase(anisotropy, cosTheta);
+}
+
+float HeightDensity(float h, float H) {
+    return exp(-h/H);
+}
+
+float3 WorldScale(float3 p) {
+    p.xz = sign(p.xz) * pow(abs(p.xz), _WorldScaleExponent);
+    return p;
+}
+
+void VolundTransferScatter(float3 worldPos, out float4 coords1, out float4 coords2, out float4 coords3) {
+    const float3 scaledWorldPos = WorldScale(worldPos);
+    const float3 worldCamPos = WorldScale(_WorldSpaceCameraPos.xyz);
+
+    const float c_MieScaleHeight = 1200.f;
+    const float worldRayleighDensity = 1.f;
+    const float worldMieDensity = HeightDensity(scaledWorldPos.y, c_MieScaleHeight);
+
+    const float3 worldVec = scaledWorldPos.xyz - worldCamPos.xyz;
+    const float worldVecLen = length(worldVec);
+    const float3 worldDir = worldVec / worldVecLen;
+
+    const float3 worldDirUnscaled = normalize(worldPos - _WorldSpaceCameraPos.xyz);
+
+    const float viewSunCos = dot(worldDirUnscaled, _SunDirection);
+    const float rayleighPh = min(1.f, RayleighPhase(viewSunCos) * 12.f);
+    const float miePh = MiePhase(viewSunCos, _MiePhaseAnisotropy);
+
+    const float angle20 = 0.324f / 1.5f;
+    const float angle10 = 0.174f / 1.5f;
+    const float angleY = worldDir.y * saturate(worldVecLen / 250.0);
+
+    float3 rayleighColor;
+    if(angleY >= angle10) rayleighColor = lerp(_RayleighColorP10, _RayleighColorP20, saturate((angleY - angle10) / (angle20 - angle10)));
+    else if(angleY >= 0.f) rayleighColor = lerp(_RayleighColorO00, _RayleighColorP10, angleY / angle10);
+    else if(angleY >= -angle10) rayleighColor = lerp(_RayleighColorM10, _RayleighColorO00, (angleY + angle10) / angle10);
+    else rayleighColor = lerp(_RayleighColorM20, _RayleighColorM10, saturate((angleY + angle20) / (angle20 - angle10)));
+
+    float3 mieColor;
+    if(angleY >= 0.f) mieColor = lerp(_MieColorO00, _MieColorP20, saturate(angleY / angle20));
+    else mieColor = lerp(_MieColorM20, _MieColorO00, saturate((angleY + angle20) / angle20));
+
+    const float pushedDistance = max(0.f, worldVecLen + _WorldNearScatterPush);
+    const float pushedDensity = /*HeightDensity **/ pushedDistance /** exp(-scaledWorldPos.y / 8000.f)*/;
+    const float rayleighScatter = (1.f - exp(_WorldRayleighDensity * pushedDensity)) * rayleighPh;
+#ifdef IS_RENDERING_SKY
+    const float mieScatter = (1.f - exp(_WorldMieDensity * pushedDensity));
+#else
+    const float mieScatter = (1.f - exp(_WorldMieDensity * pushedDensity)) * miePh;
+#endif
+
+    const float heightShift = dot(worldVec, _HeightPlaneShift);
+    const float heightScaledOffset = (scaledWorldPos.y - heightShift - _HeightSeaLevel) * _HeightDistanceRcp;
+    const float HeightDensity = exp(-heightScaledOffset);
+    const float pushedHeightDistance = max(0.f, worldVecLen + _HeightNearScatterPush);
+    const float heightScatter = (1.f - exp(_HeightRayleighDensity * pushedHeightDistance)) * HeightDensity;
+#ifdef IS_RENDERING_SKY
+    const float heightMieScatter = (1.f - exp(_HeightMieDensity * pushedHeightDistance)) * HeightDensity;
+#else
+    const float heightMieScatter = (1.f - exp(_HeightMieDensity * pushedHeightDistance)) * HeightDensity * miePh;
+#endif
+
+    rayleighColor = lerp(Luminance(rayleighColor).rrr, rayleighColor, saturate(pushedDistance * _WorldNormalDistanceRcp));
+    float3 heightRayleighColor = lerp(Luminance(_HeightRayleighColor.xyz).rrr, _HeightRayleighColor.xyz, saturate(pushedHeightDistance * _HeightNormalDistanceRcp));
+
+    coords1.rgb = rayleighScatter * rayleighColor;
+    coords1.a = rayleighScatter;
+
+    coords3.rgb = saturate(heightScatter) * heightRayleighColor;
+    coords3.a = heightScatter;
+
+    coords2.rgb = mieScatter * mieColor + saturate(heightMieScatter) * mieColor;
+    coords2.a = mieScatter;
+}
+
+void VolundTransferScatter(float3 scaledWorldPos, out float4 coords1) {
+     float4 c1, c2, c3;
+     VolundTransferScatter(scaledWorldPos, c1, c2, c3);
+
+#ifdef IS_RENDERING_SKY
+    coords1.rgb = c3.rgb;
+    coords1.a = max(0.f, 1.f - c3.a * _HeightExtinctionFactor);
+#else
+    coords1.rgb = c1.rgb;
+    coords1.rgb += c3.rgb;
+    coords1.a = max(0.f, 1.f - c1.a * _RayleighExtinctionFactor - c3.a * _HeightExtinctionFactor);
+#endif
+
+    coords1.rgb += c2.rgb;
+    coords1.a *= max(0.f, 1.f - c2.a * _MieExtinctionFactor);
+
+#ifdef ATMOSPHERICS_DEBUG
+    if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_RAYLEIGH)
+        coords1.rgb = c1.rgb;
+    else if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_MIE)
+        coords1.rgb = c2.rgb;
+    else if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_HEIGHT)
+        coords1.rgb = c3.rgb;
+#endif
+}
+
+float2 UVFromPos(float2 pos) {
+    return pos / _ScreenParams.xy;
+}
+
+float3 VolundApplyScatter(float4 coords1, float2 pos, float3 color) {
+#ifdef ATMOSPHERICS_DEBUG
+    if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_OCCLUSION)
+        return 1;
+    else if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_SCATTERING || _AtmosphericsDebugMode == ATMOSPHERICS_DBG_OCCLUDEDSCATTERING)
+        return coords1.rgb;
+    else if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_RAYLEIGH || _AtmosphericsDebugMode == ATMOSPHERICS_DBG_MIE || _AtmosphericsDebugMode == ATMOSPHERICS_DBG_HEIGHT)
+        return coords1.rgb;
+#endif
+
+    return color * coords1.a + coords1.rgb;
+}
+
+float3 VolundApplyScatterAdd(float coords1, float3 color) {
+    return color * coords1;
+}
+
+void VolundTransferScatterOcclusion(float3 scaledWorldPos, out float4 coords1, out float3 coords2) {
+     float4 c1, c2, c3;
+     VolundTransferScatter(scaledWorldPos, c1, c2, c3);
+
+    coords1.rgb = c1.rgb * _RayleighInScatterPct.x;
+    coords1.a = max(0.f, 1.f - c1.a * _RayleighExtinctionFactor - c3.a * _HeightExtinctionFactor);
+
+    coords1.rgb += c2.rgb;
+    coords1.a *= max(0.f, 1.f - c2.a * _MieExtinctionFactor);
+
+    coords2.rgb = c3.rgb + c1.rgb * _RayleighInScatterPct.y;
+
+#ifdef ATMOSPHERICS_DEBUG
+    if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_RAYLEIGH)
+        coords1.rgb = c1.rgb;
+    else if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_MIE)
+        coords1.rgb = c2.rgb;
+    else if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_HEIGHT)
+        coords1.rgb = c3.rgb;
+#endif
+}
+
+float VolundSampleScatterOcclusion(float2 pos) {
+#if defined(ATMOSPHERICS_OCCLUSION)
+    float2 uv = UVFromPos(pos);
+#if defined(ATMOSPHERICS_OCCLUSION_EDGE_FIXUP)
+    float4 baseUV = float4(uv.x, uv.y, 0.f, 0.f);
+
+    float cDepth = SAMPLE_TEXTURE2D_LOD(_CameraDepthTexture, SRL_BilinearSampler, baseUV, 0.f).r;
+    cDepth = LinearEyeDepth(cDepth, _ZBufferParams);
+
+    float4 xDepth;
+    baseUV.xy = uv + _DepthTextureScaledTexelSize.zy; xDepth.x = SAMPLE_TEXTURE2D_LOD(_CameraDepthTexture, SRL_BilinearSampler, baseUV);
+    baseUV.xy = uv + _DepthTextureScaledTexelSize.xy; xDepth.y = SAMPLE_TEXTURE2D_LOD(_CameraDepthTexture, SRL_BilinearSampler, baseUV);
+    baseUV.xy = uv + _DepthTextureScaledTexelSize.xw; xDepth.z = SAMPLE_TEXTURE2D_LOD(_CameraDepthTexture, SRL_BilinearSampler, baseUV);
+    baseUV.xy = uv + _DepthTextureScaledTexelSize.zw; xDepth.w = SAMPLE_TEXTURE2D_LOD(_CameraDepthTexture, SRL_BilinearSampler, baseUV);
+
+    xDepth.x = LinearEyeDepth(xDepth.x, _ZBufferParams);
+    xDepth.y = LinearEyeDepth(xDepth.y, _ZBufferParams);
+    xDepth.z = LinearEyeDepth(xDepth.z, _ZBufferParams);
+    xDepth.w = LinearEyeDepth(xDepth.w, _ZBufferParams);
+
+    float4 diffDepth = xDepth - cDepth.rrrr;
+    float4 maskDepth = abs(diffDepth) < _OcclusionDepthThreshold;
+    float maskWeight = dot(maskDepth, maskDepth);
+
+    UNITY_BRANCH
+    if(maskWeight == 4.f || maskWeight == 0.f) {
+        return SAMPLE_TEXTURE2D_LOD(_OcclusionTexture, SRL_BilinearSampler, uv, 0.f).r;
+    } else {
+        float4 occ = GATHER_TEXTURE2D(_OcclusionTexture, SRL_BilinearSampler, uv);
+
+        float4 fWeights;
+        fWeights.xy = frac(uv * _OcclusionTexture_TexelSize.zw - 0.5f);
+        fWeights.zw = float2(1.f, 1.f) - fWeights.xy;
+
+        float4 mfWeights = float4(fWeights.z * fWeights.y, fWeights.x * fWeights.y, fWeights.x * fWeights.w, fWeights.z * fWeights.w);
+        return dot(occ, mfWeights * maskDepth) / dot(mfWeights, maskDepth);
+    }
+#endif //defined(ATMOSPHERICS_OCCLUSION_EDGE_FIXUP)
+#else //defined(ATMOSPHERICS_OCCLUSION)
+    return 1.f;
+#endif //defined(ATMOSPHERICS_OCCLUSION)
+}
+
+float3 VolundApplyScatterOcclusion(float4 coords1, float3 coords2, float2 pos, float3 color) {
+    float occlusion = VolundSampleScatterOcclusion(pos);
+
+#ifdef ATMOSPHERICS_DEBUG
+    if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_SCATTERING)
+        return coords1.rgb + coords2.rgb;
+    else if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_OCCLUSION)
+        return occlusion;
+    else if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_OCCLUDEDSCATTERING)
+        return coords1.rgb * min(1.f, occlusion + _ShadowBias)  + coords2.rgb * min(1.f, occlusion + _ShadowBiasIndirect);
+    else if(_AtmosphericsDebugMode == ATMOSPHERICS_DBG_RAYLEIGH || _AtmosphericsDebugMode == ATMOSPHERICS_DBG_MIE || _AtmosphericsDebugMode == ATMOSPHERICS_DBG_HEIGHT)
+        return coords1.rgb;
+#endif
+
+    return
+        color * coords1.a
+        + coords1.rgb * min(1.f, occlusion + _ShadowBias) + coords2.rgb * min(1.f, occlusion + _ShadowBiasIndirect);
+    ;
+}
+
+float VolundCloudOcclusion(float2 pos) {
+#if defined(ATMOSPHERICS_OCCLUSION)
+    return min(1.f, VolundSampleScatterOcclusion(pos) + _ShadowBiasClouds);
+#else
+    return 1.f;
+#endif
+}
+
+
+float4 VolundApplyCloudScatter(float4 coords1, float4 color) {
+#if defined(DBG_ATMOSPHERICS_SCATTERING) || defined(DBG_ATMOSPHERICS_OCCLUDEDSCATTERING)
+    return float4(coords1.rgb, color.a);
+#elif defined(DBG_ATMOSPHERICS_OCCLUSION)
+    return 1;
+#endif
+
+    color.rgb = color.rgb * coords1.a + coords1.rgb;
+    return color;
+}
+
+float4 VolundApplyCloudScatterOcclusion(float4 coords1, float3 coords2, float2 pos, float4 color) {
+    float occlusion = VolundSampleScatterOcclusion(pos);
+#ifdef ATMOSPHERICS_OCCLUSION_DEBUG2
+    color.rgb = coords1.rgb * min(1.f, occlusion + _ShadowBias) + coords2.rgb * min(1.f, occlusion + _ShadowBiasIndirect);
+    return color;
+#endif
+#ifdef ATMOSPHERICS_OCCLUSION_DEBUG
+    return occlusion;
+#endif
+
+    color.rgb = color.rgb * coords1.a + coords1.rgb * min(1.f, occlusion + _ShadowBias) + coords2.rgb * min(1.f, occlusion + _ShadowBiasIndirect);
+
+    float cloudOcclusion = min(1.f, occlusion + _ShadowBiasClouds);
+    color.a *= cloudOcclusion;
+
+    return color;
+}
+
+// Original vert/frag macros
+#if defined(ATMOSPHERICS_OCCLUSION)
+    #define VOLUND_SCATTER_COORDS(idx1, idx2) float4 scatterCoords1 : TEXCOORD##idx1; float3 scatterCoords2 : TEXCOORD##idx2;
+    #define VOLUND_TRANSFER_SCATTER(pos, o) o.scatterCoords1 = pos.xyzz; o.scatterCoords2 = pos.xyz;
+    #define VOLUND_APPLY_SCATTER(i, color) VolundTransferScatterOcclusion(i.scatterCoords1.xyz, i.scatterCoords1, i.scatterCoords2); color = VolundApplyScatterOcclusion(i.scatterCoords1, i.scatterCoords2, i.pos.xy, color)
+    #define VOLUND_CLOUD_SCATTER(i, color) VolundTransferScatterOcclusion(i.scatterCoords1.xyz, i.scatterCoords1, i.scatterCoords2); color = VolundApplyCloudScatterOcclusion(i.scatterCoords1, i.scatterCoords2, i.pos.xy, color)
+#else
+    #define VOLUND_SCATTER_COORDS(idx1, idx2) float4 scatterCoords1 : TEXCOORD##idx1;
+    #define VOLUND_TRANSFER_SCATTER(pos, o) o.scatterCoords1 = pos.xyzz;
+    #define VOLUND_APPLY_SCATTER(i, color) VolundTransferScatter(i.scatterCoords1.xyz, i.scatterCoords1); color = VolundApplyScatter(i.scatterCoords1, i.pos.xy, color);
+    #define VOLUND_CLOUD_SCATTER(i, color) VolundTransferScatter(i.scatterCoords1.xyz, i.scatterCoords1); color = VolundApplyCloudScatter(i.scatterCoords1, color);
+#endif
+
+#if !defined(SURFACE_SCATTER_COORDS)
+                                                /* surface shader analysis currently forces us to include stuff even when unused */
+                                                /* we also have to convince the analyzer to not optimize out stuff we need */
+    #define SURFACE_SCATTER_COORDS              float3 scaledWorldPos; float4 scatterCoords1; float3 scatterCoords2;
+    #define SURFACE_SCATTER_TRANSFER(pos, o)    o.scatterCoords1.r = o.scatterCoords2.r = pos.x;
+    #define SURFACE_SCATTER_APPLY(i, color)     color += (i.scaledWorldPos + i.scatterCoords1.xyz + i.scatterCoords2.xyz) * 0.000001f
+#endif
+
+#endif //FILE_ATMOSPHERICSCATTERING

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/AtmosphericScattering.hlsl.meta

+fileFormatVersion: 2
+guid: b0be9dce952dbb9479a5eb30e49c07a3
+timeCreated: 1480068393
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/basicrenderloop.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: 22228a1bd982b864ea6c84db2fc11dd1, type: 3}
+  m_Name: basicrenderloop
+  m_EditorClassIdentifier: 

Assets/basicrenderloop.asset.meta

+fileFormatVersion: 2
+guid: f77fc78803cb35147ab3c0811feb562d
+timeCreated: 1480085360
+licenseType: Pro
+NativeFormatImporter:
+  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/ScriptableRenderLoop/ScriptableRenderLoop.cs

-using UnityEngine.Experimental.Rendering;
-
-namespace UnityEngine.Experimental.ScriptableRenderLoop
-{
-    public abstract class ScriptableRenderLoop : ScriptableObject
-    {
-        public abstract void Render(Camera[] cameras, RenderLoop renderLoop);
-        public virtual void Rebuild() {}
-
-        #if UNITY_EDITOR
-        public virtual UnityEditor.SupportedRenderingFeatures GetSupportedRenderingFeatures() { return new UnityEditor.SupportedRenderingFeatures(); }
-        #endif
-    }
-}

Assets/ScriptableRenderLoop/ScriptableRenderLoop.cs.meta

-fileFormatVersion: 2
-guid: 4a2689a80c91a4fb8bec214a015b9cdc
-timeCreated: 1466769781
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/ScriptableRenderLoop/ScriptableRenderLoopPicker.cs

-using UnityEngine.Experimental.Rendering;
-
-namespace UnityEngine.Experimental.ScriptableRenderLoop
-{
-    //@TODO: This should be moved into GraphicsSettings
-    [ExecuteInEditMode]
-    public class ScriptableRenderLoopPicker : MonoBehaviour
-    {
-        public ScriptableRenderLoop renderloop
-        {
-            get { return m_RenderLoop; }
-            set { m_RenderLoop = value; }
-        }
-
-        [SerializeField]
-        private ScriptableRenderLoop m_RenderLoop;
-
-        void OnEnable()
-        {
-            RenderLoop.renderLoopDelegate += Render;
-
-            SyncRenderingFeatures();
-        }
-
-        void OnValidate()
-        {
-            SyncRenderingFeatures();
-        }
-
-        void SyncRenderingFeatures()
-        {
-#if UNITY_EDITOR
-            if (m_RenderLoop != null && isActiveAndEnabled)
-                UnityEditor.SupportedRenderingFeatures.active = m_RenderLoop.GetSupportedRenderingFeatures();
-            else
-                UnityEditor.SupportedRenderingFeatures.active = UnityEditor.SupportedRenderingFeatures.Default;
-#endif
-        }
-
-        void OnDisable()
-        {
-            RenderLoop.renderLoopDelegate -= Render;
-
-            #if UNITY_EDITOR
-            UnityEditor.SupportedRenderingFeatures.active = UnityEditor.SupportedRenderingFeatures.Default;
-            #endif
-        }
-
-        bool Render(Camera[] cameras, RenderLoop loop)
-        {
-            if (m_RenderLoop == null)
-                return false;
-
-#if UNITY_EDITOR
-            if (m_AssetVersion != s_GlobalAssetVersion)
-            {
-                m_AssetVersion = s_GlobalAssetVersion;
-                m_RenderLoop.Rebuild();
-            }
-#endif
-
-            m_RenderLoop.Render(cameras, loop);
-            return true;
-        }
-
-#if UNITY_EDITOR
-        // Temporary hack to allow compute shader reloading
-        internal class AssetReloader : UnityEditor.AssetPostprocessor
-        {
-            static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
-            {
-                foreach (var str in importedAssets)
-                {
-                    if (str.EndsWith(".compute"))
-                    {
-                        s_GlobalAssetVersion++;
-                        break;
-                    }
-                }
-            }
-        }
-        static int s_GlobalAssetVersion = 0;
-        int m_AssetVersion = 0;
-#endif
-    }
-}

Assets/ScriptableRenderLoop/ScriptableRenderLoopPicker.cs.meta

-fileFormatVersion: 2
-guid: 92bb16b4ee20841929b24d6bd771738d
-timeCreated: 1467028218
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/ScriptableRenderLoop/Tests.meta

-fileFormatVersion: 2
-guid: 7641c43fc081f6d46b70eee4b602efcc
-folderAsset: yes
-timeCreated: 1474997398
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

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: