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

Assets/BasicRenderLoopTutorial/BasicRenderLoop.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.ScriptableRenderPipeline;
 
 // Very basic scriptable rendering loop example:
 // - Use with BasicRenderLoopShader.shader (the loop expects "BasicPass" pass type to exist)
 [ExecuteInEditMode]
 public class BasicRenderLoop : RenderPipeline
 {
-
 #if UNITY_EDITOR
     [UnityEditor.MenuItem("Renderloop/Create BasicRenderLoop")]
     static void CreateBasicRenderLoop()
     }
 #endif
 
-    public override void Build()
-    {
-    }
-
-    public override void Cleanup()
+    [NonSerialized]
+    readonly List<Camera> m_CamerasToRender = new List<Camera>();
+    public override void Render(ScriptableRenderContext renderLoop, IScriptableRenderDataStore dataStore)
+        base.Render(renderLoop, dataStore);
+        cameraProvider.GetCamerasToRender(m_CamerasToRender);
+        Render(renderLoop, m_CamerasToRender);
+        CleanCameras(m_CamerasToRender);
+        m_CamerasToRender.Clear();
-    public override void Render(Camera[] cameras, RenderLoop loop)
+    public static void Render(ScriptableRenderContext context, IEnumerable<Camera> cameras)
     {
         foreach (var camera in cameras)
         {
                 continue;
-            CullResults cull = CullResults.Cull (ref cullingParams, loop);
+            CullResults cull = CullResults.Cull (ref cullingParams, context);
-            loop.SetupCameraProperties (camera);
+            context.SetupCameraProperties (camera);
-            loop.ExecuteCommandBuffer(cmd);
+            context.ExecuteCommandBuffer(cmd);
-            SetupLightShaderVariables (cull.visibleLights, loop);
+            SetupLightShaderVariables (cull.visibleLights, context);
-            loop.DrawRenderers (ref settings);
+            context.DrawRenderers (ref settings);
-            loop.DrawSkybox (camera);
+            context.DrawSkybox (camera);
-            loop.DrawRenderers (ref settings);
+            context.DrawRenderers (ref settings);
-            loop.Submit ();
+            context.Submit ();
-    static void SetupLightShaderVariables (VisibleLight[] lights, RenderLoop loop)
+    static void SetupLightShaderVariables (VisibleLight[] lights, ScriptableRenderContext context)
     {
         // We only support up to 8 visible lights here. More complex approaches would
         // be doing some sort of per-object light setups, but here we go for simplest possible
         cmd.SetGlobalVectorArray ("globalLightAtten", lightAtten);
         cmd.SetGlobalVector ("globalLightCount", new Vector4 (lightCount, 0, 0, 0));
         cmd.SetGlobalVectorArray ("globalSH", shConstants);
-        loop.ExecuteCommandBuffer (cmd);
+        context.ExecuteCommandBuffer (cmd);
         cmd.Dispose ();
     }
 
         outCoefficients[6].z = ambientProbe[2, 8];
         outCoefficients[6].w = 1.0f;
     }
+
 }

Assets/Editor/Tests/RenderloopTests/CullResultsTest.cs

 [TestFixture]
 public class CullResultsTest
 {
-    void InspectCullResults(Camera camera, CullResults cullResults, RenderLoop renderLoop)
+    void InspectCullResults(Camera camera, CullResults cullResults, ScriptableRenderContext renderLoop)
     {
         VisibleReflectionProbe[] probes = cullResults.visibleReflectionProbes;
 

Assets/Editor/Tests/RenderloopTests/RenderloopTestFixture.cs

-using System.Collections;
+using System;
-using UnityEngine.Experimental.ScriptableRenderLoop;
+using UnityEngine.ScriptableRenderPipeline;
-    public delegate void TestDelegate(Camera camera, CullResults cullResults, RenderLoop renderLoop);
+    public delegate void TestDelegate(Camera camera, CullResults cullResults, ScriptableRenderContext renderLoop);
-    public override void Render(Camera[] cameras, RenderLoop renderLoop)
+    [NonSerialized]
+    readonly List<Camera> m_CamerasToRender = new List<Camera>();
+
+    public override void Render(ScriptableRenderContext renderLoop, IScriptableRenderDataStore dataStore)
-        foreach (var camera in cameras)
+        cameraProvider.GetCamerasToRender(m_CamerasToRender);
+
+        foreach (var camera in m_CamerasToRender)
+            if (!camera.enabled)
+                continue;
+        
             CullingParameters cullingParams;
             bool gotCullingParams = CullResults.GetCullingParameters(camera, out cullingParams);
             Assert.IsTrue(gotCullingParams);
         }
 
         renderLoop.Submit();
-    }
-    public override void Build()
-    {
-        
+        CleanCameras(m_CamerasToRender);
+        m_CamerasToRender.Clear();
-
-    public override void Cleanup()
-    {
-        
-    }
-
+    
     public static void Run(TestDelegate renderCallback)
     {
         if (m_Instance == null)

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/HDRenderLoopInspector.cs

             public readonly GUIContent bigTilePrepass = new GUIContent("Enable big tile prepass", "Toggle");
             public readonly GUIContent clustered = new GUIContent("Enable clustered", "Toggle");
             public readonly GUIContent disableTileAndCluster = new GUIContent("Disable Tile/clustered", "Toggle");
-            
+            public readonly GUIContent disableDeferredShadingInCompute = new GUIContent("Disable deferred shading in compute", "Toggle");
+
 
 
             public readonly GUIContent textureSettings = new GUIContent("Texture Settings");
                     EditorUtility.SetDirty(renderLoop); // Repaint
 
                     // SetAssetDirty will tell renderloop to rebuild
-                    renderLoop.SetAssetDirty();
+                    renderLoop.ClearCachedData();
                 }
 
                 EditorGUI.BeginChangeCheck();
                 tilePass.disableTileAndCluster = EditorGUILayout.Toggle(styles.disableTileAndCluster, tilePass.disableTileAndCluster);
+                tilePass.disableDeferredShadingInCompute = EditorGUILayout.Toggle(styles.disableDeferredShadingInCompute, tilePass.disableDeferredShadingInCompute);
 
                 if (EditorGUI.EndChangeCheck())
                 {

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

 using UnityEngine.Experimental.Rendering;
 using System.Collections.Generic;
 using System;
+using UnityEngine.ScriptableRenderPipeline;
 
 namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
             }
         }
 #endif
+        private class HDLoopDataStore : RenderingDataStore
+        {
+            public HDLoopDataStore(BaseRenderPipeline owner) : base(owner)
+            { }
+
+            protected override void InternalBuild()
+            {
+                base.InternalBuild(); 
+                HDRenderLoop theOwner = owner as HDRenderLoop;
+                if (theOwner != null)
+                    theOwner.Build();
+            }
+
+            protected override void InternalCleanup()
+            {
+                base.InternalCleanup();
+                HDRenderLoop theOwner = owner as HDRenderLoop;
+                if (theOwner != null)
+                    theOwner.Cleanup();
+            }
+        }
+
+        public override IScriptableRenderDataStore ConstructDataStore()
+        {
+            return new HDLoopDataStore(this);
+        }
 
         SkyManager m_SkyManager = new SkyManager();
         public SkyManager skyManager
             get { return m_CommonSettings; }
         }
 
-        public override void Build()
+        public void Build()
         {
 #if UNITY_EDITOR
             UnityEditor.SupportedRenderingFeatures.active = new UnityEditor.SupportedRenderingFeatures
             m_lightLoop.Build(m_TextureSettings);
         }
 
-        public override void Cleanup()
+        public void Cleanup()
         {
             m_lightLoop.Cleanup();
             m_LitRenderLoop.Cleanup();
            UnityEngine.Rendering.GraphicsSettings.lightsUseCCT = previousLightsUseCCT;
         }
 
-        void InitAndClearBuffer(Camera camera, RenderLoop renderLoop)
+        void InitAndClearBuffer(Camera camera, ScriptableRenderContext renderLoop)
         {
             using (new Utilities.ProfilingSample("InitAndClearBuffer", renderLoop))
             {
                     int w = camera.pixelWidth;
                     int h = camera.pixelHeight;
 
-                    cmd.GetTemporaryRT(m_CameraColorBuffer, w, h, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
+                    cmd.GetTemporaryRT(m_CameraColorBuffer, w, h, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear, 1, true);   // Enable UAV
                     cmd.GetTemporaryRT(m_CameraDepthBuffer, w, h, 24, FilterMode.Point, RenderTextureFormat.Depth);
                     if (!debugParameters.useForwardRenderingOnly)
                     {
             }
         }
 
-        void RenderOpaqueRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName, RendererConfiguration rendererConfiguration = 0)
+        void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderLoop, string passName, RendererConfiguration rendererConfiguration = 0)
         {
             if (!debugParameters.displayOpaqueObjects)
                 return;
             renderLoop.DrawRenderers(ref settings);
         }
 
-        void RenderTransparentRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName, RendererConfiguration rendererConfiguration = 0)
+        void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderLoop, string passName, RendererConfiguration rendererConfiguration = 0)
         {
             if (!debugParameters.displayTransparentObjects)
                 return;
             renderLoop.DrawRenderers(ref settings);
         }
 
