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

# Conflicts:
#	Assets/ScriptableRenderPipeline/PostProcessing

Assets/GraphicsTests/Framework/Editor/TestFrameworkCustomBuild.cs

-using System.IO;
-using UnityEditor;
-	public class TestFrameworkCustomBuild
-	{
-		private static readonly string s_TestSceneFolder = "/GraphicsTests/Scenes";
-		private static readonly string s_BuildFolder = "/TestScenesBuild";
+    public class TestFrameworkCustomBuild
+    {
+        private static readonly string s_TestSceneFolder = "/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Scenes";
+        private static readonly string s_BuildFolder = "/TestScenesBuild";
+
+        [MenuItem("RenderPipeline/TestFramework/Build-iOS")]
+        public static void BuildiOS()
+        {
+            TestFrameworkCustomBuild builder = new TestFrameworkCustomBuild();
+            builder.Build(BuildTarget.iOS, BuildOptions.AcceptExternalModificationsToPlayer);
+        }
+
+        [MenuItem("RenderPipeline/TestFramework/Build-iOS", true)]
+
+        public static bool ValidateBuildiOS()
+        {
+#if UNITY_STANDALONE_OSX
+            return true;
+#else
+            return false;
+#endif
+        }
+
+        public void Build(BuildTarget target, BuildOptions options)
+        {
+            var absoluteScenesPath = Application.dataPath + s_TestSceneFolder;
+            string[] levels = System.IO.Directory.GetFiles(absoluteScenesPath, "*.unity", System.IO.SearchOption.AllDirectories);
+            CheckAndAddGotoNextSceneBehavior(levels);
-		[MenuItem("RenderPipeline/TestFramework/Build-iOS")]
-		public static void BuildiOS()
-		{
-			TestFrameworkCustomBuild builder = new TestFrameworkCustomBuild();
-			builder.Build(BuildTarget.iOS, BuildOptions.AcceptExternalModificationsToPlayer);
-		}
+            string savePath = EditorUtility.SaveFolderPanel("Select folder to save project", "", "");
+            BuildPipeline.BuildPlayer(levels, savePath + s_BuildFolder, target, options);
+        }
-		public void Build(BuildTarget target, BuildOptions options)
-		{
-			var absoluteScenesPath = Application.dataPath + s_TestSceneFolder;
-			string[] levels = System.IO.Directory.GetFiles(absoluteScenesPath, "*.unity", System.IO.SearchOption.AllDirectories);
-			CheckAndAddGotoNextSceneBehavior(levels);
+        private void CheckAndAddGotoNextSceneBehavior(string[] levels)
+        {
+            for (int i = 0; i < levels.Length; ++i)
+            {
+                string levelPath = levels[i];
+                var scene = EditorSceneManager.OpenScene(levelPath);
+                GameObject[] objects = scene.GetRootGameObjects();
+                bool componentFound = false;
-			string savePath = EditorUtility.SaveFolderPanel("Select folder to save project", "", "");
-			BuildPipeline.BuildPlayer(levels, savePath + s_BuildFolder, target, options);
-		}
+                foreach (GameObject go in objects)
+                {
+                    GotoNextScene component = go.GetComponent<GotoNextScene>();
+                    if (component != null)
+                    {
+                        component.m_NextSceneIndex = (i + 1) % levels.Length;
+                        componentFound = true;
+                        break;
+                    }
+                }
-		private void CheckAndAddGotoNextSceneBehavior(string[] levels)
-		{
-			for (int i = 0; i < levels.Length; ++i)
-			{
-				string levelPath = levels[i];
-				var scene = EditorSceneManager.OpenScene(levelPath);
-				GameObject[] objects = scene.GetRootGameObjects();
-				bool componentFound = false;
+                if (!componentFound)
+                {
+                    GameObject gotoNextScene = new GameObject("GotoNextScene");
+                    GotoNextScene component = gotoNextScene.AddComponent<GotoNextScene>();
+                    component.m_NextSceneIndex = (i + 1) % levels.Length;
+                }
-				foreach (GameObject go in objects)
-				{
-					GotoNextScene component = go.GetComponent<GotoNextScene>();
-					if (component != null)
-					{
-						component.m_NextSceneIndex = (i + 1) % levels.Length;
-						componentFound = true;
-						break;
-					}
-				}
-				
-				if (!componentFound)
-				{
-					GameObject gotoNextScene = new GameObject("GotoNextScene");
-					GotoNextScene component = gotoNextScene.AddComponent<GotoNextScene>();
-					component.m_NextSceneIndex = (i + 1) % levels.Length;
-				}
-				
-				EditorSceneManager.SaveScene(scene);
-				EditorSceneManager.UnloadSceneAsync(scene);
-			}
-		}
-	}
-}
+                EditorSceneManager.SaveScene(scene);
+                EditorSceneManager.UnloadSceneAsync(scene);
+            }
+        }
+    }
+}

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Assets/LDPipe_CommonAssets/Materials/Cornell Box.mat

   m_ShaderKeywords: _SPECULAR_COLOR
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Assets/LDPipe_CommonAssets/Materials/Cornell Box_green.mat

   m_ShaderKeywords: _SPECULAR_COLOR
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Assets/LDPipe_CommonAssets/Materials/Cornell Box_red.mat

   m_ShaderKeywords: _SPECULAR_COLOR
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Assets/LDPipe_Shader/LDPipe_LitMat_05_Emission.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: LDPipe_LitMat_05_Emission
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
-  m_ShaderKeywords: _EMISSION_MAP _SPECULAR_COLOR
-  m_LightmapFlags: 4
+  m_ShaderKeywords: _EMISSION _SPECULAR_COLOR
+  m_LightmapFlags: 2
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Assets/LDPipe_Shader/LDPipe_LitMat_Reflection_Non.mat

   m_ShaderKeywords: _SPECULAR_COLOR
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Scenes/Shaders/LDPipe_LitShaderLightProbes.unity

     m_PVRFilteringAtrousColorSigma: 1
     m_PVRFilteringAtrousNormalSigma: 1
     m_PVRFilteringAtrousPositionSigma: 1
-  m_LightingDataAsset: {fileID: 112000002, guid: 47357896581e84c039d57ae749fa9786,
+  m_LightingDataAsset: {fileID: 112000002, guid: de71753d509098b47b2d1fc3de525375,
     type: 2}
   m_UseShadowmask: 0
 --- !u!196 &4
     manualTileSize: 0
     tileSize: 256
     accuratePlacement: 0
+    debug:
+      m_Flags: 0
   m_NavMeshData: {fileID: 0}
 --- !u!1 &98766303
 GameObject:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Scenes/Shaders/LDPipe_LitShaderLightProbes/LightingData.asset.meta

 fileFormatVersion: 2
-guid: 47357896581e84c039d57ae749fa9786
-timeCreated: 1493310899
+guid: de71753d509098b47b2d1fc3de525375
+timeCreated: 1496152305
 licenseType: Pro
 NativeFormatImporter:
   mainObjectFileID: 25800000

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Scenes/Shaders/LDPipe_LitShaderLightProbes/Lightmap-0_comp_light.exr.meta

 fileFormatVersion: 2
-guid: e4dc9d638c4ff407599842bfe66fed2b
-timeCreated: 1493310899
+guid: 63403075b192e934286da6ba690accf9
+timeCreated: 1496152305
 licenseType: Pro
 TextureImporter:
   fileIDToRecycleName: {}
   platformSettings:
   - buildTarget: DefaultTexturePlatform
     maxTextureSize: 2048
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50

Assets/ScriptableRenderPipeline/Core/Camera/CameraSwitcher.cs

             m_CameraNames[GetCameraCount() - 1] = new GUIContent("Original Camera");
             m_CameraIndices[GetCameraCount() - 1] = GetCameraCount() - 1;
 
-            DebugMenuManager.instance.AddDebugItem<int>("Camera", "Camera Switcher", () => m_CurrentCameraIndex, (value) => SetCameraIndex((int)value), false, new DebugItemDrawerIntEnum(m_CameraNames, m_CameraIndices));
+            DebugMenuManager.instance.AddDebugItem<int>("Camera", "Camera Switcher", () => m_CurrentCameraIndex, (value) => SetCameraIndex((int)value), false, new DebugItemHandlerIntEnum(m_CameraNames, m_CameraIndices));
         }
 
         int GetCameraCount()

Assets/ScriptableRenderPipeline/Core/Debugging/DebugActionManager.cs

         public enum DebugAction
         {
             EnableDebugMenu,
-            PreviousDebugMenu,
-            NextDebugMenu,
+            PreviousDebugPanel,
+            NextDebugPanel,
-            Persistent,
+            MakePersistent,
             MoveVertical,
             MoveHorizontal,
             DebugActionCount
             enableDebugMenu.repeatMode = DebugActionRepeatMode.Never;
             AddAction(DebugAction.EnableDebugMenu, enableDebugMenu);
 
-            DebugActionDesc nextDebugMenu = new DebugActionDesc();
-            nextDebugMenu.buttonTriggerList.Add(new[] { kDebugNextBtn });
-            nextDebugMenu.repeatMode = DebugActionRepeatMode.Never;
-            AddAction(DebugAction.NextDebugMenu, nextDebugMenu);
+            DebugActionDesc nextDebugPanel = new DebugActionDesc();
+            nextDebugPanel.buttonTriggerList.Add(new[] { kDebugNextBtn });
+            nextDebugPanel.repeatMode = DebugActionRepeatMode.Never;
+            AddAction(DebugAction.NextDebugPanel, nextDebugPanel);
-            DebugActionDesc previousDebugMenu = new DebugActionDesc();
-            previousDebugMenu.buttonTriggerList.Add(new[] { kDebugPreviousBtn });
-            previousDebugMenu.repeatMode = DebugActionRepeatMode.Never;
-            AddAction(DebugAction.PreviousDebugMenu, previousDebugMenu);
+            DebugActionDesc previousDebugPanel = new DebugActionDesc();
+            previousDebugPanel.buttonTriggerList.Add(new[] { kDebugPreviousBtn });
+            previousDebugPanel.repeatMode = DebugActionRepeatMode.Never;
+            AddAction(DebugAction.PreviousDebugPanel, previousDebugPanel);
 
             DebugActionDesc validate = new DebugActionDesc();
             validate.buttonTriggerList.Add(new[] { kValidateBtn });
             DebugActionDesc persistent = new DebugActionDesc();
             persistent.buttonTriggerList.Add(new[] { kPersistentBtn });
             persistent.repeatMode = DebugActionRepeatMode.Never;
-            AddAction(DebugAction.Persistent, persistent);
+            AddAction(DebugAction.MakePersistent, persistent);
             
             AddAction(DebugAction.MoveVertical, new DebugActionDesc { axisTrigger = kDPadVertical, repeatMode = DebugActionRepeatMode.Delay, repeatDelay = 0.2f } );
             AddAction(DebugAction.MoveHorizontal, new DebugActionDesc { axisTrigger = kDPadHorizontal, repeatMode = DebugActionRepeatMode.Delay, repeatDelay = 0.2f } );

Assets/ScriptableRenderPipeline/Core/Debugging/DebugMenuManager.cs

 {
     public class DebugMenuManager
     {
-        static private DebugMenuManager s_Instance = null;
+        private static DebugMenuManager s_Instance = null;
+        private static string s_MenuStateAssetPath = "Assets/DebugMenuState.asset";
+
+        private DebugMenuState m_DebugMenuState = null;
 
         static public DebugMenuManager instance
         {
                 {
                     s_Instance = new DebugMenuManager();
+                    s_Instance.Initialize();
                 }
 
                 return s_Instance;
+        List<DebugPanel>    m_DebugPanels = new List<DebugPanel>();
+        DebugPanel          m_PersistentDebugPanel = null;
+        DebugMenuUI         m_DebugMenuUI = null;
+        bool                m_UpdateFromItemStateRequired = false;
+
+        public int          panelCount          { get { return m_DebugPanels.Count; } }
+        public DebugMenuUI  menuUI              { get { return m_DebugMenuUI; } }
+
-            LookUpDebugMenuClasses();
-            m_PersistentDebugMenu = new DebugMenu("Persistent");
+            m_PersistentDebugPanel = new DebugPanel<DebugPanelUI>("Persistent");
-        }
-        bool            m_Enabled = false;
-        int             m_ActiveMenuIndex = 0;
-        List<DebugMenu> m_DebugMenus = new List<DebugMenu>();
-        DebugMenu       m_PersistentDebugMenu = null;
-        DebugMenuUI     m_DebugMenuUI = null;
+            LookUpDebugPanelClasses();
-        public bool isEnabled       { get { return m_Enabled; } }
-        public int activeMenuIndex  { get { return m_ActiveMenuIndex; } set { m_ActiveMenuIndex = value; } }
-        public int  menuCount       { get { return m_DebugMenus.Count; } }
-
-        public DebugMenu GetDebugMenu(int index)
-        {
-            if (index < m_DebugMenus.Count)
-                return m_DebugMenus[index];
-            else
-                return null;
+            var updater = GameObject.Find("DebugMenuUpdater");
+            if (updater == null)
+            {
+                GameObject go = new GameObject("DebugMenuUpdater");
+                go.hideFlags = HideFlags.HideAndDontSave;
+                go.AddComponent<DebugMenuUpdater>();
+            }
-        public DebugMenu GetPersistentDebugMenu()
+        private void Initialize()
-            return m_PersistentDebugMenu;
-        }
+#if UNITY_EDITOR
+            m_DebugMenuState = UnityEditor.AssetDatabase.LoadAssetAtPath<DebugMenuState>(s_MenuStateAssetPath);
-        void LookUpDebugMenuClasses()
-        {
-            // Prepare all debug menus
-            var types = Assembly.GetAssembly(typeof(DebugMenu)).GetTypes()
-                .Where(t => t.IsSubclassOf(typeof(DebugMenu)));
-
-            m_DebugMenus.Clear();
-
-            foreach (var type in types)
+            if (m_DebugMenuState == null)
-                m_DebugMenus.Add((DebugMenu)Activator.CreateInstance(type));
+                m_DebugMenuState = ScriptableObject.CreateInstance<DebugMenuState>();
+                UnityEditor.AssetDatabase.CreateAsset(m_DebugMenuState, s_MenuStateAssetPath);
+#endif
-        public void PreviousDebugMenu()
+        public void RequireUpdateFromDebugItemState()
-            m_DebugMenus[m_ActiveMenuIndex].SetSelected(false);
-            m_ActiveMenuIndex = m_ActiveMenuIndex - 1;
-            if (m_ActiveMenuIndex == -1)
-                m_ActiveMenuIndex = m_DebugMenus.Count - 1;
-
-            m_DebugMenus[m_ActiveMenuIndex].SetSelected(true);
+            m_UpdateFromItemStateRequired = true;
-        public void NextDebugMenu()
+        public DebugItemState FindDebugItemState(string itemName, string menuName)
-            m_DebugMenus[m_ActiveMenuIndex].SetSelected(false);
-            m_ActiveMenuIndex = (m_ActiveMenuIndex + 1) % m_DebugMenus.Count;
-            m_DebugMenus[m_ActiveMenuIndex].SetSelected(true);
+            return m_DebugMenuState.FindDebugItemState(itemName, menuName);
-        public void ToggleMenu()
+        public void AddDebugItemState(DebugItemState state)
-            m_Enabled = !m_Enabled;
+            m_DebugMenuState.AddDebugItemState(state);
+        }
-            m_DebugMenuUI.BuildGUI();
-            m_DebugMenuUI.Toggle();
-            m_DebugMenus[m_ActiveMenuIndex].SetSelected(m_Enabled);
+        public DebugPanel GetDebugPanel(int index)
+        {
+            if (index < m_DebugPanels.Count)
+                return m_DebugPanels[index];
+            else
+                return null;
-        public void OnValidate()
+        public DebugPanel GetPersistentDebugPanel()
-            m_DebugMenus[m_ActiveMenuIndex].OnValidate();
+            return m_PersistentDebugPanel;
-        public void OnMakePersistent()
+        void LookUpDebugPanelClasses()
-            DebugMenuItem selectedItem = m_DebugMenus[m_ActiveMenuIndex].GetSelectedDebugMenuItem();
-            if(selectedItem != null && selectedItem.readOnly)
-            {
-                if(m_PersistentDebugMenu.HasItem(selectedItem))
-                {
-                    m_PersistentDebugMenu.RemoveDebugItem(selectedItem);
-                }
-                else
-                {
-                    m_PersistentDebugMenu.AddDebugItem(selectedItem);
-                }
-            }
+            // Prepare all debug menus
+            var types = Assembly.GetAssembly(typeof(DebugPanel)).GetTypes()
+                .Where(t => t.IsSubclassOf(typeof(DebugPanel)));
-            if(m_PersistentDebugMenu.itemCount == 0)
+            m_DebugPanels.Clear();
+
+            foreach (var type in types)
-                m_PersistentDebugMenu.SetSelected(false);
-                m_DebugMenuUI.EnablePersistentView(false); // Temp, should just need the above. Wait for background UI to be moved to menu itself
-            }
-            else
-            {
-                m_PersistentDebugMenu.SetSelected(true);
-                m_DebugMenuUI.EnablePersistentView(true);
+                if(!type.IsGenericTypeDefinition)
+                    AddDebugPanel((DebugPanel)Activator.CreateInstance(type));
-        public void OnMoveHorizontal(float value)
-        {
-            m_DebugMenus[m_ActiveMenuIndex].OnMoveHorizontal(value);
-        }
-
-        public void OnMoveVertical(float value)
-        {
-            m_DebugMenus[m_ActiveMenuIndex].OnMoveVertical(value);
-        }
-
-        T GetDebugMenu<T>() where T:DebugMenu
+        T GetDebugPanel<T>() where T:DebugPanel
-            foreach(DebugMenu menu in m_DebugMenus)
+            foreach(DebugPanel menu in m_DebugPanels)
             {
                 if (menu is T)
                     return menu as T;
         }
 
-        DebugMenu GetDebugMenu(string name)
+        public DebugPanel GetDebugPanel(string name)
-            foreach(DebugMenu menu in m_DebugMenus)
+            foreach(DebugPanel menu in m_DebugPanels)
             {
                 if (menu.name == name)
                     return menu;
 
         public void Update()
         {
-            if (m_ActiveMenuIndex != -1)
-                m_DebugMenus[m_ActiveMenuIndex].Update();
+            m_DebugMenuUI.Update();
-            m_PersistentDebugMenu.Update();
+            if(m_UpdateFromItemStateRequired)
+            {
+                m_UpdateFromItemStateRequired = false;
+                m_DebugMenuState.UpdateAllDebugItems();
+            }
-        public void AddDebugItem<DebugMenuType, ItemType>(string name, Func<object> getter, Action<object> setter = null, bool dynamicDisplay = false, DebugItemDrawer drawer = null) where DebugMenuType : DebugMenu
+        private void AddDebugPanel(DebugPanel panel)
-            DebugMenuType debugMenu = GetDebugMenu<DebugMenuType>();
+            m_DebugPanels.Add(panel);
+            m_DebugMenuUI.AddDebugPanel(panel);
+        }
+
+        public void AddDebugItem<DebugPanelType, DebugItemType>(string name, Func<object> getter, Action<object> setter = null, bool dynamicDisplay = false, DebugItemHandler handler = null) where DebugPanelType : DebugPanel
+        {
+            DebugPanelType debugMenu = GetDebugPanel<DebugPanelType>();
-                debugMenu.AddDebugMenuItem<ItemType>(name, getter, setter, dynamicDisplay, drawer);
+                debugMenu.AddDebugItem<DebugItemType>(name, getter, setter, dynamicDisplay, handler);
-        public void AddDebugItem<ItemType>(string debugMenuName, string name, Func<object> getter, Action<object> setter = null, bool dynamicDisplay = false, DebugItemDrawer drawer = null)
+        public void AddDebugItem<DebugItemType>(string debugPanelName, string name, Func<object> getter, Action<object> setter = null, bool dynamicDisplay = false, DebugItemHandler handler = null)
-            DebugMenu debugMenu = GetDebugMenu(debugMenuName);
+            DebugPanel debugPanel = GetDebugPanel(debugPanelName);
-            if(debugMenu == null)
+            if(debugPanel == null)
-                debugMenu = new DebugMenu(debugMenuName);
-                m_DebugMenus.Add(debugMenu);
+                debugPanel = new DebugPanel<DebugPanelUI>(debugPanelName);
+                AddDebugPanel(debugPanel);
-            if (debugMenu != null)
+            if (debugPanel != null)
-                debugMenu.AddDebugMenuItem<ItemType>(name, getter, setter, dynamicDisplay, drawer);
+                debugPanel.AddDebugItem<DebugItemType>(name, getter, setter, dynamicDisplay, handler);
             }
         }
     }

Assets/ScriptableRenderPipeline/Core/Debugging/DebugMenuUI.cs

         public static Color kBackgroundColor = new Color(0.5f, 0.5f, 0.5f, 0.4f);
         public static float kDebugItemNameWidth = 150.0f;
 
+        bool                m_Enabled = false;
+        int                 m_ActivePanelIndex = 0;
-        GameObject[]        m_MenuRoots = null;
+        GameObject          m_MainPanelLayout = null;
+        GameObject          m_PersistentPanelLayout = null;
+        List<DebugPanelUI>  m_DebugPanelUIs = new List<DebugPanelUI>();
+        DebugPanelUI        m_PersistentDebugPanelUI = null;
-        GameObject          m_PersistentMenuRoot = null;
-        bool                m_Enabled = false;
+        GameObject          m_PersistentPanelRoot = null;
+        public int  panelCount          { get { return m_DebugPanelUIs.Count; } }
+        public bool isEnabled           { get { return m_Enabled; } }
+        public int  activePanelIndex    { get { return m_ActivePanelIndex; } set { m_ActivePanelIndex = value; } }
+
+        static bool         s_UIChanged = false;
+        static public bool  changed     { get { return s_UIChanged; } set { s_UIChanged = value; } }
+
-        public void Toggle()
+        public void EnablePersistentView(bool value)
+        {
+            m_PersistentPanelRoot.SetActive(value);
+        }
+
+        public void PreviousDebugPanel()
+        {
+            m_DebugPanelUIs[m_ActivePanelIndex].SetSelected(false);
+            m_ActivePanelIndex = m_ActivePanelIndex - 1;
+            if (m_ActivePanelIndex == -1)
+                m_ActivePanelIndex = m_DebugPanelUIs.Count - 1;
+
+            m_DebugPanelUIs[m_ActivePanelIndex].SetSelected(true);
+
+            // HACK: for some reason, the layout of the selected menu may fail if the previous menu in the list is disabled
+            // Disabling and re-enabling everything seems to fix the issue...
+            m_MainMenuRoot.SetActive(false);
+            m_MainMenuRoot.SetActive(true);
+        }
+
+        public void NextDebugPanel()
+        {
+            m_DebugPanelUIs[m_ActivePanelIndex].SetSelected(false);
+            m_ActivePanelIndex = (m_ActivePanelIndex + 1) % m_DebugPanelUIs.Count;
+            m_DebugPanelUIs[m_ActivePanelIndex].SetSelected(true);
+
+            // HACK: for some reason, the layout of the selected menu may fail if the previous menu in the list is disabled
+            // Disabling and re-enabling everything seems to fix the issue...
+            m_MainMenuRoot.SetActive(false);
+            m_MainMenuRoot.SetActive(true);
+        }
+
+        public void ToggleMenu()
-            m_MainMenuRoot.SetActive(m_Enabled);
+            if(m_Enabled)
+            {
+                BuildGUI();
+                m_MainMenuRoot.SetActive(true);
+                m_DebugPanelUIs[m_ActivePanelIndex].SetSelected(m_Enabled);
+            }
+            else
+            {
+                m_MainMenuRoot.SetActive(false);
+            }
+        }
+
+        public void OnValidate()
+        {
+            m_DebugPanelUIs[m_ActivePanelIndex].OnValidate();
-        public void EnablePersistentView(bool value)
+        public void OnMoveHorizontal(float value)
-            m_PersistentMenuRoot.SetActive(value);
+            m_DebugPanelUIs[m_ActivePanelIndex].OnMoveHorizontal(value);
+        }
+
+        public void OnMoveVertical(float value)
+        {
+            m_DebugPanelUIs[m_ActivePanelIndex].OnMoveVertical(value);
+        }
+
+        public void Update()
+        {
+            if(m_PersistentDebugPanelUI != null)
+                m_PersistentDebugPanelUI.Update();
+
+            if (!m_Enabled)
+                return;
+
+            if (m_ActivePanelIndex != -1)
+                m_DebugPanelUIs[m_ActivePanelIndex].Update();
-        void CleanUpGUI()
+        public void OnMakePersistent()
-            Object.Destroy(m_Root);
+            DebugPanel persistentPanel = DebugMenuManager.instance.GetPersistentDebugPanel();
+
+            DebugItem selectedItem = m_DebugPanelUIs[m_ActivePanelIndex].GetSelectedDebugItem();
+            if (selectedItem != null && selectedItem.readOnly)
+            {
+                if (persistentPanel.HasDebugItem(selectedItem))
+                {
+                    persistentPanel.RemoveDebugItem(selectedItem);
+                }
+                else
+                {
+                    persistentPanel.AddDebugItem(selectedItem);
+                }
+            }
+
+            if (m_PersistentDebugPanelUI.itemCount == 0)
+            {
+                m_PersistentDebugPanelUI.SetSelected(false);
+                EnablePersistentView(false); // Temp, should just need the above. Wait for background UI to be moved to menu itself
+            }
+            else
+            {
+                m_PersistentDebugPanelUI.SetSelected(true);
+                EnablePersistentView(true);
+            }
         }
 
         public void BuildGUI()
             image.rectTransform.sizeDelta = new Vector2(-(kBorderSize * 2.0f), -(kBorderSize * 2.0f));
             image.color = kBackgroundColor;
 
-            GameObject goVL = DebugMenuUI.CreateVerticalLayoutGroup("DebugMenu VLayout", true, true, true, false, 5.0f, m_MainMenuRoot);
-            RectTransform menuVLRectTransform = goVL.GetComponent<RectTransform>();
+            m_MainPanelLayout = DebugMenuUI.CreateVerticalLayoutGroup("DebugMenu VLayout", true, true, true, false, 5.0f, m_MainMenuRoot);
+            RectTransform menuVLRectTransform = m_MainPanelLayout.GetComponent<RectTransform>();
             menuVLRectTransform.pivot = new Vector2(0.0f, 0.0f);
             menuVLRectTransform.localPosition = Vector3.zero;
             menuVLRectTransform.localScale = Vector3.one;
             menuVLRectTransform.sizeDelta = new Vector2(-(kBorderSize * 2.0f), -(kBorderSize * 2.0f));
 
             // TODO: Move background an layout to the menu itself.
-            m_PersistentMenuRoot = new GameObject("Background_Persistent");
-            m_PersistentMenuRoot.AddComponent<CanvasRenderer>();
-            image = m_PersistentMenuRoot.AddComponent<UI.Image>();
-            m_PersistentMenuRoot.transform.SetParent(m_Root.transform, false);
+            m_PersistentPanelRoot = new GameObject("Background_Persistent");
+            m_PersistentPanelRoot.AddComponent<CanvasRenderer>();
+            image = m_PersistentPanelRoot.AddComponent<UI.Image>();
+            m_PersistentPanelRoot.transform.SetParent(m_Root.transform, false);
             image.rectTransform.pivot = new Vector2(0.0f, 0.0f);
             image.rectTransform.localPosition = Vector3.zero;
             image.rectTransform.localScale = Vector3.one;
             image.rectTransform.sizeDelta = new Vector2(-(kBorderSize * 2.0f), -(kBorderSize * 2.0f));
             image.color = kBackgroundColor;
 
-            GameObject goVL2 = DebugMenuUI.CreateVerticalLayoutGroup("DebugMenu VLayout", true, true, true, false, 5.0f, m_PersistentMenuRoot);
-            menuVLRectTransform = goVL2.GetComponent<RectTransform>();
+            m_PersistentPanelLayout = DebugMenuUI.CreateVerticalLayoutGroup("DebugMenu VLayout", true, true, true, false, 5.0f, m_PersistentPanelRoot);
+            menuVLRectTransform = m_PersistentPanelLayout.GetComponent<RectTransform>();
             menuVLRectTransform.pivot = new Vector2(0.0f, 0.0f);
             menuVLRectTransform.localPosition = Vector3.zero;
             menuVLRectTransform.localScale = Vector3.one;
             menuVLRectTransform.sizeDelta = new Vector2(-(kBorderSize * 2.0f), -(kBorderSize * 2.0f));
 
-            m_PersistentMenuRoot.SetActive(false);
+            m_PersistentPanelRoot.SetActive(false);
-            DebugMenuUI.CreateTextElement("DebugMenuTitle", "Debug Menu", 14, TextAnchor.MiddleCenter, goVL);
+            DebugMenuUI.CreateTextElement("DebugMenuTitle", "Debug Menu", 14, TextAnchor.MiddleCenter, m_MainPanelLayout);
-            int menuCount = m_DebugMenuManager.menuCount;
-            m_MenuRoots = new GameObject[menuCount];
-            for (int i = 0; i < menuCount; ++i)
+            m_DebugMenuManager.GetPersistentDebugPanel().panelUI.BuildGUI(m_PersistentPanelLayout);
+            m_PersistentDebugPanelUI = m_DebugMenuManager.GetPersistentDebugPanel().panelUI;
+
+            for (int i = 0; i < m_DebugMenuManager.panelCount; ++i)
-                m_MenuRoots[i] = m_DebugMenuManager.GetDebugMenu(i).BuildGUI(goVL);
+                m_DebugMenuManager.GetDebugPanel(i).panelUI.BuildGUI(m_MainPanelLayout);
+                m_DebugPanelUIs[i].SetSelected(false);
+        }
-            m_DebugMenuManager.GetPersistentDebugMenu().BuildGUI(goVL2);
+        public void AddDebugPanel(DebugPanel panel)
+        {
+            m_DebugPanelUIs.Add(panel.panelUI);
+
+#if UNITY_EDITOR
+        public void OnEditorGUI()
+        {
+            s_UIChanged = false;
+            m_DebugPanelUIs[m_ActivePanelIndex].OnEditorGUI();
+            if(s_UIChanged)
+            {
+                UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+            }
+        }
+#endif
 
         public static GameObject CreateVerticalLayoutGroup(string name, bool controlWidth, bool controlHeight, bool forceExpandWidth, bool forceExpandHeight, GameObject parent = null )
         {

Assets/ScriptableRenderPipeline/Core/Debugging/DebugMenuUpdater.cs

 
             if (DebugActionManager.instance.GetAction(DebugActionManager.DebugAction.EnableDebugMenu) != 0.0f)
             {
-                DebugMenuManager.instance.ToggleMenu();
+                DebugMenuManager.instance.menuUI.ToggleMenu();
-            if (DebugMenuManager.instance.isEnabled)
+            if (DebugMenuManager.instance.menuUI.isEnabled)
-                if (DebugActionManager.instance.GetAction(DebugActionManager.DebugAction.PreviousDebugMenu) != 0.0f)
+                if (DebugActionManager.instance.GetAction(DebugActionManager.DebugAction.PreviousDebugPanel) != 0.0f)
-                    DebugMenuManager.instance.PreviousDebugMenu();
+                    DebugMenuManager.instance.menuUI.PreviousDebugPanel();
-                if (DebugActionManager.instance.GetAction(DebugActionManager.DebugAction.NextDebugMenu) != 0.0f)
+                if (DebugActionManager.instance.GetAction(DebugActionManager.DebugAction.NextDebugPanel) != 0.0f)
-                    DebugMenuManager.instance.NextDebugMenu();
+                    DebugMenuManager.instance.menuUI.NextDebugPanel();
-                    DebugMenuManager.instance.OnValidate();
+                    DebugMenuManager.instance.menuUI.OnValidate();
-                if (DebugActionManager.instance.GetAction(DebugActionManager.DebugAction.Persistent) != 0.0f)
+                if (DebugActionManager.instance.GetAction(DebugActionManager.DebugAction.MakePersistent) != 0.0f)
-                    DebugMenuManager.instance.OnMakePersistent();
+                    DebugMenuManager.instance.menuUI.OnMakePersistent();
-                    DebugMenuManager.instance.OnMoveHorizontal(moveHorizontal);
+                    DebugMenuManager.instance.menuUI.OnMoveHorizontal(moveHorizontal);
-                    DebugMenuManager.instance.OnMoveVertical(moveVertical);
+                    DebugMenuManager.instance.menuUI.OnMoveVertical(moveVertical);
                 }
             }
         }

Assets/ScriptableRenderPipeline/Core/Debugging/Editor/DebugMenuEditor.cs

 
             // Contrary to the menu in the player, here we always render the menu wether it's enabled or not. This is a separate window so user can manage it however they want.
             EditorGUI.BeginChangeCheck();
-            int debugMenuCount = m_DebugMenu.menuCount;
-            int activeMenuIndex = m_DebugMenu.activeMenuIndex;
+            DebugMenuUI debugMenuUI = m_DebugMenu.menuUI;
+            int debugMenuCount = m_DebugMenu.panelCount;
+            int activePanelIndex = debugMenuUI.activePanelIndex;
             using (new EditorGUILayout.HorizontalScope())
             {
                 for(int i = 0 ; i < debugMenuCount ; ++i)
                         style = EditorStyles.miniButtonLeft;
                     if (i == debugMenuCount - 1)
                         style = EditorStyles.miniButtonRight;
-                    if (GUILayout.Toggle(i == activeMenuIndex, new GUIContent(m_DebugMenu.GetDebugMenu(i).name), style))
-                        activeMenuIndex = i;
+
+                    string name = m_DebugMenu.GetDebugPanel(i).name;
+                    if (GUILayout.Toggle(i == activePanelIndex, new GUIContent(name), style))
+                        activePanelIndex = i;
-                m_DebugMenu.activeMenuIndex = activeMenuIndex;
+                debugMenuUI.activePanelIndex = activePanelIndex;
-           
-            using(new EditorGUILayout.VerticalScope())
-            {
-                DebugMenu activeMenu = m_DebugMenu.GetDebugMenu(m_DebugMenu.activeMenuIndex);
-                bool needRepaint = false;
-                for (int i = 0; i < activeMenu.itemCount; ++i)
-                {
-                    needRepaint = needRepaint || activeMenu.GetDebugMenuItem(i).drawer.OnEditorGUI();
-                }
-                if (needRepaint)
-                    UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
-            }
+            debugMenuUI.OnEditorGUI();
         }
     }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

         VisualizeCascade
     }
 
