wip buffered RTHandle system for cameras

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using UnityEngine.Assertions;
 using UnityEngine.Rendering;
 
 
-    public partial class RTHandleSystem
+    public partial class RTHandleSystem : IDisposable
     {
         internal enum RTCategory
         {
         public int maxWidth { get { return GetMaxWidth(m_ScaledRTCurrentCategory); } }
         public int maxHeight { get { return GetMaxHeight(m_ScaledRTCurrentCategory); } }
 
-        internal RTHandleSystem()
+        public RTHandleSystem()
         {
             m_AutoSizedRTs = new List<RTHandle>();
             for (int i = 0; i < (int)RTCategory.Count; ++i)
             }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
         }
 
         // Call this once to set the initial size and allow msaa targets or not.
 
         int GetMaxWidth(RTCategory category) { return m_MaxWidths[(int)category]; }
         int GetMaxHeight(RTCategory category) { return m_MaxHeights[(int)category]; }
+
+        void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                for (int i = 0, c = m_AutoSizedRTs.Count; i < c; ++i)
+                {
+                    var rt = m_AutoSizedRTs[i];
+                    Release(rt);
+                }
+                m_AutoSizedRTs.Clear();
+            }
+        }
 
         void Resize(int width, int height, RTCategory category, MSAASamples msaaSamples)
         {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDAdditionalCameraData.cs

         bool    m_IsDebugRegistered = false;
         string  m_CameraRegisterName;
 
+        BufferedRTHandleSystem m_HistoryRTSystem;
+        public BufferedRTHandleSystem historyRTSystem { get { return m_HistoryRTSystem; } }
+
         // This is the function use outside to access FrameSettings. It return the current state of FrameSettings for the camera
         // taking into account the customization via the debug menu
         public FrameSettings GetFrameSettings()
             }
         }
 