-        void RenderDepthPrepass(CullResults cull, Camera camera, RenderLoop renderLoop)
+        void RenderDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderLoop)
         {
             // 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...
             }
         }
 
-        void RenderGBuffer(CullResults cull, Camera camera, RenderLoop renderLoop)
+        void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext renderLoop)
         {
             if (debugParameters.useForwardRenderingOnly)
             {
         }
 
         // This pass is use in case of forward opaque and deferred rendering. We need to render forward objects before tile lighting pass
-        void RenderForwardOnlyDepthPrepass(CullResults cull, Camera camera, RenderLoop renderLoop)
+        void RenderForwardOnlyDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderLoop)
         {
             // If we are forward only we don't need to render ForwardOpaqueDepth object
             // But in case we request a prepass we render it
             }
         }
 
-        void RenderDebugViewMaterial(CullResults cull, HDCamera hdCamera, RenderLoop renderLoop)
+        void RenderDebugViewMaterial(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderLoop)
         {
             using (new Utilities.ProfilingSample("DebugView Material Mode Pass", renderLoop))
             // Render Opaque forward
             }
         }
 
-        void RenderDeferredLighting(HDCamera hdCamera, RenderLoop renderLoop)
+        void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderLoop)
         {
             if (debugParameters.useForwardRenderingOnly)
             {
             m_lightLoop.RenderDeferredLighting(hdCamera, renderLoop, m_CameraColorBuffer);
         }
 
-        void UpdateSkyEnvironment(HDCamera hdCamera, RenderLoop renderLoop)
+        void UpdateSkyEnvironment(HDCamera hdCamera, ScriptableRenderContext renderLoop)
-        void RenderSky(HDCamera hdCamera, RenderLoop renderLoop)
+        void RenderSky(HDCamera hdCamera, ScriptableRenderContext renderLoop)
-        void RenderForward(CullResults cullResults, Camera camera, RenderLoop renderLoop, bool renderOpaque)
+        void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderLoop, bool renderOpaque)
         {
             // TODO: Currently we can't render opaque object forward when deferred is enabled
             // miss option
 
         // Render material that are forward opaque only (like eye)
         // TODO: Think about hair that could be render both as opaque and transparent...
-        void RenderForwardOnly(CullResults cullResults, Camera camera, RenderLoop renderLoop)
+        void RenderForwardOnly(CullResults cullResults, Camera camera, ScriptableRenderContext renderLoop)
         {
             using (new Utilities.ProfilingSample("Forward Only Pass", renderLoop))
             {
             }
         }
 
-        void RenderForwardUnlit(CullResults cullResults, Camera camera, RenderLoop renderLoop)
+        void RenderForwardUnlit(CullResults cullResults, Camera camera, ScriptableRenderContext renderLoop)
         {
             using (new Utilities.ProfilingSample("Forward Unlit Pass", renderLoop))
             {
             }
         }
 
-        void RenderVelocity(CullResults cullResults, Camera camera, RenderLoop renderLoop)
+        void RenderVelocity(CullResults cullResults, Camera camera, ScriptableRenderContext renderLoop)
         {
             using (new Utilities.ProfilingSample("Velocity Pass", renderLoop))
             {
             }
         }
 
-        void RenderDistortion(CullResults cullResults, Camera camera, RenderLoop renderLoop)
+        void RenderDistortion(CullResults cullResults, Camera camera, ScriptableRenderContext renderLoop)
         {
             if (!debugParameters.useDistortion)
                 return ;
             }
         }
 
-        void FinalPass(RenderLoop renderLoop)
+        void FinalPass(ScriptableRenderContext renderLoop)
         {
             using (new Utilities.ProfilingSample("Final Pass", renderLoop))
             {
             }
         }
 
-        public void PushGlobalParams(HDCamera hdCamera, RenderLoop renderLoop)
+        public void PushGlobalParams(HDCamera hdCamera, ScriptableRenderContext renderLoop)
         {
             if (m_SkyManager.IsSkyValid())
             {
             }
         }
 
-        public override void Render(Camera[] cameras, RenderLoop renderLoop)
+        [NonSerialized]
+        readonly List<Camera> m_CamerasToRender = new List<Camera>();
+
+        public override void Render(ScriptableRenderContext renderLoop, IScriptableRenderDataStore dataStore)
+            base.Render(renderLoop, dataStore);
+            cameraProvider.GetCamerasToRender(m_CamerasToRender);
+            
             if (!m_LitRenderLoop.isInit)
             {
                 m_LitRenderLoop.RenderInit(renderLoop);
             // Set Frame constant buffer
             // TODO...
 
-            foreach (var camera in cameras)
+            foreach (var camera in m_CamerasToRender)
             {
                 // Set camera constant buffer
                 // TODO...
 
                 renderLoop.Submit();
             }
+
+            CleanCameras(m_CamerasToRender);
+            m_CamerasToRender.Clear();
 
             // Post effects
         }

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightLoop.cs

         public virtual void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput) { }
         
         // TODO: this should not be part of the interface but for now make something working
-        public virtual void BuildGPULightLists(Camera camera, RenderLoop loop, RenderTargetIdentifier cameraDepthBufferRT) { }
+        public virtual void BuildGPULightLists(Camera camera, ScriptableRenderContext loop, RenderTargetIdentifier cameraDepthBufferRT) { }
-        public virtual void PushGlobalParams(Camera camera, RenderLoop loop) {}
+        public virtual void PushGlobalParams(Camera camera, ScriptableRenderContext loop) {}
-        public virtual void RenderDeferredLighting(HDRenderLoop.HDCamera hdCamera, RenderLoop renderLoop, RenderTargetIdentifier cameraColorBufferRT) {}
+        public virtual void RenderDeferredLighting(HDRenderLoop.HDCamera hdCamera, ScriptableRenderContext renderLoop, RenderTargetIdentifier cameraColorBufferRT) {}
-        public virtual void RenderForward(Camera camera, RenderLoop renderLoop, bool renderOpaque) {}
+        public virtual void RenderForward(Camera camera, ScriptableRenderContext renderLoop, bool renderOpaque) {}
 
         public Light GetCurrentSunLight() { return m_CurrentSunLight;  }
     }

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

             static ComputeBuffer s_EnvLightDatas = null;
             static ComputeBuffer s_shadowDatas = null;
 
+            static Texture2DArray m_DefaultTexture2DArray;
+
             TextureCacheCubemap m_CubeReflTexArray;
             TextureCache2D m_CookieTexArray;
             TextureCacheCubemap m_CubeCookieTexArray;
             static ComputeShader buildPerTileLightListShader = null;     // FPTL
             static ComputeShader buildPerBigTileLightListShader = null;
             static ComputeShader buildPerVoxelLightListShader = null;    // clustered
+            static ComputeShader shadeOpaqueShader = null;
+            static int s_shadeOpaqueClusteredKernel;
+            static int s_shadeOpaqueFptlKernel;
+
             static ComputeBuffer s_LightVolumeDataBuffer = null;
             static ComputeBuffer s_ConvexBoundsBuffer = null;
             static ComputeBuffer s_AABBBoundsBuffer = null;
 
             public bool enableDrawLightBoundsDebug = false;
             public bool disableTileAndCluster = true; // For debug / test
+            public bool disableDeferredShadingInCompute = true;
             public bool enableSplitLightEvaluation = true;
             public bool enableComputeLightEvaluation = false;
 
                 buildPerTileLightListShader = Resources.Load<ComputeShader>("lightlistbuild");
                 buildPerBigTileLightListShader = Resources.Load<ComputeShader>("lightlistbuild-bigtile");
                 buildPerVoxelLightListShader = Resources.Load<ComputeShader>("lightlistbuild-clustered");
+                shadeOpaqueShader = Resources.Load<ComputeShader>("shadeopaque");
 
                 s_GenAABBKernel = buildScreenAABBShader.FindKernel("ScreenBoundsAABB");
                 s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(enableBigTilePrepass ? "TileLightListGen_SrcBigTile" : "TileLightListGen");
                     buildPerBigTileLightListShader.SetBuffer(s_GenListPerBigTileKernel, "g_data", s_ConvexBoundsBuffer);
                 }
 
+                s_shadeOpaqueClusteredKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Clustered");
+                s_shadeOpaqueFptlKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Fptl");
+
                 s_LightList = null;
 
                 m_DeferredDirectMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
 
                 m_SingleDeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
                 m_SingleDeferredMaterial.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
+
+                m_DefaultTexture2DArray = new Texture2DArray(1, 1, 1, TextureFormat.ARGB32, false);
+                m_DefaultTexture2DArray.SetPixels32(new Color32[1] { new Color32(128, 128, 128, 128) }, 0);
+                m_DefaultTexture2DArray.Apply();
 
 #if UNITY_EDITOR
                 UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
                 cmd.DispatchCompute(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, numTilesX, numTilesY, 1);
             }
 
-            public override void BuildGPULightLists(Camera camera, RenderLoop loop, RenderTargetIdentifier cameraDepthBufferRT)
+            public override void BuildGPULightLists(Camera camera, ScriptableRenderContext loop, RenderTargetIdentifier cameraDepthBufferRT)
             {
                 var w = camera.pixelWidth;
                 var h = camera.pixelHeight;
                 cmd.Dispose();
             }
 