-    [Serializable]
-        public bool displayMaterialDebug = false;
-        public bool displayRenderingDebug = false;
-        public bool displayLightingDebug = false;
 
         public MaterialDebugSettings materialDebugSettings = new MaterialDebugSettings();
         public LightingDebugSettings lightingDebugSettings = new LightingDebugSettings();
             DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Rate", () => 1.0f / Time.deltaTime, null, true);
             DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Time", () => Time.deltaTime * 1000.0f, null, true);
 
-            DebugMenuManager.instance.AddDebugItem<int>("Material", "Material",() => materialDebugSettings.debugViewMaterial, (value) => SetDebugViewMaterial((int)value), false, new DebugItemDrawerIntEnum(DebugDisplaySettings.debugViewMaterialStrings, DebugDisplaySettings.debugViewMaterialValues));
-            DebugMenuManager.instance.AddDebugItem<int>("Material", "Engine",() => materialDebugSettings.debugViewEngine, (value) => SetDebugViewEngine((int)value), false, new DebugItemDrawerIntEnum(DebugDisplaySettings.debugViewEngineStrings, DebugDisplaySettings.debugViewEngineValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "Material",() => materialDebugSettings.debugViewMaterial, (value) => SetDebugViewMaterial((int)value), false, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialStrings, DebugDisplaySettings.debugViewMaterialValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "Engine",() => materialDebugSettings.debugViewEngine, (value) => SetDebugViewEngine((int)value), false, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewEngineStrings, DebugDisplaySettings.debugViewEngineValues));
-            DebugMenuManager.instance.AddDebugItem<int>("Material", "GBuffer",() => materialDebugSettings.debugViewGBuffer, (value) => SetDebugViewGBuffer((int)value), false, new DebugItemDrawerIntEnum(DebugDisplaySettings.debugViewMaterialGBufferStrings, DebugDisplaySettings.debugViewMaterialGBufferValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "GBuffer",() => materialDebugSettings.debugViewGBuffer, (value) => SetDebugViewGBuffer((int)value), false, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialGBufferStrings, DebugDisplaySettings.debugViewMaterialGBufferValues));
-            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, bool>("Enable Shadows", () => lightingDebugSettings.enableShadows, (value) => lightingDebugSettings.enableShadows = (bool)value);
-            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, ShadowMapDebugMode>("Shadow Debug Mode", () => lightingDebugSettings.shadowDebugMode, (value) => lightingDebugSettings.shadowDebugMode = (ShadowMapDebugMode)value);
-            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, uint>("Shadow Map Index", () => lightingDebugSettings.shadowMapIndex, (value) => lightingDebugSettings.shadowMapIndex = (uint)value);
-            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, DebugLightingMode>("Lighting Debug Mode", () => lightingDebugSettings.debugLightingMode, (value) => SetDebugLightingMode((DebugLightingMode)value));
-            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, bool>("Override Smoothness", () => lightingDebugSettings.overrideSmoothness, (value) => lightingDebugSettings.overrideSmoothness = (bool)value);
-            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, float>("Override Smoothness Value", () => lightingDebugSettings.overrideSmoothnessValue, (value) => lightingDebugSettings.overrideSmoothnessValue = (float)value, false, new DebugItemDrawFloatMinMax(0.0f, 1.0f));
-            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, Color>("Debug Lighting Albedo", () => lightingDebugSettings.debugLightingAlbedo, (value) => lightingDebugSettings.debugLightingAlbedo = (Color)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, bool>("Enable Shadows", () => lightingDebugSettings.enableShadows, (value) => lightingDebugSettings.enableShadows = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, ShadowMapDebugMode>("Shadow Debug Mode", () => lightingDebugSettings.shadowDebugMode, (value) => lightingDebugSettings.shadowDebugMode = (ShadowMapDebugMode)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, uint>("Shadow Map Index", () => lightingDebugSettings.shadowMapIndex, (value) => lightingDebugSettings.shadowMapIndex = (uint)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, DebugLightingMode>("Lighting Debug Mode", () => lightingDebugSettings.debugLightingMode, (value) => SetDebugLightingMode((DebugLightingMode)value));
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, bool>("Override Smoothness", () => lightingDebugSettings.overrideSmoothness, (value) => lightingDebugSettings.overrideSmoothness = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>("Override Smoothness Value", () => lightingDebugSettings.overrideSmoothnessValue, (value) => lightingDebugSettings.overrideSmoothnessValue = (float)value, false, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, Color>("Debug Lighting Albedo", () => lightingDebugSettings.debugLightingAlbedo, (value) => lightingDebugSettings.debugLightingAlbedo = (Color)value);
-            DebugMenuManager.instance.AddDebugItem<LightingDebugMenu, float>("Sky Reflection Mipmap", () => lightingDebugSettings.skyReflectionMipmap, (value) => lightingDebugSettings.skyReflectionMipmap = (float)value, false, new DebugItemDrawFloatMinMax(0.0f, 1.0f));
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>("Sky Reflection Mipmap", () => lightingDebugSettings.skyReflectionMipmap, (value) => lightingDebugSettings.skyReflectionMipmap = (float)value, false, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
 
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Opaque",() => renderingDebugSettings.displayOpaqueObjects, (value) => renderingDebugSettings.displayOpaqueObjects = (bool)value);
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Transparency",() => renderingDebugSettings.displayTransparentObjects, (value) => renderingDebugSettings.displayTransparentObjects = (bool)value);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
-    [CustomEditor(typeof(HDRenderPipeline))]
+    [CustomEditor(typeof(HDRenderPipelineAsset))]
     public class HDRenderPipelineInspector : Editor
     {
         private class Styles
 
             // Tile pass Settings
             public readonly GUIContent tileLightLoopSettings = new GUIContent("Tile Light Loop Settings");
-            public readonly string[] tileLightLoopDebugTileFlagStrings = new string[] { "Punctual Light", "Area Light", "Env Light"};
-            public readonly GUIContent splitLightEvaluation = new GUIContent("Split light and reflection evaluation", "Toggle");
-            public readonly GUIContent bigTilePrepass = new GUIContent("Enable big tile prepass", "Toggle");
-            public readonly GUIContent clustered = new GUIContent("Enable clustered", "Toggle");
-            public readonly GUIContent enableTileAndCluster = new GUIContent("Enable Tile/clustered", "Toggle");
+            public readonly GUIContent enableTileAndCluster = new GUIContent("Enable tile/clustered", "Toggle");
+            public readonly GUIContent enableSplitLightEvaluation = new GUIContent("Split light and reflection evaluation", "Toggle");
+            public readonly GUIContent enableComputeFeatureVariants = new GUIContent("Enable Compute Features Variants", "Toggle");
+            public readonly GUIContent enableClustered = new GUIContent("Enable clustered", "Toggle");
+            public readonly GUIContent enableFptlForOpaqueWhenClustered = new GUIContent("Enable Fptl For Opaque When Clustered", "Toggle");
+            public readonly GUIContent enableBigTilePrepass = new GUIContent("Enable big tile prepass", "Toggle");
+            public readonly GUIContent tileDebugByCategory = new GUIContent("Enable Debug By Category", "Toggle");
-
-            // Debug Display Settings
-            public readonly GUIContent debugging = new GUIContent("Debugging");
-            public readonly GUIContent debugOverlayRatio = new GUIContent("Overlay Ratio");
-
-            // Material debug
-            public readonly GUIContent materialDebugLabel = new GUIContent("Material Debug");
-            public readonly GUIContent debugViewMaterial = new GUIContent("DebugView Material", "Display various properties of Materials.");
-            public readonly GUIContent debugViewEngine = new GUIContent("DebugView Engine", "Display various properties of Materials.");
-            public readonly GUIContent debugViewMaterialVarying = new GUIContent("DebugView Attributes", "Display varying input of Materials.");
-            public readonly GUIContent debugViewMaterialGBuffer = new GUIContent("DebugView GBuffer", "Display GBuffer properties.");
-
-            // Rendering Debug
-            public readonly GUIContent renderingDebugSettings = new GUIContent("Rendering Debug");
-            public readonly GUIContent displayOpaqueObjects = new GUIContent("Display Opaque Objects", "Toggle opaque objects rendering on and off.");
-            public readonly GUIContent displayTransparentObjects = new GUIContent("Display Transparent Objects", "Toggle transparent objects rendering on and off.");
-            public readonly GUIContent enableDistortion = new GUIContent("Enable Distortion");
-            public readonly GUIContent enableSSS = new GUIContent("Enable Subsurface Scattering");
-
-            // Lighting Debug
-            public readonly GUIContent lightingDebugSettings = new GUIContent("Lighting Debug");
-            public readonly GUIContent shadowDebugEnable = new GUIContent("Enable Shadows");
-            public readonly GUIContent lightingVisualizationMode = new GUIContent("Lighting Debug Mode");
-            public readonly GUIContent[] debugViewLightingStrings = { new GUIContent("None"), new GUIContent("Diffuse Lighting"), new GUIContent("Specular Lighting"), new GUIContent("Visualize Cascades") };
-            public readonly int[] debugViewLightingValues = { (int)DebugLightingMode.None, (int)DebugLightingMode.DiffuseLighting, (int)DebugLightingMode.SpecularLighting, (int)DebugLightingMode.VisualizeCascade };
-            public readonly GUIContent shadowDebugVisualizationMode = new GUIContent("Shadow Maps Debug Mode");
-            public readonly GUIContent shadowDebugVisualizeShadowIndex = new GUIContent("Visualize Shadow Index");
-            public readonly GUIContent lightingDebugOverrideSmoothness = new GUIContent("Override Smoothness");
-            public readonly GUIContent lightingDebugOverrideSmoothnessValue = new GUIContent("Smoothness Value");
-            public readonly GUIContent lightingDebugAlbedo = new GUIContent("Lighting Debug Albedo");
-            public readonly GUIContent lightingDisplaySkyReflection = new GUIContent("Display Sky Reflection");
-            public readonly GUIContent lightingDisplaySkyReflectionMipmap = new GUIContent("Reflection Mipmap");
         }
 
         private static Styles s_Styles = null;
         private SerializedProperty m_DefaultDiffuseMaterial;
         private SerializedProperty m_DefaultShader;
 
-        // Display Debug
-        SerializedProperty m_ShowMaterialDebug = null;
-        SerializedProperty m_ShowLightingDebug = null;
-        SerializedProperty m_ShowRenderingDebug = null;
-        SerializedProperty m_DebugOverlayRatio = null;
-
-        // Rendering Debug
-        SerializedProperty m_DisplayOpaqueObjects = null;
-        SerializedProperty m_DisplayTransparentObjects = null;
-        SerializedProperty m_EnableDistortion = null;
-        SerializedProperty m_EnableSSS = null;
-
-        // Lighting debug
-        SerializedProperty m_DebugShadowEnabled = null;
-        SerializedProperty m_ShadowDebugMode = null;
-        SerializedProperty m_ShadowDebugShadowMapIndex = null;
-        SerializedProperty m_LightingDebugOverrideSmoothness = null;
-        SerializedProperty m_LightingDebugOverrideSmoothnessValue = null;
-        SerializedProperty m_LightingDebugAlbedo = null;
-        SerializedProperty m_LightingDebugDisplaySkyReflection = null;
-        SerializedProperty m_LightingDebugDisplaySkyReflectionMipmap = null;
+        // TilePass settings
+        SerializedProperty m_enableTileAndCluster;
+        SerializedProperty m_enableSplitLightEvaluation;
+        SerializedProperty m_enableComputeLightEvaluation;
+        SerializedProperty m_enableComputeFeatureVariants;
+        SerializedProperty m_enableClustered;
+        SerializedProperty m_enableFptlForOpaqueWhenClustered;
+        SerializedProperty m_enableBigTilePrepass;
+        SerializedProperty m_tileDebugByCategory;
 
         // Rendering Settings
         SerializedProperty m_RenderingUseForwardOnly = null;
             m_DefaultDiffuseMaterial = serializedObject.FindProperty("m_DefaultDiffuseMaterial");
             m_DefaultShader = serializedObject.FindProperty("m_DefaultShader");
 
-            // DebugDisplay debug
-            m_DebugOverlayRatio = FindProperty(x => x.debugDisplaySettings.debugOverlayRatio);
-            m_ShowLightingDebug = FindProperty(x => x.debugDisplaySettings.displayLightingDebug);
-            m_ShowRenderingDebug = FindProperty(x => x.debugDisplaySettings.displayRenderingDebug);
-            m_ShowMaterialDebug = FindProperty(x => x.debugDisplaySettings.displayMaterialDebug);
+            // Following way of getting property allow to handle change of properties name with serializations
+
+            // Tile settings
+            m_enableTileAndCluster = FindProperty(x => x.tileSettings.enableTileAndCluster);
+            m_enableSplitLightEvaluation = FindProperty(x => x.tileSettings.enableSplitLightEvaluation);
+            m_enableComputeLightEvaluation = FindProperty(x => x.tileSettings.enableComputeLightEvaluation);
+            m_enableComputeFeatureVariants = FindProperty(x => x.tileSettings.enableComputeFeatureVariants);
+            m_enableClustered = FindProperty(x => x.tileSettings.enableClustered);
+            m_enableFptlForOpaqueWhenClustered = FindProperty(x => x.tileSettings.enableFptlForOpaqueWhenClustered);
+            m_enableBigTilePrepass = FindProperty(x => x.tileSettings.enableBigTilePrepass);
+            m_tileDebugByCategory = FindProperty(x => x.tileSettings.tileDebugByCategory);
-            // Rendering debug
-            m_DisplayOpaqueObjects = FindProperty(x => x.debugDisplaySettings.renderingDebugSettings.displayOpaqueObjects);
-            m_DisplayTransparentObjects = FindProperty(x => x.debugDisplaySettings.renderingDebugSettings.displayTransparentObjects);
-            m_EnableDistortion = FindProperty(x => x.debugDisplaySettings.renderingDebugSettings.enableDistortion);
-            m_EnableSSS = FindProperty(x => x.debugDisplaySettings.renderingDebugSettings.enableSSS);
+            // Shadow settings
-            // Lighting debug
-            m_DebugShadowEnabled = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.enableShadows);
-            m_ShadowDebugMode = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.shadowDebugMode);
-            m_ShadowDebugShadowMapIndex = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.shadowMapIndex);
-            m_LightingDebugOverrideSmoothness = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.overrideSmoothness);
-            m_LightingDebugOverrideSmoothnessValue = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.overrideSmoothnessValue);
-            m_LightingDebugAlbedo = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.debugLightingAlbedo);
-            m_LightingDebugDisplaySkyReflection = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.displaySkyReflection);
-            m_LightingDebugDisplaySkyReflectionMipmap = FindProperty(x => x.debugDisplaySettings.lightingDebugSettings.skyReflectionMipmap);
+            //TODO!
 
             // Rendering settings
             m_RenderingUseForwardOnly = FindProperty(x => x.renderingSettings.useForwardRenderingOnly);
             m_NumProfiles = m_Profiles.FindPropertyRelative("Array.size");
         }
 
-        SerializedProperty FindProperty<TValue>(Expression<Func<HDRenderPipeline, TValue>> expr)
+        SerializedProperty FindProperty<TValue>(Expression<Func<HDRenderPipelineAsset, TValue>> expr)
         {
             var path = Utilities.GetFieldPath(expr);
             return serializedObject.FindProperty(path);
                 method.Invoke(asset, new object[0]);
         }
 