+        void Awake()
+        {
+            m_HistoryRTSystem = new BufferedRTHandleSystem();
+        }
+
         void OnEnable()
         {
             // Be sure legacy HDR option is disable on camera as it cause banding in SceneView. Yes, it is a contradiction, but well, Unity...
         void OnDisable()
         {
             UnRegisterDebug();
+        }
+
+        void OnDestroy()
+        {
+            m_HistoryRTSystem.Dispose();
+            m_HistoryRTSystem = null;
         }
 
         public void OnBeforeSerialize()

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

         public Matrix4x4 nonJitteredProjMatrix;
         public Vector4   worldSpaceCameraPos;
         public float     detViewMatrix;
-        public Vector4   screenSize;
-        public Frustum   frustum;
+        public Vector4 screenSize;
+        public Frustum frustum;
-        public Camera    camera;
-        public uint      taaFrameIndex;
-        public Vector2   taaFrameRotation;
+        public Camera camera;
+        public uint taaFrameIndex;
+        public Vector2 taaFrameRotation;
         public Vector4   zBufferParams;
         public Vector4   unity_OrthoParams;
         public Vector4   projectionParams;
         static List<Camera> s_Cleanup = new List<Camera>(); // Recycled to reduce GC pressure
 
         HDAdditionalCameraData m_AdditionalCameraData;
+
+        public BufferedRTHandleSystem historyRTSystem 
+        {
+             get { return m_AdditionalCameraData != null ? m_AdditionalCameraData.historyRTSystem : null; } 
+        }
 
         public HDCamera(Camera cam)
         {
             // Unfortunately sometime (like in the HDCameraEditor) HDUtils.hdrpSettings can be null because of scripts that change the current pipeline...
             m_msaaSamples = HDUtils.hdrpSettings != null ? HDUtils.hdrpSettings.msaaSampleCount : MSAASamples.None;
             RTHandles.SetReferenceSize(m_ActualWidth, m_ActualHeight, frameSettings.enableMSAA, m_msaaSamples);
+            historyRTSystem.SetReferenceSize(m_ActualWidth, m_ActualHeight, frameSettings.enableMSAA, m_msaaSamples);
+            historyRTSystem.Swap();
 
             int maxWidth = RTHandles.maxWidth;
             int maxHeight = RTHandles.maxHeight;
-            screenSize   = new Vector4(screenWidth, screenHeight, 1.0f / screenWidth, 1.0f / screenHeight);
+            screenSize = new Vector4(screenWidth, screenHeight, 1.0f / screenWidth, 1.0f / screenHeight);
             screenParams = new Vector4(screenSize.x, screenSize.y, 1 + screenSize.z, 1 + screenSize.w);
         }
 
         // Set up UnityPerView CBuffer.
         public void SetupGlobalParams(CommandBuffer cmd, float time, float lastTime)
         {
-            cmd.SetGlobalMatrix(HDShaderIDs._ViewMatrix,                viewMatrix);
-            cmd.SetGlobalMatrix(HDShaderIDs._InvViewMatrix,             viewMatrix.inverse);
-            cmd.SetGlobalMatrix(HDShaderIDs._ProjMatrix,                projMatrix);
-            cmd.SetGlobalMatrix(HDShaderIDs._InvProjMatrix,             projMatrix.inverse);
-            cmd.SetGlobalMatrix(HDShaderIDs._ViewProjMatrix,            viewProjMatrix);
-            cmd.SetGlobalMatrix(HDShaderIDs._InvViewProjMatrix,         viewProjMatrix.inverse);
+            cmd.SetGlobalMatrix(HDShaderIDs._ViewMatrix, viewMatrix);
+            cmd.SetGlobalMatrix(HDShaderIDs._InvViewMatrix, viewMatrix.inverse);
+            cmd.SetGlobalMatrix(HDShaderIDs._ProjMatrix, projMatrix);
+            cmd.SetGlobalMatrix(HDShaderIDs._InvProjMatrix, projMatrix.inverse);
+            cmd.SetGlobalMatrix(HDShaderIDs._ViewProjMatrix, viewProjMatrix);
+            cmd.SetGlobalMatrix(HDShaderIDs._InvViewProjMatrix, viewProjMatrix.inverse);
-            cmd.SetGlobalVector(HDShaderIDs._ScreenSize,                screenSize);
-            cmd.SetGlobalVector(HDShaderIDs._ScreenToTargetScale,       scaleBias);
+            cmd.SetGlobalVector(HDShaderIDs._ScreenSize, screenSize);
+            cmd.SetGlobalVector(HDShaderIDs._ScreenToTargetScale, scaleBias);
-            cmd.SetGlobalVectorArray(HDShaderIDs._FrustumPlanes,        frustumPlaneEquations);
+            cmd.SetGlobalVectorArray(HDShaderIDs._FrustumPlanes, frustumPlaneEquations);
 
             // Time is also a part of the UnityPerView CBuffer.
             // Different views can have different values of the "Animated Materials" setting.
             cmd.SetGlobalMatrixArray(HDShaderIDs._InvViewMatrixStereo, invViewStereo);
             cmd.SetGlobalMatrixArray(HDShaderIDs._InvProjMatrixStereo, invProjStereo);
             cmd.SetGlobalMatrixArray(HDShaderIDs._InvViewProjMatrixStereo, invViewProjStereo);
+        }
+
+        public RTHandleSystem.RTHandle GetPreviousFrameRT(int id)
+        {
+            if (m_AdditionalCameraData == null)
+                return null;
+
+            return m_AdditionalCameraData.historyRTSystem.GetFrameRT(id, 1);
+        }
+
+        public RTHandleSystem.RTHandle GetCurrentFrameRT(int id)
+        {
+            if (m_AdditionalCameraData == null)
+                return null;
+            
+            return m_AdditionalCameraData.historyRTSystem.GetFrameRT(id, 0);
+        }
+
+        // Allocate buffers frames and return current frame
+        public RTHandleSystem.RTHandle AllocHistoryFrameRT(int id, Func<RTHandleSystem, RTHandleSystem.RTHandle> allocator)
+        {
+            
+            if (m_AdditionalCameraData == null)
+                return null;
+
+            m_AdditionalCameraData.historyRTSystem.AllocBuffer(id, allocator, 2);
+            return m_AdditionalCameraData.historyRTSystem.GetFrameRT(id, 0);
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDCustomSamplerId.cs

         TransparentDepthPostpass,
         ObjectsVelocity,
         CameraVelocity,
-        GaussianPyramidColor,
-        PyramidDepth,
+        ColorPyramid,
+        DepthPyramid,
         PostProcessing,
         RenderDebug,
         ClearBuffers,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             if (m_Asset.renderPipelineSettings.supportDBuffer)
                 m_DbufferManager.CreateBuffers();
 
-            m_BufferPyramid.CreateBuffers();
-
             m_SSSBufferManager.InitSSSBuffers(m_GbufferManager, m_Asset.renderPipelineSettings);
 
             m_CameraColorBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBHalf, sRGB : false, enableRandomWrite: true, enableMSAA: true, name : "CameraColor");
                     ?? ScreenSpaceRefraction.@default;
                 ssrefraction.PushShaderParameters(cmd);
 
+                var previousDepthPyramidRT = hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.DepthPyramid);
+                if (previousDepthPyramidRT != null)
+                    cmd.SetGlobalTexture(HDShaderIDs._DepthPyramidTexture, previousDepthPyramidRT);
+                var previousColorPyramidRT = hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.ColorPyramid);
+                if (previousColorPyramidRT != null)
+                    cmd.SetGlobalTexture(HDShaderIDs._ColorPyramidTexture, previousColorPyramidRT);
+
                 // Set up UnityPerView CBuffer.
                 hdCamera.SetupGlobalParams(cmd, m_Time, m_LastTime);
                 if (m_FrameSettings.enableStereo) hdCamera.SetupGlobalStereoParams(cmd);
                     // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
                     UpdateSkyEnvironment(hdCamera, cmd);
 