-            public override void PushGlobalParams(Camera camera, RenderLoop loop)
+            // This is a workaround for global properties not being accessible from compute.
+            // When activeComputeShader is set, all calls to SetGlobalXXX will set the property on the select compute shader instead of the global scope.
+            private ComputeShader activeComputeShader;
+            private int activeComputeKernel;
+            private CommandBuffer activeCommandBuffer;
+            private void SetGlobalPropertyRedirect(ComputeShader computeShader, int computeKernel, CommandBuffer commandBuffer)
-                Shader.SetGlobalTexture("_CookieTextures", m_CookieTexArray.GetTexCache());
-                Shader.SetGlobalTexture("_CookieCubeTextures", m_CubeCookieTexArray.GetTexCache());
-                Shader.SetGlobalTexture("_EnvTextures", m_CubeReflTexArray.GetTexCache());
+                activeComputeShader = computeShader;
+                activeComputeKernel = computeKernel;
+                activeCommandBuffer = commandBuffer;
+            }
-                s_DirectionalLightDatas.SetData(m_lightList.directionalLights.ToArray());
-                s_LightDatas.SetData(m_lightList.lights.ToArray());
-                s_EnvLightDatas.SetData(m_lightList.envLights.ToArray());
-                s_shadowDatas.SetData(m_lightList.shadows.ToArray());
+            private void SetGlobalTexture(string name, Texture value)
+            {
+                if (activeComputeShader)
+                    activeCommandBuffer.SetComputeTextureParam(activeComputeShader, activeComputeKernel, name, value);
+                else
+                    Shader.SetGlobalTexture(name, value);
-                // These two buffers have been set in Rebuild()
-                s_ConvexBoundsBuffer.SetData(m_lightList.bounds.ToArray());
-                s_LightVolumeDataBuffer.SetData(m_lightList.lightVolumes.ToArray());
+            }
+
+            private void SetGlobalBuffer(string name, ComputeBuffer buffer)
+            {
+                if (activeComputeShader)
+                    activeCommandBuffer.SetComputeBufferParam(activeComputeShader, activeComputeKernel, name, buffer);
+                else
+                    Shader.SetGlobalBuffer(name, buffer);
+            }
-                Shader.SetGlobalBuffer("_DirectionalLightDatas", s_DirectionalLightDatas);
-                Shader.SetGlobalInt("_DirectionalLightCount", m_lightList.directionalLights.Count);
-                Shader.SetGlobalBuffer("_LightDatas", s_LightDatas);
-                Shader.SetGlobalInt("_PunctualLightCount", m_punctualLightCount);
-                Shader.SetGlobalInt("_AreaLightCount", m_areaLightCount);
-                Shader.SetGlobalBuffer("_EnvLightDatas", s_EnvLightDatas);
-                Shader.SetGlobalInt("_EnvLightCount", m_lightList.envLights.Count);
-                Shader.SetGlobalBuffer("_ShadowDatas", s_shadowDatas);
-                Shader.SetGlobalVectorArray("_DirShadowSplitSpheres", m_lightList.directionalShadowSplitSphereSqr);
+            private void SetGlobalInt(string name, int value)
+            {
+                if (activeComputeShader)
+                    activeCommandBuffer.SetComputeIntParam(activeComputeShader, name, value);
+                else
+                    Shader.SetGlobalInt(name, value);
+            }
+
+            private void SetGlobalFloat(string name, float value)
+            {
+                if (activeComputeShader)
+                    activeCommandBuffer.SetComputeFloatParam(activeComputeShader, name, value);
+                else
+                    Shader.SetGlobalFloat(name, value);
+            }
+
+            private void SetGlobalVectorArray(string name, Vector4[] values)
+            {
+                if (activeComputeShader)
+                {
+                    int numVectors = values.Length;
+                    var data = new float[numVectors * 4];
+
+                    for (int n = 0; n < numVectors; n++)
+                    {
+                        for (int i = 0; i < 4; i++)
+            {
+                            data[4 * n + i] = values[n][i];
+                        }
+                    }
+
+                    activeCommandBuffer.SetComputeFloatParams(activeComputeShader, name, data);
+                }
+                else
+                {
+                    Shader.SetGlobalVectorArray(name, values);
+                }
+            }
+
+            private void BindGlobalParams(CommandBuffer cmd, ComputeShader computeShader, int kernelIndex, Camera camera, ScriptableRenderContext loop)
+            {
+                SetGlobalPropertyRedirect(computeShader, kernelIndex, cmd);
+
+                SetGlobalTexture("_CookieTextures", m_CookieTexArray.GetTexCache());
+                SetGlobalTexture("_CookieCubeTextures", m_CubeCookieTexArray.GetTexCache());
+                SetGlobalTexture("_EnvTextures", m_CubeReflTexArray.GetTexCache());
-                var cmd = new CommandBuffer { name = "Push Global Parameters" };
+                SetGlobalBuffer("_DirectionalLightDatas", s_DirectionalLightDatas);
+                SetGlobalInt("_DirectionalLightCount", m_lightList.directionalLights.Count);
+                SetGlobalBuffer("_LightDatas", s_LightDatas);
+                SetGlobalInt("_PunctualLightCount", m_punctualLightCount);
+                SetGlobalInt("_AreaLightCount", m_areaLightCount);
+                SetGlobalBuffer("_EnvLightDatas", s_EnvLightDatas);
+                SetGlobalInt("_EnvLightCount", m_lightList.envLights.Count);
+                SetGlobalBuffer("_ShadowDatas", s_shadowDatas);
+                SetGlobalVectorArray("_DirShadowSplitSpheres", m_lightList.directionalShadowSplitSphereSqr);
-                cmd.SetGlobalFloat("_NumTileX", (float)GetNumTileX(camera));
-                cmd.SetGlobalFloat("_NumTileY", (float)GetNumTileY(camera));
+                SetGlobalInt("_NumTileX", GetNumTileX(camera));
+                SetGlobalInt("_NumTileY", GetNumTileY(camera));
-                    cmd.SetGlobalBuffer("g_vBigTileLightList", s_BigTileLightList);
+                    SetGlobalBuffer("g_vBigTileLightList", s_BigTileLightList);
-                    cmd.SetGlobalFloat("g_fClustScale", m_ClustScale);
-                    cmd.SetGlobalFloat("g_fClustBase", k_ClustLogBase);
-                    cmd.SetGlobalFloat("g_fNearPlane", camera.nearClipPlane);
-                    cmd.SetGlobalFloat("g_fFarPlane", camera.farClipPlane);
-                    cmd.SetGlobalFloat("g_iLog2NumClusters", k_Log2NumClusters);
+                    SetGlobalFloat("g_fClustScale", m_ClustScale);
+                    SetGlobalFloat("g_fClustBase", k_ClustLogBase);
+                    SetGlobalFloat("g_fNearPlane", camera.nearClipPlane);
+                    SetGlobalFloat("g_fFarPlane", camera.farClipPlane);
+                    SetGlobalFloat("g_iLog2NumClusters", k_Log2NumClusters);
-                    cmd.SetGlobalFloat("g_isLogBaseBufferEnabled", k_UseDepthBuffer ? 1 : 0);
+                    SetGlobalFloat("g_isLogBaseBufferEnabled", k_UseDepthBuffer ? 1 : 0);
-                    cmd.SetGlobalBuffer("g_vLayeredOffsetsBuffer", s_PerVoxelOffset);
+                    SetGlobalBuffer("g_vLayeredOffsetsBuffer", s_PerVoxelOffset);
-                        cmd.SetGlobalBuffer("g_logBaseBuffer", s_PerTileLogBaseTweak);
+                        SetGlobalBuffer("g_logBaseBuffer", s_PerTileLogBaseTweak);
+            }
+
+            public override void PushGlobalParams(Camera camera, ScriptableRenderContext loop)
+            {
+                var cmd = new CommandBuffer { name = "Push Global Parameters" };
+
+
+                s_DirectionalLightDatas.SetData(m_lightList.directionalLights.ToArray());
+                s_LightDatas.SetData(m_lightList.lights.ToArray());
+                s_EnvLightDatas.SetData(m_lightList.envLights.ToArray());
+                s_shadowDatas.SetData(m_lightList.shadows.ToArray());
+
+                // These two buffers have been set in Rebuild()
+                s_ConvexBoundsBuffer.SetData(m_lightList.bounds.ToArray());
+                s_LightVolumeDataBuffer.SetData(m_lightList.lightVolumes.ToArray());
+
+
+                BindGlobalParams(cmd, null, 0, camera, loop);
+
+                SetGlobalPropertyRedirect(null, 0, null);
 
                 loop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             }
 #endif
 
-            public override void RenderDeferredLighting(HDRenderLoop.HDCamera hdCamera, RenderLoop renderLoop, RenderTargetIdentifier cameraColorBufferRT)
+            public override void RenderDeferredLighting(HDRenderLoop.HDCamera hdCamera, ScriptableRenderContext renderLoop, RenderTargetIdentifier cameraColorBufferRT)
             {
                 var bUseClusteredForDeferred = !usingFptl;
 
                     mousePixelCoord.y = (hdCamera.screenSize.y - 1.0f) - mousePixelCoord.y;
                 }
 #endif