-        private void DebuggingUI(HDRenderPipeline renderContext, HDRenderPipelineInstance renderpipelineInstance)
+        private void TileSettingsUI(HDRenderPipelineAsset renderContext)
-            EditorGUILayout.LabelField(styles.debugging);
-
-            // Debug Display settings
-            EditorGUI.indentLevel++;
-            m_DebugOverlayRatio.floatValue = EditorGUILayout.Slider(styles.debugOverlayRatio, m_DebugOverlayRatio.floatValue, 0.1f, 1.0f);
-            RenderingDebugSettingsUI(renderContext);
-            MaterialDebugSettingsUI(renderContext);
-            LightingDebugSettingsUI(renderContext, renderpipelineInstance);
-
-            EditorGUILayout.Space();
-
-            EditorGUI.indentLevel--;
-        }
-
-        private void MaterialDebugSettingsUI(HDRenderPipeline renderContext)
-        {
-            HDRenderPipeline hdPipe = target as HDRenderPipeline;
-
-            m_ShowMaterialDebug.boolValue = EditorGUILayout.Foldout(m_ShowMaterialDebug.boolValue, styles.materialDebugLabel);
-            if (!m_ShowMaterialDebug.boolValue)
-                return;
-
+            EditorGUILayout.LabelField(styles.tileLightLoopSettings);
-
-            bool dirty = false;
-            int value = EditorGUILayout.IntPopup(styles.debugViewMaterial, hdPipe.debugDisplaySettings.materialDebugSettings.debugViewMaterial, DebugDisplaySettings.debugViewMaterialStrings, DebugDisplaySettings.debugViewMaterialValues);
-            if (EditorGUI.EndChangeCheck())
-            {
-                hdPipe.debugDisplaySettings.SetDebugViewMaterial(value);
-                dirty = true;
-            }
-            EditorGUI.BeginChangeCheck();
-            value = EditorGUILayout.IntPopup(styles.debugViewEngine, hdPipe.debugDisplaySettings.materialDebugSettings.debugViewEngine, DebugDisplaySettings.debugViewEngineStrings, DebugDisplaySettings.debugViewEngineValues);
-            if (EditorGUI.EndChangeCheck())
-            {
-                hdPipe.debugDisplaySettings.SetDebugViewEngine(value);
-                dirty = true;
-            }
+            EditorGUILayout.PropertyField(m_enableTileAndCluster, styles.enableTileAndCluster);
+            EditorGUILayout.PropertyField(m_enableSplitLightEvaluation, styles.enableSplitLightEvaluation);
+            EditorGUILayout.PropertyField(m_enableComputeLightEvaluation, styles.enableComputeLightEvaluation);
+            EditorGUILayout.PropertyField(m_enableComputeFeatureVariants, styles.enableComputeFeatureVariants);
+            EditorGUILayout.PropertyField(m_enableClustered, styles.enableClustered);
+            EditorGUILayout.PropertyField(m_enableFptlForOpaqueWhenClustered, styles.enableFptlForOpaqueWhenClustered);
+            EditorGUILayout.PropertyField(m_enableBigTilePrepass, styles.enableBigTilePrepass);
+            EditorGUILayout.PropertyField(m_tileDebugByCategory, styles.tileDebugByCategory);
-            EditorGUI.BeginChangeCheck();
-            value = EditorGUILayout.IntPopup(styles.debugViewMaterialVarying, (int)hdPipe.debugDisplaySettings.materialDebugSettings.debugViewVarying, DebugDisplaySettings.debugViewMaterialVaryingStrings, DebugDisplaySettings.debugViewMaterialVaryingValues);
-                hdPipe.debugDisplaySettings.SetDebugViewVarying((Attributes.DebugViewVarying)value);
-                dirty = true;
+                HackSetDirty(renderContext); // Repaint
-
-            EditorGUI.BeginChangeCheck();
-            value = EditorGUILayout.IntPopup(styles.debugViewMaterialGBuffer, (int)hdPipe.debugDisplaySettings.materialDebugSettings.debugViewGBuffer, DebugDisplaySettings.debugViewMaterialGBufferStrings, DebugDisplaySettings.debugViewMaterialGBufferValues);
-            if (EditorGUI.EndChangeCheck())
-            {
-                hdPipe.debugDisplaySettings.SetDebugViewGBuffer(value);
-                dirty = true;
-            }
-
-            if(dirty)
-                HackSetDirty(renderContext); // Repaint
-
-        private void RenderingDebugSettingsUI(HDRenderPipeline renderContext)
-        {
-            m_ShowRenderingDebug.boolValue = EditorGUILayout.Foldout(m_ShowRenderingDebug.boolValue, styles.renderingDebugSettings);
-            if (!m_ShowRenderingDebug.boolValue)
-                return;
-
-            EditorGUI.indentLevel++;
-            EditorGUILayout.PropertyField(m_DisplayOpaqueObjects, styles.displayOpaqueObjects);
-            EditorGUILayout.PropertyField(m_DisplayTransparentObjects, styles.displayTransparentObjects);
-            EditorGUILayout.PropertyField(m_EnableDistortion, styles.enableDistortion);
-            EditorGUILayout.PropertyField(m_EnableSSS, styles.enableSSS);
-            EditorGUI.indentLevel--;
-        }
-
-        private void SssSettingsUI(HDRenderPipeline pipe)
+        private void SssSettingsUI(HDRenderPipelineAsset renderContext)
         {
             EditorGUILayout.Space();
 
             EditorGUI.indentLevel--;
         }
 
-        private void LightingDebugSettingsUI(HDRenderPipeline renderContext, HDRenderPipelineInstance renderpipelineInstance)
-        {
-            m_ShowLightingDebug.boolValue = EditorGUILayout.Foldout(m_ShowLightingDebug.boolValue, styles.lightingDebugSettings);
-            if (!m_ShowLightingDebug.boolValue)
-                return;
-
-            HDRenderPipeline hdPipe = target as HDRenderPipeline;
-
-            bool dirty = false;
-            EditorGUI.BeginChangeCheck();
-            EditorGUI.indentLevel++;
-            EditorGUILayout.PropertyField(m_DebugShadowEnabled, styles.shadowDebugEnable);
-            EditorGUILayout.PropertyField(m_ShadowDebugMode, styles.shadowDebugVisualizationMode);
-            if (!m_ShadowDebugMode.hasMultipleDifferentValues)
-            {
-                if ((ShadowMapDebugMode)m_ShadowDebugMode.intValue == ShadowMapDebugMode.VisualizeShadowMap)
-                {
-                    EditorGUILayout.IntSlider(m_ShadowDebugShadowMapIndex, 0, renderpipelineInstance.GetCurrentShadowCount() - 1, styles.shadowDebugVisualizeShadowIndex);
-                }
-            }
-            if (EditorGUI.EndChangeCheck())
-            {
-                dirty = true;
-            }
-
-            EditorGUI.BeginChangeCheck();
-            int value = EditorGUILayout.IntPopup(styles.lightingVisualizationMode, (int)hdPipe.debugDisplaySettings.lightingDebugSettings.debugLightingMode, styles.debugViewLightingStrings, styles.debugViewLightingValues);
-            if (EditorGUI.EndChangeCheck())
-            {
-                hdPipe.debugDisplaySettings.SetDebugLightingMode((DebugLightingMode)value);
-                dirty = true;
-            }
-
-            EditorGUI.BeginChangeCheck();
-            if (hdPipe.debugDisplaySettings.GetDebugLightingMode() == DebugLightingMode.DiffuseLighting)
-            {
-                EditorGUI.indentLevel++;
-                EditorGUILayout.PropertyField(m_LightingDebugAlbedo, styles.lightingDebugAlbedo);
-                EditorGUI.indentLevel--;
-            }
-
-            if (hdPipe.debugDisplaySettings.GetDebugLightingMode() == DebugLightingMode.SpecularLighting)
-            {
-                EditorGUI.indentLevel++;
-                EditorGUILayout.PropertyField(m_LightingDebugOverrideSmoothness, styles.lightingDebugOverrideSmoothness);
-                if (!m_LightingDebugOverrideSmoothness.hasMultipleDifferentValues && m_LightingDebugOverrideSmoothness.boolValue == true)
-                {
-                    EditorGUI.indentLevel++;
-                    EditorGUILayout.PropertyField(m_LightingDebugOverrideSmoothnessValue, styles.lightingDebugOverrideSmoothnessValue);
-                    EditorGUI.indentLevel--;
-                }
-                EditorGUI.indentLevel--;
-            }
-
-            EditorGUILayout.PropertyField(m_LightingDebugDisplaySkyReflection, styles.lightingDisplaySkyReflection);
-            if (!m_LightingDebugDisplaySkyReflection.hasMultipleDifferentValues && m_LightingDebugDisplaySkyReflection.boolValue == true)
-            {
-                EditorGUI.indentLevel++;
-                EditorGUILayout.PropertyField(m_LightingDebugDisplaySkyReflectionMipmap, styles.lightingDisplaySkyReflectionMipmap);
-                EditorGUI.indentLevel--;
-            }
-
-            EditorGUI.indentLevel--;
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                dirty = true;
-            }
-
-            if(dirty)
-                HackSetDirty(renderContext);
-        }
-
-        private void SettingsUI(HDRenderPipeline renderContext)
+        private void SettingsUI(HDRenderPipelineAsset renderContext)
-            EditorGUI.BeginChangeCheck();
-
-            renderContext.lightLoopProducer = (LightLoopProducer)EditorGUILayout.ObjectField(new GUIContent("Light Loop"), renderContext.lightLoopProducer, typeof(LightLoopProducer), false);
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                HackSetDirty(renderContext); // Repaint
-            }
-
-            //TilePassUI(renderContext);
+            TileSettingsUI(renderContext);
-        private void ShadowSettingsUI(HDRenderPipeline renderContext)
+        private void ShadowSettingsUI(HDRenderPipelineAsset renderContext)
         {
             EditorGUILayout.Space();
             var shadowSettings = renderContext.shadowSettings;
             EditorGUI.indentLevel--;
         }
 
-        private void RendereringSettingsUI(HDRenderPipeline renderContext)
+        private void RendereringSettingsUI(HDRenderPipelineAsset renderContext)
         {
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(styles.renderingSettingsLabel);
             EditorGUI.indentLevel--;
         }
 
-        private void TextureSettingsUI(HDRenderPipeline renderContext)
+        private void TextureSettingsUI(HDRenderPipelineAsset renderContext)
         {
             EditorGUILayout.Space();
             var textureSettings = renderContext.textureSettings;
             EditorGUI.indentLevel--;
         }
 
-        /*  private void TilePassUI(HDRenderPipeline renderContext)
-        {
-            EditorGUILayout.Space();
-
-            // TODO: we should call a virtual method or something similar to setup the UI, inspector should not know about it
-            var tilePass = renderContext.tileSettings;
-            if (tilePass != null)
-            {
-                EditorGUILayout.LabelField(styles.tileLightLoopSettings);
-                EditorGUI.indentLevel++;
-                EditorGUI.BeginChangeCheck();
-
-                tilePass.enableBigTilePrepass = EditorGUILayout.Toggle(styles.bigTilePrepass, tilePass.enableBigTilePrepass);
-                tilePass.enableClustered = EditorGUILayout.Toggle(styles.clustered, tilePass.enableClustered);
-
-                if (EditorGUI.EndChangeCheck())
-                {
-                   HackSetDirty(renderContext); // Repaint
-
-                    // SetAssetDirty will tell renderloop to rebuild
-                    renderContext.DestroyCreatedInstances();
-                }
-
-                EditorGUI.BeginChangeCheck();
-
-                tilePass.debugViewTilesFlags = EditorGUILayout.MaskField("DebugView Tiles", tilePass.debugViewTilesFlags, styles.tileLightLoopDebugTileFlagStrings);
-                tilePass.enableSplitLightEvaluation = EditorGUILayout.Toggle(styles.splitLightEvaluation, tilePass.enableSplitLightEvaluation);
-                tilePass.enableTileAndCluster = EditorGUILayout.Toggle(styles.enableTileAndCluster, tilePass.enableTileAndCluster);
-                tilePass.enableComputeLightEvaluation = EditorGUILayout.Toggle(styles.enableComputeLightEvaluation, tilePass.enableComputeLightEvaluation);
-
-                if (EditorGUI.EndChangeCheck())
-                {
-                   HackSetDirty(renderContext); // Repaint
-                    UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
-                }
-                EditorGUI.indentLevel--;
-            }
-        }*/
-
         public void OnEnable()
         {
             InitializeProperties();
         {
-            var renderContext = target as HDRenderPipeline;
-            HDRenderPipelineInstance renderpipelineInstance = UnityEngine.Experimental.Rendering.RenderPipelineManager.currentPipeline as HDRenderPipelineInstance;
+            var renderContext = target as HDRenderPipelineAsset;
+            HDRenderPipeline renderpipeline = UnityEngine.Experimental.Rendering.RenderPipelineManager.currentPipeline as HDRenderPipeline;
-            if (!renderContext || renderpipelineInstance == null)
+            if (!renderContext || renderpipeline == null)
                 return;
 
             serializedObject.Update();
             EditorGUILayout.PropertyField(m_DefaultShader, Styles.defaultShader);
             EditorGUI.indentLevel--;
 
-            DebuggingUI(renderContext, renderpipelineInstance);
             SettingsUI(renderContext);
 
             serializedObject.ApplyModifiedProperties();

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

 {
     public class HDRenderPipelineMenuItems
     {
-        // This script is a helper for the artits to re-synchronise all layered materials
+        // This script is a helper for the artists to re-synchronise all layered materials
         [MenuItem("HDRenderPipeline/Synchronize all Layered materials")]
         static void SynchronizeAllLayeredMaterial()
         {
             }
         }
 
+        // TEMP: will be remove after data upgrade
         [MenuItem("HDRenderPipeline/Swap standard and SSS material IDs")]
         static void SwapStandardAndSssMaterialIds()
         {
             }
         }
 
+        // Funtion used only to check performance of data with and without tessellation
         [MenuItem("HDRenderPipeline/Debug/Remove tessellation materials (not reversible)")]
         static void RemoveTessellationMaterials()
         {
         [MenuItem("HDRenderPipeline/Export Sky to Image")]
         static void ExportSkyToImage()
         {
-            HDRenderPipelineInstance renderpipelineInstance = UnityEngine.Experimental.Rendering.RenderPipelineManager.currentPipeline as HDRenderPipelineInstance;
-            if(renderpipelineInstance == null)
+            HDRenderPipeline renderpipeline = UnityEngine.Experimental.Rendering.RenderPipelineManager.currentPipeline as HDRenderPipeline;
+            if(renderpipeline == null)
-            Texture2D result = renderpipelineInstance.ExportSkyToTexture();
+            Texture2D result = renderpipeline.ExportSkyToTexture();
             if(result == null)
             {
                 return;

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
-    [ExecuteInEditMode]
-    // This HDRenderPipeline assume linear lighting. Don't work with gamma.
-    public class HDRenderPipeline : RenderPipelineAsset
-    {
-        const string k_HDRenderPipelinePath = "Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.asset";
-
-#if UNITY_EDITOR
-        [MenuItem("RenderPipeline/Create HDRenderPipeline")]
-        static void CreateHDRenderPipeline()
-        {
-            var instance = CreateInstance<HDRenderPipeline>();
-            AssetDatabase.CreateAsset(instance, k_HDRenderPipelinePath);
-        }
-
-        [UnityEditor.MenuItem("HDRenderPipeline/UpdateHDRenderPipeline")]
-        static void UpdateHDRenderPipeline()
-        {
-            var guids = AssetDatabase.FindAssets("t:HDRenderPipeline");
-            foreach (var guid in guids)
-            {
-                string path = AssetDatabase.GUIDToAssetPath(guid);
-                var pipeline = AssetDatabase.LoadAssetAtPath<HDRenderPipeline>(path);
-                EditorUtility.SetDirty(pipeline);
-            }
-        }
-
-        [UnityEditor.MenuItem("HDRenderPipeline/Add \"Additional Light Data\" (if not present)")]
-        static void AddAdditionalLightData()
-        {
-            Light[] lights = FindObjectsOfType(typeof(Light)) as Light[];
-
-            foreach (Light light in lights)
-            {
-                // Do not add a component if there already is one.
-                if (light.GetComponent<AdditionalLightData>() == null)
-                {
-                    light.gameObject.AddComponent<AdditionalLightData>();
-                }
-            }
-        }
-
-#endif
-
-        private HDRenderPipeline()
-        {}
-
-        [SerializeField]
-        private LightLoopProducer m_LightLoopProducer;
-        public LightLoopProducer lightLoopProducer
-        {
-            get { return m_LightLoopProducer; }
-            set { m_LightLoopProducer = value; }
-        }
-
-        protected override IRenderPipeline InternalCreatePipeline()
-        {
-            return new HDRenderPipelineInstance(this);
-        }
-
-        // NOTE:
-        // All those properties are public because of how HDRenderPipelineInspector retrieve those properties via serialization/reflection
-        // Those that are not will be refatored later.
-
-        // Debugging
-        public DebugDisplaySettings debugDisplaySettings = new DebugDisplaySettings();
-
-        // Renderer Settings (per project)
-        public RenderingSettings            renderingSettings = new RenderingSettings();
-        public SubsurfaceScatteringSettings sssSettings = new SubsurfaceScatteringSettings();
-
-        [SerializeField]
-        ShadowSettings               m_ShadowSettings  = ShadowSettings.Default;
-        [SerializeField]
-        TextureSettings              m_TextureSettings = TextureSettings.Default;
-
-        public ShadowSettings shadowSettings                { get { return m_ShadowSettings; } }
-        public TextureSettings textureSettings              { get { return m_TextureSettings; } set { m_TextureSettings = value; } }
-
-        // Renderer Settings (per "scene")
-        [SerializeField] private CommonSettings.Settings    m_CommonSettings = CommonSettings.Settings.s_Defaultsettings;
-        [SerializeField] private SkySettings                m_SkySettings;
-
-        public CommonSettings.Settings commonSettingsToUse
-        {
-            get
-            {
-                if (CommonSettingsSingleton.overrideSettings)
-                    return CommonSettingsSingleton.overrideSettings.settings;
-
-                return m_CommonSettings;
-            }
-        }
-
-        public SkySettings skySettings
-        {
-            get { return m_SkySettings; }
-            set { m_SkySettings = value; }
-        }
-
-        public SkySettings skySettingsToUse
-        {
-            get
-            {
-                if (SkySettingsSingleton.overrideSettings)
-                    return SkySettingsSingleton.overrideSettings;
-
-                return m_SkySettings;
-            }
-        }
-
-        [SerializeField] private Material m_DefaultDiffuseMaterial;
-        [SerializeField] private Shader m_DefaultShader;
-
-        public Material DefaultDiffuseMaterial
-        {
-            get { return m_DefaultDiffuseMaterial; }
-            private set { m_DefaultDiffuseMaterial = value; }
-        }
-
-        public Shader DefaultShader
-        {
-            get { return m_DefaultShader; }
-            private set { m_DefaultShader = value; }
-        }
-
-        public override Shader GetDefaultShader()
-        {
-            return m_DefaultShader;
-        }
-
-        public override Material GetDefaultMaterial()
-        {
-            return m_DefaultDiffuseMaterial;
-        }
-
-        public override Material GetDefaultParticleMaterial()
-        {
-            return null;
-        }
-
-        public override Material GetDefaultLineMaterial()
-        {
-            return null;
-        }
-
-        public override Material GetDefaultTerrainMaterial()
-        {
-            return null;
-        }
-
-        public override Material GetDefaultUIMaterial()
-        {
-            return null;
-        }
-
-        public override Material GetDefaultUIOverdrawMaterial()
-        {
-            return null;
-        }
-
-        public override Material GetDefaultUIETC1SupportedMaterial()
-        {
-            return null;
-        }
-
-        public override Material GetDefault2DMaterial()
-        {
-            return null;
-        }
-
-        public void ApplyDebugDisplaySettings()
-        {
-            m_ShadowSettings.enabled = debugDisplaySettings.lightingDebugSettings.enableShadows;
-
-            LightingDebugSettings lightingDebugSettings = debugDisplaySettings.lightingDebugSettings;
-            Vector4 debugAlbedo = new Vector4(lightingDebugSettings.debugLightingAlbedo.r, lightingDebugSettings.debugLightingAlbedo.g, lightingDebugSettings.debugLightingAlbedo.b, 0.0f);
-            Vector4 debugSmoothness = new Vector4(lightingDebugSettings.overrideSmoothness ? 1.0f : 0.0f, lightingDebugSettings.overrideSmoothnessValue, 0.0f, 0.0f);
-
-            Shader.SetGlobalInt("_DebugViewMaterial", (int)debugDisplaySettings.GetDebugMaterialIndex());
-            Shader.SetGlobalInt("_DebugLightingMode", (int)debugDisplaySettings.GetDebugLightingMode());
-            Shader.SetGlobalVector("_DebugLightingAlbedo", debugAlbedo);
-            Shader.SetGlobalVector("_DebugLightingSmoothness", debugSmoothness);
-        }
-
-        public void UpdateCommonSettings()
-        {
-            var commonSettings = commonSettingsToUse;
-
-            m_ShadowSettings.directionalLightCascadeCount = commonSettings.shadowCascadeCount;
-            m_ShadowSettings.directionalLightCascades = new Vector3(commonSettings.shadowCascadeSplit0, commonSettings.shadowCascadeSplit1, commonSettings.shadowCascadeSplit2);
-            m_ShadowSettings.maxShadowDistance = commonSettings.shadowMaxDistance;
-            m_ShadowSettings.directionalLightNearPlaneOffset = commonSettings.shadowNearPlaneOffset;
-        }
-
-        public void OnValidate()
-        {
-            debugDisplaySettings.OnValidate();
-            sssSettings.OnValidate();
-        }
-
-        void OnEnable()
-        {
-            debugDisplaySettings.RegisterDebug();
-        }
-    }
-
     [Serializable]
     public class RenderingSettings
     {
         RenderTextureReadWrite[] sRGBWrites = new RenderTextureReadWrite[MaxGbuffer];
     }
 
-    public class HDRenderPipelineInstance : RenderPipeline
+    public class HDRenderPipeline : RenderPipeline
-        private readonly HDRenderPipeline m_Owner;
+        private readonly HDRenderPipelineAsset m_Asset;
 
         // TODO: Find a way to automatically create/iterate through deferred material
         // TODO TO CHECK: SebL I move allocation from Build() to here, but there was a comment "// Our object can be garbage collected, so need to be allocate here", it is still true ?
         public int GetCurrentShadowCount() { return m_LightLoop.GetCurrentShadowCount(); }
 
         readonly SkyManager m_SkyManager = new SkyManager();
-        private readonly BaseLightLoop m_LightLoop;
+        readonly LightLoop m_LightLoop = new LightLoop();
-            get { return m_Owner.debugDisplaySettings; }
+            get { return m_Asset.debugDisplaySettings; }
-            get { return m_Owner.sssSettings; }
+            get { return m_Asset.sssSettings; }
-        public HDRenderPipelineInstance(HDRenderPipeline owner)
+        public HDRenderPipeline(HDRenderPipelineAsset asset)
-            m_Owner = owner;
+            m_Asset = asset;
 
             m_CameraColorBuffer             = Shader.PropertyToID("_CameraColorTexture");
             m_CameraSubsurfaceBuffer        = Shader.PropertyToID("_CameraSubsurfaceTexture");
             m_DistortionBuffer = Shader.PropertyToID("_DistortionTexture");
             m_DistortionBufferRT = new RenderTargetIdentifier(m_DistortionBuffer);
 
-            m_LitRenderLoop.Build();
+            m_LitRenderLoop.Build(asset.renderPipelineResources);
-            if (owner.lightLoopProducer)
-                m_LightLoop = owner.lightLoopProducer.CreateLightLoop();
+            m_LightLoop.Build(asset.renderPipelineResources, asset.tileSettings, asset.textureSettings);
-            if (m_LightLoop != null)
-                m_LightLoop.Build(owner.textureSettings);
-
-            m_SkyManager.Build();
-            m_SkyManager.skySettings = owner.skySettingsToUse;
+            m_SkyManager.Build(asset.renderPipelineResources);
+            m_SkyManager.skySettings = asset.skySettingsToUse;
 
             m_PostProcessContext = new PostProcessRenderContext();
         }
-            m_DebugViewMaterialGBuffer = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugViewMaterialGBuffer");
-            m_DebugDisplayLatlong = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugDisplayLatlong");
+            m_DebugViewMaterialGBuffer = Utilities.CreateEngineMaterial(m_Asset.renderPipelineResources.debugViewMaterialGBufferShader);
+            m_DebugDisplayLatlong = Utilities.CreateEngineMaterial(m_Asset.renderPipelineResources.debugDisplayLatlongShader);
-            m_LitRenderLoop.Build();
+            m_LitRenderLoop.Build(m_Asset.renderPipelineResources);
         }
 
         public override void Dispose()
-            if (m_LightLoop != null)
-                m_LightLoop.Cleanup();
+            m_LightLoop.Cleanup();
 
             m_LitRenderLoop.Cleanup();
 
             // 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_SkyManager.skySettings = m_Owner.skySettingsToUse;
-            m_SkyManager.Resize(camera.nearClipPlane, camera.farClipPlane); // TODO: Also a bad naming, here we just want to realloc texture if skyparameters change (usefull for lookdev)
-
-            if (m_LightLoop == null)
-                return;
+            m_SkyManager.skySettings = m_Asset.skySettingsToUse;
+            m_SkyManager.Resize(camera.nearClipPlane, camera.farClipPlane); // TODO: Also a bad naming, here we just want to realloc texture if skyparameters change (useful for lookdev)
 
             bool resolutionChanged = camera.pixelWidth != m_CurrentWidth || camera.pixelHeight != m_CurrentHeight;
 
                 m_LitRenderLoop.RenderInit(renderContext);
 
             // Do anything we need to do upon a new frame.
+            m_LightLoop.NewFrame();
-            if (m_LightLoop != null)
-                m_LightLoop.NewFrame();
-
-            m_Owner.ApplyDebugDisplaySettings();
-            m_Owner.UpdateCommonSettings();
+            m_Asset.ApplyDebugDisplaySettings();
+            m_Asset.UpdateCommonSettings();
 
             // Set Frame constant buffer
             // TODO...
 
             // If full forward rendering, we did not do any rendering yet, so don't need to copy the buffer.
             // If Deferred then the depth buffer is full (regular GBuffer + ForwardOnly depth prepass are done so we can copy it safely.
-            if (!m_Owner.renderingSettings.useForwardRenderingOnly)
+            if (!m_Asset.renderingSettings.useForwardRenderingOnly)
             {
                 CopyDepthBufferIfNeeded(renderContext);
             }
             }
             else
             {
-                if (m_LightLoop != null)
+                using (new Utilities.ProfilingSample("Build Light list and render shadows", renderContext))
-                    using (new Utilities.ProfilingSample("Build Light list and render shadows", renderContext))
-                    {
-                        m_LightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera);
-                        m_LightLoop.RenderShadows(renderContext, cullResults);
-                        renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
-                        m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT); // TODO: Use async compute here to run light culling during shadow
-                    }
+                    m_LightLoop.PrepareLightsForGPU(m_Asset.shadowSettings, cullResults, camera);
+                    m_LightLoop.RenderShadows(renderContext, cullResults);
+                    renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
+                    m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT); // TODO: Use async compute here to run light culling during shadow
-                PushGlobalParams(hdCamera, renderContext, m_Owner.sssSettings);
+                PushGlobalParams(hdCamera, renderContext, m_Asset.sssSettings);
 
                 // Caution: We require sun light here as some sky use the sun light to render, mean UpdateSkyEnvironment
                 // must be call after BuildGPULightLists.
                 // We compute subsurface scattering here. Therefore, no objects rendered afterwards will exhibit SSS.
                 // Currently, there is no efficient way to switch between SRT and MRT for the forward pass;
                 // therefore, forward-rendered objects do not output split lighting required for the SSS pass.
-                CombineSubsurfaceScattering(hdCamera, renderContext, m_Owner.sssSettings);
+                CombineSubsurfaceScattering(hdCamera, renderContext, m_Asset.sssSettings);
 
                 // For opaque forward we have split rendering in two categories
                 // Material that are always forward and material that can be deferred or forward depends on render pipeline options (like switch to rendering forward only mode)
 
                 // If full forward rendering, we did just rendered everything, so we can copy the depth buffer
                 // If Deferred nothing needs copying anymore.
