Port integral and density buffers to the RTHandle system

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.cs

                     rt.height = scaledSize.y;
 
                     rt.name = CoreUtils.GetRenderTargetAutoName(
-                        rt.width, 
-                        rt.height, 
-                        rt.format, 
-                        rth.m_Name, 
-                        mips: rt.useMipMap, 
-                        enableMSAA : enableMSAA, 
+                        rt.width,
+                        rt.height,
+                        rt.format,
+                        rth.m_Name,
+                        mips: rt.useMipMap,
+                        enableMSAA : enableMSAA,
                         msaaSamples: m_ScaledRTCurrentMSAASamples
                     );
                     rt.Create();
             {
                 var rth = m_AutoSizedRTsArray[i];
                 rth.referenceSize = maxSize;
-                
+
                 var rt = rth.m_RTs[(int)category];
 
                 // This can happen if you create a RTH for MSAA. By default we only create the MSAA version of the target.
             newRT.m_Name = name;
 
             newRT.referenceSize = new Vector2Int(width, height);
-            
+
             return newRT;
         }
 
         // Since MSAA cannot be changed on the fly for a given RenderTexture, a separate instance will be created if the user requires it. This instance will be the one used after the next call of SetReferenceSize if MSAA is required.
         public RTHandle Alloc(
                 Vector2 scaleFactor,
+                int slices = 1,
                 DepthBits depthBufferBits = DepthBits.None,
                 RenderTextureFormat colorFormat = RenderTextureFormat.Default,
                 FilterMode filterMode = FilterMode.Point,
 
             var rth = AllocAutoSizedRenderTexture(width,
                 height,
-                1,
+                slices,
                 depthBufferBits,
                 colorFormat,
                 filterMode,
         //
         public RTHandle Alloc(
                 ScaleFunc scaleFunc,
+                int slices = 1,
                 DepthBits depthBufferBits = DepthBits.None,
                 RenderTextureFormat colorFormat = RenderTextureFormat.Default,
                 FilterMode filterMode = FilterMode.Point,
 
             var rth = AllocAutoSizedRenderTexture(width,
                 height,
-                1,
+                slices,
                 depthBufferBits,
                 colorFormat,
                 filterMode,

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandles.cs

-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering
         public static int maxHeight { get { return s_DefaultInstance.maxHeight; } }
 
         public static RTHandleSystem.RTHandle Alloc(
-            int width, 
-            int height, 
-            int slices = 1, 
-            DepthBits depthBufferBits = DepthBits.None, 
-            RenderTextureFormat colorFormat = RenderTextureFormat.Default, 
-            FilterMode filterMode = FilterMode.Point, 
-            TextureWrapMode wrapMode = TextureWrapMode.Repeat, 
-            TextureDimension dimension = TextureDimension.Tex2D, 
-            bool sRGB = true, 
-            bool enableRandomWrite = false, 
-            bool useMipMap = false, 
-            bool autoGenerateMips = true, 
-            int anisoLevel = 1, 
-            float mipMapBias = 0, 
-            MSAASamples msaaSamples = MSAASamples.None, 
-            bool bindTextureMS = false, 
-            bool useDynamicScale = false, 
-            VRTextureUsage vrUsage = VRTextureUsage.None, 
-            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None, 
+            int width,
+            int height,
+            int slices = 1,
+            DepthBits depthBufferBits = DepthBits.None,
+            RenderTextureFormat colorFormat = RenderTextureFormat.Default,
+            FilterMode filterMode = FilterMode.Point,
+            TextureWrapMode wrapMode = TextureWrapMode.Repeat,
+            TextureDimension dimension = TextureDimension.Tex2D,
+            bool sRGB = true,
+            bool enableRandomWrite = false,
+            bool useMipMap = false,
+            bool autoGenerateMips = true,
+            int anisoLevel = 1,
+            float mipMapBias = 0,
+            MSAASamples msaaSamples = MSAASamples.None,
+            bool bindTextureMS = false,
+            bool useDynamicScale = false,
+            VRTextureUsage vrUsage = VRTextureUsage.None,
+            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
             string name = ""
         )
         {
         }
 
         public static RTHandleSystem.RTHandle Alloc(
-            Vector2 scaleFactor, 
-            DepthBits depthBufferBits = DepthBits.None, 
-            RenderTextureFormat colorFormat = RenderTextureFormat.Default, 
-            FilterMode filterMode = FilterMode.Point, 
-            TextureWrapMode wrapMode = TextureWrapMode.Repeat, 
-            TextureDimension dimension = TextureDimension.Tex2D, 
-            bool sRGB = true, 
-            bool enableRandomWrite = false, 
-            bool useMipMap = false, 
-            bool autoGenerateMips = true, 
-            int anisoLevel = 1, 
-            float mipMapBias = 0, 
-            bool enableMSAA = false, 
-            bool bindTextureMS = false, 
-            bool useDynamicScale = false, 
-            VRTextureUsage vrUsage = VRTextureUsage.None, 
-            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None, 
+            Vector2 scaleFactor,
+            int slices = 1,
+            DepthBits depthBufferBits = DepthBits.None,
+            RenderTextureFormat colorFormat = RenderTextureFormat.Default,
+            FilterMode filterMode = FilterMode.Point,
+            TextureWrapMode wrapMode = TextureWrapMode.Repeat,
+            TextureDimension dimension = TextureDimension.Tex2D,
+            bool sRGB = true,
+            bool enableRandomWrite = false,
+            bool useMipMap = false,
+            bool autoGenerateMips = true,
+            int anisoLevel = 1,
+            float mipMapBias = 0,
+            bool enableMSAA = false,
+            bool bindTextureMS = false,
+            bool useDynamicScale = false,
+            VRTextureUsage vrUsage = VRTextureUsage.None,
+            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
+                slices,
                 depthBufferBits,
                 colorFormat,
                 filterMode,
         }
 
         public static RTHandleSystem.RTHandle Alloc(
-            ScaleFunc scaleFunc, 
-            DepthBits depthBufferBits = DepthBits.None, 
-            RenderTextureFormat colorFormat = RenderTextureFormat.Default, 
-            FilterMode filterMode = FilterMode.Point, 
-            TextureWrapMode wrapMode = TextureWrapMode.Repeat, 
-            TextureDimension dimension = TextureDimension.Tex2D, 
-            bool sRGB = true, 
-            bool enableRandomWrite = false, 
+            ScaleFunc scaleFunc,
+            int slices = 1,
+            DepthBits depthBufferBits = DepthBits.None,
+            RenderTextureFormat colorFormat = RenderTextureFormat.Default,
+            FilterMode filterMode = FilterMode.Point,
+            TextureWrapMode wrapMode = TextureWrapMode.Repeat,
+            TextureDimension dimension = TextureDimension.Tex2D,
+            bool sRGB = true,
+            bool enableRandomWrite = false,
-            bool autoGenerateMips = true, 
-            int anisoLevel = 1, 
-            float mipMapBias = 0, 
-            bool enableMSAA = false, 
-            bool bindTextureMS = false, 
-            bool useDynamicScale = false, 
-            VRTextureUsage vrUsage = VRTextureUsage.None, 
-            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None, 
+            bool autoGenerateMips = true,
+            int anisoLevel = 1,
+            float mipMapBias = 0,
+            bool enableMSAA = false,
+            bool bindTextureMS = false,
+            bool useDynamicScale = false,
+            VRTextureUsage vrUsage = VRTextureUsage.None,
+            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
+                slices,
                 depthBufferBits,
                 colorFormat,
                 filterMode,
         }
 
         public static void Initialize(
-            int width, 
-            int height, 
-            bool scaledRTsupportsMSAA, 
+            int width,
+            int height,
+            bool scaledRTsupportsMSAA,
             MSAASamples scaledRTMSAASamples
         )
         {
         }
 
         public static void ResetReferenceSize(
-            int width, 
-            int height, 
-            bool msaa, 
+            int width,
+            int height,
+            bool msaa,
             MSAASamples msaaSamples
         )
         {
         }
 
         public static void SetReferenceSize(
-            int width, 
-            int height, 
-            bool msaa, 
+            int width,
+            int height,
+            bool msaa,
             MSAASamples msaaSamples
         )
         {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

         // This is the size actually used for this camera (as it can be altered by VR for example)
         int m_ActualWidth;
         int m_ActualHeight;
-        // This is the scale and bias of the camera viewport compared to the reference size of our Render Targets (RHandle.maxSize)
-        Vector2 m_CameraScaleBias;
+        // This is the scale of the camera viewport compared to the reference size of our Render Targets (RTHandle.maxSize)
+        Vector2 m_ViewportScaleCurrentFrame;
+        Vector2 m_ViewportScalePreviousFrame;
-        public Vector2 scaleBias { get { return m_CameraScaleBias; } }
+        public Vector2 viewportScale { get { return m_ViewportScaleCurrentFrame; } }
+        public Vector4 doubleBufferedViewportScale { get { return new Vector4(m_ViewportScaleCurrentFrame.x, m_ViewportScaleCurrentFrame.y, m_ViewportScalePreviousFrame.x, m_ViewportScalePreviousFrame.y); } }
         public MSAASamples msaaSamples { get { return m_msaaSamples; } }
 
         public Matrix4x4 viewProjMatrix
 
             int maxWidth = RTHandles.maxWidth;
             int maxHeight = RTHandles.maxHeight;
-            m_CameraScaleBias.x = (float)m_ActualWidth / maxWidth;
-            m_CameraScaleBias.y = (float)m_ActualHeight / maxHeight;
+            m_ViewportScalePreviousFrame = m_ViewportScaleCurrentFrame; // Double-buffer
+            m_ViewportScaleCurrentFrame.x = (float)m_ActualWidth / maxWidth;
+            m_ViewportScaleCurrentFrame.y = (float)m_ActualHeight / maxHeight;
 
             screenSize   = new Vector4(screenWidth, screenHeight, 1.0f / screenWidth, 1.0f / screenHeight);
             screenParams = new Vector4(screenSize.x, screenSize.y, 1 + screenSize.z, 1 + screenSize.w);
             cmd.SetGlobalVector(HDShaderIDs._WorldSpaceCameraPos,       worldSpaceCameraPos);
             cmd.SetGlobalFloat( HDShaderIDs._DetViewMatrix,             detViewMatrix);
             cmd.SetGlobalVector(HDShaderIDs._ScreenSize,                screenSize);
-            cmd.SetGlobalVector(HDShaderIDs._ScreenToTargetScale,       scaleBias);
+            cmd.SetGlobalVector(HDShaderIDs._ScreenToTargetScale,       doubleBufferedViewportScale);
             cmd.SetGlobalVector(HDShaderIDs._ZBufferParams,             zBufferParams);
             cmd.SetGlobalVector(HDShaderIDs._ProjectionParams,          projectionParams);
             cmd.SetGlobalVector(HDShaderIDs.unity_OrthoParams,          unity_OrthoParams);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCameraFrameHistoryType.cs

 {
     public enum HDCameraFrameHistoryType
     {
-        DepthPyramid,
-        ColorPyramid
+        DepthPyramid       = 0,
+        ColorPyramid       = 1,
+        VolumetricLighting = 2,
+        Count              = 3 // Keep this last
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             }
 
             m_Asset = asset;
+
+            // Initial state of the RTHandle system.
+            // Tells the system that we will require MSAA or not so that we can avoid wasteful render texture allocation.
+            // TODO: Might want to initialize to at least the window resolution to avoid un-necessary re-alloc in the player
+            RTHandles.Initialize(1, 1, m_Asset.renderPipelineSettings.supportMSAA, m_Asset.renderPipelineSettings.msaaSampleCount);
+
+
             var bufferPyramidProcessor = new BufferPyramidProcessor(
                 asset.renderPipelineResources.colorPyramidCS,
                 asset.renderPipelineResources.depthPyramidCS,
 
         void InitializeRenderTextures()
         {
-            // Initial state of the RTHandle system.
-            // Tells the system that we will require MSAA or not so that we can avoid wasteful render texture allocation.
-            // TODO: Might want to initialize to at least the window resolution to avoid un-necessary re-alloc in the player
-            RTHandles.Initialize(1, 1, m_Asset.renderPipelineSettings.supportMSAA, m_Asset.renderPipelineSettings.msaaSampleCount);
-
             if(!m_Asset.renderPipelineSettings.supportForwardOnly)
                 m_GbufferManager.CreateBuffers();
 
 
             // TODO: For MSAA, we'll need to add a Draw path in order to support MSAA properly
             m_DeferredShadowBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGB32, sRGB: false, enableRandomWrite: true, name: "DeferredShadow");
+
+            m_VolumetricLightingSystem.CreateBuffers();
 
             if (Debug.isDebugBuild)
             {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDUtils.cs

         {
             // Will set the correct camera viewport as well.
             SetRenderTarget(cmd, camera, destination);
-            BlitTexture(cmd, source, destination, camera.scaleBias, mipLevel, bilinear);
+            BlitTexture(cmd, source, destination, camera.viewportScale, mipLevel, bilinear);
         }
 
         // This case, both source and destination are camera-scaled but we want to override the scale/bias parameter.
         {
             SetRenderTarget(cmd, camera, destination);
             cmd.SetViewport(destViewport);
-            BlitTexture(cmd, source, destination, camera.scaleBias, mipLevel, bilinear);
+            BlitTexture(cmd, source, destination, camera.viewportScale, mipLevel, bilinear);
-            cmd.Blit(source, destination, new Vector2(camera.scaleBias.x, camera.scaleBias.y), Vector2.zero);
+            cmd.Blit(source, destination, new Vector2(camera.viewportScale.x, camera.viewportScale.y), Vector2.zero);
         }
 
         // This particular case is for blitting a non-scaled texture into a scaled texture. So we setup the partial viewport but don't scale the input UVs.
                                             MaterialPropertyBlock properties = null, int shaderPassId = 0)
         {
             HDUtils.SetRenderTarget(commandBuffer, camera, colorBuffer);
-            commandBuffer.SetGlobalVector(HDShaderIDs._ScreenToTargetScale, camera.scaleBias);
+            commandBuffer.SetGlobalVector(HDShaderIDs._ScreenToTargetScale, camera.doubleBufferedViewportScale);
             commandBuffer.DrawProcedural(Matrix4x4.identity, material, shaderPassId, MeshTopology.Triangles, 3, 1, properties);
         }
 
         {
             HDUtils.SetRenderTarget(commandBuffer, camera, colorBuffer, depthStencilBuffer);
-            commandBuffer.SetGlobalVector(HDShaderIDs._ScreenToTargetScale, camera.scaleBias);
+            commandBuffer.SetGlobalVector(HDShaderIDs._ScreenToTargetScale, camera.doubleBufferedViewportScale);
             commandBuffer.DrawProcedural(Matrix4x4.identity, material, shaderPassId, MeshTopology.Triangles, 3, 1, properties);
         }
 
         {
             HDUtils.SetRenderTarget(commandBuffer, camera, colorBuffers, depthStencilBuffer);
-            commandBuffer.SetGlobalVector(HDShaderIDs._ScreenToTargetScale, camera.scaleBias);
+            commandBuffer.SetGlobalVector(HDShaderIDs._ScreenToTargetScale, camera.doubleBufferedViewportScale);
             commandBuffer.DrawProcedural(Matrix4x4.identity, material, shaderPassId, MeshTopology.Triangles, 3, 1, properties);
         }
 
         {
             CoreUtils.SetRenderTarget(commandBuffer, colorBuffer);
-            commandBuffer.SetGlobalVector(HDShaderIDs._ScreenToTargetScale, camera.scaleBias);
+            commandBuffer.SetGlobalVector(HDShaderIDs._ScreenToTargetScale, camera.doubleBufferedViewportScale);
             commandBuffer.DrawProcedural(Matrix4x4.identity, material, shaderPassId, MeshTopology.Triangles, 3, 1, properties);
         }
 
             Vector2 mousePixelCoord = MousePositionDebug.instance.GetMousePosition(camera.screenSize.y);
-            return new Vector4(mousePixelCoord.x, mousePixelCoord.y, camera.scaleBias.x * mousePixelCoord.x / camera.screenSize.x, camera.scaleBias.y * mousePixelCoord.y / camera.screenSize.y);
+            return new Vector4(mousePixelCoord.x, mousePixelCoord.y, camera.viewportScale.x * mousePixelCoord.x / camera.screenSize.x, camera.viewportScale.y * mousePixelCoord.y / camera.screenSize.y);
         }
 
         // Returns mouse click coordinates: (x,y) in pixels and (z,w) normalized inside the render target (not the viewport)
-            return new Vector4(mousePixelCoord.x, mousePixelCoord.y, camera.scaleBias.x * mousePixelCoord.x / camera.screenSize.x, camera.scaleBias.y * mousePixelCoord.y / camera.screenSize.y);
+            return new Vector4(mousePixelCoord.x, mousePixelCoord.y, camera.viewportScale.x * mousePixelCoord.x / camera.screenSize.x, camera.viewportScale.y * mousePixelCoord.y / camera.screenSize.y);
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VBuffer.hlsl

 float4 SampleVBuffer(TEXTURE3D_ARGS(VBuffer, clampSampler),
                      float2 positionNDC,
                      float  linearDepth,
+                     float2 viewportScale,
                      float4 VBufferResolution,
                      float2 VBufferSliceCount,
                      float4 VBufferDepthEncodingParams,
                      bool   clampToBorder)
 {
-    float2 uv = positionNDC;
+    float2 uv = positionNDC * viewportScale;
     float  w;
 
     // The distance between slices is log-encoded.
 float4 SampleVBuffer(TEXTURE3D_ARGS(VBuffer, clampSampler),
                      float3   positionWS,
                      float4x4 viewProjMatrix,
+                     float2   viewportScale,
                      float4   VBufferResolution,
                      float2   VBufferSliceCount,
                      float4   VBufferDepthEncodingParams,
     return SampleVBuffer(TEXTURE3D_PARAM(VBuffer, clampSampler),
                          positionNDC,
                          linearDepth,
+                         viewportScale,
                          VBufferResolution,
                          VBufferSliceCount,
                          VBufferDepthEncodingParams,
     return FastTonemapInvert(SampleVBuffer(TEXTURE3D_PARAM(VBufferLighting, clampSampler),
                                            positionNDC,
                                            linearDepth,
+                                           GetViewportScaleCurrentFrame(),
                                            VBufferResolution,
                                            VBufferSliceCount,
                                            VBufferDepthEncodingParams,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VolumetricLighting.compute

         float4 reprojValue = SampleVBuffer(TEXTURE3D_PARAM(_VBufferLightingHistory, s_linear_clamp_sampler),
                                            centerWS,
                                            _PrevViewProjMatrix,
+                                           1, // GetViewportScalePreviousFrame(),
                                            _VBufferPrevResolution,
                                            _VBufferPrevSliceCount.xy,
                                            _VBufferPrevDepthEncodingParams,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VolumetricLighting.cs

     static ComputeBuffer    s_VisibleVolumeBoundsBuffer = null;
     static ComputeBuffer    s_VisibleVolumeDataBuffer   = null;
 
+    // These two buffers do not depend on the frameID and are therefore shared by all views.
+    RTHandleSystem.RTHandle m_DensityBufferHandle;
+    RTHandleSystem.RTHandle m_LightingBufferHandle;
+
-        m_VolumeVoxelizationCS      = asset.renderPipelineResources.volumeVoxelizationCS;
-        m_VolumetricLightingCS      = asset.renderPipelineResources.volumetricLightingCS;
+        m_VolumeVoxelizationCS = asset.renderPipelineResources.volumeVoxelizationCS;
+        m_VolumetricLightingCS = asset.renderPipelineResources.volumetricLightingCS;
+    }
+
+    public void CreateBuffers()
+    {
+        if (preset == VolumetricLightingPreset.Off) return;
+
+        Debug.Assert(m_VolumetricLightingCS != null);
+
+
+        int tileSize = ComputeVBufferTileSize(preset);
+        int depth    = ComputeVBufferSliceCount(preset);
+
+        m_DensityBufferHandle = RTHandles.Alloc(scaleFunc: size => new Vector2Int((size.x + (tileSize - 1)) / tileSize, (size.y + (tileSize - 1)) / tileSize),
+                                                slices:            depth,
+                                                dimension:         TextureDimension.Tex3D,
+                                                colorFormat:       RenderTextureFormat.ARGBHalf,
+                                                sRGB:              false,
+                                                enableRandomWrite: true,
+                                                enableMSAA:        false,
+                                                /* useDynamicScale: true, // <- TODO */
+                                                name:              "VBufferDensity");
+
+        m_LightingBufferHandle = RTHandles.Alloc(scaleFunc: size => new Vector2Int((size.x + (tileSize - 1)) / tileSize, (size.y + (tileSize - 1)) / tileSize),
+                                                 slices:            depth,
+                                                 dimension:         TextureDimension.Tex3D,
+                                                 colorFormat:       RenderTextureFormat.ARGBHalf,
+                                                 sRGB:              false,
+                                                 enableRandomWrite: true,
+                                                 enableMSAA:        false,
+                                                 /* useDynamicScale: true, // <- TODO */
+                                                 name:              "VBufferIntegral");
-    public void Cleanup()
+    public void DestroyBuffers()
-        if (preset == VolumetricLightingPreset.Off) return;
-
-        m_VolumeVoxelizationCS = null;
-        m_VolumetricLightingCS = null;
-
+        RTHandles.Release(m_DensityBufferHandle);
+        RTHandles.Release(m_LightingBufferHandle);
+
+        CoreUtils.SafeRelease(s_VisibleVolumeBoundsBuffer);
+        CoreUtils.SafeRelease(s_VisibleVolumeDataBuffer);
+
+    }
+
+    public void Cleanup()
+    {
+        if (preset == VolumetricLightingPreset.Off) return;
-        CoreUtils.SafeRelease(s_VisibleVolumeBoundsBuffer);
-        CoreUtils.SafeRelease(s_VisibleVolumeDataBuffer);
+        DestroyBuffers();
+
+        m_VolumeVoxelizationCS = null;
+        m_VolumetricLightingCS = null;
     }
 
     public void ResizeVBufferAndUpdateProperties(HDCamera camera, uint frameIndex)
         cmd.SetGlobalVector( HDShaderIDs._VBufferPrevSliceCount,          prevFrameParams.sliceCount);
         cmd.SetGlobalVector( HDShaderIDs._VBufferPrevDepthEncodingParams, prevFrameParams.depthEncodingParams);
         cmd.SetGlobalVector( HDShaderIDs._VBufferPrevDepthDecodingParams, prevFrameParams.depthDecodingParams);
-        cmd.SetGlobalTexture(HDShaderIDs._VBufferLighting,                vBuffer.GetLightingIntegralBuffer());
+        cmd.SetGlobalTexture(HDShaderIDs._VBufferLighting,                m_LightingBufferHandle);
     }
 
     public DensityVolumeList PrepareVisibleDensityVolumeList(HDCamera camera, CommandBuffer cmd)
                 obb.center -= camOffset;
 
                 // Frustum cull on the CPU for now. TODO: do it on the GPU.
+                // TODO: account for custom near and far planes of the V-Buffer's frustum.
+                // It's typically much shorter (along the Z axis) than the camera's frustum.
                 if (GeometryUtils.Overlap(obb, camera.frustum, 6, 8))
                 {
                     // TODO: cache these?
             // Compose the matrix which allows us to compute the world space view direction.
             Matrix4x4 transform   = HDUtils.ComputePixelCoordToWorldSpaceViewDirectionMatrix(vFoV, resolution, camera.viewMatrix, false);
 
-            cmd.SetComputeTextureParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VBufferDensity, vBuffer.GetDensityBuffer());
+            cmd.SetComputeTextureParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VBufferDensity, m_DensityBufferHandle);
             cmd.SetComputeBufferParam( m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeBounds,   s_VisibleVolumeBoundsBuffer);
             cmd.SetComputeBufferParam( m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeData,     s_VisibleVolumeDataBuffer);
 
             cmd.SetComputeMatrixParam( m_VolumetricLightingCS,         HDShaderIDs._VBufferCoordToViewDirWS, transform);
             cmd.SetComputeVectorParam( m_VolumetricLightingCS,         HDShaderIDs._VBufferSampleOffset,     offset);
             cmd.SetComputeFloatParam(  m_VolumetricLightingCS,         HDShaderIDs._CornetteShanksConstant,  CornetteShanksPhasePartConstant(fog.anisotropy));
-            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferDensity,          vBuffer.GetDensityBuffer());          // Read
-            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingIntegral, vBuffer.GetLightingIntegralBuffer()); // Write
+            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferDensity,          m_DensityBufferHandle);  // Read
+            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingIntegral, m_LightingBufferHandle); // Write
+            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingHistory,  vBuffer.GetLightingHistoryBuffer(frameIndex));  // Read
-            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingHistory,  vBuffer.GetLightingHistoryBuffer(frameIndex));  // Read
             }
 
             int w = (int)resolution.x;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

 
 // ----------------------------------------------------------------------------
 
-// TODO: all affine matrices should be 3x4.
-// Note: please use UNITY_MATRIX_X macros instead of referencing matrix variables directly.
+// Important: please use macros or functions to access the CBuffer data.
+// The member names and data layout can (and will) change!
+    // TODO: all affine matrices should be 3x4.
     float4x4 _ViewMatrix;
     float4x4 _InvViewMatrix;
     float4x4 _ProjMatrix;
 #endif
     float  _DetViewMatrix;              // determinant(_ViewMatrix)
     float4 _ScreenSize;                 // { w, h, 1 / w, 1 / h }
-    float4 _ScreenToTargetScale;        // { w / RTHandle.maxWidth, h / RTHandle.maxHeight, 0, 0 }
+    float4 _ScreenToTargetScale;        // { w / RTHandle.maxWidth, h / RTHandle.maxHeight } : xy = currFrame, zw = prevFrame
 
     // Values used to linearize the Z buffer (http://www.humus.name/temp/Linearize%20depth.txt)
     // x = 1 - f/n

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariablesFunctions.hlsl

     return GetFullScreenTriangleTexCoord(vertexID) * _ScreenToTargetScale.xy;
 }
 
+// The size of the render target can be larger than the size of the viewport.
+// This function returns the fraction of the render target covered by the viewport:
+// ViewportScale = ViewportResolution / RenderTargetResolution.
+// Do not assume that their size is the same, or that sampling outside of the viewport returns 0.
+float2 GetViewportScaleCurrentFrame()
+{
+    return _ScreenToTargetScale.xy;
+}
+
+float2 GetViewportScalePreviousFrame()
+{
+    return _ScreenToTargetScale.zw;
+}
+
 #endif // UNITY_SHADER_VARIABLES_FUNCTIONS_INCLUDED