-
-                Utilities.SetupMaterialHDCamera(hdCamera, m_DeferredDirectMaterial);
-                m_DeferredDirectMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                m_DeferredDirectMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                m_DeferredDirectMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                m_DeferredDirectMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-
-                Utilities.SetupMaterialHDCamera(hdCamera, m_DeferredIndirectMaterial);
-                m_DeferredIndirectMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                m_DeferredIndirectMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One); // Additive
-                m_DeferredIndirectMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                m_DeferredIndirectMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-
-                Utilities.SetupMaterialHDCamera(hdCamera, m_DeferredAllMaterial);
-                m_DeferredAllMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                m_DeferredAllMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                m_DeferredAllMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                m_DeferredAllMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-
-                Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewTilesMaterial);
-                m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", debugViewTilesFlags);
-                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");
-
-                Utilities.SetupMaterialHDCamera(hdCamera, m_SingleDeferredMaterial);
-                m_SingleDeferredMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                m_SingleDeferredMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-
-                    cmd.SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
+
+                    SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
+                    SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlKernel : s_shadeOpaqueClusteredKernel, cmd);
+                    SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
+
+
-                        cmd.SetGlobalFloat("_UseTileLightList", 0);
+                        SetGlobalFloat("_UseTileLightList", 0);
-                    /*
-                    if (enableComputeLightEvaluation)  //TODO: temporary workaround for "All kernels must use same constant buffer layouts"
+                    if (disableTileAndCluster)
-                        var w = camera.pixelWidth;
-                        var h = camera.pixelHeight;
-                        var numTilesX = (w + 7) / 8;
-                        var numTilesY = (h + 7) / 8;
+                        Utilities.SetupMaterialHDCamera(hdCamera, m_SingleDeferredMaterial);
+                        m_SingleDeferredMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        m_SingleDeferredMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                        string kernelName = "ShadeDeferred" + (bUseClusteredForDeferred ? "_Clustered" : "_Fptl") + (enableDrawTileDebug ? "_Debug" : "");
-                        int kernel = deferredComputeShader.FindKernel(kernelName);
+                        cmd.Blit(null, cameraColorBufferRT, m_SingleDeferredMaterial, 0);
+                    }
+                    else
+                    {
+                        if (!disableDeferredShadingInCompute)
+                        {
+                            // Compute shader evaluation
+                            int kernel = bUseClusteredForDeferred ? s_shadeOpaqueClusteredKernel : s_shadeOpaqueFptlKernel;
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraDepthTexture", new RenderTargetIdentifier(s_CameraDepthTexture));
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture0", new RenderTargetIdentifier(s_GBufferAlbedo));
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture1", new RenderTargetIdentifier(s_GBufferSpecRough));
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture2", new RenderTargetIdentifier(s_GBufferNormal));
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture3", new RenderTargetIdentifier(s_GBufferEmission));
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_spotCookieTextures", m_CookieTexArray.GetTexCache());
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_pointCookieTextures", m_CubeCookieTexArray.GetTexCache());
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_reflCubeTextures", m_CubeReflTexArray.GetTexCache());
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_reflRootCubeTexture", ReflectionProbe.GetDefaultTexture());
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "g_tShadowBuffer", new RenderTargetIdentifier(m_shadowBufferID));
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "unity_NHxRoughness", m_NHxRoughnessTexture);
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_LightTextureB0", m_LightAttentuationTexture);
+                            var camera = hdCamera.camera;
-                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
-                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "_LightVolumeData", s_LightVolumeDataBuffer);
-                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_dirLightData", s_DirLightList);
+                            int w = camera.pixelWidth;
+                            int h = camera.pixelHeight;
+                            int numTilesX = GetNumTileX(camera);
+                            int numTilesY = GetNumTileY(camera);
-                        var defdecode = ReflectionProbe.GetDefaultTextureHDRDecodeValues();
-                        cmd.SetComputeFloatParam(deferredComputeShader, "_reflRootHdrDecodeMult", defdecode.x);
-                        cmd.SetComputeFloatParam(deferredComputeShader, "_reflRootHdrDecodeExp", defdecode.y);
+                            // Pass global parameters to compute shader
+                            // TODO: get rid of this by making global parameters visible to compute shaders
+                            BindGlobalParams(cmd, shadeOpaqueShader, kernel, camera, renderLoop);
-                        cmd.SetComputeFloatParam(deferredComputeShader, "g_fClustScale", m_ClustScale);
-                        cmd.SetComputeFloatParam(deferredComputeShader, "g_fClustBase", k_ClustLogBase);
-                        cmd.SetComputeFloatParam(deferredComputeShader, "g_fNearPlane", camera.nearClipPlane);
-                        cmd.SetComputeFloatParam(deferredComputeShader, "g_fFarPlane", camera.farClipPlane);
-                        cmd.SetComputeIntParam(deferredComputeShader, "g_iLog2NumClusters", k_Log2NumClusters);
-                        cmd.SetComputeIntParam(deferredComputeShader, "g_isLogBaseBufferEnabled", k_UseDepthBuffer ? 1 : 0);
-                        cmd.SetComputeIntParam(deferredComputeShader, "_UseTileLightList", 0);
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_CameraDepthTexture", Shader.PropertyToID("_CameraDepthTexture"));
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture0", Shader.PropertyToID("_GBufferTexture0"));
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture1", Shader.PropertyToID("_GBufferTexture1"));
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture2", Shader.PropertyToID("_GBufferTexture2"));
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture3", Shader.PropertyToID("_GBufferTexture3"));
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture4", Shader.PropertyToID("_GBufferTexture4"));
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "g_tShadowBuffer", Shader.PropertyToID("g_tShadowBuffer"));
-                        //
-                        var proj = camera.projectionMatrix;
-                        var temp = new Matrix4x4();
-                        temp.SetRow(0, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
-                        temp.SetRow(1, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
-                        temp.SetRow(2, new Vector4(0.0f, 0.0f, 0.5f, 0.5f));
-                        temp.SetRow(3, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
-                        var projh = temp * proj;
-                        var invProjh = projh.inverse;
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_PreIntegratedFGD", Shader.GetGlobalTexture("_PreIntegratedFGD"));
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcGGXMatrix", Shader.GetGlobalTexture("_LtcGGXMatrix"));
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcDisneyDiffuseMatrix", Shader.GetGlobalTexture("_LtcDisneyDiffuseMatrix"));
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcMultiGGXFresnelDisneyDiffuse", Shader.GetGlobalTexture("_LtcMultiGGXFresnelDisneyDiffuse"));
-                        temp.SetRow(0, new Vector4(0.5f * w, 0.0f, 0.0f, 0.5f * w));
-                        temp.SetRow(1, new Vector4(0.0f, 0.5f * h, 0.0f, 0.5f * h));
-                        temp.SetRow(2, new Vector4(0.0f, 0.0f, 0.5f, 0.5f));
-                        temp.SetRow(3, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
-                        var projscr = temp * proj;
-                        var invProjscr = projscr.inverse;
+                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_InvViewProjMatrix", Shader.GetGlobalMatrix("_InvViewProjMatrix"));
+                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_ViewProjMatrix", Shader.GetGlobalMatrix("_ViewProjMatrix"));
+                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "g_mInvScrProjection", Shader.GetGlobalMatrix("g_mInvScrProjection"));
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenSize", Shader.GetGlobalVector("_ScreenSize"));
+                            cmd.SetComputeIntParam(shadeOpaqueShader, "_UseTileLightList", Shader.GetGlobalInt("_UseTileLightList"));
-                        cmd.SetComputeIntParam(deferredComputeShader, "_EnvLightIndexShift", m_lightList.lights.Count);
-                        cmd.SetComputeIntParam(deferredComputeShader, "g_iNrVisibLights", numLights);
-                        SetMatrixCS(cmd, deferredComputeShader, "g_mScrProjection", projscr);
-                        SetMatrixCS(cmd, deferredComputeShader, "g_mInvScrProjection", invProjscr);
-                        SetMatrixCS(cmd, deferredComputeShader, "g_mViewToWorld", camera.cameraToWorldMatrix);
-
-
-                        if (bUseClusteredForDeferred)
-                        {
-                            cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLayeredOffsetsBuffer", s_PerVoxelOffset);
-                            if (k_UseDepthBuffer)
-                            {
-                                cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_logBaseBuffer", s_PerTileLogBaseTweak);
-                            }
-                        }
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "_Time", Shader.GetGlobalVector("_Time"));
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "_SinTime", Shader.GetGlobalVector("_SinTime"));
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "_CosTime", Shader.GetGlobalVector("_CosTime"));
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "unity_DeltaTime", Shader.GetGlobalVector("unity_DeltaTime"));
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "_WorldSpaceCameraPos", Shader.GetGlobalVector("_WorldSpaceCameraPos"));
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "_ProjectionParams", Shader.GetGlobalVector("_ProjectionParams"));
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenParams", Shader.GetGlobalVector("_ScreenParams"));
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "_ZBufferParams", Shader.GetGlobalVector("_ZBufferParams"));
+                            cmd.SetComputeVectorParam(shadeOpaqueShader, "unity_OrthoParams", Shader.GetGlobalVector("unity_OrthoParams"));
+                            cmd.SetComputeIntParam(shadeOpaqueShader, "_EnvLightSkyEnabled", Shader.GetGlobalInt("_EnvLightSkyEnabled"));
-                        cmd.SetComputeIntParam(deferredComputeShader, "g_widthRT", w);
-                        cmd.SetComputeIntParam(deferredComputeShader, "g_heightRT", h);
-                        cmd.SetComputeIntParam(deferredComputeShader, "g_nNumDirLights", numDirLights);
-                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_dirLightData", s_DirLightList);
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, "uavOutput", new RenderTargetIdentifier(s_CameraTarget));
+                            Texture skyTexture = Shader.GetGlobalTexture("_SkyTexture");
+                            Texture IESArrayTexture = Shader.GetGlobalTexture("_IESArray");
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_IESArray", IESArrayTexture ? IESArrayTexture : m_DefaultTexture2DArray);
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_SkyTexture", skyTexture ? skyTexture : m_DefaultTexture2DArray);
-                        SetMatrixArrayCS(cmd, deferredComputeShader, "g_matWorldToShadow", m_MatWorldToShadow);
-                        SetVectorArrayCS(cmd, deferredComputeShader, "g_vDirShadowSplitSpheres", m_DirShadowSplitSpheres);
-                        cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms0", m_Shadow3X3PCFTerms[0]);
-                        cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms1", m_Shadow3X3PCFTerms[1]);
-                        cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms2", m_Shadow3X3PCFTerms[2]);
-                        cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms3", m_Shadow3X3PCFTerms[3]);
-
-                        cmd.DispatchCompute(deferredComputeShader, kernel, numTilesX, numTilesY, 1);
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "uavOutput", cameraColorBufferRT);
+                            cmd.DispatchCompute(shadeOpaqueShader, kernel, numTilesX, numTilesY, 1);
-                    {*/
-
-                    if (disableTileAndCluster)
-                        cmd.Blit(null, cameraColorBufferRT, m_SingleDeferredMaterial, 0);
-                    }
-                    else
-                    {
+                            // Pixel shader evaluation
+                                Utilities.SetupMaterialHDCamera(hdCamera, m_DeferredDirectMaterial);
+                                m_DeferredDirectMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                                m_DeferredDirectMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                                m_DeferredDirectMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                                m_DeferredDirectMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+
+                                Utilities.SetupMaterialHDCamera(hdCamera, m_DeferredIndirectMaterial);
+                                m_DeferredIndirectMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                                m_DeferredIndirectMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One); // Additive
+                                m_DeferredIndirectMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                                m_DeferredIndirectMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+
+                                Utilities.SetupMaterialHDCamera(hdCamera, m_DeferredAllMaterial);
+                                m_DeferredAllMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                                m_DeferredAllMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                                m_DeferredAllMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                                m_DeferredAllMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+
+                        }
+                        // Draw tile debugging
+                            Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewTilesMaterial);
+                            m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", debugViewTilesFlags);
+                            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");
+
+                    SetGlobalPropertyRedirect(null, 0, null);
                     //}
 
                     renderLoop.ExecuteCommandBuffer(cmd);
 