-                    RenderPyramidDepth(hdCamera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
+                    RenderDepthPyramid(hdCamera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
 
                     StopStereoRendering(renderContext, hdCamera.camera);
 
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
                         RenderForwardError(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
 
-                        RenderGaussianPyramidColor(hdCamera, cmd, renderContext, true);
+                        RenderColorPyramid(hdCamera, cmd, renderContext, true);
+                        RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.OpaqueSSReflection);
 
                         // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
                         RenderTransparentDepthPostpass(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
 
-                        RenderGaussianPyramidColor(hdCamera, cmd, renderContext, false);
+                        RenderColorPyramid(hdCamera, cmd, renderContext, false);
 
                         AccumulateDistortion(m_CullResults, hdCamera, renderContext, cmd);
                         RenderDistortion(cmd, m_Asset.renderPipelineResources, hdCamera);
 
             using (new ProfilingSample(cmd, "ApplyDistortion", CustomSamplerId.ApplyDistortion.GetSampler()))
             {
-                Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera);
+                var colorPyramidRT = hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.ColorPyramid);
+                var pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera, colorPyramidRT);
 
                 // Need to account for the fact that the gaussian pyramid is actually rendered inside the camera viewport in a square texture so we mutiply by the PyramidToScreen scale
                 var size = new Vector4(hdCamera.screenSize.x, hdCamera.screenSize.y, pyramidScale.x / hdCamera.screenSize.x, pyramidScale.y / hdCamera.screenSize.y);
-                cmd.SetComputeTextureParam(m_applyDistortionCS, m_applyDistortionKernel, HDShaderIDs._ColorPyramidTexture, m_BufferPyramid.colorPyramid);
+                cmd.SetComputeTextureParam(m_applyDistortionCS, m_applyDistortionKernel, HDShaderIDs._ColorPyramidTexture, colorPyramidRT);
                 cmd.SetComputeTextureParam(m_applyDistortionCS, m_applyDistortionKernel, HDShaderIDs._CameraColorTexture, m_CameraColorBuffer);
                 cmd.SetComputeVectorParam(m_applyDistortionCS, HDShaderIDs._Size, size);
 
             }
         }
 