-                if (m_Owner.renderingSettings.useForwardRenderingOnly)
+                if (m_Asset.renderingSettings.useForwardRenderingOnly)
                 {
                     CopyDepthBufferIfNeeded(renderContext);
                 }
         {
             // If we are forward only we will do a depth prepass
             // TODO: Depth prepass should be enabled based on light loop settings. LightLoop define if they need a depth prepass + forward only...
-            if (!m_Owner.renderingSettings.useDepthPrepass)
+            if (!m_Asset.renderingSettings.useDepthPrepass)
                 return;
 
             using (new Utilities.ProfilingSample("Depth Prepass", renderContext))
 
         void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext renderContext)
         {
-            if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
+            if (m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
             {
                 return;
             }
         {
             // If we are forward only we don't need to render ForwardOnlyOpaqueDepthOnly object
             // But in case we request a prepass we render it
-            if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly() && !m_Owner.renderingSettings.useDepthPrepass)
+            if (m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() && !m_Asset.renderingSettings.useDepthPrepass)
                 return;
 
             using (new Utilities.ProfilingSample("Forward opaque depth", renderContext))
             }
 
             // Render GBuffer opaque
-            if (!m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
+            if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
             {
                 Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewMaterialGBuffer);
 
 
         void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext)
         {
-            if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly() || m_LightLoop == null)
+            if (m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
             {
                 return;
             }
         void CombineSubsurfaceScattering(HDCamera hdCamera, ScriptableRenderContext context, SubsurfaceScatteringSettings sssParameters)
         {
             // Currently, forward-rendered objects do not output split lighting required for the SSS pass.
-            if (m_Owner.renderingSettings.ShouldUseForwardRenderingOnly()) return;
+            if (m_Asset.renderingSettings.ShouldUseForwardRenderingOnly()) return;
 
             if (!debugDisplaySettings.renderingDebugSettings.enableSSS) return;
 
 
         void UpdateSkyEnvironment(HDCamera hdCamera, ScriptableRenderContext renderContext)
         {
-            m_SkyManager.UpdateEnvironment(hdCamera, m_LightLoop == null ? null :  m_LightLoop.GetCurrentSunLight(), renderContext);
+            m_SkyManager.UpdateEnvironment(hdCamera,m_LightLoop.GetCurrentSunLight(), renderContext);
-            m_SkyManager.RenderSky(hdCamera, m_LightLoop == null ? null : m_LightLoop.GetCurrentSunLight(), m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, renderContext);
+            m_SkyManager.RenderSky(hdCamera, m_LightLoop.GetCurrentSunLight(), m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, renderContext);
         }
 
         public Texture2D ExportSkyToTexture()
 
         void RenderLightingDebug(HDCamera camera, ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer)
         {
-            if (m_LightLoop != null)
-                m_LightLoop.RenderLightingDebug(camera, renderContext, colorBuffer);
+            m_LightLoop.RenderLightingDebug(camera, renderContext, colorBuffer);
         }
 
         void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
-            if (!m_Owner.renderingSettings.ShouldUseForwardRenderingOnly() && renderOpaque)
+            if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() && renderOpaque)
                 return;
 
             string passName = debugDisplaySettings.IsDebugDisplayEnabled() ? "ForwardDisplayDebug" : "Forward";
                 Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
 
-                if (m_LightLoop != null)
-                    m_LightLoop.RenderForward(camera, renderContext, renderOpaque);
+                m_LightLoop.RenderForward(camera, renderContext, renderOpaque);
 
                 if (renderOpaque)
                 {
             {
                 Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
 
-                if (m_LightLoop != null)
-                    m_LightLoop.RenderForward(camera, renderContext, true);
+                m_LightLoop.RenderForward(camera, renderContext, true);
 
                 RenderOpaqueRenderList(cullResults, camera, renderContext, passName, Utilities.kRendererConfigurationBakedLighting);
             }
             using (new Utilities.ProfilingSample("Velocity", renderContext))
             {
                 // If opaque velocity have been render during GBuffer no need to render it here
-                if ((ShaderConfig.s_VelocityInGbuffer == 1) || m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
+                if ((ShaderConfig.s_VelocityInGbuffer == 1) || m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
                     return;
 
                 int w = camera.pixelWidth;
 
             renderContext.ExecuteCommandBuffer(debugCB);
 
-            if (m_LightLoop != null)
-                m_LightLoop.RenderDebugOverlay(camera, renderContext, debugDisplaySettings, ref x, ref y, overlaySize, camera.pixelWidth);
+            m_LightLoop.RenderDebugOverlay(camera, renderContext, debugDisplaySettings, ref x, ref y, overlaySize, camera.pixelWidth);
         }
 
         void InitAndClearBuffer(Camera camera, ScriptableRenderContext renderContext)
                     cmd.GetTemporaryRT(m_CameraSubsurfaceBuffer,        w, h,  0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
                     cmd.GetTemporaryRT(m_CameraFilteringBuffer,         w, h,  0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
 
-                    if (!m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
+                    if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
                     {
                         m_gbufferManager.InitGBuffers(w, h, cmd);
                     }
                 }
 
                 // Clear GBuffers
-                if (!m_Owner.renderingSettings.ShouldUseForwardRenderingOnly())
+                if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
                 {
                     using (new Utilities.ProfilingSample("Clear GBuffer", renderContext))
                     {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             public float unused2;
         };
 
-        public class LightLoop : BaseLightLoop
+        [Serializable]
+        public class TileSettings
+        {
+            public bool enableTileAndCluster; // For debug / test
+            public bool enableSplitLightEvaluation;
+            public bool enableComputeLightEvaluation;
+            public bool enableComputeFeatureVariants;
+
+            // clustered light list specific buffers and data begin
+            public bool enableClustered;
+            public bool enableFptlForOpaqueWhenClustered; // still useful on opaques. Should be true by default to force tile on opaque.
+            public bool enableBigTilePrepass;
+
+            [Range(0.0f, 1.0f)]
+            public float diffuseGlobalDimmer = 1.0f;
+            [Range(0.0f, 1.0f)]
+            public float specularGlobalDimmer = 1.0f;
+
+            public enum TileDebug : int
+            {
+                None = 0, Punctual = 1, Area = 2, AreaAndPunctual = 3, Projector = 4, ProjectorAndPunctual = 5, ProjectorAndArea = 6, ProjectorAndAreaAndPunctual = 7,
+                Environment = 8, EnvironmentAndPunctual = 9, EnvironmentAndArea = 10, EnvironemntAndAreaAndPunctual = 11,
+                EnvironmentAndProjector = 12, EnvironmentAndProjectorAndPunctual = 13, EnvironmentAndProjectorAndArea = 14, EnvironmentAndProjectorAndAreaAndPunctual = 15,
+                FeatureVariants = 16
+            }; //TODO: we should probably make this checkboxes
+            public TileDebug tileDebugByCategory;
+
+            public TileSettings()
+            {
+                enableTileAndCluster = true;
+                enableSplitLightEvaluation = true;
+                enableComputeLightEvaluation = false;
+                enableComputeFeatureVariants = false;
+
+                enableClustered = true;
+                enableFptlForOpaqueWhenClustered = true;
+                enableBigTilePrepass = true;
+
+                diffuseGlobalDimmer = 1.0f;
+                specularGlobalDimmer = 1.0f;
+
+                tileDebugByCategory = TileDebug.None;
+            }
+        }
+
+        public class LightLoop
         {
             public const int k_MaxDirectionalLightsOnScreen = 4;
             public const int k_MaxPunctualLightsOnScreen    = 512;
             int m_projectorLightCount = 0;
             int m_lightCount = 0;
 
-            private ComputeShader buildScreenAABBShader { get { return m_PassResources.buildScreenAABBShader; } }
-            private ComputeShader buildPerTileLightListShader { get { return m_PassResources.buildPerTileLightListShader; } }
-            private ComputeShader buildPerBigTileLightListShader { get { return m_PassResources.buildPerBigTileLightListShader; } }
-            private ComputeShader buildPerVoxelLightListShader { get { return m_PassResources.buildPerVoxelLightListShader; } }
+            private ComputeShader buildScreenAABBShader { get { return m_Resources.buildScreenAABBShader; } }
+            private ComputeShader buildPerTileLightListShader { get { return m_Resources.buildPerTileLightListShader; } }
+            private ComputeShader buildPerBigTileLightListShader { get { return m_Resources.buildPerBigTileLightListShader; } }
+            private ComputeShader buildPerVoxelLightListShader { get { return m_Resources.buildPerVoxelLightListShader; } }
-            private ComputeShader clearDispatchIndirectShader { get { return m_PassResources.clearDispatchIndirectShader; } }
-            private ComputeShader shadeOpaqueShader { get { return m_PassResources.shadeOpaqueShader; } }
+            private ComputeShader clearDispatchIndirectShader { get { return m_Resources.clearDispatchIndirectShader; } }
+            private ComputeShader shadeOpaqueShader { get { return m_Resources.shadeOpaqueShader; } }
 
             static int s_GenAABBKernel;
             static int s_GenListPerTileKernel;
                 get
                 {
                     bool isEnabledMSAA = false;
-                    Debug.Assert(!isEnabledMSAA || m_PassSettings.enableClustered);
-                    bool disableFptl = (!m_PassSettings.enableFptlForOpaqueWhenClustered && m_PassSettings.enableClustered) || isEnabledMSAA;
+                    Debug.Assert(!isEnabledMSAA || m_TileSettings.enableClustered);
+                    bool disableFptl = (!m_TileSettings.enableFptlForOpaqueWhenClustered && m_TileSettings.enableClustered) || isEnabledMSAA;
                     return !disableFptl;
                 }
             }
             Material m_SingleDeferredMaterialSRT   = null;
             Material m_SingleDeferredMaterialMRT   = null;
 
+            Light m_CurrentSunLight = null;
+            public Light GetCurrentSunLight() { return m_CurrentSunLight; }
+
-            private Material m_DebugDisplayShadowMap;
+            Material m_DebugDisplayShadowMap;
 
             // shadow related stuff
             FrameId                 m_FrameId = new FrameId();
 
             bool GetFeatureVariantsEnabled()
             {
-                return m_PassSettings.enableComputeLightEvaluation && m_PassSettings.enableComputeFeatureVariants && !(m_PassSettings.enableClustered && !m_PassSettings.enableFptlForOpaqueWhenClustered);
+                return m_TileSettings.enableComputeLightEvaluation && m_TileSettings.enableComputeFeatureVariants && !(m_TileSettings.enableClustered && !m_TileSettings.enableFptlForOpaqueWhenClustered);
-            TileLightLoopProducer.TileSettings m_PassSettings;
-            private TilePassResources m_PassResources;
+            TileSettings m_TileSettings = null;
+            RenderPipelineResources m_Resources = null;
-            public LightLoop(TileLightLoopProducer producer)
+            public LightLoop()
+            {}
+
+            public void Build(RenderPipelineResources renderPipelineResources, TileSettings tileSettings, TextureSettings textureSettings)
-                m_PassSettings = producer.tileSettings;
-                m_PassResources = producer.passResources;
-            }
+                m_Resources = renderPipelineResources;
+                m_TileSettings = tileSettings;
-            public override void Build(TextureSettings textureSettings)
-            {
                 m_lightList = new LightList();
                 m_lightList.Allocate();
 
                 bool enableFeatureVariants = GetFeatureVariantsEnabled();
                 if (enableFeatureVariants)
                 {
-                    s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(m_PassSettings.enableBigTilePrepass ? "TileLightListGen_SrcBigTile_FeatureFlags" : "TileLightListGen_FeatureFlags");
+                    s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(m_TileSettings.enableBigTilePrepass ? "TileLightListGen_SrcBigTile_FeatureFlags" : "TileLightListGen_FeatureFlags");
-                    s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(m_PassSettings.enableBigTilePrepass ? "TileLightListGen_SrcBigTile" : "TileLightListGen");
+                    s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(m_TileSettings.enableBigTilePrepass ? "TileLightListGen_SrcBigTile" : "TileLightListGen");
                 }
                 s_AABBBoundsBuffer = new ComputeBuffer(2 * k_MaxLightsOnScreen, 3 * sizeof(float));
                 s_ConvexBoundsBuffer = new ComputeBuffer(k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(SFiniteLightBound)));
-                if (m_PassSettings.enableClustered)
+                if (m_TileSettings.enableClustered)
-                    var kernelName = m_PassSettings.enableBigTilePrepass ? (k_UseDepthBuffer ? "TileLightListGen_DepthRT_SrcBigTile" : "TileLightListGen_NoDepthRT_SrcBigTile") : (k_UseDepthBuffer ? "TileLightListGen_DepthRT" : "TileLightListGen_NoDepthRT");
+                    var kernelName = m_TileSettings.enableBigTilePrepass ? (k_UseDepthBuffer ? "TileLightListGen_DepthRT_SrcBigTile" : "TileLightListGen_NoDepthRT_SrcBigTile") : (k_UseDepthBuffer ? "TileLightListGen_DepthRT" : "TileLightListGen_NoDepthRT");
-                if (m_PassSettings.enableBigTilePrepass)
+                if (m_TileSettings.enableBigTilePrepass)
                 {
                     s_GenListPerBigTileKernel = buildPerBigTileLightListShader.FindKernel("BigTileLightListGen");
                 }
 
                 string[] tileKeywords = {"LIGHTLOOP_TILE_DIRECT", "LIGHTLOOP_TILE_INDIRECT", "LIGHTLOOP_TILE_ALL"};
 
-                m_DeferredDirectMaterialSRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_DeferredDirectMaterialSRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
                 Utilities.SelectKeyword(m_DeferredDirectMaterialSRT, tileKeywords, 0);
                 m_DeferredDirectMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredDirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredDirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
-                m_DeferredDirectMaterialMRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_DeferredDirectMaterialMRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
                 Utilities.SelectKeyword(m_DeferredDirectMaterialMRT, tileKeywords, 0);
                 m_DeferredDirectMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredDirectMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredDirectMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
-                m_DeferredIndirectMaterialSRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_DeferredIndirectMaterialSRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
                 Utilities.SelectKeyword(m_DeferredIndirectMaterialSRT, tileKeywords, 1);
                 m_DeferredIndirectMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredIndirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredIndirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.One); // Additive color & alpha source
 
-                m_DeferredIndirectMaterialMRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_DeferredIndirectMaterialMRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
                 Utilities.SelectKeyword(m_DeferredIndirectMaterialMRT, tileKeywords, 1);
                 m_DeferredIndirectMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredIndirectMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredIndirectMaterialMRT.SetInt("_DstBlend", (int)BlendMode.One); // Additive color & alpha source
 
-                m_DeferredAllMaterialSRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_DeferredAllMaterialSRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
                 Utilities.SelectKeyword(m_DeferredAllMaterialSRT, tileKeywords, 2);
                 m_DeferredAllMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredAllMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredAllMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
-                m_DeferredAllMaterialMRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_DeferredAllMaterialMRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
                 Utilities.SelectKeyword(m_DeferredAllMaterialMRT, tileKeywords, 2);
                 m_DeferredAllMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredAllMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredAllMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
-                m_DebugViewTilesMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugViewTiles");
-
-                m_SingleDeferredMaterialSRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_SingleDeferredMaterialSRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
                 m_SingleDeferredMaterialSRT.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
                 m_SingleDeferredMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)StencilBits.SSS);
 
-                m_SingleDeferredMaterialMRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_SingleDeferredMaterialMRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
                 m_SingleDeferredMaterialMRT.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
                 m_SingleDeferredMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_SingleDeferredMaterialMRT.SetInt("_StencilRef", (int)StencilBits.SSS);
 
-                m_DebugDisplayShadowMap = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugDisplayShadowMap");
+                m_DebugViewTilesMaterial = Utilities.CreateEngineMaterial(m_Resources.debugViewTilesShader);
+                m_DebugDisplayShadowMap = Utilities.CreateEngineMaterial(m_Resources.debugDisplayShadowMapShader);
 
                 m_DefaultTexture2DArray = new Texture2DArray(1, 1, 1, TextureFormat.ARGB32, false);
                 m_DefaultTexture2DArray.SetPixels32(new Color32[1] { new Color32(128, 128, 128, 128) }, 0);
                 InitShadowSystem(ShadowSettings.Default);
             }
 
-            public override void Cleanup()
+            public void Cleanup()
             {
                 DeinitShadowSystem();
 
                 s_DefaultAdditionalLightData = null;
             }
 
-            public override void NewFrame()
+            public void NewFrame()
             {
                 m_CookieTexArray.NewFrame();
                 m_CubeCookieTexArray.NewFrame();
-            public override bool NeedResize()
+            public bool NeedResize()
-                    (s_BigTileLightList == null && m_PassSettings.enableBigTilePrepass) ||
-                    (s_PerVoxelLightLists == null && m_PassSettings.enableClustered);
+                    (s_BigTileLightList == null && m_TileSettings.enableBigTilePrepass) ||
+                    (s_PerVoxelLightLists == null && m_TileSettings.enableClustered);
-            public override void ReleaseResolutionDependentBuffers()
+            public void ReleaseResolutionDependentBuffers()
             {
                 Utilities.SafeRelease(s_LightList);
                 Utilities.SafeRelease(s_TileList);
                 return 8 * (1 << k_Log2NumClusters);       // total footprint for all layers of the tile (measured in light index entries)
             }
 
-            public override void AllocResolutionDependentBuffers(int width, int height)
+            public void AllocResolutionDependentBuffers(int width, int height)
             {
                 var nrTilesX = (width + LightDefinitions.TILE_SIZE_FPTL - 1) / LightDefinitions.TILE_SIZE_FPTL;
                 var nrTilesY = (height + LightDefinitions.TILE_SIZE_FPTL - 1) / LightDefinitions.TILE_SIZE_FPTL;
                 s_LightList = new ComputeBuffer((int)LightCategory.Count * dwordsPerTile * nrTiles, sizeof(uint));       // enough list memory for a 4k x 4k display
                 s_TileList = new ComputeBuffer((int)LightDefinitions.NUM_FEATURE_VARIANTS * nrTiles, sizeof(uint));
 
-                if (m_PassSettings.enableClustered)
+                if (m_TileSettings.enableClustered)
                 {
                     var nrClustersX = (width + LightDefinitions.TILE_SIZE_CLUSTERED - 1) / LightDefinitions.TILE_SIZE_CLUSTERED;
                     var nrClustersY = (height + LightDefinitions.TILE_SIZE_CLUSTERED - 1) / LightDefinitions.TILE_SIZE_CLUSTERED;
                     }
                 }
 
-                if (m_PassSettings.enableBigTilePrepass)
+                if (m_TileSettings.enableBigTilePrepass)
                 {
                     var nrBigTilesX = (width + 63) / 64;
                     var nrBigTilesY = (height + 63) / 64;
             {
                 var directionalLightData = new DirectionalLightData();
 
-                float diffuseDimmer = m_PassSettings.diffuseGlobalDimmer * additionalData.lightDimmer;
-                float specularDimmer = m_PassSettings.specularGlobalDimmer * additionalData.lightDimmer;
+                float diffuseDimmer = m_TileSettings.diffuseGlobalDimmer * additionalData.lightDimmer;
+                float specularDimmer = m_TileSettings.specularGlobalDimmer * additionalData.lightDimmer;
                 if (diffuseDimmer  <= 0.0f && specularDimmer <= 0.0f)
                     return false;
 
                 float distanceFade = ComputeLinearDistanceFade(distanceToCamera, additionalData.fadeDistance);
                 float lightScale = additionalData.lightDimmer * distanceFade;
 
-                lightData.diffuseScale = additionalData.affectDiffuse ? lightScale * m_PassSettings.diffuseGlobalDimmer : 0.0f;
-                lightData.specularScale = additionalData.affectSpecular ? lightScale * m_PassSettings.specularGlobalDimmer : 0.0f;
+                lightData.diffuseScale = additionalData.affectDiffuse ? lightScale * m_TileSettings.diffuseGlobalDimmer : 0.0f;
+                lightData.specularScale = additionalData.affectSpecular ? lightScale * m_TileSettings.specularGlobalDimmer : 0.0f;
 
                 if (lightData.diffuseScale <= 0.0f && lightData.specularScale <= 0.0f)
                     return false;
                 m_lightList.bounds.Add(bound);
                 m_lightList.lightVolumes.Add(lightVolumeData);
             }
-            public override int GetCurrentShadowCount()
+            public int GetCurrentShadowCount()
-            public override void UpdateCullingParameters(ref CullingParameters cullingParams)
+            public void UpdateCullingParameters(ref CullingParameters cullingParams)
-            public override void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera)
+            public void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera)
             {
                 m_lightList.Clear();
 
                         }
                     }
 
-                    float oldSpecularGlobalDimmer = m_PassSettings.specularGlobalDimmer;
+                    float oldSpecularGlobalDimmer = m_TileSettings.specularGlobalDimmer;
-                        m_PassSettings.specularGlobalDimmer = 0.0f;
+                        m_TileSettings.specularGlobalDimmer = 0.0f;
                     }
 
                     // 1. Count the number of lights and sort all lights by category, type and volume - This is required for the fptl/cluster shader code
                     Debug.Assert(m_lightList.envLights.Count == envLightCount);
 
                     // Restore values after "special rendering"
-                    m_PassSettings.specularGlobalDimmer = oldSpecularGlobalDimmer;
+                    m_TileSettings.specularGlobalDimmer = oldSpecularGlobalDimmer;
                 }
 
                 m_lightCount = m_lightList.lights.Count + m_lightList.envLights.Count;
                 cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_vLayeredLightList", s_PerVoxelLightLists);
                 cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_LayeredOffset", s_PerVoxelOffset);
                 cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_LayeredSingleIdxBuffer", s_GlobalLightListAtomic);
-                if (m_PassSettings.enableBigTilePrepass)
+                if (m_TileSettings.enableBigTilePrepass)
                     cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_vBigTileLightList", s_BigTileLightList);
 
                 if (k_UseDepthBuffer)
                 cmd.DispatchCompute(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, numTilesX, numTilesY, 1);
             }
 
-            public override void BuildGPULightLists(Camera camera, ScriptableRenderContext loop, RenderTargetIdentifier cameraDepthBufferRT)
+            public void BuildGPULightLists(Camera camera, ScriptableRenderContext loop, RenderTargetIdentifier cameraDepthBufferRT)
             {
                 var w = camera.pixelWidth;
                 var h = camera.pixelHeight;
                 }
 
                 // enable coarse 2D pass on 64x64 tiles (used for both fptl and clustered).
-                if (m_PassSettings.enableBigTilePrepass)
+                if (m_TileSettings.enableBigTilePrepass)
                 {
                     cmd.SetComputeIntParams(buildPerBigTileLightListShader, "g_viDimensions", new int[2] { w, h });
                     cmd.SetComputeIntParam(buildPerBigTileLightListShader, "_EnvLightIndexShift", m_lightList.lights.Count);
                     Utilities.SetMatrixCS(cmd, buildPerTileLightListShader, "g_mInvScrProjection", invProjscr);
                     cmd.SetComputeTextureParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_depth_tex", cameraDepthBufferRT);
                     cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_vLightList", s_LightList);
-                    if (m_PassSettings.enableBigTilePrepass)
+                    if (m_TileSettings.enableBigTilePrepass)
                         cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_vBigTileLightList", s_BigTileLightList);
 
 
                     cmd.DispatchCompute(buildPerTileLightListShader, s_GenListPerTileKernel, numTilesX, numTilesY, 1);
                 }
 
-                if (m_PassSettings.enableClustered)        // works for transparencies too.
+                if (m_TileSettings.enableClustered)        // works for transparencies too.
                 {
                     VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBufferRT);
                 }
                 SetGlobalInt("_NumTileClusteredX", GetNumTileClusteredX(camera));
                 SetGlobalInt("_NumTileClusteredY", GetNumTileClusteredY(camera));
 
-                if (m_PassSettings.enableBigTilePrepass)
+                if (m_TileSettings.enableBigTilePrepass)
-                if (m_PassSettings.enableClustered)
+                if (m_TileSettings.enableClustered)
                 {
                     SetGlobalFloat("g_fClustScale", m_ClustScale);
                     SetGlobalFloat("g_fClustBase", k_ClustLogBase);
 
 #endif
 
-            public override void RenderShadows(ScriptableRenderContext renderContext, CullResults cullResults)
+            public void RenderShadows(ScriptableRenderContext renderContext, CullResults cullResults)
             {
                 // kick off the shadow jobs here
                 m_ShadowMgr.RenderShadows(m_FrameId, renderContext, cullResults, cullResults.visibleLights);
                 Utilities.SetKeyword(m_SingleDeferredMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
             }
 
-            public override void RenderLightingDebug(HDCamera hdCamera, ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer)
+            public void RenderLightingDebug(HDCamera hdCamera, ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer)
-                if (m_PassSettings.tileDebugByCategory == TileLightLoopProducer.TileSettings.TileDebug.None)
+                if (m_TileSettings.tileDebugByCategory == TileSettings.TileDebug.None)
                     return;
 
                 var cmd = new CommandBuffer();
 
                 // Debug tiles
                 PushGlobalParams(hdCamera.camera, renderContext, null, 0);
-                if (m_PassSettings.tileDebugByCategory == TileLightLoopProducer.TileSettings.TileDebug.FeatureVariants)
+                if (m_TileSettings.tileDebugByCategory == TileSettings.TileDebug.FeatureVariants)
                 {
                     if (GetFeatureVariantsEnabled())
                     {
-                        m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_PassSettings.tileDebugByCategory);
+                        m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_TileSettings.tileDebugByCategory);
                         m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
                         m_DebugViewTilesMaterial.SetBuffer("g_TileList", s_TileList);
                         m_DebugViewTilesMaterial.SetBuffer("g_DispatchIndirectBuffer", s_DispatchIndirectBuffer);
                         cmd.DrawProcedural(Matrix4x4.identity, m_DebugViewTilesMaterial, 0, MeshTopology.Triangles, numTiles * 6);
                     }
                 }
-                else if (m_PassSettings.tileDebugByCategory != TileLightLoopProducer.TileSettings.TileDebug.None)
+                else if (m_TileSettings.tileDebugByCategory != TileSettings.TileDebug.None)
-                    m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_PassSettings.tileDebugByCategory);
+                    m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_TileSettings.tileDebugByCategory);
                     m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
                     m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                     m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                 cmd.Dispose();
             }
 
-            public override void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
+            public void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
                                                         DebugDisplaySettings debugDisplaySettings,
                                                         RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthStencilTexture,
                                                         bool outputSplitLightingForSSS)