-            public override void RenderForward(Camera camera, RenderLoop renderLoop, bool renderOpaque)
+            public override void RenderForward(Camera camera, ScriptableRenderContext renderLoop, bool renderOpaque)
             {
                 // Note: if we use render opaque with deferred tiling we need to render a opque depth pass for these opaque objects
                 bool useFptl = renderOpaque && usingFptl;

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

             public readonly GUIContent layerTexWorldScaleText = new GUIContent("Tiling", "Tiling factor applied to Planar/Trilinear mapping");
             public readonly GUIContent UVBaseText = new GUIContent("Base UV Mapping", "Base UV Mapping mode of the layer.");
             public readonly GUIContent UVDetailText = new GUIContent("Detail UV Mapping", "Detail UV Mapping mode of the layer.");
+            public readonly GUIContent useHeightBasedBlendText = new GUIContent("Use Height Based Blend", "Layer will be blended with the underlying layer based on the height.");
+            public readonly GUIContent heightOffsetText = new GUIContent("HeightOffset", "Height offset from the previous layer.");
+            public readonly GUIContent heightFactorText = new GUIContent("Height Multiplier", "Scale applied to the height of the layer.");
+            public readonly GUIContent blendSizeText = new GUIContent("Blend Size", "Thickness over which the layer will be blended with the previous one.");
+
+
         }
 
         static StylesLayer s_Styles = null;
         MaterialProperty[] layerUVDetail = new MaterialProperty[kMaxLayerCount];
         MaterialProperty[] layerUVDetailsMappingMask = new MaterialProperty[kMaxLayerCount];
 
+        const string kUseHeightBasedBlend = "_UseHeightBasedBlend";
+        MaterialProperty[] useHeightBasedBlend = new MaterialProperty[kMaxLayerCount-1];
+        const string kHeightOffset = "_HeightOffset";
+        MaterialProperty[] heightOffset = new MaterialProperty[kMaxLayerCount-1];
+        const string kHeightFactor = "_HeightFactor";
+        MaterialProperty[] heightFactor = new MaterialProperty[kMaxLayerCount-1];
+        const string kBlendSize = "_BlendSize";
+        MaterialProperty[] blendSize = new MaterialProperty[kMaxLayerCount-1];
+
         MaterialProperty layerEmissiveColor = null;
         MaterialProperty layerEmissiveColorMap = null;
         MaterialProperty layerEmissiveIntensity = null;
                 layerUVMappingPlanar[i] = FindProperty(string.Format("{0}{1}", kUVMappingPlanar, i), props);
                 layerUVDetail[i] = FindProperty(string.Format("{0}{1}", kUVDetail, i), props);
                 layerUVDetailsMappingMask[i] = FindProperty(string.Format("{0}{1}", kUVDetailsMappingMask, i), props);
+
+                if(i != 0)
+                {
+                    useHeightBasedBlend[i-1] = FindProperty(string.Format("{0}{1}", kUseHeightBasedBlend, i), props);
+                    heightOffset[i-1] = FindProperty(string.Format("{0}{1}", kHeightOffset, i), props);
+                    heightFactor[i-1] = FindProperty(string.Format("{0}{1}", kHeightFactor, i), props);
+                    blendSize[i-1] = FindProperty(string.Format("{0}{1}", kBlendSize, i), props);
+                }
             }
 
             layerEmissiveColor = FindProperty(kEmissiveColor, props);
 
         void SynchronizeLayerProperties(int layerIndex)
         {
-            string[] exclusionList = { kTexWorldScale, kUVBase, kUVMappingMask, kUVDetail, kUVDetailsMappingMask };
+            string[] exclusionList = { kTexWorldScale, kUVBase, kUVMappingMask, kUVDetail, kUVMappingPlanar, kUVDetailsMappingMask };
 
             Material material = m_MaterialEditor.target as Material;
             Material layerMaterial = m_MaterialLayers[layerIndex];
                 }
             }
 
+            if(layerIndex > 0)
+            {
+                int heightParamIndex = layerIndex - 1;
+                EditorGUI.BeginChangeCheck();
+                EditorGUI.showMixedValue = useHeightBasedBlend[heightParamIndex].hasMixedValue;
+                bool enabled = EditorGUILayout.Toggle(styles.useHeightBasedBlendText, useHeightBasedBlend[heightParamIndex].floatValue > 0.0f);
+                if(EditorGUI.EndChangeCheck())
+                {
+                    useHeightBasedBlend[heightParamIndex].floatValue = enabled ? 1.0f : 0.0f;
+                }
+
+                if(enabled)
+                {
+                    m_MaterialEditor.ShaderProperty(heightOffset[heightParamIndex], styles.heightOffsetText);
+                    m_MaterialEditor.ShaderProperty(heightFactor[heightParamIndex], styles.heightFactorText);
+                    m_MaterialEditor.ShaderProperty(blendSize[heightParamIndex], styles.blendSizeText);
+                }
+            }
+
             EditorGUI.indentLevel--;
 
             return result;
             }
 
             m_MaterialEditor.serializedObject.ApplyModifiedProperties();
-
-            if (layerChanged)
-            {
-                materialImporter.SaveAndReimport();
-            }
         }
     }
 } // namespace UnityEditor

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

         _LayerMaskMap("LayerMaskMap", 2D) = "white" {}
         [ToggleOff]  _LayerMaskVertexColor("Use Vertex Color Mask", Float) = 0.0
 
+        // Height based blend (layer 0 does not need it)
+        _UseHeightBasedBlend1("UseHeightBasedBlend1", Float) = 0.0
+        _UseHeightBasedBlend2("UseHeightBasedBlend2", Float) = 0.0
+        _UseHeightBasedBlend3("UseHeightBasedBlend3", Float) = 0.0
+
+        _HeightOffset1("_HeightOffset1", Range(-0.3, 0.3)) = 0.0
+        _HeightOffset2("_HeightOffset2", Range(-0.3, 0.3)) = 0.0
+        _HeightOffset3("_HeightOffset3", Range(-0.3, 0.3)) = 0.0
+
+        _HeightFactor1("_HeightFactor1", Range(0, 5)) = 1
+        _HeightFactor2("_HeightFactor2", Range(0, 5)) = 1
+        _HeightFactor3("_HeightFactor3", Range(0, 5)) = 1
+
+        _BlendSize1("_BlendSize1", Range(0, 0.05)) = 0.0
+        _BlendSize2("_BlendSize2", Range(0, 0.05)) = 0.0
+        _BlendSize3("_BlendSize3", Range(0, 0.05)) = 0.0
+
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
         _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
 
     TEXTURE2D(_LayerMaskMap);
     SAMPLER2D(sampler_LayerMaskMap);
+
+    float _UseHeightBasedBlend1;
+    float _UseHeightBasedBlend2;
+    float _UseHeightBasedBlend3;
+    float _HeightOffset1;
+    float _HeightOffset2;
+    float _HeightOffset3;
+    float _HeightFactor1;
+    float _HeightFactor2;
+    float _HeightFactor3;
+    float _BlendSize1;
+    float _BlendSize2;
+    float _BlendSize3;
 
     float3 _EmissiveColor;
     TEXTURE2D(_EmissiveColorMap);

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

                 isInit = false;
             }
 
-            public void RenderInit(UnityEngine.Experimental.Rendering.RenderLoop renderLoop)
+            public void RenderInit(Rendering.ScriptableRenderContext renderLoop)
             {
                 var cmd = new CommandBuffer();
                 cmd.name = "Init PreFGD";

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

     return result;
 }
 
+float ApplyHeightBasedBlend(inout float inputFactor, float previousLayerHeight, float layerHeight, float heightOffset, float heightFactor, float edgeBlendStrength)
+{
+    float finalLayerHeight = layerHeight * heightFactor + heightOffset;
+
+    edgeBlendStrength = max(0.001, edgeBlendStrength);
+
+    float heightThreshold = previousLayerHeight + edgeBlendStrength;
+
+    if (previousLayerHeight >= finalLayerHeight)
+    {
+        inputFactor = 0.0;
+    }
+    else if (finalLayerHeight > previousLayerHeight && finalLayerHeight < previousLayerHeight + edgeBlendStrength)
+    {
+        inputFactor = inputFactor * pow((finalLayerHeight - previousLayerHeight) / edgeBlendStrength, 0.5);
+    }
+
+    return max(finalLayerHeight, previousLayerHeight);
+}
+
+
 #define SURFACEDATA_BLEND_COLOR(surfaceData, name, mask) BlendLayeredColor(surfaceData##0.##name, surfaceData##1.##name, surfaceData##2.##name, surfaceData##3.##name, mask);
 #define SURFACEDATA_BLEND_NORMAL(surfaceData, name, mask) BlendLayeredNormal(surfaceData##0.##name, surfaceData##1.##name, surfaceData##2.##name, surfaceData##3.##name, mask);
 #define SURFACEDATA_BLEND_SCALAR(surfaceData, name, mask) BlendLayeredScalar(surfaceData##0.##name, surfaceData##1.##name, surfaceData##2.##name, surfaceData##3.##name, mask);
 
     // Transform view vector in tangent space
     float3 viewDirTS = TransformWorldToTangent(V, input.tangentToWorld);
-    ApplyDisplacement0(input, viewDirTS, layerTexCoord);
-    ApplyDisplacement1(input, viewDirTS, layerTexCoord);
-    ApplyDisplacement2(input, viewDirTS, layerTexCoord);
-    ApplyDisplacement3(input, viewDirTS, layerTexCoord);
+    float height0 = ApplyDisplacement0(input, viewDirTS, layerTexCoord);
+    float height1 = ApplyDisplacement1(input, viewDirTS, layerTexCoord);
+    float height2 = ApplyDisplacement2(input, viewDirTS, layerTexCoord);
+    float height3 = ApplyDisplacement3(input, viewDirTS, layerTexCoord);
     float depthOffset = 0.0;
 
 #ifdef _DEPTHOFFSET_ON
 #if defined(_LAYER_MASK_VERTEX_COLOR)
     maskValues *= input.vertexColor.rgb;
 #endif
+
+    float baseLayerHeight = height0;
+    if (_UseHeightBasedBlend1 > 0.0f)
+    {
+        baseLayerHeight = ApplyHeightBasedBlend(maskValues.r, baseLayerHeight, height1, _HeightOffset1, _HeightFactor1, _BlendSize1);
+    }
+    if (_UseHeightBasedBlend2 > 0.0f)
+    {
+        baseLayerHeight = ApplyHeightBasedBlend(maskValues.g, baseLayerHeight, height2, _HeightOffset2 + _HeightOffset1, _HeightFactor2, _BlendSize2);
+    }
+    if (_UseHeightBasedBlend3 > 0.0f)
+    {
+        ApplyHeightBasedBlend(maskValues.b, baseLayerHeight, height3, _HeightOffset3 + _HeightOffset2 + _HeightOffset1, _HeightFactor3, _BlendSize3);
+    }
 
     float weights[_MAX_LAYER];
     ComputeMaskWeights(maskValues, weights);

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

     ADD_IDX(layerTexCoord.details).uvXY = TRANSFORM_TEX(uvXY, ADD_IDX(_DetailMap));
 }
 
-void ADD_IDX(ApplyDisplacement)(inout FragInputs input, float3 viewDirTS, inout LayerTexCoord layerTexCoord)
+float ADD_IDX(ApplyDisplacement)(inout FragInputs input, float3 viewDirTS, inout LayerTexCoord layerTexCoord)
+    float height = 0.0f;
+
-   #ifndef _HEIGHTMAP_AS_DISPLACEMENT
-    float height = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), ADD_IDX(layerTexCoord.base)).r * ADD_IDX(_HeightScale) + ADD_IDX(_HeightBias);
-    float2 offset = ParallaxOffset(viewDirTS, height);
+    height = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), ADD_IDX(layerTexCoord.base)).r * ADD_IDX(_HeightScale) + ADD_IDX(_HeightBias);
-    ADD_IDX(layerTexCoord.base).uv += offset;
-    ADD_IDX(layerTexCoord.base).uvYZ += offset;
-    ADD_IDX(layerTexCoord.base).uvZX += offset;
-    ADD_IDX(layerTexCoord.base).uvXY += offset;
+   //#ifndef _HEIGHTMAP_AS_DISPLACEMENT
+   // //height = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), ADD_IDX(layerTexCoord.base)).r * ADD_IDX(_HeightScale) + ADD_IDX(_HeightBias);
+   // float2 offset = ParallaxOffset(viewDirTS, height);
-    ADD_IDX(layerTexCoord.details).uv += offset;
-    ADD_IDX(layerTexCoord.details).uvYZ += offset;
-    ADD_IDX(layerTexCoord.details).uvZX += offset;
-    ADD_IDX(layerTexCoord.details).uvXY += offset;
+   // ADD_IDX(layerTexCoord.base).uv += offset;
+   // ADD_IDX(layerTexCoord.base).uvYZ += offset;
+   // ADD_IDX(layerTexCoord.base).uvZX += offset;
+   // ADD_IDX(layerTexCoord.base).uvXY += offset;
-    // Only modify texcoord for first layer, this will be use by for builtin data (like lightmap)
-    if (LAYER_INDEX == 0)
-    {
-        input.texCoord0 += offset;
-        input.texCoord1 += offset;
-        input.texCoord2 += offset;
-        input.texCoord3 += offset;
-    }
-    #endif
+   // ADD_IDX(layerTexCoord.details).uv += offset;
+   // ADD_IDX(layerTexCoord.details).uvYZ += offset;
+   // ADD_IDX(layerTexCoord.details).uvZX += offset;
+   // ADD_IDX(layerTexCoord.details).uvXY += offset;
+
+   // // Only modify texcoord for first layer, this will be use by for builtin data (like lightmap)
+   // if (LAYER_INDEX == 0)
+   // {
+   //     input.texCoord0 += offset;
+   //     input.texCoord1 += offset;
+   //     input.texCoord2 += offset;
+   //     input.texCoord3 += offset;
+   // }
+
+   // // Need to refetch for the right parallaxed height for layer blending to behave correctly...
+   // height = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), ADD_IDX(layerTexCoord.base)).r * ADD_IDX(_HeightScale) + ADD_IDX(_HeightBias);
+
+   // #endif
+
+    return height;
 }
 
 // Return opacity

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/SkyManager.cs

         public Vector3                  cameraPosWS;
         public Vector4                  screenSize;
         public Mesh                     skyMesh;
-        public RenderLoop               renderLoop;
+        public ScriptableRenderContext  renderLoop;
         public Light                    sunLight;
         public RenderTargetIdentifier   colorBuffer;
         public RenderTargetIdentifier   depthBuffer;
             }
         }
 
-        private void BuildProbabilityTables(RenderLoop renderLoop)
+        private void BuildProbabilityTables(ScriptableRenderContext renderLoop)
         {
             // Bind the input cubemap.
             m_BuildProbabilityTablesCS.SetTexture(m_ConditionalDensitiesKernel, "envMap", m_SkyboxCubemapRT);
             cmd.Dispose();
         }
 
-        private void RenderCubemapGGXConvolution(RenderLoop renderLoop, BuiltinSkyParameters builtinParams, SkyParameters skyParams, Texture input, RenderTexture target)
+        private void RenderCubemapGGXConvolution(ScriptableRenderContext renderLoop, BuiltinSkyParameters builtinParams, SkyParameters skyParams, Texture input, RenderTexture target)
         {
             using (new Utilities.ProfilingSample("Sky Pass: GGX Convolution", renderLoop))
             {
             m_UpdateRequired = true;
         }
 
-        public void UpdateEnvironment(HDRenderLoop.HDCamera camera, Light sunLight, RenderLoop renderLoop)
+        public void UpdateEnvironment(HDRenderLoop.HDCamera camera, Light sunLight, ScriptableRenderContext renderLoop)
         {
             {
                 using (new Utilities.ProfilingSample("Sky Environment Pass", renderLoop))
             }
         }
 
-        public void RenderSky(HDRenderLoop.HDCamera camera, Light sunLight, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, RenderLoop renderLoop)
+        public void RenderSky(HDRenderLoop.HDCamera camera, Light sunLight, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ScriptableRenderContext renderLoop)
         {
             using (new Utilities.ProfilingSample("Sky Pass", renderLoop))
             {

Assets/ScriptableRenderLoop/HDRenderLoop/Utilities.cs

         // Render Target Management.
         public const ClearFlag kClearAll = ClearFlag.ClearDepth | ClearFlag.ClearColor;
 
-        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier buffer, ClearFlag clearFlag = ClearFlag.ClearNone, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(ScriptableRenderContext renderLoop, RenderTargetIdentifier buffer, ClearFlag clearFlag = ClearFlag.ClearNone, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
         {
             var cmd = new CommandBuffer();
             cmd.name = "";
         }
 
-        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(ScriptableRenderContext renderLoop, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
-        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(ScriptableRenderContext renderLoop, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
-        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(ScriptableRenderContext renderLoop, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
         {
             var cmd = new CommandBuffer();
             cmd.name = "";
             cmd.Dispose();
         }
 
-        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer)
+        public static void SetRenderTarget(ScriptableRenderContext renderLoop, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer)
-        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag = ClearFlag.ClearNone)
+        public static void SetRenderTarget(ScriptableRenderContext renderLoop, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag = ClearFlag.ClearNone)
-        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor)
+        public static void SetRenderTarget(ScriptableRenderContext renderLoop, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor)
         {
             var cmd = new CommandBuffer();
             cmd.name = "";
             : IDisposable
         {
             bool        disposed = false;
-            RenderLoop  renderLoop;
+            ScriptableRenderContext  renderLoop;
-            public ProfilingSample(string _name, RenderLoop _renderloop)
+            public ProfilingSample(string _name, ScriptableRenderContext _renderloop)
             {
                 renderLoop = _renderloop;
                 name = _name;

Assets/ScriptableRenderLoop/RenderPasses/ShadowRenderPass.cs

             parameters.shadowDistance = Mathf.Min(m_Settings.maxShadowDistance, parameters.shadowDistance);
         }
 
-        public void Render(RenderLoop loop, CullResults cullResults, out ShadowOutput packedShadows)
+        public void Render(ScriptableRenderContext loop, CullResults cullResults, out ShadowOutput packedShadows)
         {
             if (!m_Settings.enabled)
             {
         //---------------------------------------------------------------------------------------------------------------------------------------------------
         // Render shadows
         //---------------------------------------------------------------------------------------------------------------------------------------------------
-        void RenderPackedShadows(RenderLoop loop, CullResults cullResults, ref ShadowOutput packedShadows)
+        void RenderPackedShadows(ScriptableRenderContext loop, CullResults cullResults, ref ShadowOutput packedShadows)
         {
             var setRenderTargetCommandBuffer = new CommandBuffer();
 
         }
 
         //---------------------------------------------------------------------------------------------------------------------------------------------------
-        private void RenderShadowSplit(ref ShadowSliceData slice, Vector3 lightDirection, Matrix4x4 proj, Matrix4x4 view, ref RenderLoop loop, DrawShadowsSettings settings)
+        private void RenderShadowSplit(ref ShadowSliceData slice, Vector3 lightDirection, Matrix4x4 proj, Matrix4x4 view, ref ScriptableRenderContext loop, DrawShadowsSettings settings)
         {
             var commandBuffer = new CommandBuffer { name = "ShadowSetup" };
 

Assets/ScriptableRenderLoop/common/SkyboxHelper.cs

 using System.Collections.Generic;
 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering;
 
 public class SkyboxHelper
 {
         get { return m_Mesh; }
     }
 
-    public void Draw(RenderLoop loop, Camera camera)
+    public void Draw(ScriptableRenderContext loop, Camera camera)
     {
         if (camera.clearFlags != CameraClearFlags.Skybox)
         {

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

 using UnityEngine.Experimental.Rendering;
 using System;
 using System.Collections.Generic;
+using UnityEngine.ScriptableRenderPipeline;
 
 namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
             UnityEditor.AssetDatabase.CreateAsset(instance, "Assets/renderloopfptl.asset");
             //AssetDatabase.CreateAsset(instance, "Assets/ScriptableRenderLoop/fptl/renderloopfptl.asset");
         }
-
+        private class FptlLightingDataStore : RenderingDataStore
+        {
+            public FptlLightingDataStore(BaseRenderPipeline owner) : base(owner)
+            {}
+
+            protected override void InternalBuild()
+            {
+                base.InternalBuild();
+                FptlLighting theOwner = owner as FptlLighting;
+                if (theOwner != null)
+                    theOwner.Build();
+            }
+            
+            protected override void InternalCleanup()
+            {
+                base.InternalCleanup();
+                FptlLighting theOwner = owner as FptlLighting;
+                if (theOwner != null)
+                    theOwner.Cleanup();
+            }
+        }
+
         [SerializeField]
         ShadowSettings m_ShadowSettings = ShadowSettings.Default;
         ShadowRenderPass m_ShadowPass;
         private Texture2D m_LightAttentuationTexture;
         private int m_shadowBufferID;
 
-        public override void Cleanup()
+        public void Cleanup()
         {
             if (m_DeferredMaterial) DestroyImmediate(m_DeferredMaterial);
             if (m_DeferredReflectionMaterial) DestroyImmediate(m_DeferredReflectionMaterial);
             }
         }
 
-        public override void Build()
+        public void Build()
         {
             s_GBufferAlbedo = Shader.PropertyToID("_CameraGBufferTexture0");
             s_GBufferSpecRough = Shader.PropertyToID("_CameraGBufferTexture1");
             m_shadowBufferID = Shader.PropertyToID("g_tShadowBuffer");
         }
 
+        public override IScriptableRenderDataStore ConstructDataStore()
+        {
+            return new FptlLightingDataStore(this);
+        }
+
         static void SetupGBuffer(int width, int height, CommandBuffer cmd)
         {
             var format10 = RenderTextureFormat.ARGB32;
             //@TODO: render VR occlusion mesh
         }
 
-        static void RenderGBuffer(CullResults cull, Camera camera, RenderLoop loop)
+        static void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext loop)
         {
             // setup GBuffer for rendering
             var cmd = new CommandBuffer { name = "Create G-Buffer" };
             loop.DrawRenderers(ref settings);
         }
 
-        void RenderForward(CullResults cull, Camera camera, RenderLoop loop, bool opaquesOnly)
+        void RenderForward(CullResults cull, Camera camera, ScriptableRenderContext loop, bool opaquesOnly)
         {
             var cmd = new CommandBuffer { name = opaquesOnly ? "Prep Opaques Only Forward Pass" : "Prep Forward Pass" };
 
             loop.DrawRenderers(ref settings);
         }
 
-        static void DepthOnlyForForwardOpaques(CullResults cull, Camera camera, RenderLoop loop)
+        static void DepthOnlyForForwardOpaques(CullResults cull, Camera camera, ScriptableRenderContext loop)
         {
             var cmd = new CommandBuffer { name = "Forward Opaques - Depth Only" };
             cmd.SetRenderTarget(new RenderTargetIdentifier(s_GBufferZ));
             }
         }
         
-        static void CopyDepthAfterGBuffer(RenderLoop loop)
+        static void CopyDepthAfterGBuffer(ScriptableRenderContext loop)
         {
             var cmd = new CommandBuffer { name = "Copy depth" };
             cmd.CopyTexture(new RenderTargetIdentifier(s_GBufferZ), new RenderTargetIdentifier(s_CameraDepthTexture));
 
-        void DoTiledDeferredLighting(Camera camera, RenderLoop loop, int numLights, int numDirLights)
+        void DoTiledDeferredLighting(Camera camera, ScriptableRenderContext loop, int numLights, int numDirLights)
         {
             var bUseClusteredForDeferred = !usingFptl;
             var cmd = new CommandBuffer();
             return numLightsOut + numProbesOut;
         }
 
-        public override void Render(Camera[] cameras, RenderLoop renderLoop)
+        [NonSerialized]
+        readonly List<Camera> m_CamerasToRender = new List<Camera>();
+
+        public override void Render(ScriptableRenderContext renderLoop, IScriptableRenderDataStore dataStore)
-            foreach (var camera in cameras)
+            base.Render(renderLoop, dataStore);
+            cameraProvider.GetCamerasToRender(m_CamerasToRender);
+
+            foreach (var camera in m_CamerasToRender)
             {
                 CullingParameters cullingParams;
                 if (!CullResults.GetCullingParameters(camera, out cullingParams))
             }
 
             renderLoop.Submit();
+
+            CleanCameras(m_CamerasToRender);
+            m_CamerasToRender.Clear();
-        void FinalPass(RenderLoop loop)
+        void FinalPass(ScriptableRenderContext loop)
         {
             var cmd = new CommandBuffer { name = "FinalPass" };
             cmd.Blit(s_CameraTarget, BuiltinRenderTextureType.CameraTarget, m_BlitMaterial, 0);
 
-        void ExecuteRenderLoop(Camera camera, CullResults cullResults, RenderLoop loop)
+        void ExecuteRenderLoop(Camera camera, CullResults cullResults, ScriptableRenderContext loop)
         {
             var w = camera.pixelWidth;
             var h = camera.pixelHeight;
 
         }
 
-        void DrawLightBoundsDebug(RenderLoop loop, int numLights)
+        void DrawLightBoundsDebug(ScriptableRenderContext loop, int numLights)
         {
             var cmd = new CommandBuffer { name = "DrawLightBoundsDebug" };
             m_DebugLightBoundsMaterial.SetBuffer("g_data", s_ConvexBoundsBuffer);
             m_CubeReflTexArray.NewFrame();
         }
 
-        void RenderShadowMaps(CullResults cullResults, RenderLoop loop)
+        void RenderShadowMaps(CullResults cullResults, ScriptableRenderContext loop)
         {
             ShadowOutput shadows;
             m_ShadowPass.Render(loop, cullResults, out shadows);
             cmd.DispatchCompute(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, numTilesX, numTilesY, 1);
         }
 
-        void BuildPerTileLightLists(Camera camera, RenderLoop loop, int numLights, Matrix4x4 projscr, Matrix4x4 invProjscr)
+        void BuildPerTileLightLists(Camera camera, ScriptableRenderContext loop, int numLights, Matrix4x4 projscr, Matrix4x4 invProjscr)
         {
             var w = camera.pixelWidth;
             var h = camera.pixelHeight;
             cmd.Dispose();
         }
 
-        void PushGlobalParams(Camera camera, RenderLoop loop, Matrix4x4 viewToWorld, Matrix4x4 scrProj, Matrix4x4 incScrProj, int numDirLights)
+        void PushGlobalParams(Camera camera, ScriptableRenderContext loop, Matrix4x4 viewToWorld, Matrix4x4 scrProj, Matrix4x4 incScrProj, int numDirLights)
         {
             var cmd = new CommandBuffer { name = "Push Global Parameters" };
 

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

+#pragma kernel ShadeOpaque_Fptl				SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl				USE_FPTL_LIGHTLIST=1
+#pragma kernel ShadeOpaque_Clustered		SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered		USE_CLUSTERED_LIGHTLIST=1
+
+
+#define LIGHTLOOP_TILE_PASS 1
+#define LIGHTLOOP_TILE_DIRECT 1
+#define LIGHTLOOP_TILE_INDIRECT 1
+#define LIGHTLOOP_TILE_ALL 1
+#define USE_FPTL_LIGHTLIST 1
+
+
+//-------------------------------------------------------------------------------------
+// Include
+//-------------------------------------------------------------------------------------
+
+#include "Common.hlsl"
+
+// Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
+// deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
+// the deferred shader will require to use multicompile.
+#define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
+#include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderConfig.cs.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Lighting.hlsl" // This include Material.hlsl
+
+//-------------------------------------------------------------------------------------
+// variable declaration
+//-------------------------------------------------------------------------------------
+
+DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
+
+TEXTURE2D(_CameraDepthTexture);
+SAMPLER2D(sampler_CameraDepthTexture);
+
+RWTexture2D<float4> uavOutput;
+
+[numthreads(TILE_SIZE, TILE_SIZE, 1)]
+void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
+{
+    // input.positionCS is SV_Position
+    uint2 pixelCoord = dispatchThreadId;
+    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw);
+    float depth = LOAD_TEXTURE2D(_CameraDepthTexture, 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, bsdfData, bakeDiffuseLighting);
+
+    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
+
+    float3 diffuseLighting;
+    float3 specularLighting;
+    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
+
+    uavOutput[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
+}
+

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/Resources/shadeopaque.compute.meta

+fileFormatVersion: 2
+guid: 0b64f79746d2daf4198eaf6eab9af259
+timeCreated: 1481798903
+licenseType: Pro
+ComputeShaderImporter:
+  currentAPIMask: 4
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/core.meta

+fileFormatVersion: 2
+guid: 2850f79359a84d84793e8feefa3ebb54
+folderAsset: yes
+timeCreated: 1483004461
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/core/DefaultCameraProvider.cs

+using System.Collections.Generic;
+using UnityEngine.Experimental.Rendering;
+
+namespace UnityEngine.ScriptableRenderPipeline
+{
+	public class DefaultCameraProvider : ICameraProvider
+	{
+		public Camera overrideCamera { get; set; }
+
+		public static void GetCamerasToRenderDefault(List<Camera> cameras)
+		{
+			cameras.Clear();
+			foreach (var c in Camera.allCameras)
+			{
+				if (c.enabled)
+					cameras.Add(c);
+			}
+		}
+
+		public void GetCamerasToRender(List<Camera> cameras)
+		{
+			if (overrideCamera != null)
+			{
+				cameras.Clear();
+				cameras.Add(overrideCamera);
+			}
+			else
+			{
+				GetCamerasToRenderDefault(cameras);
+			}
+		}
+	}
+}

Assets/ScriptableRenderLoop/core/DefaultCameraProvider.cs.meta

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

Assets/ScriptableRenderLoop/core/RenderPipeline.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.Experimental.Rendering;
+
+namespace UnityEngine.ScriptableRenderPipeline
+{
+	public abstract class RenderPipeline : BaseRenderPipeline
+	{
+		private readonly HashSet<IScriptableRenderDataStore> m_AssociatedDataStores = new HashSet<IScriptableRenderDataStore>();
+		private ICameraProvider m_CameraProvider;
+
+		public override ICameraProvider cameraProvider
+		{
+			get
+			{
+				if (m_CameraProvider == null)
+					m_CameraProvider = ConstructCameraProvider();
+
+				return m_CameraProvider;
+			}
+			set { m_CameraProvider = value; }
+		}
+
+		public override void Render(ScriptableRenderContext renderContext, IScriptableRenderDataStore dataStore)
+		{
+			if (dataStore == null)
+				throw new ArgumentException(string.Format("Null DataStore has been passed into pipe {0}", this));
+
+			if (dataStore.owner == null)
+				throw new ArgumentException(string.Format("DataStore owner is null. It needs o be owned by loop {0}", this));
+
+			if (dataStore.owner != null && !ReferenceEquals(dataStore.owner, this))
+				throw new ArgumentException(string.Format("DataStore {0} has been passed into pipe {1}, but is owned by {2}", dataStore, this, dataStore.owner));
+
+			m_AssociatedDataStores.Add(dataStore);
+			dataStore.Build();
+		}
+
+		public override void ClearCachedData()
+		{
+			foreach (var store in m_AssociatedDataStores)
+				store.Cleanup();
+
+			m_AssociatedDataStores.Clear();
+		}
+
+		public override ICameraProvider ConstructCameraProvider()
+		{
+			return new DefaultCameraProvider();
+		}
+
+		public override IScriptableRenderDataStore ConstructDataStore()
+		{
+			return new RenderingDataStore(this);
+		}
+		
+		public static void CleanCameras(IEnumerable<Camera> cameras)
+		{
+			foreach (var camera in cameras)
+				camera.ClearIntermediateRenderers();
+		}
+	}
+}

Assets/ScriptableRenderLoop/core/RenderPipeline.cs.meta

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

Assets/ScriptableRenderLoop/core/RenderingDataStore.cs

+using UnityEngine.Experimental.Rendering;
+
+namespace UnityEngine.ScriptableRenderPipeline
+{ 
+	public class RenderingDataStore : IScriptableRenderDataStore
+	{
+		private bool m_NeedsBuild = true;
+
+		public RenderingDataStore(IRenderPipeline owner)
+		{
+			this.owner = owner;
+		}
+
+		public void Build()
+		{
+			if (m_NeedsBuild)
+			{
+				InternalBuild();
+				m_NeedsBuild = false;
+			}
+		}
+
+		protected virtual void InternalBuild()
+		{}
+
+		public void Cleanup()
+		{
+			if (!m_NeedsBuild)
+			{
+				InternalCleanup();
+				m_NeedsBuild = true;
+			}
+		}
+
+		protected virtual void InternalCleanup()
+		{}
+
+		public IRenderPipeline owner { get; private set; }
+	}
+}

Assets/ScriptableRenderLoop/core/RenderingDataStore.cs.meta

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