-        void RenderGaussianPyramidColor(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, bool isPreRefraction)
+        void RenderColorPyramid(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, bool isPreRefraction)
         {
             if (isPreRefraction)
             {
                     return;
             }
 
-            using (new ProfilingSample(cmd, "Gaussian Pyramid Color", CustomSamplerId.GaussianPyramidColor.GetSampler()))
-                m_BufferPyramid.RenderColorPyramid(hdCamera, cmd, renderContext, m_CameraColorBuffer);
+            var cameraRT = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.ColorPyramid)
+                ?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.ColorPyramid, m_BufferPyramid.AllocColorRT);
-            Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera);
-            PushFullScreenDebugTextureMip(cmd, m_BufferPyramid.colorPyramid, m_BufferPyramid.GetPyramidLodCount(hdCamera), new Vector4(pyramidScale.x, pyramidScale.y, 0.0f, 0.0f), hdCamera, isPreRefraction ? FullScreenDebugMode.PreRefractionColorPyramid : FullScreenDebugMode.FinalColorPyramid);
+            using (new ProfilingSample(cmd, "Color Pyramid", CustomSamplerId.ColorPyramid.GetSampler()))
+                m_BufferPyramid.RenderColorPyramid(hdCamera, cmd, renderContext, m_CameraColorBuffer, cameraRT);
+
+            Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera, cameraRT);
+            PushFullScreenDebugTextureMip(cmd, cameraRT, m_BufferPyramid.GetPyramidLodCount(hdCamera), new Vector4(pyramidScale.x, pyramidScale.y, 0.0f, 0.0f), hdCamera, isPreRefraction ? FullScreenDebugMode.PreRefractionColorPyramid : FullScreenDebugMode.FinalColorPyramid);
-        void RenderPyramidDepth(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
+        void RenderDepthPyramid(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
-            using (new ProfilingSample(cmd, "Pyramid Depth", CustomSamplerId.PyramidDepth.GetSampler()))
-                m_BufferPyramid.RenderDepthPyramid(hdCamera, cmd, renderContext, GetDepthTexture());
+            var cameraRT = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.DepthPyramid)
+                ?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.DepthPyramid, m_BufferPyramid.AllocDepthRT);
+
+            using (new ProfilingSample(cmd, "Depth Pyramid", CustomSamplerId.DepthPyramid.GetSampler()))
+                m_BufferPyramid.RenderDepthPyramid(hdCamera, cmd, renderContext, GetDepthTexture(), cameraRT);
-            Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera);
-            PushFullScreenDebugTextureMip(cmd, m_BufferPyramid.depthPyramid, m_BufferPyramid.GetPyramidLodCount(hdCamera), new Vector4(pyramidScale.x, pyramidScale.y, 0.0f, 0.0f), hdCamera, debugMode);
+            Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera, cameraRT);
+            PushFullScreenDebugTextureMip(cmd, cameraRT, m_BufferPyramid.GetPyramidLodCount(hdCamera), new Vector4(pyramidScale.x, pyramidScale.y, 0.0f, 0.0f), hdCamera, debugMode);
         }
 
         void RenderPostProcess(HDCamera hdcamera, CommandBuffer cmd, PostProcessLayer layer)
                     // (i.e. we have perform a flip, we need to flip the input texture)
                     m_DebugFullScreen.SetFloat(HDShaderIDs._RequireToFlipInputTexture, hdCamera.camera.cameraType != CameraType.SceneView ? 1.0f : 0.0f);
                     m_DebugFullScreen.SetBuffer(HDShaderIDs._DebugScreenSpaceTracingData, m_DebugScreenSpaceTracingData);