-                using (new Utilities.ProfilingSample((m_PassSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLightingForSSS ? " MRT" : ""), renderContext))
+                using (new Utilities.ProfilingSample((m_TileSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLightingForSSS ? " MRT" : ""), renderContext))
                 {
                     var cmd = new CommandBuffer();
                     cmd.name = bUseClusteredForDeferred ? "Clustered pass" : "Tiled pass";
                     SetupDebugDisplayMode(debugDisplaySettings.IsDebugDisplayEnabled());
 
-                    if (!m_PassSettings.enableTileAndCluster)
+                    if (!m_TileSettings.enableTileAndCluster)
                     {
                         PushGlobalParams(camera, renderContext, null, 0);
 
                         int numTilesY = (h + 15) / 16;
                         int numTiles = numTilesX * numTilesY;
 
-                        if (m_PassSettings.enableComputeLightEvaluation)
+                        if (m_TileSettings.enableComputeLightEvaluation)
                         {
                             bool enableFeatureVariants = GetFeatureVariantsEnabled() && !debugDisplaySettings.IsDebugDisplayEnabled();
 
                             // Pixel shader evaluation
                             PushGlobalParams(camera, renderContext, null, 0);
 
-                            if (m_PassSettings.enableSplitLightEvaluation)
+                            if (m_TileSettings.enableSplitLightEvaluation)
                             {
                                 if (outputSplitLightingForSSS)
                                 {
                 } // TilePass - Deferred Lighting Pass
             }
 
-            public override void RenderForward(Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
+            public void RenderForward(Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
             {
                 // Note: if we use render opaque with deferred tiling we need to render a opaque depth pass for these opaque objects
                 bool useFptl = renderOpaque && usingFptl;
-                if (!m_PassSettings.enableTileAndCluster)
+                if (!m_TileSettings.enableTileAndCluster)
                 {
                     cmd.name = "Forward pass";
                     cmd.EnableShaderKeyword("LIGHTLOOP_SINGLE_PASS");
                 cmd.Dispose();
             }
 
-            public override void RenderDebugOverlay(Camera camera, ScriptableRenderContext renderContext, DebugDisplaySettings debugDisplaySettings, ref float x, ref float y, float overlaySize, float width)
+            public void RenderDebugOverlay(Camera camera, ScriptableRenderContext renderContext, DebugDisplaySettings debugDisplaySettings, ref float x, ref float y, float overlaySize, float width)
             {
                 LightingDebugSettings lightingDebug = debugDisplaySettings.lightingDebugSettings;
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassProducer.asset

     diffuseGlobalDimmer: 1
     specularGlobalDimmer: 1
     tileDebugByCategory: 0
-  m_PassResources: {fileID: 11400000, guid: 7f2998544b2ac3848822b80ec3e6c446, type: 2}
+  m_PassResources: {fileID: 11400000, guid: 42086e81f4f0c724f96f7f09cc995354, type: 2}

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

         [HideInInspector] _ZTestMode("_ZTestMode", Int) = 8
 
         [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
-        [ToggleOff] _DoubleSidedMirrorEnable("Double sided mirror enable", Float) = 1.0
+        [Enum(None, 0, Mirror, 1, Flip, 2)] _DoubleSidedNormalMode("Double sided normal mode", Float) = 1
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_FORWARD
             #include "../../Debug/DebugDisplay.hlsl"
-            #include "../../Lighting/Forward.hlsl"            
+            #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

         [HideInInspector] _ZTestMode("_ZTestMode", Int) = 8
 
         [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
-        [ToggleOff] _DoubleSidedMirrorEnable("Double sided mirror enable", Float) = 1.0
+        [Enum(None, 0, Mirror, 1, Flip, 2)] _DoubleSidedNormalMode("Double sided normal mode", Float) = 1
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/BaseLitUI.cs

     {
         protected static class StylesBaseLit
         {
-            public static GUIContent doubleSidedMirrorEnableText = new GUIContent("Mirror normal", "This will mirror the normal with vertex normal plane if enabled, else flip the normal");
+            public static GUIContent doubleSidedNormalModeText = new GUIContent("Normal mode", "This will modify the normal base on the selected mode. None: untouch, Mirror: Mirror the normal with vertex normal plane, Flip: Flip the normal");
             public static GUIContent depthOffsetEnableText = new GUIContent("Enable Depth Offset", "EnableDepthOffset on this shader (Use with heightmap)");
 
             // Material ID
             public static string vertexAnimation = "Vertex Animation";
         }
 
+        public enum DoubleSidedNormalMode
+        {
+           None,
+           Mirror,
+           Flip
+        }
+
         public enum TessellationMode
         {
             Phong,
 
-        protected MaterialProperty doubleSidedMirrorEnable = null;
-        protected const string kDoubleSidedMirrorEnable = "_DoubleSidedMirrorEnable";
+        protected MaterialProperty doubleSidedNormalMode = null;
+        protected const string kDoubleSidedNormalMode = "_DoubleSidedNormalMode";
         protected MaterialProperty depthOffsetEnable = null;
         protected const string kDepthOffsetEnable = "_DepthOffsetEnable";
 
         {
             base.FindBaseMaterialProperties(props);
 
-            doubleSidedMirrorEnable = FindProperty(kDoubleSidedMirrorEnable, props);
+            doubleSidedNormalMode = FindProperty(kDoubleSidedNormalMode, props);
             depthOffsetEnable = FindProperty(kDepthOffsetEnable, props);
 
             // MaterialID
             if (doubleSidedEnable.floatValue > 0.0f)
             {
                 EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(doubleSidedMirrorEnable, StylesBaseLit.doubleSidedMirrorEnableText);
+                m_MaterialEditor.ShaderProperty(doubleSidedNormalMode, StylesBaseLit.doubleSidedNormalModeText);
                 EditorGUI.indentLevel--;
             }
 
             SetupBaseUnlitKeywords(material);
 
             bool doubleSidedEnable = material.GetFloat(kDoubleSidedEnable) > 0.0f;
-            bool doubleSidedMirrorEnable = material.GetFloat(kDoubleSidedMirrorEnable) > 0.0f;
-                if (doubleSidedMirrorEnable)
-                {
-                    // Mirror mode (in tangent space)
-                    material.SetVector("_DoubleSidedConstants", new Vector4(1.0f, 1.0f, -1.0f, 0.0f));
-                }
-                else
+                DoubleSidedNormalMode doubleSidedNormalMode = (DoubleSidedNormalMode)material.GetFloat(kDoubleSidedNormalMode);
+                switch (doubleSidedNormalMode)
-                    // Flip mode (in tangent space)
-                    material.SetVector("_DoubleSidedConstants", new Vector4(-1.0f, -1.0f, -1.0f, 0.0f));
+                    case DoubleSidedNormalMode.None:
+                        material.SetVector("_DoubleSidedConstants", new Vector4(1.0f, 1.0f, 1.0f, 0.0f));
+                        break;
+
+                    case DoubleSidedNormalMode.Mirror: // Mirror mode (in tangent space)
+                        material.SetVector("_DoubleSidedConstants", new Vector4(1.0f, 1.0f, -1.0f, 0.0f));
+                        break;
+
+                    case DoubleSidedNormalMode.Flip: // Flip mode (in tangent space)
+                        material.SetVector("_DoubleSidedConstants", new Vector4(-1.0f, -1.0f, -1.0f, 0.0f));
+                        break;
-            bool depthOffsetEnable = material.GetFloat(kDepthOffsetEnable) > 0.0f;
+            // Depth offset is only enabled if per pixel displacement is
+            bool depthOffsetEnable = (material.GetFloat(kDepthOffsetEnable) > 0.0f) && (material.GetFloat(kEnablePerPixelDisplacement) > 0.0f);
             SetKeyword(material, "_DEPTHOFFSET_ON", depthOffsetEnable);
 
             // Set the reference value for the stencil test.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/LitUI.cs

 
         protected void ShaderSSSInputGUI(Material material)
         {
-            HDRenderPipelineInstance hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipelineInstance;
+            HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
 
             if (subsurfaceProfile == null)
             {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

                 tex.SetPixels(pixels, arrayElement);
             }
 
-            public void Build()
+            public void Build(RenderPipelineResources renderPipelineResources)
             {
                 m_InitPreFGD = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

         [HideInInspector] _ZTestMode("_ZTestMode", Int) = 8
 
         [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
-        [ToggleOff] _DoubleSidedMirrorEnable("Double sided mirror enable", Float) = 1.0
+        [Enum(None, 0, Mirror, 1, Flip, 2)] _DoubleSidedNormalMode("Double sided normal mode", Float) = 1
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
         [Enum(UV0, 0, Planar, 1, TriPlanar, 2)] _UVBase("UV Set for base", Float) = 0

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

         [HideInInspector] _ZTestMode("_ZTestMode", Int) = 8
 
         [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
-        [ToggleOff] _DoubleSidedMirrorEnable("Double sided mirror enable", Float) = 1.0
+        [Enum(None, 0, Mirror, 1, Flip, 2)] _DoubleSidedNormalMode("Double sided normal mode", Float) = 1
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
         [Enum(UV0, 0, Planar, 1, TriPlanar, 2)] _UVBase("UV Set for base", Float) = 0

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringProfile.cs

             if (EditorGUI.EndChangeCheck())
             {
                 // Validate each individual asset and update caches.
-                HDRenderPipelineInstance hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipelineInstance;
+                HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
                 hdPipeline.sssSettings.OnValidate();
             }
         }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/MaterialUtilities.hlsl

     // Orthonormalize the basis vectors using the Gram-Schmidt process.
     // We assume that the length of the surface normal is sufficiently close to 1.
     // This is use with anisotropic material
-    tangentWS = normalize(tangentWS - dot(tangentWS, normalWS));
+    tangentWS = normalize(tangentWS - dot(tangentWS, normalWS) * normalWS);
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs

             public static GUIContent distortionEnableText = new GUIContent("Distortion", "Enable distortion on this shader");
             public static GUIContent distortionOnlyText = new GUIContent("Distortion Only", "This shader will only be use to render distortion");
             public static GUIContent distortionDepthTestText = new GUIContent("Distortion Depth Test", "Enable the depth test for distortion");
+
+            public static string advancedText = "Advanced Options";
         }
 
         public enum SurfaceType
                 MaterialPropertiesGUI(material);
 
                 DoEmissionArea(material);
+
+                GUILayout.Label(StylesBaseUnlit.advancedText, EditorStyles.boldLabel);
+                // NB renderqueue editor is not shown on purpose: we want to override it based on blend mode
+                m_MaterialEditor.DoubleSidedGIField();
             }
 
             if (EditorGUI.EndChangeCheck())

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/SceneSettings.cs

         {
             SceneSettingsManager.instance.AddSceneSettings(this);
 
-            HDRenderPipelineInstance hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipelineInstance;
+            HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
 
             if (hdPipeline != null)
             {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/RuntimeFilterIBL.cs

 
         bool          m_SupportMIS = !TextureCache.isMobileBuildTarget;
 
+        RenderPipelineResources m_RenderPipelinesResources;
+
+        public IBLFilterGGX(RenderPipelineResources renderPipelinesResources)
+        {
+            m_RenderPipelinesResources = renderPipelinesResources;
+        }
+
         public bool IsInitialized()
         {
             return m_GgxIblSampleData != null;
         {
             if (!m_ComputeGgxIblSampleDataCS)
             {
-                m_ComputeGgxIblSampleDataCS     = Resources.Load<ComputeShader>("ComputeGgxIblSampleData");
+                m_ComputeGgxIblSampleDataCS     = m_RenderPipelinesResources.computeGgxIblSampleData;
-                m_BuildProbabilityTablesCS   = Resources.Load<ComputeShader>("BuildProbabilityTables");
+                m_BuildProbabilityTablesCS   = m_RenderPipelinesResources.buildProbabilityTables;
                 m_ConditionalDensitiesKernel = m_BuildProbabilityTablesCS.FindKernel("ComputeConditionalDensities");
                 m_MarginalRowDensitiesKernel = m_BuildProbabilityTablesCS.FindKernel("ComputeMarginalRowDensities");
             }
-                m_GgxConvolveMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/GGXConvolve");
+                m_GgxConvolveMaterial = Utilities.CreateEngineMaterial(m_RenderPipelinesResources.GGXConvolve);
             }
 
             if (!m_GgxIblSampleData)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

             RebuildSkyMeshes(nearPlane, farPlane);
         }
 
-        public void Build()
+        public void Build(RenderPipelineResources renderPipelinesResources)
-            m_iblFilterGgx = new IBLFilterGGX();
+            m_iblFilterGgx = new IBLFilterGGX(renderPipelinesResources);
-            m_StandardSkyboxMaterial = Utilities.CreateEngineMaterial("Skybox/Cubemap");
+            m_StandardSkyboxMaterial = Utilities.CreateEngineMaterial(renderPipelinesResources.skyboxCubemap);
-            m_BlitCubemapMaterial = Utilities.CreateEngineMaterial("Hidden/BlitCubemap");
+            m_BlitCubemapMaterial = Utilities.CreateEngineMaterial(renderPipelinesResources.blitCubemap);
 
             m_CurrentUpdateTime = 0.0f;
         }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

             return mat;
         }
 
+        public static Material CreateEngineMaterial(Shader shader)
+        {
+            var mat = new Material(shader)
+            {
+                hideFlags = HideFlags.HideAndDontSave
+            };
+            return mat;
+        }
+
         public static void Destroy(UnityObject obj)
         {
             if (obj != null)
                     material.DisableKeyword(keywords[i]);
                 }
             }
-        }
-
-        public static HDRenderPipeline GetHDRenderPipeline()
-        {
-            HDRenderPipeline renderContext = GraphicsSettings.renderPipelineAsset as HDRenderPipeline;
-            if (renderContext == null)
-            {
-                Debug.LogWarning("HDRenderPipeline is not instantiated.");
-                return null;
-            }
-
-            return renderContext;
         }
 
         // Draws a full screen triangle as a faster alternative to drawing a full screen quad.

Assets/ScriptableRenderPipeline/LowEndMobilePipeline/Editor/LowendMobilePipelineMaterialEditor.cs

         m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, bumpMapProp);
 
         EditorGUILayout.Space();
-        m_MaterialEditor.TexturePropertySingleLine(Styles.emissionMapLabel, emissionMapProp, emissionColorProp);
+        DoEmission();
 
         EditorGUILayout.Space();
         DoReflection();
                     kMinShininessValue, 1.0f);
             if (EditorGUI.EndChangeCheck())
                 shininessProp.floatValue = shininess;
+        }
+    }
+
+    private void DoEmission()
+    {
+        if (m_MaterialEditor.EmissionEnabledProperty())
+        {
+            bool hadEmissionMap = emissionMapProp.textureValue != null;
+            m_MaterialEditor.TexturePropertySingleLine(Styles.emissionMapLabel, emissionMapProp, emissionColorProp);
+
+            float maxValue = emissionColorProp.colorValue.maxColorComponent;
+            if (emissionMapProp.textureValue != null && !hadEmissionMap && maxValue <= 0.0f)
+                emissionColorProp.colorValue = Color.white;
+
+            m_MaterialEditor.LightmapEmissionFlagsProperty(MaterialEditor.kMiniTextureFieldLabelIndentLevel, true);
         }
     }
 

Assets/ScriptableRenderPipeline/LowEndMobilePipeline/Editor/LowendUpgraders.cs

             UpdateMaterialReflectionSource(material);
             SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap"));
             SetKeyword(material, "_CUBEMAP_REFLECTION", material.GetTexture("_Cube"));
-            SetKeyword(material, "_EMISSION_MAP", material.GetTexture("_EmissionMap"));
+            SetKeyword(material, "_EMISSION", material.GetTexture("_EmissionMap"));
         }
 
         private static void UpdateMaterialBlendMode(Material material)

Assets/ScriptableRenderPipeline/LowEndMobilePipeline/LowEndMobilePipeline.cs

             }
 
             context.Submit();
-            Shader.globalRenderPipeline = prevPipe;
         }
 
         private void BuildShadowSettings()

Assets/ScriptableRenderPipeline/LowEndMobilePipeline/Shaders/LowEndMobilePipeline.shader

             [HideInInspector] _ZWrite("__zw", Float) = 1.0
     }
 
-        SubShader
-        {
-            Tags { "RenderType" = "Opaque" "RenderPipeline" = "LowEndMobilePipeline" }
-            LOD 300
+    SubShader
+    {
+        Tags { "RenderType" = "Opaque" "RenderPipeline" = "LowEndMobilePipeline" }
+        LOD 300
-            Pass
-            {
-                Name "LD_SINGLE_PASS_FORWARD"
-                Tags { "LightMode" = "LowEndMobileForward" }
+        Pass
+        {
+            Name "LD_SINGLE_PASS_FORWARD"
+            Tags { "LightMode" = "LowEndMobileForward" }
 
             // Use same blending / depth states as Standard shader
             Blend[_SrcBlend][_DstBlend]
-            #pragma target 2.0
+            #pragma target 3.0
-            #pragma shader_feature _EMISSION_MAP
+            #pragma shader_feature _EMISSION
             #pragma shader_feature _ _REFLECTION_CUBEMAP _REFLECTION_PROBE
 
             #pragma multi_compile _ LIGHTMAP_ON
                 NormalMap(i, normal);
 
                 half4 specularGloss;
-                SpecularGloss(i.uv01.xy, diffuse, alpha, specularGloss);
+                SpecularGloss(i.uv01.xy, alpha, specularGloss);
 
                 half3 viewDir = i.viewDir.xyz;
 
                     LightInput lightData;
                     half NdotL;
                     INITIALIZE_LIGHT(lightData, lightIndex);
-                    color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir, NdotL); 
+                    color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir, NdotL);
-                    	#if _NORMALMAP
-                    	float3 vertexNormal = float3(i.tangentToWorld0.z, i.tangentToWorld1.z, i.tangentToWorld2.z);
-                    	#else
-                    	float3 vertexNormal = i.normal;
-                    	#endif
+                        #if _NORMALMAP
+                        float3 vertexNormal = float3(i.tangentToWorld0.z, i.tangentToWorld1.z, i.tangentToWorld2.z);
+                        #else
+                        float3 vertexNormal = i.normal;
+                        #endif
                         float bias = max(globalLightData.z, (1.0 - NdotL) * globalLightData.w);
                         color *= ComputeShadowAttenuation(i, vertexNormal * bias);
                     }
-                half3 emissionColor;
-                Emission(i, emissionColor);
-                color += emissionColor;
+                Emission(i.uv01.xy, color);
 
 #if defined(LIGHTMAP_ON)
                 color += (DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, i.uv01.zw)) + i.fogCoord.yzw) * diffuse;
             Cull Off
 
             CGPROGRAM
+            #define UNITY_SETUP_BRDF_INPUT SpecularSetup
-            #pragma fragment frag_meta
+            #pragma fragment frag_meta_ld
-            #pragma shader_feature _METALLICGLOSSMAP
+            #pragma shader_feature _SPECGLOSSMAP
+            #include "LowEndMobilePipelineCore.cginc"
+
+            fixed4 frag_meta_ld(v2f_meta i) : SV_Target
+            {
+                UnityMetaInput o;
+                UNITY_INITIALIZE_OUTPUT(UnityMetaInput, o);
+
+                o.Albedo = Albedo(i.uv);
+
+                half4 specularColor;
+                SpecularGloss(i.uv.xy, 1.0, specularColor);
+                o.SpecularColor = specularColor;
+
+                Emission(i.uv.xy, o.Emission);
+
+                return UnityMetaFragment(o);
+            }
             ENDCG
         }
     }

Assets/ScriptableRenderPipeline/LowEndMobilePipeline/Shaders/LowEndMobilePipelineCore.cginc

 #endif
 }
 
-inline void SpecularGloss(half2 uv, half3 diffuse, half alpha, out half4 specularGloss)
+inline void SpecularGloss(half2 uv, half alpha, out half4 specularGloss)
 {
 #ifdef _SPECGLOSSMAP
     specularGloss = tex2D(_SpecGlossMap, uv) * _SpecColor;
 #endif
 }
 
-inline void Emission(v2f i, out half3 emission)
+inline void Emission(half2 uv, inout half3 color)
-#ifdef _EMISSION_MAP
-    emission = tex2D(_EmissionMap, i.uv01.xy) * _EmissionColor;
+#ifdef _EMISSION
+    color += tex2D(_EmissionMap, uv) * _EmissionColor;
-    emission = _EmissionColor;
+    color += _EmissionColor;
 #endif
 }
 

Assets/ScriptableRenderPipeline/LowEndMobilePipeline/Shaders/LowEndMobilePipelineShadows.cginc

 #endif
 }
 
-inline half ComputeShadowAttenuation(v2f i, float3 offset)
-{
-	float3 posWorldOffsetNormal = i.posWS + offset;
-	int cascadeIndex = 0;
-
-#ifdef _SHADOW_CASCADES
-    cascadeIndex = ComputeCascadeIndex(i.posWS);
-    if (cascadeIndex >= MAX_SHADOW_CASCADES)
-        return 1.0;
-#endif
-    float4 shadowCoord = mul(_WorldToShadow[cascadeIndex], float4(posWorldOffsetNormal, 1.0));
-    shadowCoord.xyz /= shadowCoord.w;
-    shadowCoord.z = saturate(shadowCoord.z);
-
-#if defined(_SOFT_SHADOWS) || defined(_SOFT_SHADOWS_CASCADES)
-    return ShadowPCF(shadowCoord.xyz);
-#else
-    return ShadowAttenuation(shadowCoord.xyz);
-#endif
-}
-
 inline half ComputeCascadeIndex(float3 wpos)
 {
     float3 fromCenter0 = wpos.xyz - _DirShadowSplitSpheres[0].xyz;
         ShadowAttenuation(half3(shadowCoord.xy + half2(_PCFKernel[4], _PCFKernel[5]) + offset, shadowCoord.z)) +
         ShadowAttenuation(half3(shadowCoord.xy + half2(_PCFKernel[6], _PCFKernel[7]) + offset, shadowCoord.z));
     return attenuation * 0.25;
-}
+}
+
+inline half ComputeShadowAttenuation(v2f i, float3 offset)
+{
+    float3 posWorldOffsetNormal = i.posWS + offset;
+    int cascadeIndex = 0;
+
+#ifdef _SHADOW_CASCADES
+    cascadeIndex = ComputeCascadeIndex(i.posWS);
+    if (cascadeIndex >= MAX_SHADOW_CASCADES)
+        return 1.0;
+#endif
+    float4 shadowCoord = mul(_WorldToShadow[cascadeIndex], float4(posWorldOffsetNormal, 1.0));
+    shadowCoord.xyz /= shadowCoord.w;
+    shadowCoord.z = saturate(shadowCoord.z);
+
+#if defined(_SOFT_SHADOWS) || defined(_SOFT_SHADOWS_CASCADES)
+    return ShadowPCF(shadowCoord.xyz);
+#else
+    return ShadowAttenuation(shadowCoord.xyz);
+#endif
+}

Assets/ScriptableRenderPipeline/ShaderLibrary/ImageBasedLighting.hlsl

 {
     float perceptualRoughness = saturate(mipmapLevel / UNITY_SPECCUBE_LOD_STEPS);
 
-    return saturate(1.7 / 1.4 - sqrt(2.89 - 2.8 * perceptualRoughness) / 1.4);
+    return saturate(1.7 / 1.4 - sqrt(2.89 / 1.96 - (2.8 / 1.96) * perceptualRoughness));
 }
 
 // Ref: "Moving Frostbite to PBR", p. 69.

ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 2017.2.0a1
+m_EditorVersion: 2017.2.0a2

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplayLatlong.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #include "../../../ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderLibrary/ImageBasedLighting.hlsl"
+            #include "../../ShaderLibrary/Common.hlsl"
+            #include "../../ShaderLibrary/ImageBasedLighting.hlsl"
 
             TEXTURECUBE(_InputCubemap);
             SAMPLERCUBE(sampler_InputCubemap);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplayShadowMap.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #include "../../../ShaderLibrary/Common.hlsl"
+            #include "../../ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderLibrary/Shadow/Shadow.hlsl"
+            #include "../../ShaderLibrary/Shadow/Shadow.hlsl"
             #undef SHADOW_TILEPASS
 
             SamplerState ltc_linear_clamp_sampler;
             {
                 ShadowContext shadowContext = InitShadowContext();
 
-                // Caution: ShadowContext is define in Shadowcontext.hlsl for current render pipeline. This shader must be in sync with its content else it doesn't work. 
+                // Caution: ShadowContext is define in Shadowcontext.hlsl for current render pipeline. This shader must be in sync with its content else it doesn't work.
                 return SAMPLE_TEXTURE2D_ARRAY(_ShadowmapExp_PCF, ltc_linear_clamp_sampler, input.texcoord, 0).xxxx;
             }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewMaterialGBuffer.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #include "../../../ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderLibrary/Color.hlsl"
+            #include "../../ShaderLibrary/Common.hlsl"
+            #include "../../ShaderLibrary/Color.hlsl"
-            #include "../../ShaderConfig.cs.hlsl"
-            #include "../../ShaderVariables.hlsl"
+            #include "../ShaderConfig.cs.hlsl"
+            #include "../ShaderVariables.hlsl"
-            #include "../../Debug/DebugDisplay.hlsl"
-            #include "../../Material/Material.hlsl"
+            #include "../Debug/DebugDisplay.hlsl"
+            #include "../Material/Material.hlsl"
 
             DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewTiles.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "../../../ShaderLibrary/Common.hlsl"
+            #include "../../ShaderLibrary/Common.hlsl"
-            #include "../../ShaderConfig.cs.hlsl"
-            #include "../../ShaderVariables.hlsl"
-            #include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
+            #include "../ShaderConfig.cs.hlsl"
+            #include "../ShaderVariables.hlsl"
+            #include "../Lighting/Lighting.hlsl" // This include Material.hlsl
 
             //-------------------------------------------------------------------------------------
             // variable declaration

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild-bigtile.compute

 #pragma kernel BigTileLightListGen
 
-#include "../../../../ShaderLibrary/common.hlsl"
-#include "../TilePass.cs.hlsl"
-#include "../LightingConvexHullUtils.hlsl"
-#include "../SortingComputeUtils.hlsl"
+#include "../../../ShaderLibrary/common.hlsl"
+#include "TilePass.cs.hlsl"
+#include "LightingConvexHullUtils.hlsl"
+#include "SortingComputeUtils.hlsl"
 
 #define EXACT_EDGE_TESTS
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 
 	float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne();
 	float halfTileSizeAtZDistOne = 32*onePixDiagDist;		// scale by half a tile
-	
+
-	
+
 		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius) )
 			lightsListLDS[l]=0xffffffff;
 	}
 		[branch]if(canEnter)
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
-	
+
 			const float3 boxX = lgtDat.boxAxisX.xyz;
 			const float3 boxY = lgtDat.boxAxisY.xyz;
 			const float3 boxZ = -lgtDat.boxAxisZ.xyz;	// flip axis (so it points away from the light direction for a spot-light)
 				int idx_cur=0, idx_twin=0;
 				float3 vP0, vE0;
 				GetHullEdge(idx_cur, idx_twin, vP0, vE0, e0, boxX, boxY, boxZ, center, scaleXY);
-				
-			
+
+
-				
+
-			
+
 				int positive=0, negative=0;
 				for(int k=1; k<8; k++)		// only need to test 7 verts (technically just 6).
 				{

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/scrbound.compute

 
 #pragma kernel ScreenBoundsAABB
 
-#include "../../../../ShaderLibrary/common.hlsl"
-#include "../TilePass.cs.hlsl"
+#include "../../../ShaderLibrary/common.hlsl"
+#include "TilePass.cs.hlsl"
 
 uniform int g_iNrVisibLights;
 uniform float4x4 g_mInvProjection;
 int ClipAgainstPlane(const int iSrcIndex, const int iNrSrcVerts, const int subLigt, const int p);
 void CalcBound(out bool2 bIsMinValid, out bool2 bIsMaxValid, out float2 vMin, out float2 vMax, float4x4 InvProjection, float3 pos_view_space, float r);
 
-#include "../LightingConvexHullUtils.hlsl"
+#include "LightingConvexHullUtils.hlsl"
 
 
 [numthreads(NR_THREADS, 1, 1)]
-	
+
 	//uint vindex = groupID * NR_THREADS + threadID;
 	unsigned int g = groupID;
 	unsigned int t = threadID;
 	const int sideIndex = (int) (t%8);
-	
+
-	
+
 	const float3 boxX = lgtDat.boxAxisX.xyz;
 	const float3 boxY = lgtDat.boxAxisY.xyz;
 	const float3 boxZ = -lgtDat.boxAxisZ.xyz;           // flip axis (so it points away from the light direction for a spot-light)
 			const unsigned int uFlag3 = GetClip(vP3);
 
 			const float4 vPnts[] = {vP0, vP1, vP2, vP3};
-				
+
 			// screen-space AABB of one quad (assuming no intersection)
 			float3 vMin, vMax;
 			for(int k=0; k<4; k++)
 				fW = fS * (fWabs<FLT_EPSILON ? FLT_EPSILON : fWabs);
 				float3 vP = float3(vPnts[k].x/fW, vPnts[k].y/fW, vPnts[k].z/fW);
 				if(k==0) { vMin=vP; vMax=vP; }
-				
+
 				vMax = max(vMax, vP); vMin = min(vMin, vP);
 			}
 
 
 						float3 vFaceMi = float3(posX[subLigt*MAX_PNTS*2 + sideIndex + 0], posY[subLigt*MAX_PNTS*2 + sideIndex + 0], posZ[subLigt*MAX_PNTS*2 + sideIndex + 0]);
 						float3 vFaceMa = float3(posX[subLigt*MAX_PNTS*2 + sideIndex + 6], posY[subLigt*MAX_PNTS*2 + sideIndex + 6], posZ[subLigt*MAX_PNTS*2 + sideIndex + 6]);
