Merge branch 'master'

Assets/ScriptableRenderPipeline/Core/Debugging/DebugActionManager.cs

         {
 #if UNITY_EDITOR
             // Grab reference to input manager
+            var currentSelection = UnityEditor.Selection.activeObject;
             UnityEditor.EditorApplication.ExecuteMenuItem("Edit/Project Settings/Input");
             var inputManager = UnityEditor.Selection.activeObject;
 
 
             // Commit
             soInputManager.ApplyModifiedProperties();
+
+            UnityEditor.Selection.activeObject = currentSelection;
 #endif
         }
 

Assets/ScriptableRenderPipeline/Core/Shadow/Shadow.cs

             cb.ClearRenderTarget( true, !IsNativeDepth(), m_ClearColor );
         }
 
-        override public void Update( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights)
+        override public void Update( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights)
-            var profilingSample = new HDPipeline.Utilities.ProfilingSample(string.Format("Shadowmap{0}",m_TexSlot), renderContext);
+            var profilingSample = new HDPipeline.Utilities.ProfilingSample(string.Format("Shadowmap{0}",m_TexSlot), cmd);
+            string cbName = "";
-                var cb = CommandBufferPool.Get();
-                cb.name = "Shadowmap.EnableShadowKeyword";
-                cb.EnableShaderKeyword(m_ShaderKeyword);
-                renderContext.ExecuteCommandBuffer( cb );
-                CommandBufferPool.Release(cb);
+                cbName = "Shadowmap.EnableShadowKeyword";
+                cmd.BeginSample(cbName);
+                cmd.EnableShaderKeyword(m_ShaderKeyword);
+                cmd.EndSample(cbName);
             }
 
             // loop for generating each individual shadowmap
                 if( !cullResults.GetShadowCasterBounds( m_EntryCache[i].key.visibleIdx, out bounds ) )
                     continue;
 
-                var cb = CommandBufferPool.Get();
-                    cb.name = string.Format("Shadowmap.Update.Slice{0}", entrySlice);
+                    cbName = string.Format("Shadowmap.Update.Slice{0}", entrySlice);
+                    cmd.BeginSample(cbName);
-                        PostUpdate( frameId, cb, curSlice, lights );
+                        PostUpdate( frameId, cmd, curSlice, lights );
-                    PreUpdate( frameId, cb, curSlice );
+                    PreUpdate( frameId, cmd, curSlice );
+
+                    cmd.EndSample(cbName);
-                cb.name = string.Format("Shadowmap.Update - slice: {0}, vp.x: {1}, vp.y: {2}, vp.w: {3}, vp.h: {4}", curSlice, m_EntryCache[i].current.viewport.x, m_EntryCache[i].current.viewport.y, m_EntryCache[i].current.viewport.width, m_EntryCache[i].current.viewport.height);
-                cb.SetViewport( m_EntryCache[i].current.viewport );
-                cb.SetViewProjectionMatrices( m_EntryCache[i].current.view, m_EntryCache[i].current.proj );
-                cb.SetGlobalVector( "g_vLightDirWs", m_EntryCache[i].current.lightDir );
-                renderContext.ExecuteCommandBuffer( cb );
-                CommandBufferPool.Release(cb);
+                cbName = string.Format("Shadowmap.Update - slice: {0}, vp.x: {1}, vp.y: {2}, vp.w: {3}, vp.h: {4}", curSlice, m_EntryCache[i].current.viewport.x, m_EntryCache[i].current.viewport.y, m_EntryCache[i].current.viewport.width, m_EntryCache[i].current.viewport.height);
+                cmd.BeginSample(cbName);
+                cmd.SetViewport( m_EntryCache[i].current.viewport );
+                cmd.SetViewProjectionMatrices( m_EntryCache[i].current.view, m_EntryCache[i].current.proj );
+                cmd.SetGlobalVector( "g_vLightDirWs", m_EntryCache[i].current.lightDir );
+                cmd.EndSample(cbName);
+
+                // This is done here because DrawRenderers API lives outside command buffers so we need to make sur eto call this before doing any DrawRenders
+                renderContext.ExecuteCommandBuffer(cmd);
+                cmd.Clear();
+
-            var cblast = CommandBufferPool.Get();
-            PostUpdate( frameId, cblast, curSlice, lights );
+            PostUpdate( frameId, cmd, curSlice, lights );
-                cblast.name = "Shadowmap.DisableShaderKeyword";
-                cblast.DisableShaderKeyword( m_ShaderKeyword );
+                cmd.BeginSample("Shadowmap.DisableShaderKeyword");
+                cmd.DisableShaderKeyword( m_ShaderKeyword );
+                cmd.EndSample("Shadowmap.DisableShaderKeyword");
-            renderContext.ExecuteCommandBuffer( cblast );
-            CommandBufferPool.Release(cblast);
 
             m_ActiveEntriesCount = 0;
 
             // Nothing to do for this implementation here, as the atlas is reconstructed each frame, instead of keeping state across frames
         }
 
-        override public void DisplayShadowMap(ScriptableRenderContext renderContext, Vector4 scaleBias, uint slice, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
+        override public void DisplayShadowMap(CommandBuffer debugCB, Vector4 scaleBias, uint slice, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
-            CommandBuffer debugCB = CommandBufferPool.Get();
-            debugCB.name = "";
-
             Vector4 validRange = new Vector4(minValue, 1.0f / (maxValue - minValue));
 
             MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
             propertyBlock.SetVector("_ValidRange", validRange);
             debugCB.SetViewport(new Rect(screenX, screenY, screenSizeX, screenSizeY));
             debugCB.DrawProcedural(Matrix4x4.identity, m_DebugMaterial, m_DebugMaterial.FindPass("REGULARSHADOW"), MeshTopology.Triangles, 3, 1, propertyBlock);
-
-            renderContext.ExecuteCommandBuffer(debugCB);
-
-            CommandBufferPool.Release(debugCB);
         }
     }
 
 
         protected override void PostUpdate( FrameId frameId, CommandBuffer cb, uint rendertargetSlice, List<VisibleLight> lights)
         {
-            cb.name = "VSM conversion";
             if ( rendertargetSlice == uint.MaxValue )
             {
                 base.PostUpdate( frameId, cb, rendertargetSlice, lights );
             if( i >= cnt || m_EntryCache[i].current.slice > rendertargetSlice )
                 return;
 
+
+            cb.BeginSample("VSM conversion");
 
             int kernelIdx = 2;
             int currentKernel = 0;
                 i++;
             }
            base.PostUpdate( frameId, cb, rendertargetSlice, lights );
+           cb.EndSample("VSM conversion");
-        override public void DisplayShadowMap(ScriptableRenderContext renderContext, Vector4 scaleBias, uint slice, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
+        override public void DisplayShadowMap(CommandBuffer debugCB, Vector4 scaleBias, uint slice, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
-            CommandBuffer debugCB = CommandBufferPool.Get();
-            debugCB.name = "";
-
             Vector4 validRange = new Vector4(minValue, 1.0f / (maxValue - minValue));
 
             MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
             propertyBlock.SetVector("_ValidRange", validRange);
             debugCB.SetViewport(new Rect(screenX, screenY, screenSizeX, screenSizeY));
             debugCB.DrawProcedural(Matrix4x4.identity, m_DebugMaterial, m_DebugMaterial.FindPass("VARIANCESHADOW"), MeshTopology.Triangles, 3, 1, propertyBlock);
-
-            renderContext.ExecuteCommandBuffer(debugCB);
-            CommandBufferPool.Release(debugCB);
         }
     }
 // -------------------------------------------------------------------------------------------------------------------------------------------------
             }
         }
 