-                    m_DebugFullScreen.SetTexture(HDShaderIDs._DepthPyramidTexture, m_BufferPyramid.depthPyramid);
+                    m_DebugFullScreen.SetTexture(HDShaderIDs._DepthPyramidTexture, hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.DepthPyramid));
                     HDUtils.DrawFullScreen(cmd, hdCamera, m_DebugFullScreen, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
 
                     PushColorPickerDebugTexture(cmd, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget, hdCamera);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/BufferPyramid.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
-        RTHandleSystem.RTHandle m_ColorPyramidBuffer;
-
-        RTHandleSystem.RTHandle m_DepthPyramidBuffer;
-
-        public RTHandleSystem.RTHandle colorPyramid { get { return m_ColorPyramidBuffer; } }
-        public RTHandleSystem.RTHandle depthPyramid { get { return m_DepthPyramidBuffer; } }
 
         BufferPyramidProcessor m_Processor;
 
             return scale;
         }
 
-        public void CreateBuffers()
-        {
-            m_ColorPyramidBuffer = RTHandles.Alloc(size => CalculatePyramidSize(size), filterMode: FilterMode.Trilinear, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, useMipMap: true, autoGenerateMips: false, enableRandomWrite: true, name: "ColorPyramid");
-            m_DepthPyramidBuffer = RTHandles.Alloc(size => CalculatePyramidSize(size), filterMode: FilterMode.Trilinear, colorFormat: RenderTextureFormat.RGFloat, sRGB: false, useMipMap: true, autoGenerateMips: false, enableRandomWrite: true, name: "DepthPyramid"); // Need randomReadWrite because we downsample the first mip with a compute shader.
-        }
-
-            RTHandles.Release(m_ColorPyramidBuffer);
-            RTHandles.Release(m_DepthPyramidBuffer);
-
-            {
-            }
-            {
-            }
         }
 
         public int GetPyramidLodCount(HDCamera camera)
             }
         }
 
-        public Vector2 GetPyramidToScreenScale(HDCamera camera)
+        public Vector2 GetPyramidToScreenScale(HDCamera camera, RTHandleSystem.RTHandle rth)
-            return new Vector2((float)camera.actualWidth / m_DepthPyramidBuffer.rt.width, (float)camera.actualHeight / m_DepthPyramidBuffer.rt.height);
+            return new Vector2((float)camera.actualWidth / rth.rt.width, (float)camera.actualHeight / rth.rt.height);
         }
 
         public void RenderDepthPyramid(
-            RTHandleSystem.RTHandle depthTexture)
+            RTHandleSystem.RTHandle sourceDepthTexture,
+            RTHandleSystem.RTHandle targetDepthTexture)
-            UpdatePyramidMips(hdCamera, m_DepthPyramidBuffer.rt.format, m_DepthPyramidMips, lodCount);
+            UpdatePyramidMips(hdCamera, targetDepthTexture.rt.format, m_DepthPyramidMips, lodCount);
-            Vector2 scale = GetPyramidToScreenScale(hdCamera);
+            Vector2 scale = GetPyramidToScreenScale(hdCamera, targetDepthTexture);
             cmd.SetGlobalVector(HDShaderIDs._DepthPyramidSize, new Vector4(hdCamera.actualWidth, hdCamera.actualHeight, 1f / hdCamera.actualWidth, 1f / hdCamera.actualHeight));
             cmd.SetGlobalVector(HDShaderIDs._DepthPyramidScale, new Vector4(scale.x, scale.y, lodCount, 0.0f));
 
-                depthTexture,
-                m_DepthPyramidBuffer,
+                sourceDepthTexture,
+                targetDepthTexture,
-            cmd.SetGlobalTexture(HDShaderIDs._DepthPyramidTexture, m_DepthPyramidBuffer);
+            cmd.SetGlobalTexture(HDShaderIDs._DepthPyramidTexture, targetDepthTexture);
         }
 
         public void RenderColorPyramid(
-            RTHandleSystem.RTHandle colorTexture)
+            RTHandleSystem.RTHandle sourceColorTexture,
+            RTHandleSystem.RTHandle targetColorTexture)
-            UpdatePyramidMips(hdCamera, m_ColorPyramidBuffer.rt.format, m_ColorPyramidMips, lodCount);
+            UpdatePyramidMips(hdCamera, targetColorTexture.rt.format, m_ColorPyramidMips, lodCount);
-            Vector2 scale = GetPyramidToScreenScale(hdCamera);
+            Vector2 scale = GetPyramidToScreenScale(hdCamera, targetColorTexture);
             cmd.SetGlobalVector(HDShaderIDs._ColorPyramidSize, new Vector4(hdCamera.actualWidth, hdCamera.actualHeight, 1f / hdCamera.actualWidth, 1f / hdCamera.actualHeight));
             cmd.SetGlobalVector(HDShaderIDs._ColorPyramidScale, new Vector4(scale.x, scale.y, lodCount, 0.0f));
 