-						
+
-							
+
 							vMax = max(vMax, vP); vMin = min(vMin, vP);
 						}
 					}
 			else		// :( need true clipping
 			{
-				
+
-			
+
 					// 4 vertices to a quad of the convex hull in post projection space
 					const float4 vP0 = mul(g_mProjection, float4(q0, 1));
 					const float4 vP1 = mul(g_mProjection, float4(q1, 1));
-					
+
 					int iSrcIndex = 0;
 
 					int offs = iSrcIndex*MAX_PNTS+subLigt*MAX_PNTS*2;
 						for(int k=0; k<iNrSrcVerts; k++)
 						{
 							float4 vCur = float4(posX[offs_src+k], posY[offs_src+k], posZ[offs_src+k], posW[offs_src+k]);
-							
+
-							
+
-						
+
 				}
 
 				////////////////////// look for camera frustum verts that need to be included. That is frustum vertices inside the convex hull for the light
 					float3 vVertPSpace = float3((i&1)!=0 ? 1 : (-1), (i&2)!=0 ? 1 : (-1), (i&4)!=0 ? 1 : 0);
-				
+
 					float4 v4ViewSpace = mul(g_mInvProjection, float4(vVertPSpace,1));
 					float3 vViewSpace = float3(v4ViewSpace.x/v4ViewSpace.w, v4ViewSpace.y/v4ViewSpace.w, v4ViewSpace.z/v4ViewSpace.w);
 
 						float3 vP = float3((i&1)!=0 ? 1 : (-1), (i&2)!=0 ? 1 : (-1), (i&4)!=0 ? 1 : 0);
 
 						if(!bSetBoundYet) { vMin=vP; vMax=vP; bSetBoundYet=true; }
-							
+
 						vMax = max(vMax, vP); vMin = min(vMin, vP);
 					}
 				}
-			
+
 
 
 			// determine AABB bound in [-1;1]x[-1;1] screen space using bounding sphere.
 					float2 vMi, vMa;
 					bool2 bMi, bMa;
 					CalcBound(bMi, bMa, vMi, vMa, g_mInvProjection, center, radius);
-		
+
 					vMin.xy = bMi ? max(vMin.xy, vMi) : vMin.xy;
 					vMax.xy = bMa ? min(vMax.xy, vMa) : vMax.xy;
 				}
 			// to see if the light is occluded: vMin.z*VIEWPORT_SCALE_Z > MipTexelMaxDepth
 			//g_vBoundsBuffer[lgtIndex+0] = float3(0.5*vMin.x+0.5, -0.5*vMax.y+0.5, vMin.z*VIEWPORT_SCALE_Z);
 			//g_vBoundsBuffer[lgtIndex+g_iNrVisibLights] = float3(0.5*vMax.x+0.5, -0.5*vMin.y+0.5, vMax.z*VIEWPORT_SCALE_Z);
-			
+
 			// changed for unity
 			g_vBoundsBuffer[lgtIndex+0] = float3(0.5*vMin.x+0.5, 0.5*vMin.y+0.5, vMin.z*VIEWPORT_SCALE_Z);
 			g_vBoundsBuffer[lgtIndex+(int) g_iNrVisibLights] = float3(0.5*vMax.x+0.5, 0.5*vMax.y+0.5, vMax.z*VIEWPORT_SCALE_Z);
 				++nrVertsDst;
 			}
 		}
-							
+
 		if(bIsCurVisib)
 		{
 			//assert(nrVertsDst<MAX_PNTS);
 	const int index = ((uint) p)/2;
 	float x1 = index==0 ? vVisib.x : (index==1 ? vVisib.y : vVisib.z);
 	float x0 = index==0 ? vInvisib.x : (index==1 ? vInvisib.y : vInvisib.z);
-	
+
 	//fS*((vVisib.w-vInvisib.w)*t + vInvisib.w) = (x1-x0)*t + x0;
 
 	const float fT = (fS*vInvisib.w-x0)/((x1-x0) - fS*(vVisib.w-vInvisib.w));
 	float4 planeY0 = TransformPlaneToPostSpace(InvProjection, float4(0, planeY.x, planeY.y, 0));
 	float4 planeY1 = TransformPlaneToPostSpace(InvProjection, float4(0, planeY.z, planeY.w, 0));
 
-	
+
 	// convert planes to the forms (1,0,0,D) and (0,1,0,D)
 	// 2D bound is given by -D components
 	float2 A = -float2(planeX0.w / planeX0.x, planeY0.w / planeY0.y);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild-clustered.compute

 #pragma kernel TileLightListGen_DepthRT_MSAA_SrcBigTile		LIGHTLISTGEN=TileLightListGen_DepthRT_MSAA_SrcBigTile		ENABLE_DEPTH_TEXTURE_BACKPLANE		MSAA_ENABLED		USE_TWO_PASS_TILED_LIGHTING
 #pragma kernel ClearAtomic
 
-#include "../../../../ShaderLibrary/common.hlsl"
-#include "../ShaderBase.hlsl"
-#include "../TilePass.cs.hlsl"
-#include "../LightingConvexHullUtils.hlsl"
+#include "../../../ShaderLibrary/common.hlsl"
+#include "ShaderBase.hlsl"
+#include "TilePass.cs.hlsl"
+#include "LightingConvexHullUtils.hlsl"
-#include "../SortingComputeUtils.hlsl"
+#include "SortingComputeUtils.hlsl"
 #endif
 
 //#define EXACT_EDGE_TESTS
 uniform float g_fFarPlane;
 uniform int	  g_iLog2NumClusters;		// numClusters = (1<<g_iLog2NumClusters)
 
-#include "../ClusteredUtils.hlsl"
+#include "ClusteredUtils.hlsl"
 
 
 #ifdef MSAA_ENABLED
 		for(int p=0; p<6; p++)
 		{
 			float4 plane = lightPlanes[6*(l&3)+p];
-		
+
 			bool bAllInvisib = true;
 
 			for(int i=0; i<8; i++)
 #endif
 
 	int iNrCoarseLights = min(lightOffs,MAX_NR_COARSE_ENTRIES);
-	
+
 #ifdef PERFORM_SPHERICAL_INTERSECTION_TESTS
 	iNrCoarseLights = SphericalIntersectionTests( t, iNrCoarseLights, float2(min(viTilLL.xy+uint2(TILE_SIZE_CLUSTERED/2,TILE_SIZE_CLUSTERED/2), uint2(iWidth-1, iHeight-1))) );
 #endif
 
 
 	//////////////////////////////////////////////////////////
-	
+
 	uint start = 0;
 	int i=(int) t;
 	int iSpaceAvail = 0;
 float4 FetchPlane(int l, int p)
 {
 	SFiniteLightBound lgtDat = g_data[coarseList[l]];
-	
+
 	const float3 boxX = lgtDat.boxAxisX.xyz;
 	const float3 boxY = lgtDat.boxAxisY.xyz;
 	const float3 boxZ = -lgtDat.boxAxisZ.xyz;           // flip axis (so it points away from the light direction for a spot-light)
 
 	float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne();
 	float halfTileSizeAtZDistOne = (TILE_SIZE_CLUSTERED/2)*onePixDiagDist;		// scale by half a tile
-	
+
 	for(int l=threadID; l<iNrCoarseLights; l+=NR_THREADS)
 	{
 		SFiniteLightBound lgtDat = g_data[coarseList[l]];
 		[branch]if (_LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
-	
+
 			const float3 boxX = lgtDat.boxAxisX.xyz;
 			const float3 boxY = lgtDat.boxAxisY.xyz;
 			const float3 boxZ = -lgtDat.boxAxisZ.xyz;           // flip axis (so it points away from the light direction for a spot-light)
 				int idx_cur=0, idx_twin=0;
 				float3 vP0, vE0;
 				GetHullEdge(idx_cur, idx_twin, vP0, vE0, e0, boxX, boxY, boxZ, center, scaleXY);
-				
-			
+
+
-				
+
-			
+
 				int positive=0, negative=0;
 				for(int k=1; k<8; k++)		// only need to test 7 verts (technically just 6).
 				{

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/shadeopaque.compute

-#pragma kernel ShadeOpaque_Direct_Fptl                          SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl                              USE_FPTL_LIGHTLIST
-#pragma kernel ShadeOpaque_Direct_Fptl_DebugDisplay             SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl_DebugDisplay                 USE_FPTL_LIGHTLIST        DEBUG_DISPLAY
-#pragma kernel ShadeOpaque_Direct_Clustered                     SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered                         USE_CLUSTERED_LIGHTLIST
-#pragma kernel ShadeOpaque_Direct_Clustered_DebugDisplay        SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered_DebugDisplay            USE_CLUSTERED_LIGHTLIST   DEBUG_DISPLAY
-
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant0               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant0                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=0
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant1               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant1                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=1
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant2               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant2                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=2
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant3               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant3                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=3
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant4               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant4                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=4
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant5               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant5                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=5
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant6               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant6                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=6
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant7               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant7                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=7
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant8               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant8                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=8
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant9               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant9                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=9
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant10              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant10                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=10
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant11              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant11                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=11
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant12              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant12                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=12
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant13              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant13                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=13
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant14              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant14                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=14
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant15              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant15                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=15
-
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant1          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant1              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=1
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant2          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant2              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=2
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant3          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant3              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=3
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant4          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant4              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=4
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant5          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant5              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=5
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant6          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant6              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=6
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant7          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant7              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=7
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant8          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant8              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=8
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant9          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant9              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=9
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant10         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant10             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=10
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant11         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant11             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=11
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant12         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant12             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=12
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant13         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant13             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=13
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant14         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant14             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=14
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant15         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant15             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=15
-
-#pragma #pragma enable_d3d11_debug_symbols
-
-// Split lighting is required for the SSS pass.
-// Not currently possible since we need to access the stencil buffer from the compute shader.
-// #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
-
-#define LIGHTLOOP_TILE_PASS 1
-#define LIGHTLOOP_TILE_DIRECT 1
-#define LIGHTLOOP_TILE_INDIRECT 1
-#define LIGHTLOOP_TILE_ALL 1
-
-//-------------------------------------------------------------------------------------
-// Include
-//-------------------------------------------------------------------------------------
-
-#include "../../../../ShaderLibrary/Common.hlsl"
-#include "../../../Debug/DebugDisplay.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 "../../../ShaderConfig.cs.hlsl"
-#include "../../../ShaderVariables.hlsl"
-#include "../../../Lighting/Lighting.hlsl" // This include Material.hlsl
-#include "../../../Lighting/TilePass/FeatureFlags.hlsl"
-//-------------------------------------------------------------------------------------
-// variable declaration
-//-------------------------------------------------------------------------------------
-
-DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
-
-#ifdef OUTPUT_SPLIT_LIGHTING
-    RWTexture2D<float4> specularLightingUAV;
-    RWTexture2D<float3> diffuseLightingUAV;
-#else
-    RWTexture2D<float4> combinedLightingUAV;
-#endif
-
-#if USE_INDIRECT
-	uint g_TileListOffset;
-    StructuredBuffer<uint> g_TileList;
-// Indirect
-[numthreads(16, 16, 1)]
-void SHADE_OPAQUE_ENTRY(uint2 groupThreadId : SV_GroupThreadID, uint groupId : SV_GroupID)
-{
-    uint tileIndex = g_TileList[g_TileListOffset + groupId];
-    uint2 tileCoord = uint2(tileIndex & 0xFFFF, tileIndex >> 16);
-    uint2 pixelCoord = tileCoord * GetTileSize() + groupThreadId;
-
-    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, tileCoord);
-    uint featureFlags = TileVariantToFeatureFlags(VARIANT);
-#else
-// Direct
-[numthreads(16, 16, 1)]
-void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
-{
-    uint2 pixelCoord = dispatchThreadId;
-    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, groupId);
-	uint featureFlags = 0xFFFFFFFF;
-#endif
-    
-    float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
-    float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
-
-    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-    BSDFData bsdfData;
-    float3 bakeDiffuseLighting;
-    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeDiffuseLighting);
-
-    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
-
-    float3 diffuseLighting;
-    float3 specularLighting;
-    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, featureFlags, diffuseLighting, specularLighting);
-
-#ifdef OUTPUT_SPLIT_LIGHTING
-    specularLightingUAV[pixelCoord] = float4(specularLighting, 1.0);
-    diffuseLightingUAV[pixelCoord]  = diffuseLighting;
-#else
-    combinedLightingUAV[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
-#endif
-}
-
+#pragma kernel ShadeOpaque_Direct_Fptl                          SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl                              USE_FPTL_LIGHTLIST
+#pragma kernel ShadeOpaque_Direct_Fptl_DebugDisplay             SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl_DebugDisplay                 USE_FPTL_LIGHTLIST        DEBUG_DISPLAY
+#pragma kernel ShadeOpaque_Direct_Clustered                     SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered                         USE_CLUSTERED_LIGHTLIST
+#pragma kernel ShadeOpaque_Direct_Clustered_DebugDisplay        SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered_DebugDisplay            USE_CLUSTERED_LIGHTLIST   DEBUG_DISPLAY
+
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant0               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant0                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=0
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant1               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant1                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=1
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant2               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant2                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=2
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant3               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant3                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=3
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant4               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant4                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=4
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant5               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant5                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=5
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant6               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant6                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=6
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant7               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant7                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=7
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant8               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant8                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=8
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant9               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant9                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=9
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant10              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant10                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=10
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant11              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant11                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=11
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant12              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant12                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=12
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant13              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant13                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=13
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant14              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant14                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=14
+#pragma kernel ShadeOpaque_Indirect_Fptl_Variant15              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant15                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=15
+
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant1          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant1              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=1
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant2          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant2              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=2
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant3          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant3              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=3
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant4          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant4              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=4
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant5          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant5              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=5
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant6          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant6              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=6
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant7          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant7              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=7
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant8          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant8              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=8
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant9          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant9              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=9
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant10         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant10             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=10
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant11         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant11             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=11
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant12         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant12             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=12
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant13         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant13             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=13
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant14         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant14             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=14
+#pragma kernel ShadeOpaque_Indirect_Clustered_Variant15         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant15             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=15
+
+#pragma #pragma enable_d3d11_debug_symbols
+
+// Split lighting is required for the SSS pass.
+// Not currently possible since we need to access the stencil buffer from the compute shader.
+// #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
+
+#define LIGHTLOOP_TILE_PASS 1
+#define LIGHTLOOP_TILE_DIRECT 1
+#define LIGHTLOOP_TILE_INDIRECT 1
+#define LIGHTLOOP_TILE_ALL 1
+
+//-------------------------------------------------------------------------------------
+// Include
+//-------------------------------------------------------------------------------------
+
+#include "../../../ShaderLibrary/Common.hlsl"
+#include "../../Debug/DebugDisplay.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 "../../ShaderConfig.cs.hlsl"
+#include "../../ShaderVariables.hlsl"
+#include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
+#include "../../Lighting/TilePass/FeatureFlags.hlsl"
+//-------------------------------------------------------------------------------------
+// variable declaration
+//-------------------------------------------------------------------------------------
+
+DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
+
+#ifdef OUTPUT_SPLIT_LIGHTING
+    RWTexture2D<float4> specularLightingUAV;
+    RWTexture2D<float3> diffuseLightingUAV;
+#else
+    RWTexture2D<float4> combinedLightingUAV;
+#endif
+
+#if USE_INDIRECT
+	uint g_TileListOffset;
+    StructuredBuffer<uint> g_TileList;
+// Indirect
+[numthreads(16, 16, 1)]
+void SHADE_OPAQUE_ENTRY(uint2 groupThreadId : SV_GroupThreadID, uint groupId : SV_GroupID)
+{
+    uint tileIndex = g_TileList[g_TileListOffset + groupId];
+    uint2 tileCoord = uint2(tileIndex & 0xFFFF, tileIndex >> 16);
+    uint2 pixelCoord = tileCoord * GetTileSize() + groupThreadId;
+
+    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, tileCoord);
+    uint featureFlags = TileVariantToFeatureFlags(VARIANT);
+#else
+// Direct
+[numthreads(16, 16, 1)]
+void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
+{
+    uint2 pixelCoord = dispatchThreadId;
+    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, groupId);
+	uint featureFlags = 0xFFFFFFFF;
+#endif
+
+    float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
+    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+    float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
+
+    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
+    BSDFData bsdfData;
+    float3 bakeDiffuseLighting;
+    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeDiffuseLighting);
+
+    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
+
+    float3 diffuseLighting;
+    float3 specularLighting;
+    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, featureFlags, diffuseLighting, specularLighting);
+
+#ifdef OUTPUT_SPLIT_LIGHTING
+    specularLightingUAV[pixelCoord] = float4(specularLighting, 1.0);
+    diffuseLightingUAV[pixelCoord]  = diffuseLighting;
+#else
+    combinedLightingUAV[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
+#endif
+}
+

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "../../../ShaderLibrary/Common.hlsl"
-            #include "../../Debug/DebugDisplay.hlsl"
+            #include "../../ShaderLibrary/Common.hlsl"
+            #include "../Debug/DebugDisplay.hlsl"
-            #include "../../ShaderConfig.cs.hlsl"
-            #include "../../ShaderVariables.hlsl"
-            #include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
+            #include "../ShaderConfig.cs.hlsl"
+            #include "../ShaderVariables.hlsl"
+            #include "../Lighting/Lighting.hlsl" // This include Material.hlsl
 
             //-------------------------------------------------------------------------------------
             // variable declaration

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/DrawGaussianProfile.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "../../../ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderLibrary/Color.hlsl"
-            #include "../../ShaderVariables.hlsl"
+            #include "../../ShaderLibrary/Common.hlsl"
+            #include "../../ShaderLibrary/Color.hlsl"
+            #include "../ShaderVariables.hlsl"
 
             //-------------------------------------------------------------------------------------
             // Inputs & outputs

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/DrawTransmittanceGraph.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "../../../ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderLibrary/Color.hlsl"
-            #include "../../ShaderVariables.hlsl"
+            #include "../../ShaderLibrary/Common.hlsl"
+            #include "../../ShaderLibrary/Color.hlsl"
+            #include "../ShaderVariables.hlsl"
 
             //-------------------------------------------------------------------------------------
             // Inputs & outputs

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/BuildProbabilityTables.compute

 // Ref: PBRT v3, 13.6.7 "Piecewise-Constant 2D Distributions".
 // Note that we use the equiareal sphere-to-square mapping instead of the latitude-longitude one.
 
-#include "../../../ShaderLibrary/Common.hlsl"
-#include "../../../ShaderLibrary/ImageBasedLighting.hlsl"
+#include "../../ShaderLibrary/Common.hlsl"
+#include "../../ShaderLibrary/ImageBasedLighting.hlsl"
 
 /* --- Input --- */
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/ComputeGgxIblSampleData.compute

 // Precomputes data for IntegrateLD(). See that function for a detailed description.
 
-#include "../../../ShaderLibrary/Common.hlsl"
-#include "../../../ShaderLibrary/ImageBasedLighting.hlsl"
+#include "../../ShaderLibrary/Common.hlsl"
+#include "../../ShaderLibrary/ImageBasedLighting.hlsl"
 
 #ifdef SHADER_API_MOBILE
 #define MAX_IBL_SAMPLE_CNT 34

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/GGXConvolve.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #include "../../../ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderLibrary/ImageBasedLighting.hlsl"
-            #include "../SkyManager.cs.hlsl"
+            #include "../../ShaderLibrary/Common.hlsl"
+            #include "../../ShaderLibrary/ImageBasedLighting.hlsl"
+            #include "SkyManager.cs.hlsl"
 
             struct Attributes
             {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/BlitCubemap.shader

             #pragma fragment frag
             #pragma target 4.5
 
-            #include "../../../ShaderLibrary/Common.hlsl"
+            #include "../../ShaderLibrary/Common.hlsl"
 
             TEXTURECUBE(_MainTex);
             SAMPLERCUBE(sampler_MainTex);

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Scenes/Shaders/LDPipe_LitBakedEmission.meta

+fileFormatVersion: 2
+guid: 26a81e742d594d84db3cb22cd86db51e
+folderAsset: yes
+timeCreated: 1496152766
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Scenes/Shaders/LDPipe_LitBakedEmission.unity

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 8
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.2, g: 0.2, b: 0.2, a: 0}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 1
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_TemporalCoherenceThreshold: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 9
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_TextureWidth: 1024
+    m_TextureHeight: 1024
+    m_AO: 1
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 0
+    m_TextureCompression: 1
+    m_FinalGather: 1
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 1
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFiltering: 0
+    m_PVRFilteringMode: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousColorSigma: 1
+    m_PVRFilteringAtrousNormalSigma: 1
+    m_PVRFilteringAtrousPositionSigma: 1
+  m_LightingDataAsset: {fileID: 112000002, guid: b659eb7d7f70e4d4eb5211330bbf8d9c,
+    type: 2}
+  m_UseShadowmask: 0
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1001 &473298562
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalPosition.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalRotation.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalRotation.y
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_RootOrder
+      value: 2
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalScale.x
+      value: 1.5
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalScale.y
+      value: 1.5
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_LocalScale.z
+      value: 1.5
+      objectReference: {fileID: 0}
+    - target: {fileID: 2300000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_CastShadows
+      value: 2
+      objectReference: {fileID: 0}
+    - target: {fileID: 100000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+      propertyPath: m_StaticEditorFlags
+      value: 4294967295
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: b56f0b54c8a1042f3ae9a8904a576f5d, type: 3}
+  m_IsPrefabParent: 0
+--- !u!1 &971756569
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 971756575}
+  - component: {fileID: 971756574}
+  - component: {fileID: 971756573}
+  - component: {fileID: 971756572}
+  - component: {fileID: 971756571}
+  - component: {fileID: 971756570}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &971756570
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 971756569}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c20dfc007a9a74ad8a2bfd0d59abe398, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  renderPipeline: {fileID: 11400000, guid: 877878ed40e8ad94095582ff91179016, type: 2}
+  cameraToUse: {fileID: 971756574}
+  hdr: 0
+  width: 1280
+  height: 720
+--- !u!81 &971756571
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 971756569}
+  m_Enabled: 1
+--- !u!124 &971756572
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 971756569}
+  m_Enabled: 1
+--- !u!92 &971756573
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 971756569}
+  m_Enabled: 1
+--- !u!20 &971756574
+Camera:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 971756569}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 2
+  m_BackGroundColor: {r: 0.2509804, g: 0.2509804, b: 0.2509804, a: 1}
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 10
+  field of view: 30
+  orthographic: 0
+  orthographic size: 1
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 0
+  m_AllowMSAA: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+  m_StereoMirrorMode: 0
+--- !u!4 &971756575
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 971756569}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1.5, z: -6}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1161206970
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1161206972}
+  - component: {fileID: 1161206971}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 4294967295
+  m_IsActive: 1
+--- !u!108 &1161206971
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1161206970}
+  m_Enabled: 1
+  serializedVersion: 8
+  m_Type: 1
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 2
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 2
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_FalloffTable:
+    m_Table[0]: 0
+    m_Table[1]: 0
+    m_Table[2]: 0
+    m_Table[3]: 0
+    m_Table[4]: 0
+    m_Table[5]: 0
+    m_Table[6]: 0
+    m_Table[7]: 0
+    m_Table[8]: 0
+    m_Table[9]: 0
+    m_Table[10]: 0
+    m_Table[11]: 0
+    m_Table[12]: 0
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 5
+--- !u!4 &1161206972
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1161206970}
+  m_LocalRotation: {x: 0.7132504, y: 0, z: 0, w: 0.7009094}
+  m_LocalPosition: {x: 0, y: 3, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 91, y: 0, z: 0}
+--- !u!1 &1354589631
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1354589635}
+  - component: {fileID: 1354589634}
+  - component: {fileID: 1354589633}
+  - component: {fileID: 1354589632}
+  m_Layer: 0
+  m_Name: Sphere
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 4294967295
+  m_IsActive: 1
+--- !u!23 &1354589632
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1354589631}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: 4fe532de4bae248f4bfff4daa180fa2d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!135 &1354589633
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1354589631}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &1354589634
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1354589631}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1354589635
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1354589631}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1.511, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1755136017
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1755136019}
+  - component: {fileID: 1755136018}
+  m_Layer: 0
+  m_Name: TEMPLIGHT_DELETE ME
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!108 &1755136018
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1755136017}
+  m_Enabled: 1
+  serializedVersion: 8
+  m_Type: 1
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 0.001
+  m_Range: 10
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 1
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_FalloffTable:
+    m_Table[0]: 0
+    m_Table[1]: 0
+    m_Table[2]: 0
+    m_Table[3]: 0
+    m_Table[4]: 0
+    m_Table[5]: 0
+    m_Table[6]: 0
+    m_Table[7]: 0
+    m_Table[8]: 0
+    m_Table[9]: 0
+    m_Table[10]: 0
+    m_Table[11]: 0
+    m_Table[12]: 0
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+--- !u!4 &1755136019
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1755136017}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 1.2441416, y: 3.61, z: -3.0811512}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Scenes/Shaders/LDPipe_LitBakedEmission.unity.meta

+fileFormatVersion: 2
+guid: e23c793ace3c4a146a73360af1600fbd
+timeCreated: 1493306791
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/Core/Debugging/DebugItemHandler.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public abstract class DebugItemHandler
+    {
+        protected DebugItem m_DebugItem = null;
+
+        public void SetDebugItem(DebugItem item)
+        {
+            m_DebugItem = item;
+        }
+
+        // Method user needs to override for specific value clamping.
+        public virtual void ClampValues(Func<object> getter, Action<object> setter) {}
+        // Method that will create UI items for runtime debug menu.
+        public abstract DebugItemUI BuildGUI(GameObject parent);
+
+#if UNITY_EDITOR
+        // Method users need to override for editor specific UI
+        public abstract bool OnEditorGUIImpl();
+        public void OnEditorGUI()
+        {
+            if(OnEditorGUIImpl())
+            {
+                DebugMenuUI.changed = true;
+            }
+        }
+#endif
+
+        // Method users need to override for specific serialization of custom types.
+        public abstract DebugItemState CreateDebugItemState();
+    }
+
+    // This is the default debug item handler that handles all basic types.
+    public class DefaultDebugItemHandler
+        : DebugItemHandler
+    {
+        bool m_IsInitialized = false;
+
+        // Label for simple GUI items
+        protected GUIContent m_Label;
+
+        // Values and strings for Enum items
+        protected List<GUIContent>  m_EnumStrings = null;
+        protected List<int>         m_EnumValues = null;
+
+        public void Initialize()
+        {
+            if (m_IsInitialized)
+                return;
+
+            m_Label = new GUIContent(m_DebugItem.name);
+            Type itemType = m_DebugItem.GetItemType();
+            if(itemType.BaseType == typeof(System.Enum))
+            {
+                Array arr = Enum.GetValues(itemType);
+                m_EnumStrings = new List<GUIContent>(arr.Length);
+                m_EnumValues = new List<int>(arr.Length);
+
+                foreach(var value in arr)
+                {
+                    m_EnumStrings.Add(new GUIContent(value.ToString()));
+                    m_EnumValues.Add((int)value);
+                }
+            }
+        }
+
+        public override DebugItemState CreateDebugItemState()
+        {
+            DebugItemState newItemState = null;
+            if (m_DebugItem.GetItemType() == typeof(bool))
+            {
+                newItemState = ScriptableObject.CreateInstance<DebugItemStateBool>();
+            }
+            else if (m_DebugItem.GetItemType() == typeof(int))
+            {
+                newItemState = ScriptableObject.CreateInstance<DebugItemStateInt>();
+            }
+            else if (m_DebugItem.GetItemType() == typeof(uint))
+            {
+                newItemState = ScriptableObject.CreateInstance<DebugItemStateUInt>();
+            }
+            else if (m_DebugItem.GetItemType() == typeof(float))
+            {
+                newItemState = ScriptableObject.CreateInstance<DebugItemStateFloat>();
+            }
+            else if (m_DebugItem.GetItemType() == typeof(Color))
+            {
+                newItemState = ScriptableObject.CreateInstance<DebugItemStateColor>();
+            }
+            else if (m_DebugItem.GetItemType().BaseType == typeof(System.Enum))
+            {
+                newItemState = ScriptableObject.CreateInstance<DebugItemStateInt>(); // Need to be serialized as int. For some reason serialization of the Enum directly just fails...
+            }
+
+            return newItemState;
+        }
+
+        public override DebugItemUI BuildGUI(GameObject parent)
+        {
+            Initialize();
+
+            DebugItemUI newItemUI = null;
+            if (m_DebugItem.GetItemType() == typeof(bool))
+            {
+                newItemUI = new DebugBoolItemUI(parent, m_DebugItem, m_Label.text);
+            }
+            else if (m_DebugItem.GetItemType() == typeof(int))
+            {
+                newItemUI = new DebugIntItemUI(parent, m_DebugItem, m_Label.text);
+            }
+            else if (m_DebugItem.GetItemType() == typeof(uint))
+            {
+                newItemUI = new DebugUIntItemUI(parent, m_DebugItem, m_Label.text);
+            }
+            else if (m_DebugItem.GetItemType() == typeof(float))
+            {
+                newItemUI = new DebugFloatItemUI(parent, m_DebugItem, m_Label.text);
+            }
+            else if (m_DebugItem.GetItemType() == typeof(Color))
+            {
+                newItemUI = new DebugColorItemUI(parent, m_DebugItem, m_Label.text);
+            }
+            else if (m_DebugItem.GetItemType().BaseType == typeof(System.Enum))
+            {
+                newItemUI = new DebugEnumItemUI(parent, m_DebugItem, m_Label.text, m_EnumStrings.ToArray(), m_EnumValues.ToArray());
+            }
+
+            return newItemUI;
+        }
+
+#if UNITY_EDITOR
+        bool DrawBoolItem()
+        {
+            bool value = (bool)m_DebugItem.GetValue();
+
+            EditorGUI.BeginChangeCheck();
+            value = EditorGUILayout.Toggle(m_Label, value);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_DebugItem.SetValue(value);
+                return true;
+            }
+
+            return false;
+        }
+
+        bool DrawIntItem()
+        {
+            int value = (int)m_DebugItem.GetValue();
+            EditorGUI.BeginChangeCheck();
+            value = EditorGUILayout.IntField(m_Label, value);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_DebugItem.SetValue(value);
+                return true;
+            }
+
+            return false;
+        }
+
+        bool DrawUIntItem()
+        {
+            int value = (int)(uint)m_DebugItem.GetValue();
+            EditorGUI.BeginChangeCheck();
+            value = EditorGUILayout.IntField(m_Label, value);
+            if (EditorGUI.EndChangeCheck())
+            {
+                value = System.Math.Max(0, value);
+                m_DebugItem.SetValue((uint)value);
+                return true;
+            }
+
+            return false;
+        }
+
+        bool DrawFloatItem()
+        {
+            float value = (float)m_DebugItem.GetValue();
+            EditorGUI.BeginChangeCheck();
+            value = EditorGUILayout.FloatField(m_Label, value);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_DebugItem.SetValue(value);
+                return true;
+            }
+
+            return false;
+        }
+
+        bool DrawColorItem()
+        {
+            EditorGUI.BeginChangeCheck();
+            Color value = EditorGUILayout.ColorField(m_Label, (Color)m_DebugItem.GetValue());
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_DebugItem.SetValue(value);
+                return true;
+            }
+
+            return false;
+        }
+
+        bool DrawEnumItem()
+        {
+            EditorGUI.BeginChangeCheck();
+            int value = EditorGUILayout.IntPopup(m_Label, (int)m_DebugItem.GetValue(), m_EnumStrings.ToArray(), m_EnumValues.ToArray());
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_DebugItem.SetValue(value);
+                return true;
+            }
+
+            return false;
+        }
+
+        public override bool OnEditorGUIImpl()
+        {
+            Initialize();
+
+            if (m_DebugItem.readOnly)
+            {
+                EditorGUILayout.LabelField(m_Label, new GUIContent(m_DebugItem.GetValue().ToString()));
+                return false;
+            }
+
+            if (m_DebugItem.GetItemType() == typeof(bool))
+            {
+                return DrawBoolItem();
+            }
+            else if (m_DebugItem.GetItemType() == typeof(int))
+            {
+                return DrawIntItem();
+            }
+            else if(m_DebugItem.GetItemType() == typeof(uint))
+            {
+                return DrawUIntItem();
+            }
+            else if (m_DebugItem.GetItemType() == typeof(float))
+            {
+                return DrawFloatItem();
+            }
+            else if (m_DebugItem.GetItemType() == typeof(Color))
+            {
+                return DrawColorItem();
+            }
+            else if (m_DebugItem.GetItemType().BaseType == typeof(System.Enum))
+            {
+                return DrawEnumItem();
+            }
+
+            return false;
+        }
+#endif
+}
+
+    public class DebugItemHandlerFloatMinMax
+        : DefaultDebugItemHandler
+    {
+        float m_Min = 0.0f;
+        float m_Max = 1.0f;
+        public DebugItemHandlerFloatMinMax(float min, float max)
+        {
+            m_Min = min;
+            m_Max = max;
+        }
+
+        public override void ClampValues(Func<object> getter, Action<object> setter)
+        {
+            setter(Mathf.Clamp((float)getter(), m_Min, m_Max));
+        }
+
+#if UNITY_EDITOR
+        public override bool OnEditorGUIImpl()
+        {
+            Initialize();
+
+            EditorGUI.BeginChangeCheck();
+            float value = EditorGUILayout.Slider(m_DebugItem.name, (float)m_DebugItem.GetValue(), m_Min, m_Max);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_DebugItem.SetValue(value);
+                return true;
+            }
+
+            return false;
+        }
+#endif
+    }
+
+    public class DebugItemHandlerIntEnum
+        : DefaultDebugItemHandler
+    {
+        GUIContent[]    m_IntEnumStrings = null;
+        int[]           m_IntEnumValues = null;
+
+        public DebugItemHandlerIntEnum(GUIContent[] enumStrings, int[] enumValues)
+        {
+            m_IntEnumStrings = enumStrings;
+            m_IntEnumValues = enumValues;
+        }
+
+        public override DebugItemUI BuildGUI(GameObject parent)
+        {
+            Initialize();
+
+            return new DebugEnumItemUI(parent, m_DebugItem, m_Label.text, m_IntEnumStrings, m_IntEnumValues);
+        }
+
+#if UNITY_EDITOR
+        public override bool OnEditorGUIImpl()
+        {
+            Initialize();
+
+            UnityEditor.EditorGUI.BeginChangeCheck();
+            int value = UnityEditor.EditorGUILayout.IntPopup(m_Label, (int)m_DebugItem.GetValue(), m_IntEnumStrings, m_IntEnumValues);
+            if (UnityEditor.EditorGUI.EndChangeCheck())
+            {
+                m_DebugItem.SetValue(value);
+                return true;
+            }
+
+            return false;
+        }
+#endif
+    }
+
+}

Assets/ScriptableRenderPipeline/Core/Debugging/DebugItemUI.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    // Class that users need to extend for runtime debug menu item UI
+    public abstract class DebugItemUI
+    {
+        protected GameObject    m_Root = null;
+        protected DebugItem     m_DebugItem = null;
+
+        public bool dynamicDisplay { get { return m_DebugItem.dynamicDisplay; } }
+
+        protected DebugItemUI(DebugItem debugItem)
+        {
+            m_DebugItem = debugItem;
+        }
+
+        // Implement for selection specific beahavior (like changing color for example)
+        public abstract void SetSelected(bool value);
+        // Implement behavior when user execute the "Validate" action
+        public abstract void OnValidate();
+        // Implement behavior when user execute the "Increment" action
+        public abstract void OnIncrement();
+        // Implement behavior when user execute the "Decrement" action
+        public abstract void OnDecrement();
+        // Implement this method to update the UI with current item value.
+        // User must call it whenever Validate/Increment/Decrement is called. It will also be automatically called for dynamically displayed items.
+        public abstract void Update();
+    }
+
+    public class DebugSimpleItemUI : DebugItemUI
+    {
+        protected GameObject m_Name = null;
+        protected GameObject m_Value = null;
+
+        protected DebugSimpleItemUI(GameObject parent, DebugItem debugItem, string name)
+            : base(debugItem)
+        {
+
+            m_Root = DebugMenuUI.CreateHorizontalLayoutGroup("", true, true, false, false, parent);
+            m_Name = DebugMenuUI.CreateTextElement(m_DebugItem.name, name, 10, TextAnchor.MiddleLeft, m_Root);
+            var layoutElem = m_Name.AddComponent<UI.LayoutElement>();
+            layoutElem.minWidth = DebugMenuUI.kDebugItemNameWidth;
+            m_Value = DebugMenuUI.CreateTextElement(string.Format("{0} value", name), "", 10, TextAnchor.MiddleLeft, m_Root);
+        }
+
+        public override void SetSelected(bool value)
+        {
+            m_Name.GetComponent<UI.Text>().color = value ? DebugMenuUI.kColorSelected : DebugMenuUI.kColorUnSelected;
+            m_Value.GetComponent<UI.Text>().color = value ? DebugMenuUI.kColorSelected : DebugMenuUI.kColorUnSelected;
+        }
+
+        public override void OnValidate()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override void OnIncrement()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override void OnDecrement()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override void Update()
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+
+    public class DebugBoolItemUI : DebugSimpleItemUI
+    {
+        public DebugBoolItemUI(GameObject parent, DebugItem debugItem, string name)
+            : base(parent, debugItem, name)
+        {
+            Update();
+        }
+
+        public override void Update()
+        {
+            m_Value.GetComponent<UI.Text>().text = (bool)m_DebugItem.GetValue() ? "True" : "False";
+        }
+
+
+        public override void OnValidate()
+        {
+            m_DebugItem.SetValue(!(bool)m_DebugItem.GetValue());
+            Update();
+        }
+
+        public override void OnIncrement()
+        {
+            OnValidate();
+        }
+
+        public override void OnDecrement()
+        {
+            OnValidate();
+        }
+    }
+
+    public class DebugFloatItemUI : DebugSimpleItemUI
+    {
+        bool m_SelectIncrementMode = false;
+        int m_CurrentIncrementIndex = -1;
+
+        public DebugFloatItemUI(GameObject parent, DebugItem debugItem, string name)
+            : base(parent, debugItem, name)
+        {
+            Update();
+        }
+
+        public override void Update()
+        {
+            float currentValue = (float)m_DebugItem.GetValue();
+            bool isNegative = currentValue < 0.0f;
+            // Easier to format the string without caring about the '-' sign. We add it back at the end
+            currentValue = Mathf.Abs(currentValue);
+
+            char separator = System.Convert.ToChar(System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator);
+
+            // Start with the maximum amount of trailing zeros
+            string valueWithMaxDecimals = string.Format("{0:0.00000}", currentValue);
+
+            // Remove trailing zeros until we reach the separator or we reach the decimal we are currently editing.
+            int separatorIndex = valueWithMaxDecimals.LastIndexOf(separator);
+            int index = valueWithMaxDecimals.Length - 1;
+            while (
+                valueWithMaxDecimals[index] == '0' // Remove trailing zeros
+                && index > (separatorIndex + 1) // until we reach the separator
+                && index > (System.Math.Abs(m_CurrentIncrementIndex) + separatorIndex)) // Or it's the index of the current decimal being edited (so as to display the last trailing zero in this case)
+            {
+                index--;
+            }
+
+            string finalValue = new string(valueWithMaxDecimals.ToCharArray(), 0, index + 1);
+
+            // Add leading zeros until we reach where the current order is being edited.
+            if(m_CurrentIncrementIndex > 0)
+            {
+                float incrementValue = Mathf.Pow(10.0f, (float)m_CurrentIncrementIndex);
+                if(incrementValue > currentValue)
+                {
+                    float compareValue = currentValue + 1.0f; // Start at 1.0f because we know that we are going to increment by 10 or more
+                    while (incrementValue > compareValue)
+                    {
+                        finalValue = finalValue.Insert(0, "0");
+                        compareValue *= 10.0f;
+                    }
+                }
+            }
+
+            // When selecting which decimal/order you want to edit, we show brackets around the figure to show the user.
+            if(m_SelectIncrementMode)
+            {
+                separatorIndex = finalValue.LastIndexOf(separator); // separator may have changed place if we added leading zeros
+                int bracketIndex = separatorIndex - m_CurrentIncrementIndex;
+                if(m_CurrentIncrementIndex >= 0) // Skip separator
+                    bracketIndex -= 1;
+
+                finalValue = finalValue.Insert(bracketIndex, "[");
+                finalValue = finalValue.Insert(bracketIndex + 2, "]");
+            }
+
+            if(isNegative)
+                finalValue = finalValue.Insert(0, "-");
+
+            m_Value.GetComponent<UI.Text>().text = finalValue;
+        }
+
+        public override void OnValidate()
+        {
+            m_SelectIncrementMode = !m_SelectIncrementMode;
+            Update();
+        }
+
+        public override void OnIncrement()
+        {
+            if(!m_SelectIncrementMode)
+            {
+                m_DebugItem.SetValue((float)m_DebugItem.GetValue() + Mathf.Pow(10.0f, (float)m_CurrentIncrementIndex));
+            }
+            else
+            {
+                m_CurrentIncrementIndex -= 1; // * 0.1 (10^m_CurrentIncrementIndex)
+                m_CurrentIncrementIndex = System.Math.Max(-5, m_CurrentIncrementIndex);
+            }
+            Update();
+        }
+
+        public override void OnDecrement()
+        {
+            if (!m_SelectIncrementMode)
+            {
+                m_DebugItem.SetValue((float)m_DebugItem.GetValue() - Mathf.Pow(10.0f, (float)m_CurrentIncrementIndex));
+            }
+            else
+            {
+                m_CurrentIncrementIndex += 1; // * 10 (10^m_CurrentIncrementIndex)
+            }
+            Update();            
+        }
+    }
+
+    // Everything is done with int. We don't really care about values > 2b for debugging.
+    public class DebugIntegerItemUI : DebugSimpleItemUI
+    {
+        bool m_SelectIncrementMode = false;
+        int m_CurrentIncrementIndex = 0;
+
+        public DebugIntegerItemUI(GameObject parent, DebugItem debugItem, string name)
+            : base(parent, debugItem, name)
+        {
+        }
+
+        protected void UpdateText(int value)
+        {
+            bool isNegative = value < 0f;
+            // Easier to format the string without caring about the '-' sign. We add it back at the end
+            value = System.Math.Abs(value);
+
+            string finalValue = string.Format("{0}", value);
+
+            // Add leading zeros until we reach where the current order is being edited.
+            if(m_CurrentIncrementIndex > 0)
+            {
+                int incrementValue = (int)System.Math.Pow(10, m_CurrentIncrementIndex);
+                if(incrementValue > value)
+                {
+                    int compareValue = System.Math.Max(value, 1);
+                    while (incrementValue > compareValue)
+                    {
+                        finalValue = finalValue.Insert(0, "0");
+                        compareValue *= 10;
+                    }
+                }
+            }
+
+            // When selecting which decimal/order you want to edit, we show brackets around the figure to show the user.
+            if(m_SelectIncrementMode)
+            {
+                int bracketIndex = finalValue.Length - 1 - m_CurrentIncrementIndex;
+
+                finalValue = finalValue.Insert(bracketIndex, "[");
+                finalValue = finalValue.Insert(bracketIndex + 2, "]");
+            }
+
+            if(isNegative)
+                finalValue = finalValue.Insert(0, "-");
+
+            m_Value.GetComponent<UI.Text>().text = finalValue;
+        }
+
+        protected virtual int GetIntegerValue()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        protected virtual void SetIntegerValue(int value)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override void Update()
+        {
+            UpdateText(GetIntegerValue());
+        }
+
+        public override void OnValidate()
+        {
+            m_SelectIncrementMode = !m_SelectIncrementMode;
+            Update();
+        }
+
+        public override void OnIncrement()
+        {
+            if (!m_SelectIncrementMode)
+            {
+                SetIntegerValue(GetIntegerValue() + (int)Mathf.Pow(10.0f, (float)m_CurrentIncrementIndex));
+            }
+            else
+            {
+                m_CurrentIncrementIndex -= 1; // *= 0.1 (10^m_CurrentIncrementIndex)
+                m_CurrentIncrementIndex = System.Math.Max(0, m_CurrentIncrementIndex);
+            }
+            Update();
+        }
+
+        public override void OnDecrement()
+        {
+            if (!m_SelectIncrementMode)
+            {
+                SetIntegerValue(GetIntegerValue() - (int)Mathf.Pow(10.0f, (float)m_CurrentIncrementIndex));
+            }
+            else
+            {
+                m_CurrentIncrementIndex += 1; // *= 10 (10^m_CurrentIncrementIndex)
+                m_CurrentIncrementIndex = System.Math.Max(0, m_CurrentIncrementIndex);
+            }
+            Update();
+        }
+    }
+    public class DebugIntItemUI : DebugIntegerItemUI
+    {
+        public DebugIntItemUI(GameObject parent, DebugItem debugItem, string name)
+            : base(parent, debugItem, name)
+        {
+            UpdateText((int)m_DebugItem.GetValue());
+        }
+
+        protected override int GetIntegerValue()
+        {
+            return (int)m_DebugItem.GetValue();
+        }
+
+        protected override void SetIntegerValue(int value)
+        {
+            m_DebugItem.SetValue(value);
+        }
+    }
+
+    public class DebugUIntItemUI : DebugIntegerItemUI
+    {
+        public DebugUIntItemUI(GameObject parent, DebugItem debugItem, string name)
+            : base(parent, debugItem, name)
+        {
+            UpdateText((int)(uint)m_DebugItem.GetValue());
+        }
+
+        protected override int GetIntegerValue()
+        {
+            return (int)(uint)m_DebugItem.GetValue();
+        }
+
+        protected override void SetIntegerValue(int value)
+        {
+            m_DebugItem.SetValue((uint)System.Math.Max(0, value));
+        }
+    }
+
+    public class DebugEnumItemUI : DebugSimpleItemUI
+    {
+        int                 m_CurrentValueIndex = 0;
+        GUIContent[]        m_ValueNames;
+        int[]               m_Values;
+
+        public DebugEnumItemUI(GameObject parent, DebugItem debugItem, string name, GUIContent[] valueNames, int[] values)
+            : base(parent, debugItem, name)
+        {
+            m_Values = values;
+            m_ValueNames = valueNames;
+            m_CurrentValueIndex = FindIndexForValue((int)m_DebugItem.GetValue());
+
+            Update();
+        }
+
+        private int FindIndexForValue(int value)
+        {
+            for(int i = 0 ; i < m_Values.Length ; ++i)
+            {
+                if (m_Values[i] == value)
+                    return i;
+            }
+
+            return -1;
+        }
+
+        public override void Update()
+        {
+            if(m_CurrentValueIndex != -1)
+            {
+                m_Value.GetComponent<UI.Text>().text = m_ValueNames[m_CurrentValueIndex].text;
+            }
+        }
+
+        public override void OnValidate()
+        {
+            OnIncrement();
+        }
+
+        public override void OnIncrement()
+        {
+            m_CurrentValueIndex = (m_CurrentValueIndex + 1) % m_Values.Length;
+            m_DebugItem.SetValue(m_Values[m_CurrentValueIndex]);
+            Update();
+        }
+
+        public override void OnDecrement()
+        {
+            m_CurrentValueIndex -= 1;
+            if (m_CurrentValueIndex < 0)
+                m_CurrentValueIndex = m_Values.Length - 1;
+
+            m_DebugItem.SetValue(m_Values[m_CurrentValueIndex]);
+            Update();
+        }
+    }
+
+    public class DebugColorItemUI : DebugItemUI
+    {
+        protected GameObject m_Name = null;
+        protected GameObject m_ColorRect = null;
+
+        public DebugColorItemUI(GameObject parent, DebugItem debugItem, string name)
+            : base(debugItem)
+        {
+            m_DebugItem = debugItem;
+
+            m_Root = DebugMenuUI.CreateHorizontalLayoutGroup(name, true, true, false, false, parent);
+
+            m_Name = DebugMenuUI.CreateTextElement(m_DebugItem.name, name, 10, TextAnchor.MiddleLeft, m_Root);
+            var layoutElemName = m_Name.AddComponent<UI.LayoutElement>();
+            layoutElemName.minWidth = DebugMenuUI.kDebugItemNameWidth;
+
+            // Force layout because we need the right height for the color rect element afterward.
+            UI.LayoutRebuilder.ForceRebuildLayoutImmediate(m_Root.GetComponent<RectTransform>());
+            RectTransform nameRect = m_Name.GetComponent<RectTransform>();
+
+            m_ColorRect = new GameObject();
+            m_ColorRect.transform.SetParent(m_Root.transform, false);
+            m_ColorRect.AddComponent<UI.Image>();
+            UI.LayoutElement layoutElem = m_ColorRect.AddComponent<UI.LayoutElement>();
+            // We need to set min width/height because without an image, the size would be zero.
+            layoutElem.minHeight = nameRect.rect.height;
+            layoutElem.minWidth = 40.0f;
+
+            Update();
+        }
+
+        public override void Update()
+        {
+            Color currentValue = (Color)m_DebugItem.GetValue();
+            UI.Image image = m_ColorRect.GetComponent<UI.Image>();
+            image.color = currentValue;
+        }
+
+        public override void SetSelected(bool value)
+        {
+            m_Name.GetComponent<UI.Text>().color = value ? DebugMenuUI.kColorSelected : DebugMenuUI.kColorUnSelected;
+        }
+
+        // TODO: Edit mode!
+        public override void OnValidate()
+        {
+        }
+
+        public override void OnIncrement()
+        {
+        }
+
+        public override void OnDecrement()
+        {
+        }
+    }
+}

Assets/ScriptableRenderPipeline/Core/Debugging/DebugMenuState.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    [Serializable]
+    public abstract class DebugItemState
+        : ScriptableObject
+    {
+        public DebugItemState()
+        {
+
+        }
+
+        public string panelName = "";
+        public string itemName = "";
+
+        public abstract void UpdateDebugItemValue();
+        public abstract void SetValue(object value);
+
+        public void Initialize(string itemName, string panelName)
+        {
+            this.panelName = panelName;
+            this.itemName = itemName;
+        }
+    }
+
+    public class DebugItemState<T> : DebugItemState
+    {
+        public T value;
+
+        public override void SetValue(object value)
+        {
+#if UNITY_EDITOR
+            UnityEditor.Undo.RecordObject(this, "DebugMenu State Update");
+            UnityEditor.EditorUtility.SetDirty(this);
+#endif
+            this.value = (T)value;
+        }
+
+        public override void UpdateDebugItemValue()
+        {
+            DebugMenuManager dmm = DebugMenuManager.instance;
+            DebugPanel menu = dmm.GetDebugPanel(panelName);
+            if (menu != null)
+            {
+                DebugItem item = menu.GetDebugItem(itemName);
+                if (item != null)
+                {
+                    item.SetValue(value, false);
+                }
+            }
+
+        }
+    }
+
+    public class DebugMenuState
+        : ScriptableObject
+    {
+        [SerializeField]
+        List<DebugItemState> m_ItemStateList = new List<DebugItemState>();
+
+        public void OnEnable()
+        {
+#if UNITY_EDITOR
+            UnityEditor.Undo.undoRedoPerformed += OnUndoRedoPerformed;
+#endif
+
+            // We need to delay the actual update because at this point, some menus might not be created yet (depending on call order) so we can't update their values.
+            DebugMenuManager.instance.RequireUpdateFromDebugItemState();
+        }
+
+        public void OnDisable()
+        {
+#if UNITY_EDITOR
+            UnityEditor.Undo.undoRedoPerformed -= OnUndoRedoPerformed;
+#endif
+            // We check consistency in OnDisable instead of OnEnable because we compare the serialized state to the currently running debug menu so we need to make sure that all debug menu are properly created (which is not the case in OnEnable depending on call order)
+            CheckConsistency();
+        }
+
+
+#if UNITY_EDITOR
+        void OnUndoRedoPerformed()
+        {
+            // Maybe check a hash or something? So that we don't do that at each redo...
+            UpdateAllDebugItems();
+            UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+        }
+#endif
+
+        void CheckConsistency()
+        {
+            // Remove all objects that may have been removed from the debug menu since last serialization
+            DebugMenuManager dmm = DebugMenuManager.instance;
+            List<DebugItemState> tempList = new List<DebugItemState>();
+            foreach(var itemState in  m_ItemStateList)
+            {
+                DebugItem item = null;
+                DebugPanel menu = dmm.GetDebugPanel(itemState.panelName);
+                if(menu != null)
+                {
+                    item = menu.GetDebugItem(itemState.itemName);
+                }
+
+                // Item no longer exist, clean up its state from the asset.
+                if (item == null)
+                {
+                    tempList.Add(itemState);
+                }
+            }
+
+            foreach(var itemState in tempList)
+            {
+                m_ItemStateList.Remove(itemState);
+                Object.DestroyImmediate(itemState, true);
+            }
+        }
+
+        public void AddDebugItemState(DebugItemState state)
+        {
+#if UNITY_EDITOR
+            UnityEditor.AssetDatabase.AddObjectToAsset(state, this);
+#endif
+            m_ItemStateList.Add(state);
+        }
+
+        public DebugItemState FindDebugItemState(string itemName, string menuName)
+        {
+            return m_ItemStateList.Find(x => x.itemName == itemName && x.panelName == menuName);
+        }
+
+        public void UpdateAllDebugItems()
+        {
+            foreach (var itemState in m_ItemStateList)
+            {
+                itemState.UpdateDebugItemValue();
+            }
+        }
+    }
+}

Assets/ScriptableRenderPipeline/Core/Debugging/DebugMenuState.cs.meta

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

Assets/ScriptableRenderPipeline/Core/Debugging/DebugPanel.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class DebugItem
+    {
+        public Type             type            { get { return m_Type; } }
+        public string           name            { get { return m_Name; } }
+        public DebugItemHandler handler          { get { return m_Handler; } }
+        public bool             dynamicDisplay  { get { return m_DynamicDisplay; } }
+        public bool             readOnly        { get { return m_Setter == null; } }
+
+        public DebugItem(string name, Type type, Func<object> getter, Action<object> setter, bool dynamicDisplay = false, DebugItemHandler handler = null)
+        {
+            m_Type = type;
+            m_Setter = setter;
+            m_Getter = getter;
+            m_Name = name;
+            m_Handler = handler;
+            m_DynamicDisplay = dynamicDisplay;
+        }
+
+        public Type GetItemType()
+        {
+            return m_Type;
+        }
+
+        public void SetValue(object value, bool record = true)
+        {
+            // Setter can be null for readonly items
+            if(m_Setter != null)
+            {
+                m_Setter(value);
+                m_Handler.ClampValues(m_Getter, m_Setter);
+
+                // Update state for serialization/undo
+                if(record)
+                    m_State.SetValue(m_Getter());
+            }
+        }
+
+        public object GetValue()
+        {
+            return m_Getter();
+        }
+
+        public void SetDebugItemState(DebugItemState state)
+        {
+            m_State = state;
+        }
+
+        Func<object>        m_Getter;
+        Action<object>      m_Setter;
+        Type                m_Type;
+        string              m_Name;
+        DebugItemHandler    m_Handler = null;
+        bool                m_DynamicDisplay = false;
+        DebugItemState      m_State = null;
+    }
+
+    public class DebugPanel
+    {
+        public string       name        { get { return m_Name; } }
+        public DebugPanelUI panelUI     { get { return m_DebugPanelUI; } }
+        public int          itemCount   { get { return m_Items.Count; } }
+
+        protected string            m_Name = "Unknown Debug Menu";
+        protected List<DebugItem>   m_Items = new List<DebugItem>();
+        protected DebugPanelUI      m_DebugPanelUI = null;
+
+        protected DebugPanel(string name)
+        {
+            m_Name = name;
+        }
+
+        public DebugItem GetDebugItem(int index)
+        {
+            if (index >= m_Items.Count || index < 0)
+                return null;
+            return m_Items[index];
+        }
+
+        public DebugItem GetDebugItem(string name)
+        {
+            return m_Items.Find(x => x.name == name);
+        }
+
+        public bool HasDebugItem(DebugItem debugItem)
+        {
+            foreach(var item in m_Items)
+            {
+                if (debugItem == item)
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void RemoveDebugItem(DebugItem debugItem)
+        {
+            m_Items.Remove(debugItem);
+            m_DebugPanelUI.RebuildGUI();
+        }
+
+        public void AddDebugItem(DebugItem debugItem)
+        {
+            m_Items.Add(debugItem);
+            m_DebugPanelUI.RebuildGUI();
+        }
+
+        public void AddDebugItem<ItemType>(string name, Func<object> getter, Action<object> setter, bool dynamicDisplay = false, DebugItemHandler handler = null)
+        {
+            if (handler == null)
+                handler = new DefaultDebugItemHandler();
+            DebugItem newItem = new DebugItem(name, typeof(ItemType), getter, setter, dynamicDisplay, handler);
+            handler.SetDebugItem(newItem);
+            m_Items.Add(newItem);
+
+            DebugMenuManager dmm = DebugMenuManager.instance;
+            DebugItemState itemState = dmm.FindDebugItemState(name, m_Name);
+            if(itemState == null)
+            {
+                itemState = handler.CreateDebugItemState();
+                itemState.Initialize(name, m_Name);
+                itemState.SetValue(getter());
+                dmm.AddDebugItemState(itemState);
+            }
+
+            newItem.SetDebugItemState(itemState);
+        }
+    }
+
+    public class DebugPanel<DebugPanelUIClass>
+        : DebugPanel where DebugPanelUIClass:DebugPanelUI, new()
+    {
+        public DebugPanel(string name)
+            : base(name)
+        {
+            m_DebugPanelUI = new DebugPanelUIClass();
+            m_DebugPanelUI.SetDebugPanel(this);
+        }
+    }
+}

Assets/ScriptableRenderPipeline/Core/Debugging/DebugPanelUI.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class DebugPanelUI
+    {
+        protected GameObject        m_Root = null;
+        protected DebugPanel        m_DebugPanel = null;
+        protected List<DebugItemUI> m_ItemsUI = new List<DebugItemUI>();
+        protected int               m_SelectedItem = -1;
+
+        public int itemCount { get { return m_ItemsUI.Count; } }
+
+        public DebugPanelUI()
+        {
+        }
+
+        public void SetDebugPanel(DebugPanel panel)
+        {
+            m_DebugPanel = panel;
+        }
+
+        public void BuildGUI(GameObject parent)
+        {
+            m_Root = new GameObject(string.Format("{0}", m_DebugPanel.name));
+            m_Root.transform.SetParent(parent.transform);
+            m_Root.transform.localPosition = Vector3.zero;
+            m_Root.transform.localScale = Vector3.one;
+
+            UI.VerticalLayoutGroup menuVL = m_Root.AddComponent<UI.VerticalLayoutGroup>();
+            menuVL.spacing = 5.0f;
+            menuVL.childControlWidth = true;
+            menuVL.childControlHeight = true;
+            menuVL.childForceExpandWidth = true;
+            menuVL.childForceExpandHeight = false;
+
+            RectTransform menuVLRectTransform = m_Root.GetComponent<RectTransform>();
+            menuVLRectTransform.pivot = new Vector2(0.0f, 0.0f);
+            menuVLRectTransform.localPosition = new Vector3(0.0f, 0.0f);
+            menuVLRectTransform.anchorMin = new Vector2(0.0f, 0.0f);
+            menuVLRectTransform.anchorMax = new Vector2(1.0f, 1.0f);
+
+            BuildGUIImpl(m_Root);
+        }
+
+        public void RebuildGUI()
+        {
+            for (int i = 0; i < m_Root.transform.childCount; ++i)
+            {
+                Object.DestroyImmediate(m_Root.transform.GetChild(i).gameObject);
+            }
+            BuildGUIImpl(m_Root);
+        }
+
+        // Default Implementation: just build all items with provided handler.
+        public virtual void BuildGUIImpl(GameObject parent)
+        {
+            DebugMenuUI.CreateTextElement(string.Format("{0} Title", m_DebugPanel.name), m_DebugPanel.name, 14, TextAnchor.MiddleLeft, m_Root);
+
+            m_ItemsUI.Clear();
+            for (int i = 0; i < m_DebugPanel.itemCount; i++)
+            {
+                DebugItemHandler handler = m_DebugPanel.GetDebugItem(i).handler; // Should never be null, we have at least the default handler
+                m_ItemsUI.Add(handler.BuildGUI(parent));
+            }
+        }
+
+#if UNITY_EDITOR
+        // Default implementation for editor UI of a debug panel. Users may override this behavior.
+        // This will just display all items via their specific handlers in a vertical layout.
+        public virtual void OnEditorGUI()
+        {
+            using (new UnityEditor.EditorGUILayout.VerticalScope())
+            {
+                for (int i = 0; i < m_DebugPanel.itemCount; ++i)
+                {
+                    m_DebugPanel.GetDebugItem(i).handler.OnEditorGUI();
+                }
+            }
+        }
+#endif
+
+        public DebugItem GetSelectedDebugItem()
+        {
+            if (m_SelectedItem != -1)
+            {
+                return m_DebugPanel.GetDebugItem(m_SelectedItem);
+            }
+
+            return null;
+        }
+
+        void SetSelectedItem(int index)
+        {
+            if (m_SelectedItem != -1)
+            {
+                m_ItemsUI[m_SelectedItem].SetSelected(false);
+            }
+
+            m_SelectedItem = index;
+            m_ItemsUI[m_SelectedItem].SetSelected(true);
+        }
+
+        public void SetSelected(bool value)
+        {
+            m_Root.SetActive(value);
+
+            if (value)
+            {
+                if (m_SelectedItem == -1)
+                {
+                    NextItem();
+                }
+                else
+                    SetSelectedItem(m_SelectedItem);
+            }
+        }
+
+        void NextItem()
+        {
+            if (m_ItemsUI.Count != 0)
+            {
+                int newSelected = (m_SelectedItem + 1) % m_ItemsUI.Count;
+                SetSelectedItem(newSelected);
+            }
+        }
+
+        void PreviousItem()
+        {
+            if (m_ItemsUI.Count != 0)
+            {
+                int newSelected = m_SelectedItem - 1;
+                if (newSelected == -1)
+                    newSelected = m_ItemsUI.Count - 1;
+                SetSelectedItem(newSelected);
+            }
+        }
+
+        public void OnMoveHorizontal(float value)
+        {
+            if (m_SelectedItem != -1 && !m_DebugPanel.GetDebugItem(m_SelectedItem).readOnly)
+            {
+                if (value > 0.0f)
+                    m_ItemsUI[m_SelectedItem].OnIncrement();
+                else
+                    m_ItemsUI[m_SelectedItem].OnDecrement();
+            }
+        }
+
+        public void OnMoveVertical(float value)
+        {
+            if (value > 0.0f)
+                PreviousItem();
+            else
+                NextItem();
+        }
+
+        public void OnValidate()
+        {
+            if (m_SelectedItem != -1 && !m_DebugPanel.GetDebugItem(m_SelectedItem).readOnly)
+                m_ItemsUI[m_SelectedItem].OnValidate();
+        }
+
+        public void Update()
+        {
+            foreach (var itemUI in m_ItemsUI)
+            {
+                if (itemUI.dynamicDisplay)
+                    itemUI.Update();
+            }
+        }
+    }
+}

Assets/ScriptableRenderPipeline/Core/Debugging/DebugPanelUI.cs.meta

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

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization.meta

+fileFormatVersion: 2
+guid: a07168baba11f084daec1edd4032f153
+folderAsset: yes
+timeCreated: 1495456975
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/LightingDebugPanel.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    public class LightingDebugPanelUI
+        : DebugPanelUI
+    {
+#if UNITY_EDITOR
+        public override void OnEditorGUI()
+        {
+            using (new UnityEditor.EditorGUILayout.VerticalScope())
+            {
+                m_DebugPanel.GetDebugItem("Enable Shadows").handler.OnEditorGUI();
+
+                DebugItem shadowDebug = m_DebugPanel.GetDebugItem("Shadow Debug Mode");
+                shadowDebug.handler.OnEditorGUI();
+                if ((ShadowMapDebugMode)shadowDebug.GetValue() == ShadowMapDebugMode.VisualizeShadowMap)
+                {
+                    EditorGUI.indentLevel++;
+                    m_DebugPanel.GetDebugItem("Shadow Map Index").handler.OnEditorGUI();
+                    EditorGUI.indentLevel--;
+                }
+                DebugItem lightingDebugModeItem = m_DebugPanel.GetDebugItem("Lighting Debug Mode");
+                lightingDebugModeItem.handler.OnEditorGUI();
+                if ((DebugLightingMode)lightingDebugModeItem.GetValue() == DebugLightingMode.SpecularLighting)
+                {
+                    EditorGUI.indentLevel++;
+                    DebugItem overrideSmoothnessItem = m_DebugPanel.GetDebugItem("Override Smoothness");
+                    overrideSmoothnessItem.handler.OnEditorGUI();
+                    if ((bool)overrideSmoothnessItem.GetValue())
+                    {
+                        m_DebugPanel.GetDebugItem("Override Smoothness Value").handler.OnEditorGUI();
+                    }
+                    EditorGUI.indentLevel--;
+                }
+                else if ((DebugLightingMode)lightingDebugModeItem.GetValue() == DebugLightingMode.DiffuseLighting)
+                {
+                    EditorGUI.indentLevel++;
+                    m_DebugPanel.GetDebugItem("Debug Lighting Albedo").handler.OnEditorGUI();
+                    EditorGUI.indentLevel--;
+                }
+
+                DebugItem displaySkyReflecItem = m_DebugPanel.GetDebugItem("Display Sky Reflection");
+                displaySkyReflecItem.handler.OnEditorGUI();
+                if ((bool)displaySkyReflecItem.GetValue())
+                {
+                    EditorGUI.indentLevel++;
+                    m_DebugPanel.GetDebugItem("Sky Reflection Mipmap").handler.OnEditorGUI();
+                    EditorGUI.indentLevel--;
+                }
+            }
+        }
+#endif
+    }
+
+    public class LightingDebugPanel
+        : DebugPanel<LightingDebugPanelUI>
+    {
+        public LightingDebugPanel()
+            : base("Lighting")
+        {
+        }
+    }
+}

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/LightingDebugPanel.cs.meta

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

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.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: 0cf1dab834d4ec34195b920ea7bbf9ec, type: 3}
+  m_Name: HDRenderPipelineAsset
+  m_EditorClassIdentifier: 
+  m_RenderPipelineResources: {fileID: 11400000, guid: 42086e81f4f0c724f96f7f09cc995354,
+    type: 2}
+  renderingSettings:
+    useForwardRenderingOnly: 0
+    useDepthPrepass: 0
+  sssSettings:
+    numProfiles: 1
+    profiles:
+    - {fileID: 0}
+  tileSettings:
+    enableTileAndCluster: 1
+    enableSplitLightEvaluation: 1
+    enableComputeLightEvaluation: 0
+    enableComputeFeatureVariants: 0
+    enableClustered: 1
+    enableFptlForOpaqueWhenClustered: 1
+    enableBigTilePrepass: 1
+    diffuseGlobalDimmer: 1
+    specularGlobalDimmer: 1
+    tileDebugByCategory: 0
+  m_ShadowSettings:
+    enabled: 1
+    shadowAtlasWidth: 4096
+    shadowAtlasHeight: 4096
+    maxShadowDistance: 1000
+    directionalLightCascadeCount: 4
+    directionalLightCascades: {x: 0.05, y: 0.2, z: 0.3}
+    directionalLightNearPlaneOffset: 5
+  m_TextureSettings:
+    spotCookieSize: 128
+    pointCookieSize: 512
+    reflectionCubemapSize: 128
+  m_CommonSettings:
+    m_ShadowMaxDistance: 1000
+    m_ShadowCascadeCount: 4
+    m_ShadowCascadeSplit0: 0.05
+    m_ShadowCascadeSplit1: 0.2
+    m_ShadowCascadeSplit2: 0.3
+    m_ShadowNearPlaneOffset: 5
+  m_SkySettings: {fileID: 0}
+  m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
+    type: 2}
+  m_DefaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset.meta

+fileFormatVersion: 2
+guid: 449281dd2b4fbee49b8397de0541ea3c
+timeCreated: 1496162200
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.cs

+using UnityEngine.Rendering;
+using System;
+using System.Linq;
+using UnityEngine.Experimental.PostProcessing;
+using UnityEngine.Experimental.Rendering.HDPipeline.TilePass;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    // This HDRenderPipeline assume linear lighting. Don't work with gamma.
+    public class HDRenderPipelineAsset : RenderPipelineAsset
+    {
+#if UNITY_EDITOR
+        const string k_HDRenderPipelinePath = "Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset";
+
+        [MenuItem("RenderPipeline/HDRenderPipeline/Create Pipeline Asset")]
+        static void CreateHDRenderPipeline()
+        {
+            var instance = CreateInstance<HDRenderPipelineAsset>();
+            AssetDatabase.CreateAsset(instance, k_HDRenderPipelinePath);
+
+            // If it exist, load renderPipelineResources
+            instance.renderPipelineResources = AssetDatabase.LoadAssetAtPath<RenderPipelineResources>(RenderPipelineResources.renderPipelineResourcesPath);
+        }
+
+        [UnityEditor.MenuItem("HDRenderPipeline/Add \"Additional Light Data\" (if not present)")]
+        static void AddAdditionalLightData()
+        {
+            Light[] lights = FindObjectsOfType(typeof(Light)) as Light[];
+
+            foreach (Light light in lights)
+            {
+                // Do not add a component if there already is one.
+                if (light.GetComponent<AdditionalLightData>() == null)
+                {
+                    light.gameObject.AddComponent<AdditionalLightData>();
+                }
+            }
+        }
+#endif
+
+        private HDRenderPipelineAsset()
+        { }
+
+        protected override IRenderPipeline InternalCreatePipeline()
+        {
+            return new HDRenderPipeline(this);
+        }
+
+        [SerializeField]
+        private RenderPipelineResources m_RenderPipelineResources;
+        public RenderPipelineResources renderPipelineResources
+        {
+            get { return m_RenderPipelineResources; }
+            set { m_RenderPipelineResources = value; }
+        }
+
+        // NOTE: All those properties are public because of how HDRenderPipelineInspector retrieve those properties via serialization/reflection
+        // Doing it this way allow to change parameters name and still retrieve correct serialized value
+
+        // Debugging (Not persistent)
+        public DebugDisplaySettings debugDisplaySettings = new DebugDisplaySettings();
+
+        // Renderer Settings (per project)
+        public RenderingSettings renderingSettings = new RenderingSettings();
+        public SubsurfaceScatteringSettings sssSettings = new SubsurfaceScatteringSettings();
+        public TileSettings tileSettings = new TileSettings();
+
+        // TODO: Following two settings need to be update to the serialization/reflection way like above
+        [SerializeField]
+        ShadowSettings m_ShadowSettings = ShadowSettings.Default;
+        [SerializeField]
+        TextureSettings m_TextureSettings = TextureSettings.Default;
+        
+        public ShadowSettings shadowSettings
+        {
+            get { return m_ShadowSettings; }
+        }
+
+        public TextureSettings textureSettings
+        {
+            get { return m_TextureSettings; }
+            set { m_TextureSettings = value; }
+        }
+
+        // NOTE: Following settings are Asset so they need to be serialized as usual. no reflection/serialization here
+
+        // Renderer Settings (per "scene")
+        [SerializeField]
+        private CommonSettings.Settings m_CommonSettings = CommonSettings.Settings.s_Defaultsettings;
+        [SerializeField]
+        private SkySettings m_SkySettings;
+
+        public CommonSettings.Settings commonSettingsToUse
+        {
+            get
+            {
+                if (CommonSettingsSingleton.overrideSettings)
+                    return CommonSettingsSingleton.overrideSettings.settings;
+
+                return m_CommonSettings;
+            }
+        }
+
+        public SkySettings skySettings
+        {
+            get { return m_SkySettings; }
+            set { m_SkySettings = value; }
+        }
+
+        public SkySettings skySettingsToUse
+        {
+            get
+            {
+                if (SkySettingsSingleton.overrideSettings)
+                    return SkySettingsSingleton.overrideSettings;
+
+                return m_SkySettings;
+            }
+        }
+
+        [SerializeField]
+        Material m_DefaultDiffuseMaterial;
+        [SerializeField]
+        Shader m_DefaultShader;
+
+        public Material DefaultDiffuseMaterial
+        {
+            get { return m_DefaultDiffuseMaterial; }
+            private set { m_DefaultDiffuseMaterial = value; }
+        }
+
+        public Shader DefaultShader
+        {
+            get { return m_DefaultShader; }
+            private set { m_DefaultShader = value; }
+        }
+
+        public override Shader GetDefaultShader()
+        {
+            return m_DefaultShader;
+        }
+
+        public override Material GetDefaultMaterial()
+        {
+            return m_DefaultDiffuseMaterial;
+        }
+
+        public override Material GetDefaultParticleMaterial()
+        {
+            return null;
+        }
+
+        public override Material GetDefaultLineMaterial()
+        {
+            return null;
+        }
+
+        public override Material GetDefaultTerrainMaterial()
+        {
+            return null;
+        }
+
+        public override Material GetDefaultUIMaterial()
+        {
+            return null;
+        }
+
+        public override Material GetDefaultUIOverdrawMaterial()
+        {
+            return null;
+        }
+
+        public override Material GetDefaultUIETC1SupportedMaterial()
+        {
+            return null;
+        }
+
+        public override Material GetDefault2DMaterial()
+        {
+            return null;
+        }
+
+        public void ApplyDebugDisplaySettings()
+        {
+            m_ShadowSettings.enabled = debugDisplaySettings.lightingDebugSettings.enableShadows;
+
+            LightingDebugSettings lightingDebugSettings = debugDisplaySettings.lightingDebugSettings;
+            Vector4 debugAlbedo = new Vector4(lightingDebugSettings.debugLightingAlbedo.r, lightingDebugSettings.debugLightingAlbedo.g, lightingDebugSettings.debugLightingAlbedo.b, 0.0f);
+            Vector4 debugSmoothness = new Vector4(lightingDebugSettings.overrideSmoothness ? 1.0f : 0.0f, lightingDebugSettings.overrideSmoothnessValue, 0.0f, 0.0f);
+
+            Shader.SetGlobalInt("_DebugViewMaterial", (int)debugDisplaySettings.GetDebugMaterialIndex());
+            Shader.SetGlobalInt("_DebugLightingMode", (int)debugDisplaySettings.GetDebugLightingMode());
+            Shader.SetGlobalVector("_DebugLightingAlbedo", debugAlbedo);
+            Shader.SetGlobalVector("_DebugLightingSmoothness", debugSmoothness);
+        }
+
+        public void UpdateCommonSettings()
+        {
+            var commonSettings = commonSettingsToUse;
+
+            m_ShadowSettings.directionalLightCascadeCount = commonSettings.shadowCascadeCount;
+            m_ShadowSettings.directionalLightCascades = new Vector3(commonSettings.shadowCascadeSplit0, commonSettings.shadowCascadeSplit1, commonSettings.shadowCascadeSplit2);
+            m_ShadowSettings.maxShadowDistance = commonSettings.shadowMaxDistance;
+            m_ShadowSettings.directionalLightNearPlaneOffset = commonSettings.shadowNearPlaneOffset;
+        }
+
+        public void OnValidate()
+        {
+            debugDisplaySettings.OnValidate();
+            sssSettings.OnValidate();
+        }
+
+        void OnEnable()
+        {
+            debugDisplaySettings.RegisterDebug();
+        }
+    }
+}

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.cs.meta

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

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources.meta

+fileFormatVersion: 2
+guid: 2059a21bd962b3b4296d74ce1a6f7b9b
+folderAsset: yes
+timeCreated: 1496132665
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Scenes/Shaders/LDPipe_LitBakedEmission/LightingData.asset.meta

+fileFormatVersion: 2
+guid: b659eb7d7f70e4d4eb5211330bbf8d9c
+timeCreated: 1496157534
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 25800000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GraphicsTests/RenderPipeline/LowEndMobilePipeline/Scenes/Shaders/LDPipe_LitBakedEmission/Lightmap-0_comp_light.exr.meta

+fileFormatVersion: 2
+guid: c02213447cf3f8645aeb781608966311
+timeCreated: 1496157534
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 3
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 0
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 6
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateBool.cs.meta

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

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateColor.cs.meta

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

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateFloat.cs.meta

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

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateInt.cs.meta

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

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateUInt.cs.meta

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

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateBool.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class DebugItemStateBool : DebugItemState<bool>
+    {
+    }
+}

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateColor.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class DebugItemStateColor : DebugItemState<Color>
+    {
+    }
+}

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateFloat.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class DebugItemStateFloat : DebugItemState<float>
+    {
+    }
+}

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateInt.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class DebugItemStateInt : DebugItemState<int>
+    {
+    }
+}

Assets/ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateUInt.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class DebugItemStateUInt : DebugItemState<uint>
+    {
+    }
+}

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/DefaultCommonSettings.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: bc357c46587fc9d4cb8f311794d7d2f3, type: 3}
+  m_Name: DefaultCommonSettings
+  m_EditorClassIdentifier: 
+  m_Settings:
+    m_ShadowMaxDistance: 1000
+    m_ShadowCascadeCount: 4
+    m_ShadowCascadeSplit0: 0.05
+    m_ShadowCascadeSplit1: 0.2
+    m_ShadowCascadeSplit2: 0.3
+    m_ShadowNearPlaneOffset: 5

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/HDRenderPipelineResources.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: 8b6f86e1523e69a4282e92d393be89a4, type: 3}
+  m_Name: HDRenderPipelineResources
+  m_EditorClassIdentifier: 
+  debugDisplayLatlongShader: {fileID: 4800000, guid: c1d1d149a043a5349ba367da6c2051ba,
+    type: 3}
+  debugDisplayShadowMapShader: {fileID: 4800000, guid: ee25e539f5594f44085e0a9000c15d9b,
+    type: 3}
+  debugViewMaterialGBufferShader: {fileID: 4800000, guid: 439949ea1bfa91b4ba0d04269fcde33d,
+    type: 3}
+  debugViewTilesShader: {fileID: 4800000, guid: c7c2bd17b06ceb4468e14081aaf1b96f,
+    type: 3}
+  deferredShader: {fileID: 4800000, guid: 00dd221e34a6ab349a1196b0f2fab693, type: 3}
+  clearDispatchIndirectShader: {fileID: 7200000, guid: fc1f553acb80a6446a32d33e403d0656,
+    type: 3}
+  buildScreenAABBShader: {fileID: 7200000, guid: 728dce960f8a9c44bbc3abb3b851d8f6,
+    type: 3}
+  buildPerTileLightListShader: {fileID: 7200000, guid: 65af3444cbf4b3747a4dead7ee00cfee,
+    type: 3}
+  buildPerBigTileLightListShader: {fileID: 7200000, guid: 5ee1f9d6e09abe045b2f5e0b784b9072,
+    type: 3}
+  buildPerVoxelLightListShader: {fileID: 7200000, guid: 0bb1b7e0ddcd5c44baf3ddc7456eb196,
+    type: 3}
+  shadeOpaqueShader: {fileID: 7200000, guid: 0b64f79746d2daf4198eaf6eab9af259, type: 3}
+  drawGaussianProfileShader: {fileID: 4800000, guid: 2e8a76823cb2af944b4b45169f2649f9,
+    type: 3}
+  drawTransmittanceGraphShader: {fileID: 4800000, guid: 4517edda0467bb14489d5eccc9973ba2,
+    type: 3}
+  blitCubemap: {fileID: 4800000, guid: d05913e251bed7a4992c921c62e1b647, type: 3}
+  buildProbabilityTables: {fileID: 7200000, guid: b9f26cf340afe9145a699753531b2a4c,
+    type: 3}
+  computeGgxIblSampleData: {fileID: 7200000, guid: 764a24bb47ef5ba4781d9ae82ca07445,
+    type: 3}
+  GGXConvolve: {fileID: 4800000, guid: 123ed592ad5c2494b8aed301fd609e7b, type: 3}
+  skyboxCubemap: {fileID: 103, guid: 0000000000000000f000000000000000, type: 0}