-        public override void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights)
+        public override void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights)
-            using (new HDPipeline.Utilities.ProfilingSample("Render Shadows Exp", renderContext))
+            using (new HDPipeline.Utilities.ProfilingSample("Render Shadows Exp", cmd))
-                    sm.Update( frameId, renderContext, cullResults, lights );
+                    sm.Update( frameId, renderContext, cmd, cullResults, lights );
-        public override void DisplayShadow(ScriptableRenderContext renderContext, int shadowRequestIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
+        public override void DisplayShadow(CommandBuffer cmd, int shadowRequestIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
         {
             if (m_ShadowIndices.Count() == 0)
                 return;
             ShadowData faceData = shadowDatas[(uint)(m_ShadowIndices[index] + offset + faceIndex)];
             uint texID, samplerID, slice;
             faceData.UnpackShadowmapId(out texID, out samplerID, out slice);
-            m_Shadowmaps[texID].DisplayShadowMap(renderContext, faceData.scaleOffset, slice, screenX, screenY, screenSizeX, screenSizeY, minValue, maxValue);
+            m_Shadowmaps[texID].DisplayShadowMap(cmd, faceData.scaleOffset, slice, screenX, screenY, screenSizeX, screenSizeY, minValue, maxValue);
-        public override void DisplayShadowMap(ScriptableRenderContext renderContext, uint shadowMapIndex, uint sliceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
+        public override void DisplayShadowMap(CommandBuffer cmd, uint shadowMapIndex, uint sliceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
-            m_Shadowmaps[index].DisplayShadowMap(renderContext, new Vector4(1.0f, 1.0f, 0.0f, 0.0f), sliceIndex, screenX, screenY, screenSizeX, screenSizeY, minValue, maxValue);
+            m_Shadowmaps[index].DisplayShadowMap(cmd, new Vector4(1.0f, 1.0f, 0.0f, 0.0f), sliceIndex, screenX, screenY, screenSizeX, screenSizeY, minValue, maxValue);
         }
 
         public override void SyncData()
 
-        public override void BindResources(ScriptableRenderContext renderContext)
+        public override void BindResources(CommandBuffer cmd)
-            CommandBuffer cb = CommandBufferPool.Get(); // <- can we just keep this around or does this have to be newed every frame?
-            cb.name = "Bind resources to GPU";
-            m_ShadowCtxt.BindResources(cb);
-            renderContext.ExecuteCommandBuffer(cb);
-            CommandBufferPool.Release(cb);
+            cmd.BeginSample("Bind resources to GPU");
+            m_ShadowCtxt.BindResources(cmd);
+            cmd.EndSample("Bind resources to GPU");
         }
 
         // resets the shadow slot counters and returns the sum of all slots

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs

         abstract public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint width, uint height, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, List<VisibleLight> lights);
         abstract public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint[] widths, uint[] heights, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, List<VisibleLight> lights);
         abstract public bool ReserveFinalize( FrameId frameId, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads );
-        abstract public void Update( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights);
+        abstract public void Update( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights);
-        abstract public void DisplayShadowMap(ScriptableRenderContext renderContext, Vector4 scaleBias, uint slice, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
+        abstract public void DisplayShadowMap(CommandBuffer cmd, Vector4 scaleBias, uint slice, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
     }
 
     interface IShadowManager
         //          If there are no valid shadow casters all output arrays will be null, otherwise they will contain valid data that can be passed to shaders.
         void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
         // Renders all shadows for lights the were deemed shadow casters after the last call to ProcessShadowRequests
-        void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights);
+        void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights);
-        void DisplayShadow(ScriptableRenderContext renderContext, int shadowIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
-        void DisplayShadowMap(ScriptableRenderContext renderContext, uint shadowMapIndex, uint sliceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
+        void DisplayShadow(CommandBuffer cmd, int shadowIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
+        void DisplayShadowMap(CommandBuffer cmd, uint shadowMapIndex, uint sliceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
-        void BindResources( ScriptableRenderContext renderContext );
+        void BindResources( CommandBuffer cmd );
         // Fixes up some parameters within the cullResults
         void UpdateCullingParameters( ref ScriptableCullingParameters cullingParams );
 
     abstract public class ShadowManagerBase : ShadowRegistry, IShadowManager
     {
         public  abstract void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
-        public  abstract void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights);
-        public  abstract void DisplayShadow(ScriptableRenderContext renderContext, int shadowIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
-        public  abstract void DisplayShadowMap(ScriptableRenderContext renderContext, uint shadowMapIndex, uint sliceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
+        public  abstract void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights);
+        public  abstract void DisplayShadow(CommandBuffer cmd, int shadowIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
+        public  abstract void DisplayShadowMap(CommandBuffer cmd, uint shadowMapIndex, uint sliceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
-        public  abstract void BindResources( ScriptableRenderContext renderContext );
+        public  abstract void BindResources( CommandBuffer cmd );
         public  abstract void UpdateCullingParameters( ref ScriptableCullingParameters cullingParams );
         // sort the shadow requests in descending priority - may only modify shadowRequests
         protected abstract void PrioritizeShadowCasters( Camera camera, List<VisibleLight> lights, uint shadowRequestsCount, int[] shadowRequests );

Assets/ScriptableRenderPipeline/Fptl/FptlLighting.cs

             var numLights = GenerateSourceLightBuffers(camera, cullResults);
             BuildPerTileLightLists(camera, loop, numLights, projscr, invProjscr);
 
-
-            m_ShadowMgr.RenderShadows( m_FrameId, loop, cullResults, cullResults.visibleLights );
+            CommandBuffer cmdShadow = CommandBufferPool.Get();
+            m_ShadowMgr.RenderShadows( m_FrameId, loop, cmdShadow, cullResults, cullResults.visibleLights );
-            m_ShadowMgr.BindResources( loop );
+            m_ShadowMgr.BindResources( cmdShadow );
+            loop.ExecuteCommandBuffer(cmdShadow);
+            CommandBufferPool.Release(cmdShadow);
 
             // Push all global params
             var numDirLights = UpdateDirectionalLights(camera, cullResults.visibleLights, m_ShadowIndices);

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             m_CurrentHeight = camera.pixelHeight;
         }
 
-        public void PushGlobalParams(HDCamera hdCamera, ScriptableRenderContext renderContext, SubsurfaceScatteringSettings sssParameters)
+        public void PushGlobalParams(HDCamera hdCamera, CommandBuffer cmd, SubsurfaceScatteringSettings sssParameters)
-            var cmd = CommandBufferPool.Get("Push Global Parameters");
+            using (new Utilities.ProfilingSample("Push Global Parameters", cmd))
+            {
+                hdCamera.SetupGlobalParams(cmd);
-            hdCamera.SetupGlobalParams(cmd);
+                // TODO: cmd.SetGlobalInt() does not exist, so we are forced to use Shader.SetGlobalInt() instead.
-            // TODO: cmd.SetGlobalInt() does not exist, so we are forced to use Shader.SetGlobalInt() instead.
+                if (m_SkyManager.IsSkyValid())
+                {
+                    m_SkyManager.SetGlobalSkyTexture();
+                    Shader.SetGlobalInt("_EnvLightSkyEnabled", 1);
+                }
+                else
+                {
+                    Shader.SetGlobalInt("_EnvLightSkyEnabled", 0);
+                }
-            if (m_SkyManager.IsSkyValid())
-            {
-                m_SkyManager.SetGlobalSkyTexture();
-                Shader.SetGlobalInt("_EnvLightSkyEnabled", 1);
+                // Broadcast SSS parameters to all shaders.
+                Shader.SetGlobalInt(     "_EnableSSSAndTransmission",          m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission ? 1 : 0);
+                Shader.SetGlobalInt(     "_TexturingModeFlags", (int)sssParameters.texturingModeFlags);
+                Shader.SetGlobalInt(     "_TransmissionFlags",  (int)sssParameters.transmissionFlags);
+                cmd.SetGlobalFloatArray( "_ThicknessRemaps",         sssParameters.thicknessRemaps);
+                // We are currently supporting two different SSS mode: Jimenez (with 2-Gaussian profile) and Disney
+                // We have added the ability to switch between each other for subsurface scattering, but for transmittance this is more tricky as we need to add
+                // shader variant for forward, gbuffer and deferred shader. We want to avoid this.
+                // So for transmittance we use Disney profile formulation (that we know is more correct) in both case, and in the case of Jimenez we hack the parameters with 2-Gaussian parameters (Ideally we should fit but haven't find good fit) so it approximately match.
+                // Note: Jimenez SSS is in cm unit whereas Disney is in mm unit making an inconsistency here to compare model side by side
+                cmd.SetGlobalVectorArray("_ShapeParams",             sssParameters.useDisneySSS ? sssParameters.shapeParams : sssParameters.halfRcpWeightedVariances);
+                cmd.SetGlobalVectorArray("_TransmissionTints",       sssParameters.transmissionTints);
-            else
-            {
-                Shader.SetGlobalInt("_EnvLightSkyEnabled", 0);
-            }
-
-            // Broadcast SSS parameters to all shaders.
-            Shader.SetGlobalInt(     "_EnableSSSAndTransmission",          m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission ? 1 : 0);
-            Shader.SetGlobalInt(     "_TexturingModeFlags", (int)sssParameters.texturingModeFlags);
-            Shader.SetGlobalInt(     "_TransmissionFlags",  (int)sssParameters.transmissionFlags);
-            cmd.SetGlobalFloatArray( "_ThicknessRemaps",         sssParameters.thicknessRemaps);
-            // We are currently supporting two different SSS mode: Jimenez (with 2-Gaussian profile) and Disney
-            // We have added the ability to switch between each other for subsurface scattering, but for transmittance this is more tricky as we need to add
-            // shader variant for forward, gbuffer and deferred shader. We want to avoid this.
-            // So for transmittance we use Disney profile formulation (that we know is more correct) in both case, and in the case of Jimenez we hack the parameters with 2-Gaussian parameters (Ideally we should fit but haven't find good fit) so it approximately match.
-            // Note: Jimenez SSS is in cm unit whereas Disney is in mm unit making an inconsistency here to compare model side by side
-            cmd.SetGlobalVectorArray("_ShapeParams",             sssParameters.useDisneySSS ? sssParameters.shapeParams : sssParameters.halfRcpWeightedVariances);
-            cmd.SetGlobalVectorArray("_TransmissionTints",       sssParameters.transmissionTints);
-
-            renderContext.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
         }
 
         bool NeedDepthBufferCopy()
                 return m_CameraDepthStencilBuffer;
         }
 
-        private void CopyDepthBufferIfNeeded(ScriptableRenderContext renderContext)
+        private void CopyDepthBufferIfNeeded(CommandBuffer cmd)
-            var cmd = CommandBufferPool.Get(NeedDepthBufferCopy() ? "Copy DepthBuffer" : "Set DepthBuffer");
-
-            if (NeedDepthBufferCopy())
+            using (new Utilities.ProfilingSample(NeedDepthBufferCopy() ? "Copy DepthBuffer" : "Set DepthBuffer", cmd))
-                using (new Utilities.ProfilingSample("Copy depth-stencil buffer", renderContext))
+                if (NeedDepthBufferCopy())
-                    cmd.CopyTexture(m_CameraDepthStencilBufferRT, m_CameraDepthStencilBufferCopyRT);
+                    using (new Utilities.ProfilingSample("Copy depth-stencil buffer", cmd))
+                    {
+                        cmd.CopyTexture(m_CameraDepthStencilBufferRT, m_CameraDepthStencilBufferCopyRT);
+                    }
-            }
-            cmd.SetGlobalTexture("_MainDepthTexture", GetDepthTexture());
-            renderContext.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
+                cmd.SetGlobalTexture("_MainDepthTexture", GetDepthTexture());
+            }
         }
 
         public void UpdateCommonSettings()
             GraphicsSettings.lightsUseLinearIntensity = true;
             GraphicsSettings.lightsUseColorTemperature = true;
 
-            m_MaterialList.ForEach(material => material.RenderInit(renderContext));
+            // This is the main command buffer used for the frame.
+            CommandBuffer cmd = CommandBufferPool.Get("");
+
+            m_MaterialList.ForEach(material => material.RenderInit(cmd));
 
             // Do anything we need to do upon a new frame.
             m_LightLoop.NewFrame();
                 // TODO: Add another path dedicated to planar reflection / real time cubemap that implement simpler lighting
                 string passName = "Forward"; // It is up to the users to only send unlit object for this camera path
 
-                using (new Utilities.ProfilingSample(passName, renderContext))
+                using (new Utilities.ProfilingSample(passName, cmd))
-                    Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor | ClearFlag.ClearDepth);
-                    RenderOpaqueRenderList(m_CullResults, camera, renderContext, passName);
-                    RenderTransparentRenderList(m_CullResults, camera, renderContext, passName);
+                    Utilities.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor | ClearFlag.ClearDepth);
+                    RenderOpaqueRenderList(m_CullResults, camera, renderContext, cmd, passName);
+                    RenderTransparentRenderList(m_CullResults, camera, renderContext, cmd, passName);
+                renderContext.ExecuteCommandBuffer(cmd);
+                CommandBufferPool.Release(cmd);
-            InitAndClearBuffer(camera, renderContext);
+            InitAndClearBuffer(camera, cmd);
-            RenderDepthPrepass(m_CullResults, camera, renderContext);
+            PushGlobalParams(hdCamera, cmd, m_Asset.sssSettings);
+
+            RenderDepthPrepass(m_CullResults, camera, renderContext, cmd);
-            RenderForwardOnlyOpaqueDepthPrepass(m_CullResults, camera, renderContext);
-            RenderGBuffer(m_CullResults, camera, renderContext);
+            RenderForwardOnlyOpaqueDepthPrepass(m_CullResults, camera, renderContext, cmd);
+            RenderGBuffer(m_CullResults, camera, renderContext, cmd);
-                CopyDepthBufferIfNeeded(renderContext);
+                CopyDepthBufferIfNeeded(cmd);
-                RenderDebugViewMaterial(m_CullResults, hdCamera, renderContext);
+                RenderDebugViewMaterial(m_CullResults, hdCamera, renderContext, cmd);
-                using (new Utilities.ProfilingSample("Build Light list and render shadows", renderContext))
+                using (new Utilities.ProfilingSample("Build Light list and render shadows", cmd))
-                    m_LightLoop.RenderShadows(renderContext, m_CullResults);
+                    m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
-                    m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT);
+                    m_LightLoop.BuildGPULightLists(camera, cmd, m_CameraDepthStencilBufferRT);
-                UpdateSkyEnvironment(hdCamera, renderContext);
+                UpdateSkyEnvironment(hdCamera, cmd);
-                RenderDeferredLighting(hdCamera, renderContext);
+                RenderDeferredLighting(hdCamera, cmd);
-                CombineSubsurfaceScattering(hdCamera, renderContext, m_Asset.sssSettings);
+                CombineSubsurfaceScattering(hdCamera, cmd, m_Asset.sssSettings);
-                RenderForward(m_CullResults, camera, renderContext, true); // Render deferred or forward opaque
-                RenderForwardOnlyOpaque(m_CullResults, camera, renderContext);
+                RenderForward(m_CullResults, camera, renderContext, cmd, true); // Render deferred or forward opaque
+                RenderForwardOnlyOpaque(m_CullResults, camera, renderContext, cmd);
-                RenderLightingDebug(hdCamera, renderContext, m_CameraColorBufferRT);
+                RenderLightingDebug(hdCamera, cmd, m_CameraColorBufferRT);
-                    CopyDepthBufferIfNeeded(renderContext);
+                    CopyDepthBufferIfNeeded(cmd);
-                RenderSky(hdCamera, renderContext);
+                RenderSky(hdCamera, cmd);
-                RenderForward(m_CullResults, camera, renderContext, false);
+                RenderForward(m_CullResults, camera, renderContext, cmd, false);
-                    // Simple blit
-                    var cmd = CommandBufferPool.Get("Blit to final RT" );
-                    cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
-                    renderContext.ExecuteCommandBuffer(cmd);
-                    CommandBufferPool.Release(cmd);
+                    using (new Utilities.ProfilingSample("Blit to final RT", cmd))
+                    {
+                        // Simple blit
+                        cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
+                    }
+
-                    RenderVelocity(m_CullResults, hdCamera, renderContext); // Note we may have to render velocity earlier if we do temporalAO, temporal volumetric etc... Mean we will not take into account forward opaque in case of deferred rendering ?
+                    RenderVelocity(m_CullResults, hdCamera, renderContext, cmd); // Note we may have to render velocity earlier if we do temporalAO, temporal volumetric etc... Mean we will not take into account forward opaque in case of deferred rendering ?
-                    RenderDistortion(m_CullResults, camera, renderContext);
+                    RenderDistortion(m_CullResults, camera, renderContext, cmd);
-                    RenderPostProcesses(camera, renderContext);
+                    RenderPostProcesses(camera, cmd);
-            RenderDebug(hdCamera, renderContext);
+            RenderDebug(hdCamera, cmd);
-                var cmd = CommandBufferPool.Get();
-                renderContext.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
+            renderContext.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
-        void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, string passName, RendererConfiguration rendererConfiguration = 0)
+        void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, string passName, RendererConfiguration rendererConfiguration = 0)
+            // This is done here because DrawRenderers API lives outside command buffers so we need to make sur eto call this before doing any DrawRenders
+            renderContext.ExecuteCommandBuffer(cmd);
+            cmd.Clear();
+
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
             {
                 rendererConfiguration = rendererConfiguration,
             renderContext.DrawRenderers(ref settings);
         }
 
-        void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, string passName, RendererConfiguration rendererConfiguration = 0)
+        void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, string passName, RendererConfiguration rendererConfiguration = 0)
+            // This is done here because DrawRenderers API lives outside command buffers so we need to make sur eto call this before doing any DrawRenders
+            renderContext.ExecuteCommandBuffer(cmd);
+            cmd.Clear();
+
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
             {
                 rendererConfiguration = rendererConfiguration,
             renderContext.DrawRenderers(ref settings);
         }
 
-        void RenderDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderContext)
+        void RenderDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
             // 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...
-            using (new Utilities.ProfilingSample("Depth Prepass", renderContext))
+            using (new Utilities.ProfilingSample("Depth Prepass", cmd))
-                Utilities.SetRenderTarget(renderContext, m_CameraDepthStencilBufferRT);
-                RenderOpaqueRenderList(cull, camera, renderContext, "DepthOnly");
+                Utilities.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
+                RenderOpaqueRenderList(cull, camera, renderContext, cmd, "DepthOnly");
-        void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext renderContext)
+        void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
             if (m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
             {
             string passName = m_DebugDisplaySettings.IsDebugDisplayEnabled() ? "GBufferDebugDisplay" : "GBuffer";
 
-            using (new Utilities.ProfilingSample(passName, renderContext))
+            using (new Utilities.ProfilingSample(passName, cmd))
-                Utilities.SetRenderTarget(renderContext, m_gbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT);
+                Utilities.SetRenderTarget(cmd, m_gbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT);
-                RenderOpaqueRenderList(cull, camera, renderContext, passName, Utilities.kRendererConfigurationBakedLighting);
+                RenderOpaqueRenderList(cull, camera, renderContext, cmd, passName, Utilities.kRendererConfigurationBakedLighting);
-        void RenderForwardOnlyOpaqueDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderContext)
+        void RenderForwardOnlyOpaqueDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
             // If we are forward only we don't need to render ForwardOnlyOpaqueDepthOnly object
             // But in case we request a prepass we render it
-            using (new Utilities.ProfilingSample("Forward opaque depth", renderContext))
+            using (new Utilities.ProfilingSample("Forward opaque depth", cmd))
-                Utilities.SetRenderTarget(renderContext, m_CameraDepthStencilBufferRT);
-                RenderOpaqueRenderList(cull, camera, renderContext, "ForwardOnlyOpaqueDepthOnly");
+                Utilities.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
+                RenderOpaqueRenderList(cull, camera, renderContext, cmd, "ForwardOnlyOpaqueDepthOnly");
-        void RenderDebugViewMaterial(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext)
+        void RenderDebugViewMaterial(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd)
-            using (new Utilities.ProfilingSample("DisplayDebug ViewMaterial", renderContext))
+            using (new Utilities.ProfilingSample("DisplayDebug ViewMaterial", cmd))
-                Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, Utilities.kClearAll, Color.black);
-                RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
+                Utilities.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, Utilities.kClearAll, Color.black);
+                RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
-                    // TODO: Bind depth textures
-                    var cmd = CommandBufferPool.Get("DebugViewMaterialGBuffer" );
-                    cmd.Blit(null, m_CameraColorBufferRT, m_DebugViewMaterialGBuffer, 0);
-                    renderContext.ExecuteCommandBuffer(cmd);
-                    CommandBufferPool.Release(cmd);
+                    using (new Utilities.ProfilingSample("DebugViewMaterialGBuffer", cmd))
+                    {
+                        // TODO: Bind depth textures
+                        cmd.Blit(null, m_CameraColorBufferRT, m_DebugViewMaterialGBuffer, 0);
+                    }
-                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
+                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
-                var cmd = CommandBufferPool.Get("Blit DebugView Material Debug");
-                cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
-                renderContext.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
+                using (new Utilities.ProfilingSample("Blit DebugView Material Debug", cmd))
+                {
+                    cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
+                }
-        void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext)
+        void RenderDeferredLighting(HDCamera hdCamera, CommandBuffer cmd)
         {
             if (m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
             {
             if (m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
             {
                 // Output split lighting for materials asking for it (via stencil buffer)
-                m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, m_DebugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, new RenderTargetIdentifier(GetDepthTexture()), true);
+                m_LightLoop.RenderDeferredLighting(hdCamera, cmd, m_DebugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, new RenderTargetIdentifier(GetDepthTexture()), true);
-            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, m_DebugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, new RenderTargetIdentifier(GetDepthTexture()), false);
+            m_LightLoop.RenderDeferredLighting(hdCamera, cmd, m_DebugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, new RenderTargetIdentifier(GetDepthTexture()), false);
-        void CombineSubsurfaceScattering(HDCamera hdCamera, ScriptableRenderContext context, SubsurfaceScatteringSettings sssParameters)
+        void CombineSubsurfaceScattering(HDCamera hdCamera, CommandBuffer cmd, SubsurfaceScatteringSettings sssParameters)
-            var cmd = CommandBufferPool.Get("Subsurface Scattering");
-
-            if (sssSettings.useDisneySSS)
+            using (new Utilities.ProfilingSample("Subsurface Scattering", cmd))
-                cmd.SetGlobalTexture("_IrradianceSource", m_CameraSubsurfaceBufferRT); // Cannot set a RT on a material
-                m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_WorldScales",            sssParameters.worldScales);
-                m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_FilterKernelsNearField", sssParameters.filterKernelsNearField);
-                m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_FilterKernelsFarField",  sssParameters.filterKernelsFarField);
+                if (sssSettings.useDisneySSS)
+                {
+                    cmd.SetGlobalTexture("_IrradianceSource", m_CameraSubsurfaceBufferRT); // Cannot set a RT on a material
+                    m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_WorldScales",            sssParameters.worldScales);
+                    m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_FilterKernelsNearField", sssParameters.filterKernelsNearField);
+                    m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_FilterKernelsFarField",  sssParameters.filterKernelsFarField);
-                Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
-            }
-            else
-            {
-                // Perform the vertical SSS filtering pass.
-                cmd.SetGlobalTexture("_IrradianceSource", m_CameraSubsurfaceBufferRT);  // Cannot set a RT on a material
-                m_FilterSubsurfaceScattering.SetFloatArray("_WorldScales",               sssParameters.worldScales);
-                m_FilterSubsurfaceScattering.SetVectorArray("_FilterKernelsBasic",       sssParameters.filterKernelsBasic);
-                m_FilterSubsurfaceScattering.SetVectorArray("_HalfRcpWeightedVariances", sssParameters.halfRcpWeightedVariances);
-                Utilities.DrawFullScreen(cmd, m_FilterSubsurfaceScattering, m_CameraFilteringBufferRT, m_CameraDepthStencilBufferRT);
+                    Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                }
+                else
+                {
+                    // Perform the vertical SSS filtering pass.
+                    cmd.SetGlobalTexture("_IrradianceSource", m_CameraSubsurfaceBufferRT);  // Cannot set a RT on a material
+                    m_FilterSubsurfaceScattering.SetFloatArray("_WorldScales",               sssParameters.worldScales);
+                    m_FilterSubsurfaceScattering.SetVectorArray("_FilterKernelsBasic",       sssParameters.filterKernelsBasic);
+                    m_FilterSubsurfaceScattering.SetVectorArray("_HalfRcpWeightedVariances", sssParameters.halfRcpWeightedVariances);
+                    Utilities.DrawFullScreen(cmd, m_FilterSubsurfaceScattering, m_CameraFilteringBufferRT, m_CameraDepthStencilBufferRT);
-                // Perform the horizontal SSS filtering pass, and combine diffuse and specular lighting.
-                cmd.SetGlobalTexture("_IrradianceSource", m_CameraFilteringBufferRT);  // Cannot set a RT on a material
-                m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_WorldScales",               sssParameters.worldScales);
-                m_FilterAndCombineSubsurfaceScattering.SetVectorArray("_FilterKernelsBasic",       sssParameters.filterKernelsBasic);
-                m_FilterAndCombineSubsurfaceScattering.SetVectorArray("_HalfRcpWeightedVariances", sssParameters.halfRcpWeightedVariances);
-                Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                    // Perform the horizontal SSS filtering pass, and combine diffuse and specular lighting.
+                    cmd.SetGlobalTexture("_IrradianceSource", m_CameraFilteringBufferRT);  // Cannot set a RT on a material
+                    m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_WorldScales",               sssParameters.worldScales);
+                    m_FilterAndCombineSubsurfaceScattering.SetVectorArray("_FilterKernelsBasic",       sssParameters.filterKernelsBasic);
+                    m_FilterAndCombineSubsurfaceScattering.SetVectorArray("_HalfRcpWeightedVariances", sssParameters.halfRcpWeightedVariances);
+                    Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                }
-
-            context.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
-        void UpdateSkyEnvironment(HDCamera hdCamera, ScriptableRenderContext renderContext)
+        void UpdateSkyEnvironment(HDCamera hdCamera, CommandBuffer cmd)
-            m_SkyManager.UpdateEnvironment(hdCamera,m_LightLoop.GetCurrentSunLight(), renderContext);
+            m_SkyManager.UpdateEnvironment(hdCamera,m_LightLoop.GetCurrentSunLight(), cmd);
-        void RenderSky(HDCamera hdCamera, ScriptableRenderContext renderContext)
+        void RenderSky(HDCamera hdCamera, CommandBuffer cmd)
-            m_SkyManager.RenderSky(hdCamera, m_LightLoop.GetCurrentSunLight(), m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, renderContext);
+            m_SkyManager.RenderSky(hdCamera, m_LightLoop.GetCurrentSunLight(), m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, cmd);
         }
 
         public Texture2D ExportSkyToTexture()
 
-        void RenderLightingDebug(HDCamera camera, ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer)
+        void RenderLightingDebug(HDCamera camera, CommandBuffer cmd, RenderTargetIdentifier colorBuffer)
-            m_LightLoop.RenderLightingDebug(camera, renderContext, colorBuffer);
+            m_LightLoop.RenderLightingDebug(camera, cmd, colorBuffer);
-        void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
+        void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool renderOpaque)
         {
             // TODO: Currently we can't render opaque object forward when deferred is enabled
             // miss option
             string passName = m_DebugDisplaySettings.IsDebugDisplayEnabled() ? "ForwardDisplayDebug" : "Forward";
 
-            using (new Utilities.ProfilingSample(passName, renderContext))
+            using (new Utilities.ProfilingSample(passName, cmd))
-                Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                Utilities.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
-                m_LightLoop.RenderForward(camera, renderContext, renderOpaque);
+                m_LightLoop.RenderForward(camera, cmd, renderOpaque);
-                    RenderOpaqueRenderList(cullResults, camera, renderContext, passName, Utilities.kRendererConfigurationBakedLighting);
+                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, passName, Utilities.kRendererConfigurationBakedLighting);
-                    RenderTransparentRenderList(cullResults, camera, renderContext, passName, Utilities.kRendererConfigurationBakedLighting);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, passName, Utilities.kRendererConfigurationBakedLighting);
-        void RenderForwardOnlyOpaque(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext)
+        void RenderForwardOnlyOpaque(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
-            using (new Utilities.ProfilingSample(passName, renderContext))
+            using (new Utilities.ProfilingSample(passName, cmd))
-                Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                Utilities.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
-                m_LightLoop.RenderForward(camera, renderContext, true);
+                m_LightLoop.RenderForward(camera, cmd, true);
-                RenderOpaqueRenderList(cullResults, camera, renderContext, passName, Utilities.kRendererConfigurationBakedLighting);
+                RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, passName, Utilities.kRendererConfigurationBakedLighting);
-        void RenderVelocity(CullResults cullResults, HDCamera hdcam, ScriptableRenderContext renderContext)
+        void RenderVelocity(CullResults cullResults, HDCamera hdcam, ScriptableRenderContext renderContext, CommandBuffer cmd)
-            using (new Utilities.ProfilingSample("Velocity", renderContext))
+            using (new Utilities.ProfilingSample("Velocity", cmd))
             {
                 // If opaque velocity have been render during GBuffer no need to render it here
                 if ((ShaderConfig.s_VelocityInGbuffer == 1) || m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
                 int w = (int)hdcam.screenSize.x;
                 int h = (int)hdcam.screenSize.y;
 
-                var cmd = CommandBufferPool.Get("");
-                renderContext.ExecuteCommandBuffer(cmd);
-                RenderOpaqueRenderList(cullResults, hdcam.camera, renderContext, "MotionVectors", RendererConfiguration.PerObjectMotionVectors);
+                RenderOpaqueRenderList(cullResults, hdcam.camera, renderContext, cmd, "MotionVectors", RendererConfiguration.PerObjectMotionVectors);
-        void RenderDistortion(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext)
+        void RenderDistortion(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
-            using (new Utilities.ProfilingSample("Distortion", renderContext))
+            using (new Utilities.ProfilingSample("Distortion", cmd))
-                var cmd = CommandBufferPool.Get("");
-                renderContext.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
-                RenderTransparentRenderList(cullResults, camera, renderContext, "DistortionVectors");
+                RenderTransparentRenderList(cullResults, camera, renderContext, cmd, "DistortionVectors");
-        void RenderPostProcesses(Camera camera, ScriptableRenderContext renderContext)
+        void RenderPostProcesses(Camera camera, CommandBuffer cmd)
-            using (new Utilities.ProfilingSample("Post-processing", renderContext))
+            using (new Utilities.ProfilingSample("Post-processing", cmd))
-                var cmd = CommandBufferPool.Get("");
 
                 if (postProcessLayer != null && postProcessLayer.enabled)
                 {
                 {
                     cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
                 }
-
-                renderContext.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
             }
         }
 
         }
 
         MaterialPropertyBlock m_SharedPropertyBlock = new MaterialPropertyBlock();
-        void RenderDebug(HDCamera camera, ScriptableRenderContext renderContext)
+        void RenderDebug(HDCamera camera, CommandBuffer cmd)
-            // We make sure the depth buffer is bound because we need it to write depth at near plane for overlays otherwise the editor grid end up visible in them.
-            Utilities.SetRenderTarget(renderContext, BuiltinRenderTextureType.CameraTarget, m_CameraDepthStencilBufferRT);
+            using (new Utilities.ProfilingSample("Render Debug", cmd))
+            {
+                // We make sure the depth buffer is bound because we need it to write depth at near plane for overlays otherwise the editor grid end up visible in them.
+                Utilities.SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget, m_CameraDepthStencilBufferRT);
-            CommandBuffer debugCB = CommandBufferPool.Get();
-            debugCB.name = "Render Debug";
+                // First render full screen debug texture
+                if(m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode != FullScreenDebugMode.None && m_FullScreenDebugPushed)
+                {
+                    m_FullScreenDebugPushed = false;
+                    cmd.SetGlobalTexture("_DebugFullScreenTexture", m_DebugFullScreenTempRT);
+                    m_DebugFullScreen.SetFloat("_FullScreenDebugMode", (float)m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode);
+                    Utilities.DrawFullScreen(cmd, m_DebugFullScreen, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
+                }
-            // First render full screen debug texture
-            if(m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode != FullScreenDebugMode.None && m_FullScreenDebugPushed)
-            {
-                m_FullScreenDebugPushed = false;
-                debugCB.SetGlobalTexture("_DebugFullScreenTexture", m_DebugFullScreenTempRT);
-                m_DebugFullScreen.SetFloat("_FullScreenDebugMode", (float)m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode);
-                Utilities.DrawFullScreen(debugCB, m_DebugFullScreen, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
-            }
+                // Then overlays
+                float x = 0;
+                float overlayRatio = m_DebugDisplaySettings.debugOverlayRatio;
+                float overlaySize = Math.Min(camera.camera.pixelHeight, camera.camera.pixelWidth) * overlayRatio;
+                float y = camera.camera.pixelHeight - overlaySize;
-            // Then overlays
-            float x = 0;
-            float overlayRatio = m_DebugDisplaySettings.debugOverlayRatio;
-            float overlaySize = Math.Min(camera.camera.pixelHeight, camera.camera.pixelWidth) * overlayRatio;
-            float y = camera.camera.pixelHeight - overlaySize;
+                LightingDebugSettings lightingDebug = m_DebugDisplaySettings.lightingDebugSettings;
-            LightingDebugSettings lightingDebug = m_DebugDisplaySettings.lightingDebugSettings;
+                if (lightingDebug.displaySkyReflection)
+                {
+                    Texture skyReflection = m_SkyManager.skyReflection;
+                    m_SharedPropertyBlock.SetTexture("_InputCubemap", skyReflection);
+                    m_SharedPropertyBlock.SetFloat("_Mipmap", lightingDebug.skyReflectionMipmap);
+                    cmd.SetViewport(new Rect(x, y, overlaySize, overlaySize));
+                    cmd.DrawProcedural(Matrix4x4.identity, m_DebugDisplayLatlong, 0, MeshTopology.Triangles, 3, 1, m_SharedPropertyBlock);
+                    Utilities.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.camera.pixelWidth);
+                }
-            if (lightingDebug.displaySkyReflection)
-            {
-                Texture skyReflection = m_SkyManager.skyReflection;
-                m_SharedPropertyBlock.SetTexture("_InputCubemap", skyReflection);
-                m_SharedPropertyBlock.SetFloat("_Mipmap", lightingDebug.skyReflectionMipmap);
-                debugCB.SetViewport(new Rect(x, y, overlaySize, overlaySize));
-                debugCB.DrawProcedural(Matrix4x4.identity, m_DebugDisplayLatlong, 0, MeshTopology.Triangles, 3, 1, m_SharedPropertyBlock);
-                Utilities.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.camera.pixelWidth);
+                m_LightLoop.RenderDebugOverlay(camera.camera, cmd, m_DebugDisplaySettings, ref x, ref y, overlaySize, camera.camera.pixelWidth);
-
-            renderContext.ExecuteCommandBuffer(debugCB);
-            CommandBufferPool.Release(debugCB);
-
-            m_LightLoop.RenderDebugOverlay(camera.camera, renderContext, m_DebugDisplaySettings, ref x, ref y, overlaySize, camera.camera.pixelWidth);
-        void InitAndClearBuffer(Camera camera, ScriptableRenderContext renderContext)
+        void InitAndClearBuffer(Camera camera, CommandBuffer cmd)
-            using (new Utilities.ProfilingSample("InitAndClearBuffer", renderContext))
+            using (new Utilities.ProfilingSample("InitAndClearBuffer", cmd))
-                using (new Utilities.ProfilingSample("InitGBuffers and clear Depth/Stencil", renderContext))
+                using (new Utilities.ProfilingSample("InitGBuffers and clear Depth/Stencil", cmd))
-                    var cmd = CommandBufferPool.Get();
-                    cmd.name = "";
-
                     // Init buffer
                     // With scriptable render loop we must allocate ourself depth and color buffer (We must be independent of backbuffer for now, hope to fix that later).
                     // Also we manage ourself the HDR format, here allocating fp16 directly.
                         m_gbufferManager.InitGBuffers(w, h, cmd);
                     }
 
-                    renderContext.ExecuteCommandBuffer(cmd);
-                    CommandBufferPool.Release(cmd);
-
-                    Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearDepth);
+                    Utilities.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearDepth);
-                using (new Utilities.ProfilingSample("Clear SSS diffuse target", renderContext))
+                using (new Utilities.ProfilingSample("Clear SSS diffuse target", cmd))
-                    Utilities.SetRenderTarget(renderContext, m_CameraSubsurfaceBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                    Utilities.SetRenderTarget(cmd, m_CameraSubsurfaceBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
-                using (new Utilities.ProfilingSample("Clear SSS filtering target", renderContext))
+                using (new Utilities.ProfilingSample("Clear SSS filtering target", cmd))
-                    Utilities.SetRenderTarget(renderContext, m_CameraFilteringBuffer, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                    Utilities.SetRenderTarget(cmd, m_CameraFilteringBuffer, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
                 }
                 // <<< Old SSS Model
 
-                using (new Utilities.ProfilingSample("Clear HDR target", renderContext))
+                using (new Utilities.ProfilingSample("Clear HDR target", cmd))
-                    Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                    Utilities.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
-                    using (new Utilities.ProfilingSample("Clear GBuffer", renderContext))
+                    using (new Utilities.ProfilingSample("Clear GBuffer", cmd))
-                        Utilities.SetRenderTarget(renderContext, m_gbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                        Utilities.SetRenderTarget(cmd, m_gbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
                     }
                 }
                 // END TEMP

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

                 cmd.DispatchCompute(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, numTilesX, numTilesY, 1);
             }
 
-            public void BuildGPULightLists(Camera camera, ScriptableRenderContext loop, RenderTargetIdentifier cameraDepthBufferRT)
+            public void BuildGPULightLists(Camera camera, CommandBuffer cmd, RenderTargetIdentifier cameraDepthBufferRT)
             {
                 var w = camera.pixelWidth;
                 var h = camera.pixelHeight;
                 var projscr = temp * proj;
                 var invProjscr = projscr.inverse;
 
-                var cmd = CommandBufferPool.Get("");
                 cmd.SetRenderTarget(new RenderTargetIdentifier((Texture)null));
 
                 // generate screen-space AABBs (used for both fptl and clustered).
                     cmd.SetComputeIntParam(buildDispatchIndirectShader, "g_NumTilesX", numTilesX);
                     cmd.DispatchCompute(buildDispatchIndirectShader, s_BuildDispatchIndirectKernel, (numTiles + 63) / 64, 1, 1);
                 }
-
-                loop.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
             }
 
             // This is a workaround for global properties not being accessible from compute.
                 s_LightVolumeDataBuffer.SetData(m_lightList.lightVolumes);
             }
 
-            private void BindGlobalParams(CommandBuffer cmd, ComputeShader computeShader, int kernelIndex, Camera camera, ScriptableRenderContext loop)
+            private void BindGlobalParams(CommandBuffer cmd, ComputeShader computeShader, int kernelIndex, Camera camera)
-                m_ShadowMgr.BindResources(loop);
+                m_ShadowMgr.BindResources(cmd);
 
                 SetGlobalBuffer("g_vLightListGlobal", !usingFptl ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
 
                 }
             }
 
-            private void PushGlobalParams(Camera camera, ScriptableRenderContext loop, ComputeShader computeShader, int kernelIndex)
+            private void PushGlobalParams(Camera camera, CommandBuffer cmd, ComputeShader computeShader, int kernelIndex)
-                var cmd = CommandBufferPool.Get("Push Global Parameters");
+                using (new Utilities.ProfilingSample("Push Global Parameters", cmd))
+                {
+                    // Shadows
+                    m_ShadowMgr.SyncData();
-                // Shadows
-                m_ShadowMgr.SyncData();
-
-                SetGlobalPropertyRedirect(computeShader, kernelIndex, cmd);
-                BindGlobalParams(cmd, computeShader, kernelIndex, camera, loop);
-                SetGlobalPropertyRedirect(null, 0, null);
-
-                loop.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
+                    SetGlobalPropertyRedirect(computeShader, kernelIndex, cmd);
+                    BindGlobalParams(cmd, computeShader, kernelIndex, camera);
+                    SetGlobalPropertyRedirect(null, 0, null);
+                }
             }
 
 #if UNITY_EDITOR
 
 #endif
 
-            public void RenderShadows(ScriptableRenderContext renderContext, CullResults cullResults)
+            public void RenderShadows(ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults)
-                m_ShadowMgr.RenderShadows(m_FrameId, renderContext, cullResults, cullResults.visibleLights);
+                m_ShadowMgr.RenderShadows(m_FrameId, renderContext, cmd, cullResults, cullResults.visibleLights);
             }
 
             private void SetupDebugDisplayMode(bool debugDisplayEnable)
                 Utilities.SetKeyword(m_SingleDeferredMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
             }
 
-            public void RenderLightingDebug(HDCamera hdCamera, ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer)
+            public void RenderLightingDebug(HDCamera hdCamera, CommandBuffer cmd, RenderTargetIdentifier colorBuffer)
-                var cmd = CommandBufferPool.Get();
-                cmd.name = "Tiled Lighting Debug";
+                using (new Utilities.ProfilingSample("Tiled Lighting Debug", cmd))
+                {
+                    bool bUseClusteredForDeferred = !usingFptl;
-                bool bUseClusteredForDeferred = !usingFptl;
+                    int w = hdCamera.camera.pixelWidth;
+                    int h = hdCamera.camera.pixelHeight;
+                    int numTilesX = (w + 15) / 16;
+                    int numTilesY = (h + 15) / 16;
+                    int numTiles = numTilesX * numTilesY;
-                int w = hdCamera.camera.pixelWidth;
-                int h = hdCamera.camera.pixelHeight;
-                int numTilesX = (w + 15) / 16;
-                int numTilesY = (h + 15) / 16;
-                int numTiles = numTilesX * numTilesY;
-
-                Vector2 mousePixelCoord = Input.mousePosition;
-#if UNITY_EDITOR
-                if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
-                {
-                    mousePixelCoord = m_mousePosition;
-                    mousePixelCoord.y = (hdCamera.screenSize.y - 1.0f) - mousePixelCoord.y;
-                }
-#endif
+                    Vector2 mousePixelCoord = Input.mousePosition;
+    #if UNITY_EDITOR
+                    if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
+                    {
+                        mousePixelCoord = m_mousePosition;
+                        mousePixelCoord.y = (hdCamera.screenSize.y - 1.0f) - mousePixelCoord.y;
+                    }
+    #endif
-                // Debug tiles
-                PushGlobalParams(hdCamera.camera, renderContext, null, 0);
-                if (m_TileSettings.tileDebugByCategory == TileSettings.TileDebug.FeatureVariants)
-                {
-                    if (GetFeatureVariantsEnabled())
+                    // Debug tiles
+                    PushGlobalParams(hdCamera.camera, cmd, null, 0);
+                    if (m_TileSettings.tileDebugByCategory == TileSettings.TileDebug.FeatureVariants)
-                        // featureVariants
-                        m_DebugViewTilesMaterial.SetInt("_NumTiles", numTiles);
+                        if (GetFeatureVariantsEnabled())
+                        {
+                            // featureVariants
+                            m_DebugViewTilesMaterial.SetInt("_NumTiles", numTiles);
+                            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);
+                            m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                            m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                            m_DebugViewTilesMaterial.DisableKeyword("SHOW_LIGHT_CATEGORIES");
+                            m_DebugViewTilesMaterial.EnableKeyword("SHOW_FEATURE_VARIANTS");
+                            cmd.SetRenderTarget(colorBuffer);
+                            cmd.DrawProcedural(Matrix4x4.identity, m_DebugViewTilesMaterial, 0, MeshTopology.Triangles, numTiles * 6);
+                        }
+                    }
+                    else if (m_TileSettings.tileDebugByCategory != TileSettings.TileDebug.None)
+                    {
+                        // lightCategories
-                        m_DebugViewTilesMaterial.SetBuffer("g_TileList", s_TileList);
-                        m_DebugViewTilesMaterial.SetBuffer("g_DispatchIndirectBuffer", s_DispatchIndirectBuffer);
-                        m_DebugViewTilesMaterial.DisableKeyword("SHOW_LIGHT_CATEGORIES");
-                        m_DebugViewTilesMaterial.EnableKeyword("SHOW_FEATURE_VARIANTS");
-                        cmd.SetRenderTarget(colorBuffer);
-                        cmd.DrawProcedural(Matrix4x4.identity, m_DebugViewTilesMaterial, 0, MeshTopology.Triangles, numTiles * 6);
+                        m_DebugViewTilesMaterial.EnableKeyword("SHOW_LIGHT_CATEGORIES");
+                        m_DebugViewTilesMaterial.DisableKeyword("SHOW_FEATURE_VARIANTS");
+
+                        cmd.Blit(null, colorBuffer, m_DebugViewTilesMaterial, 0);
+                    SetGlobalPropertyRedirect(null, 0, null);
-                else if (m_TileSettings.tileDebugByCategory != TileSettings.TileDebug.None)
-                {
-                    // lightCategories
-                    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");
-                    m_DebugViewTilesMaterial.EnableKeyword("SHOW_LIGHT_CATEGORIES");
-                    m_DebugViewTilesMaterial.DisableKeyword("SHOW_FEATURE_VARIANTS");
-
-                    cmd.Blit(null, colorBuffer, m_DebugViewTilesMaterial, 0);
-                }
-                SetGlobalPropertyRedirect(null, 0, null);
-
-                renderContext.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
-            public void RenderDeferredLighting( HDCamera hdCamera, ScriptableRenderContext renderContext,
+            public void RenderDeferredLighting( HDCamera hdCamera, CommandBuffer cmd,
                                                 DebugDisplaySettings debugDisplaySettings,
                                                 RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthStencilTexture,
                                                 bool outputSplitLighting)
-                using (new Utilities.ProfilingSample((m_TileSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLighting ? " MRT" : ""), renderContext))
+                using (new Utilities.ProfilingSample((m_TileSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLighting ? " MRT" : ""), cmd))
-                    var cmd = CommandBufferPool.Get();
-                    cmd.name = bUseClusteredForDeferred ? "Clustered pass" : "Tiled pass";
-
                     var camera = hdCamera.camera;
 
                     SetupDebugDisplayMode(debugDisplaySettings.IsDebugDisplayEnabled());
-                        PushGlobalParams(camera, renderContext, null, 0);
+                        PushGlobalParams(camera, cmd, null, 0);
 
                         // This is a debug brute force renderer to debug tile/cluster which render all the lights
                         if (outputSplitLighting)
 
                                 // Pass global parameters to compute shader
                                 // TODO: get rid of this by making global parameters visible to compute shaders
-                                PushGlobalParams(camera, renderContext, shadeOpaqueShader, kernel);
+                                PushGlobalParams(camera, cmd, shadeOpaqueShader, kernel);
 
                                 // TODO: Update value like in ApplyDebugDisplaySettings() call. Sadly it is high likely that this will not be keep in sync. we really need to get rid of this by making global parameters visible to compute shaders
                                 cmd.SetComputeIntParam(shadeOpaqueShader, "_DebugViewMaterial", Shader.GetGlobalInt("_DebugViewMaterial"));
                         else
                         {
                             // Pixel shader evaluation
-                            PushGlobalParams(camera, renderContext, null, 0);
+                            PushGlobalParams(camera, cmd, null, 0);
 
                             if (m_TileSettings.enableSplitLightEvaluation)
                             {
                     }
 
                     SetGlobalPropertyRedirect(null, 0, null);
-
-                    renderContext.ExecuteCommandBuffer(cmd);
-                    CommandBufferPool.Release(cmd);
-            public void RenderForward(Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
+            public void RenderForward(Camera camera, CommandBuffer cmd, bool renderOpaque)
-
-                var cmd = CommandBufferPool.Get();
-                    cmd.name = "Forward pass";
-                    cmd.EnableShaderKeyword("LIGHTLOOP_SINGLE_PASS");
-                    cmd.DisableShaderKeyword("LIGHTLOOP_TILE_PASS");
+                    using (new Utilities.ProfilingSample("Forward pass", cmd))
+                    {
+                        cmd.EnableShaderKeyword("LIGHTLOOP_SINGLE_PASS");
+                        cmd.DisableShaderKeyword("LIGHTLOOP_TILE_PASS");
+                    }
-                    cmd.name = useFptl ? "Forward Tiled pass" : "Forward Clustered pass";
-                    // say that we want to use tile of single loop
-                    cmd.EnableShaderKeyword("LIGHTLOOP_TILE_PASS");
-                    cmd.DisableShaderKeyword("LIGHTLOOP_SINGLE_PASS");
-                    cmd.SetGlobalFloat("_UseTileLightList", useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
-                    cmd.SetGlobalBuffer("g_vLightListGlobal", useFptl ? s_LightList : s_PerVoxelLightLists);
+                    using (new Utilities.ProfilingSample(useFptl ? "Forward Tiled pass" : "Forward Clustered pass", cmd))
+                    {
+                        // say that we want to use tile of single loop
+                        cmd.EnableShaderKeyword("LIGHTLOOP_TILE_PASS");
+                        cmd.DisableShaderKeyword("LIGHTLOOP_SINGLE_PASS");
+                        cmd.SetGlobalFloat("_UseTileLightList", useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
+                        cmd.SetGlobalBuffer("g_vLightListGlobal", useFptl ? s_LightList : s_PerVoxelLightLists);
+                    }
-
-                renderContext.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
-            public void RenderDebugOverlay(Camera camera, ScriptableRenderContext renderContext, DebugDisplaySettings debugDisplaySettings, ref float x, ref float y, float overlaySize, float width)
+            public void RenderDebugOverlay(Camera camera, CommandBuffer cmd, DebugDisplaySettings debugDisplaySettings, ref float x, ref float y, float overlaySize, float width)
-                using (new Utilities.ProfilingSample("Display Shadows", renderContext))
+                using (new Utilities.ProfilingSample("Display Shadows", cmd))
                 {
                     if (lightingDebug.shadowDebugMode == ShadowMapDebugMode.VisualizeShadowMap)
                     {
                             uint faceCount = m_ShadowMgr.GetShadowRequestFaceCount((uint)index);
                             for (uint i = 0; i < faceCount; ++i)
                             {
-                                m_ShadowMgr.DisplayShadow(renderContext, index, i, x, y, overlaySize, overlaySize, lightingDebug.shadowMinValue, lightingDebug.shadowMaxValue);
+                                m_ShadowMgr.DisplayShadow(cmd, index, i, x, y, overlaySize, overlaySize, lightingDebug.shadowMinValue, lightingDebug.shadowMaxValue);
                                 Utilities.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.pixelWidth);
                             }
                         }
-                        m_ShadowMgr.DisplayShadowMap(renderContext, lightingDebug.shadowAtlasIndex, 0, x, y, overlaySize, overlaySize, lightingDebug.shadowMinValue, lightingDebug.shadowMaxValue);
+                        m_ShadowMgr.DisplayShadowMap(cmd, lightingDebug.shadowAtlasIndex, 0, x, y, overlaySize, overlaySize, lightingDebug.shadowMinValue, lightingDebug.shadowMaxValue);
                         Utilities.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.pixelWidth);
                     }
                 }

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

             m_isInit = false;
         }
 
-        public override void RenderInit(Rendering.ScriptableRenderContext renderContext)
+        public override void RenderInit(CommandBuffer cmd)
-            var cmd = CommandBufferPool.Get();
-            cmd.name = "Init PreFGD";
-            Utilities.DrawFullScreen(cmd, m_InitPreFGD, new RenderTargetIdentifier(m_PreIntegratedFGD));
-            renderContext.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
+            using (new Utilities.ProfilingSample("Init PreFGD", cmd))
+            {
+                Utilities.DrawFullScreen(cmd, m_InitPreFGD, new RenderTargetIdentifier(m_PreIntegratedFGD));
+            }
             m_isInit = true;
         }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/RenderPipelineMaterial.cs

         public virtual void Cleanup() {}
 
         // Following function can be use to initialize GPU resource (once or each frame) and bind them
-        public virtual void RenderInit(Rendering.ScriptableRenderContext renderContext) {}
+        public virtual void RenderInit(CommandBuffer cmd) {}
         public virtual void Bind() {}
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/HDRISkyRenderer.cs

         {
             if (builtinParams.depthBuffer == BuiltinSkyParameters.nullRT)
             {
-                Utilities.SetRenderTarget(builtinParams.renderContext, builtinParams.colorBuffer);
+                Utilities.SetRenderTarget(builtinParams.commandBuffer, builtinParams.colorBuffer);
-                Utilities.SetRenderTarget(builtinParams.renderContext, builtinParams.colorBuffer, builtinParams.depthBuffer);
+                Utilities.SetRenderTarget(builtinParams.commandBuffer, builtinParams.colorBuffer, builtinParams.depthBuffer);
             }
         }
 
             m_SkyHDRIMaterial.SetVector("_SkyParam", new Vector4(m_HdriSkyParams.exposure, m_HdriSkyParams.multiplier, m_HdriSkyParams.rotation, 0.0f));
 
-            var cmd = CommandBufferPool.Get("");
-            cmd.DrawMesh(builtinParams.skyMesh, Matrix4x4.identity, m_SkyHDRIMaterial, 0, renderForCubemap ? 0 : 1);
-            builtinParams.renderContext.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
+            builtinParams.commandBuffer.DrawMesh(builtinParams.skyMesh, Matrix4x4.identity, m_SkyHDRIMaterial, 0, renderForCubemap ? 0 : 1);
         }
 
         public override bool IsSkyValid()

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyRenderer.cs

         {
             // We do not bind the depth buffer as a depth-stencil target since it is
             // bound as a color texture which is then sampled from within the shader.
-            Utilities.SetRenderTarget(builtinParams.renderContext, builtinParams.colorBuffer);
+            Utilities.SetRenderTarget(builtinParams.commandBuffer, builtinParams.colorBuffer);
         }
 
         void SetKeywords(BuiltinSkyParameters builtinParams, ProceduralSkySettings param, bool renderForCubemap)
             // Set shader constants.
             SetUniforms(builtinParams, m_ProceduralSkySettings, renderForCubemap, ref properties);
 
-            var cmd = CommandBufferPool.Get("");
-            cmd.DrawMesh(builtinParams.skyMesh, Matrix4x4.identity, m_ProceduralSkyMaterial, 0, 0, properties);
-            builtinParams.renderContext.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
-
+            builtinParams.commandBuffer.DrawMesh(builtinParams.skyMesh, Matrix4x4.identity, m_ProceduralSkyMaterial, 0, 0, properties);
         }
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/RuntimeFilterIBL.cs

-using UnityEngine.Rendering;
+using UnityEngine.Rendering;
 using UnityEngine.Experimental.Rendering.HDPipeline;
 using System;
 
             get { return m_SupportMIS; }
         }
 
-        public void Initialize(ScriptableRenderContext context)
+        public void Initialize(CommandBuffer cmd)
         {
             if (!m_ComputeGgxIblSampleDataCS)
             {
 
                 m_ComputeGgxIblSampleDataCS.SetTexture(m_ComputeGgxIblSampleDataKernel, "output", m_GgxIblSampleData);
 
-                var cmd = CommandBufferPool.Get("Compute GGX IBL Sample Data");
+                using (new Utilities.ProfilingSample("Compute GGX IBL Sample Data", cmd))
+                {
-                context.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
+                }
-        void FilterCubemapCommon(ScriptableRenderContext context,
+        void FilterCubemapCommon(CommandBuffer cmd,
             Texture source, RenderTexture target, int mipCount,
             Mesh[] cubemapFaceMesh)
         {
 
             for (int mip = 1; mip < ((int)EnvConstants.SpecCubeLodStep + 1); ++mip)
             {
+                string sampleName = String.Format("Filter Cubemap Mip {0}", mip);
+                cmd.BeginSample(sampleName);
+
-                    Utilities.SetRenderTarget(context, target, ClearFlag.ClearNone, mip, (CubemapFace)face);
+                    Utilities.SetRenderTarget(cmd, target, ClearFlag.ClearNone, mip, (CubemapFace)face);
-                    var cmd = CommandBufferPool.Get();
-                    context.ExecuteCommandBuffer(cmd);
-                    CommandBufferPool.Release(cmd);
+                cmd.EndSample(sampleName);
-        public void FilterCubemap(ScriptableRenderContext context,
+        public void FilterCubemap(CommandBuffer cmd,
-            FilterCubemapCommon(context, source, target, mipCount, cubemapFaceMesh);
+            FilterCubemapCommon(cmd, source, target, mipCount, cubemapFaceMesh);
-        public void FilterCubemapMIS(ScriptableRenderContext context,
+        public void FilterCubemapMIS(CommandBuffer cmd,
             Texture source, RenderTexture target, int mipCount,
             RenderTexture conditionalCdf, RenderTexture marginalRowCdf,
             Mesh[] cubemapFaceMesh)
 
             int numRows = conditionalCdf.height;
 
-            var cmd = CommandBufferPool.Get("Build Probability Tables");
+            using (new Utilities.ProfilingSample("Build Probability Tables", cmd))
+            {
-            context.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
+            }
-            FilterCubemapCommon(context, source, target, mipCount, cubemapFaceMesh);
+            FilterCubemapCommon(cmd, source, target, mipCount, cubemapFaceMesh);
         }
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

         public Vector3                  cameraPosWS;
         public Vector4                  screenSize;
         public Mesh                     skyMesh;
-        public ScriptableRenderContext  renderContext;
+        public CommandBuffer            commandBuffer;
         public Light                    sunLight;
         public RenderTargetIdentifier   colorBuffer;
         public RenderTargetIdentifier   depthBuffer;
                 builtinParams.colorBuffer = target;
                 builtinParams.depthBuffer = BuiltinSkyParameters.nullRT;
 
-                Utilities.SetRenderTarget(builtinParams.renderContext, target, ClearFlag.ClearNone, 0, (CubemapFace)i);
+                Utilities.SetRenderTarget(builtinParams.commandBuffer, target, ClearFlag.ClearNone, 0, (CubemapFace)i);
-        private void BlitCubemap(ScriptableRenderContext renderContext, Cubemap source, RenderTexture dest)
+        private void BlitCubemap(CommandBuffer cmd, Cubemap source, RenderTexture dest)
         {
 
             MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
-                Utilities.SetRenderTarget(renderContext, dest, ClearFlag.ClearNone, 0, (CubemapFace)i);
-                var cmd = CommandBufferPool.Get();
+                Utilities.SetRenderTarget(cmd, dest, ClearFlag.ClearNone, 0, (CubemapFace)i);
-                renderContext.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
-        private void RenderCubemapGGXConvolution(ScriptableRenderContext renderContext, BuiltinSkyParameters builtinParams, SkySettings skyParams, Texture input, RenderTexture target)
+        private void RenderCubemapGGXConvolution(CommandBuffer cmd, BuiltinSkyParameters builtinParams, SkySettings skyParams, Texture input, RenderTexture target)
-            using (new Utilities.ProfilingSample("Sky Pass: GGX Convolution", renderContext))
+            using (new Utilities.ProfilingSample("Update Env: GGX Convolution", cmd))
             {
                 int mipCount = 1 + (int)Mathf.Log(input.width, 2.0f);
                 if (mipCount < ((int)EnvConstants.SpecCubeLodStep + 1))
 
                 if (!m_iblFilterGgx.IsInitialized())
                 {
-                    m_iblFilterGgx.Initialize(renderContext);
+                    m_iblFilterGgx.Initialize(cmd);
-                var cmd = CommandBufferPool.Get();
-                for (int f = 0; f < 6; f++)
+                using (new Utilities.ProfilingSample("Copy Original Mip", cmd))
-                    cmd.CopyTexture(input, f, 0, target, f, 0);
+                    for (int f = 0; f < 6; f++)
+                    {
+                        cmd.CopyTexture(input, f, 0, target, f, 0);
+                    }
-                renderContext.ExecuteCommandBuffer(cmd);
-                
-                if (m_useMIS && m_iblFilterGgx.SupportMIS)
+                using (new Utilities.ProfilingSample("GGX Convolution", cmd))
-                    m_iblFilterGgx.FilterCubemapMIS(renderContext, input, target, mipCount, m_SkyboxConditionalCdfRT, m_SkyboxMarginalRowCdfRT, m_CubemapFaceMesh);
-                }
-                else
-                {
-                    m_iblFilterGgx.FilterCubemap(renderContext, input, target, mipCount, m_CubemapFaceMesh);
+                    if (m_useMIS && m_iblFilterGgx.SupportMIS)
+                    {
+                        m_iblFilterGgx.FilterCubemapMIS(cmd, input, target, mipCount, m_SkyboxConditionalCdfRT, m_SkyboxMarginalRowCdfRT, m_CubemapFaceMesh);
+                    }
+                    else
+                    {
+                        m_iblFilterGgx.FilterCubemap(cmd, input, target, mipCount, m_CubemapFaceMesh);
+                    }
-                CommandBufferPool.Release(cmd);
             }
         }
 
         }
 
-        public void UpdateEnvironment(HDCamera camera, Light sunLight, ScriptableRenderContext renderContext)
+        public void UpdateEnvironment(HDCamera camera, Light sunLight, CommandBuffer cmd)
-            using (new Utilities.ProfilingSample("Sky Environment Pass", renderContext))
+            // We need one frame delay for this update to work since DynamicGI.UpdateEnvironment is executed direclty but the renderloop is not (so we need to wait for the sky texture to be rendered first)
+            if (m_NeedLowLevelUpdateEnvironment)
-
-                // We need one frame delay for this update to work since DynamicGI.UpdateEnvironment is executed direclty but the renderloop is not (so we need to wait for the sky texture to be rendered first)
-                if (m_NeedLowLevelUpdateEnvironment)
+                using (new Utilities.ProfilingSample("DynamicGI.UpdateEnvironment", cmd))
                 {
                     // TODO: Properly send the cubemap to Enlighten. Currently workaround is to set the cubemap in a Skybox/cubemap material
                     m_StandardSkyboxMaterial.SetTexture("_Tex", m_SkyboxCubemapRT);
 
                     m_NeedLowLevelUpdateEnvironment = false;
                 }
+            }
-                if (IsSkyValid())
-                {
-                    m_CurrentUpdateTime += Time.deltaTime;
+            if (IsSkyValid())
+            {
+                m_CurrentUpdateTime += Time.deltaTime;
-                    m_BuiltinParameters.renderContext = renderContext;
-                    m_BuiltinParameters.sunLight = sunLight;
+                m_BuiltinParameters.commandBuffer = cmd;
+                m_BuiltinParameters.sunLight = sunLight;
-                    if (
-                        m_UpdatedFramesRequired > 0 ||
-                        (skySettings.updateMode == EnvironementUpdateMode.OnChanged && skySettings.GetHash() != m_SkyParametersHash) ||
-                        (skySettings.updateMode == EnvironementUpdateMode.Realtime && m_CurrentUpdateTime > skySettings.updatePeriod)
-                        )
+                if (
+                    m_UpdatedFramesRequired > 0 ||
+                    (skySettings.updateMode == EnvironementUpdateMode.OnChanged && skySettings.GetHash() != m_SkyParametersHash) ||
+                    (skySettings.updateMode == EnvironementUpdateMode.Realtime && m_CurrentUpdateTime > skySettings.updatePeriod)
+                    )
+                {
+                    using (new Utilities.ProfilingSample("Sky Environment Pass", cmd))
-                        // Render sky into a cubemap - doesn't happen every frame, can be controlled
-                        // Note that m_SkyboxCubemapRT is created with auto-generate mipmap, it mean that here we have also our mipmap correctly box filtered for importance sampling.
-                        if(m_SkySettings.lightingOverride == null)
-                            RenderSkyToCubemap(m_BuiltinParameters, skySettings, m_SkyboxCubemapRT);
-                        // In case the user overrides the lighting, we already have a cubemap ready but we need to blit it anyway for potential resize and so that we can generate proper mipmaps for enlighten.
-                        else
-                            BlitCubemap(renderContext, m_SkySettings.lightingOverride, m_SkyboxCubemapRT);
+                        using (new Utilities.ProfilingSample("Update Env: Generate Lighting Cubemap", cmd))
+                        {
+                            // Render sky into a cubemap - doesn't happen every frame, can be controlled
+                            // Note that m_SkyboxCubemapRT is created with auto-generate mipmap, it mean that here we have also our mipmap correctly box filtered for importance sampling.
+                            if(m_SkySettings.lightingOverride == null)
+                                RenderSkyToCubemap(m_BuiltinParameters, skySettings, m_SkyboxCubemapRT);
+                            // In case the user overrides the lighting, we already have a cubemap ready but we need to blit it anyway for potential resize and so that we can generate proper mipmaps for enlighten.
+                            else
+                                BlitCubemap(cmd, m_SkySettings.lightingOverride, m_SkyboxCubemapRT);
+                        }
-                        RenderCubemapGGXConvolution(renderContext, m_BuiltinParameters, skySettings, m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT);
+                        RenderCubemapGGXConvolution(cmd, m_BuiltinParameters, skySettings, m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT);
 
                         m_NeedLowLevelUpdateEnvironment = true;
                         m_UpdatedFramesRequired--;
                 }
-                else
+            }
+            else
+            {
+                if(m_SkyParametersHash != 0)
-                    if(m_SkyParametersHash != 0)
+                    using (new Utilities.ProfilingSample("Reset Sky Environment", cmd))
-                        Utilities.ClearCubemap(renderContext, m_SkyboxCubemapRT, Color.black);
-                        RenderCubemapGGXConvolution(renderContext, m_BuiltinParameters, skySettings, m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT);
+                        Utilities.ClearCubemap(cmd, m_SkyboxCubemapRT, Color.black);
+                        RenderCubemapGGXConvolution(cmd, m_BuiltinParameters, skySettings, m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT);
 
                         m_SkyParametersHash = 0;
                         m_NeedLowLevelUpdateEnvironment = true;
         }
 
-        public void RenderSky(HDCamera camera, Light sunLight, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ScriptableRenderContext renderContext)
+        public void RenderSky(HDCamera camera, Light sunLight, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, CommandBuffer cmd)
-            using (new Utilities.ProfilingSample("Sky Pass", renderContext))
+            using (new Utilities.ProfilingSample("Sky Pass", cmd))
-                    m_BuiltinParameters.renderContext = renderContext;
+                    m_BuiltinParameters.commandBuffer = cmd;
                     m_BuiltinParameters.sunLight = sunLight;
                     m_BuiltinParameters.invViewProjMatrix = camera.viewProjMatrix.inverse;
                     m_BuiltinParameters.cameraPosWS = camera.camera.transform.position;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

         // Render Target Management.
         public const ClearFlag kClearAll = ClearFlag.ClearDepth | ClearFlag.ClearColor;
 
-        public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier buffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier buffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
-            var cmd = CommandBufferPool.Get();
-            cmd.name = "";
-            renderContext.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
-        public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier buffer, ClearFlag clearFlag = ClearFlag.ClearNone, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier buffer, ClearFlag clearFlag = ClearFlag.ClearNone, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
-            SetRenderTarget(renderContext, buffer, clearFlag, Color.black, miplevel, cubemapFace);
+            SetRenderTarget(cmd, buffer, clearFlag, Color.black, miplevel, cubemapFace);
-        public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
-            SetRenderTarget(renderContext, colorBuffer, depthBuffer, ClearFlag.ClearNone, Color.black, miplevel, cubemapFace);
+            SetRenderTarget(cmd, colorBuffer, depthBuffer, ClearFlag.ClearNone, Color.black, miplevel, cubemapFace);
-        public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
-            SetRenderTarget(renderContext, colorBuffer, depthBuffer, clearFlag, Color.black, miplevel, cubemapFace);
+            SetRenderTarget(cmd, colorBuffer, depthBuffer, clearFlag, Color.black, miplevel, cubemapFace);
-        public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
-            var cmd = CommandBufferPool.Get();
-            cmd.name = "";
-            renderContext.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
-        public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer)
-            SetRenderTarget(renderContext, colorBuffers, depthBuffer, ClearFlag.ClearNone, Color.black);
+            SetRenderTarget(cmd, colorBuffers, depthBuffer, ClearFlag.ClearNone, Color.black);
-        public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag = ClearFlag.ClearNone)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag = ClearFlag.ClearNone)
-            SetRenderTarget(renderContext, colorBuffers, depthBuffer, clearFlag, Color.black);
+            SetRenderTarget(cmd, colorBuffers, depthBuffer, clearFlag, Color.black);
-        public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor)
-            var cmd = CommandBufferPool.Get();
-            cmd.name = "";
-            renderContext.ExecuteCommandBuffer(cmd);
-            
-        public static void ClearCubemap(ScriptableRenderContext renderContext, RenderTargetIdentifier buffer, Color clearColor)
+        public static void ClearCubemap(CommandBuffer cmd, RenderTargetIdentifier buffer, Color clearColor)
-            var cmd = CommandBufferPool.Get();
-            cmd.name = "";
-
-                SetRenderTarget(renderContext, buffer, ClearFlag.ClearColor, Color.black, 0, (CubemapFace)i);
+                SetRenderTarget(cmd, buffer, ClearFlag.ClearColor, Color.black, 0, (CubemapFace)i);
-
-            renderContext.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
         }
 
         // Miscellanous
         public struct ProfilingSample
             : IDisposable
         {
-            bool        disposed;
-            ScriptableRenderContext  renderContext;
-            string      name;
+            bool            disposed;
+            CommandBuffer   cmd;
+            string          name;
-            public ProfilingSample(string _name, ScriptableRenderContext _renderloop)
+            public ProfilingSample(string _name, CommandBuffer _cmd)
-                renderContext = _renderloop;
+                cmd = _cmd;
-
-                CommandBuffer cmd = CommandBufferPool.Get();
-                cmd.name = "";
-                renderContext.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
             }
             
             public void Dispose()
 
                 if (disposing)
                 {
-                    CommandBuffer cmd = CommandBufferPool.Get();
-                    cmd.name = "";
-                    renderContext.ExecuteCommandBuffer(cmd);
-                    CommandBufferPool.Release(cmd);
                 }
 
                 disposed = true;