-                colorTexture,
-                m_ColorPyramidBuffer,
+                sourceColorTexture,
+                targetColorTexture,
-            cmd.SetGlobalTexture(HDShaderIDs._ColorPyramidTexture, m_ColorPyramidBuffer);
+            cmd.SetGlobalTexture(HDShaderIDs._ColorPyramidTexture, targetColorTexture);
+        }
+
+        public RTHandleSystem.RTHandle AllocColorRT(RTHandleSystem rtHandleSystem)
+        {
+            return rtHandleSystem.Alloc(
+                size => CalculatePyramidSize(size), 
+                filterMode: FilterMode.Trilinear, 
+                colorFormat: RenderTextureFormat.ARGBHalf, 
+                sRGB: false, 
+                useMipMap: true, 
+                autoGenerateMips: false, 
+                enableRandomWrite: true, 
+                name: "ColorPyramid"
+            );
+        }
+
+        public RTHandleSystem.RTHandle AllocDepthRT(RTHandleSystem rtHandleSystem)
+        {
+            return rtHandleSystem.Alloc(
+                size => CalculatePyramidSize(size), 
+                filterMode: FilterMode.Trilinear, 
+                colorFormat: RenderTextureFormat.RGFloat, 
+                sRGB: false, 
+                useMipMap: true, 
+                autoGenerateMips: false, 
+                enableRandomWrite: true, 
+                name: "DepthPyramid"
+            ); // Need randomReadWrite because we downsample the first mip with a compute shader.
         }
     }
 }

ScriptableRenderPipeline/Core/CoreRP/Textures/BufferedRTHandleSystem.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.Assertions;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class BufferedRTHandleSystem : IDisposable
+    {
+        Dictionary<int, RTHandleSystem.RTHandle[]> m_RTHandles = new Dictionary<int, RTHandleSystem.RTHandle[]>();
+
+        RTHandleSystem m_RTHandleSystem = new RTHandleSystem();
+        bool m_DisposedValue = false;
+
+        public RTHandleSystem.RTHandle GetFrameRT(int id, int index)
+        {
+            if (!m_RTHandles.ContainsKey(id))
+                return null;
+
+            Assert.IsTrue(index >= 0 && index < m_RTHandles[id].Length);
+
+            return m_RTHandles[id][index];
+        }
+
+        public void AllocBuffer(
+            int id, 
+            Func<RTHandleSystem, RTHandleSystem.RTHandle> allocator,
+            int bufferSize
+        )
+        {
+            m_RTHandles.Add(id, new RTHandleSystem.RTHandle[bufferSize]);
+        }
+
+        void Dispose(bool disposing)
+        {
+            if (!m_DisposedValue)
+            {
+                if (disposing)
+                {
+                    m_RTHandleSystem.Dispose();
+                    m_RTHandleSystem = null;
+                }
+
+                m_DisposedValue = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/Textures/BufferedRTHandleSystem.cs.meta

+fileFormatVersion: 2
+guid: cc56f4b85f1be9749add0bb4a25a4e4b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCameraFrameHistoryType.cs

+using UnityEngine.Serialization;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    public enum HDCameraFrameHistoryType
+    {
+        DepthPyramid,
+        ColorPyramid
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCameraFrameHistoryType.cs.meta

+fileFormatVersion: 2
+guid: 1f3be30cb97279146bc83ceb83fff369
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: