Ignore VBuffer scale

This means there is some fractional error if the screen size is not a multiple of 8 (or 4, depending on settings), but the error is typically less than 1%, so it's not very visible.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _Global_Asymmetry           = Shader.PropertyToID("_Global_Asymmetry");
         public static readonly int _CornetteShanksConstant     = Shader.PropertyToID("_CornetteShanksConstant");
         public static readonly int _VBufferResolution          = Shader.PropertyToID("_VBufferResolution");
-        public static readonly int _VBufferScaleAndSliceCount  = Shader.PropertyToID("_VBufferScaleAndSliceCount");
+        public static readonly int _VBufferSliceCount          = Shader.PropertyToID("_VBufferSliceCount");
         public static readonly int _VBufferDepthEncodingParams = Shader.PropertyToID("_VBufferDepthEncodingParams");
         public static readonly int _VBufferDepthDecodingParams = Shader.PropertyToID("_VBufferDepthDecodingParams");
         public static readonly int _VBufferCoordToViewDirWS    = Shader.PropertyToID("_VBufferCoordToViewDirWS");

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

         float  reprojZ      = mul(_PrevViewProjMatrix, float4(centerWS, 1)).w;
         float4 reprojValue  = SampleVBuffer(TEXTURE3D_PARAM(_VBufferLightingHistory, s_trilinear_clamp_sampler),
                                             false, reprojPosNDC, reprojZ,
-                                            _VBufferScaleAndSliceCount,
+                                            _VBufferSliceCount.xy,
                                             _VBufferDepthEncodingParams,
                                             _VBufferDepthDecodingParams);
 

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

 // Therefore, given 'logEncodedDepth', we compute a new depth value
 // which allows us to perform HW interpolation which is linear in the view space.
 float ComputeLerpPositionForLogEncoding(float linearDepth, float logEncodedDepth,
-                                        float4 VBufferScaleAndSliceCount,
+                                        float2 VBufferSliceCount,
-    float numSlices    = VBufferScaleAndSliceCount.z;
-    float rcpNumSlices = VBufferScaleAndSliceCount.w;
+    float numSlices    = VBufferSliceCount.x;
+    float rcpNumSlices = VBufferSliceCount.y;
 
     float s0 = floor(d * numSlices - 0.5);
     float s1 = ceil(d * numSlices - 0.5);
 // If (clampToEdge == false), out-of-bounds loads return 0.
 float4 SampleVBuffer(TEXTURE3D_ARGS(VBufferLighting, trilinearSampler), bool clampToEdge,
                      float2 positionNDC, float linearDepth,
-                     float4 VBufferScaleAndSliceCount,
+                     float2 VBufferSliceCount,
-    float numSlices    = VBufferScaleAndSliceCount.z;
-    float rcpNumSlices = VBufferScaleAndSliceCount.w;
+    float numSlices    = VBufferSliceCount.x;
+    float rcpNumSlices = VBufferSliceCount.y;
-    // Account for the visible area of the V-Buffer.
-    float2 uv = positionNDC * VBufferScaleAndSliceCount.xy;
+    float2 uv = positionNDC;
 
     // The distance between slices is log-encoded.
     float z = linearDepth;
         float w = d;
     #else
         // Adjust the texture coordinate for HW trilinear sampling.
-        float w = ComputeLerpPositionForLogEncoding(z, d, VBufferScaleAndSliceCount, VBufferDepthDecodingParams);
+        float w = ComputeLerpPositionForLogEncoding(z, d, VBufferSliceCount, VBufferDepthDecodingParams);
     #endif
 
         return SAMPLE_TEXTURE3D_LOD(VBufferLighting, trilinearSampler, float3(uv, w), 0);
 float4 SampleInScatteredRadianceAndTransmittance(TEXTURE3D_ARGS(VBufferLighting, trilinearSampler),
                                                  float2 positionNDC, float linearDepth,
                                                  float4 VBufferResolution,
-                                                 float4 VBufferScaleAndSliceCount,
+                                                 float2 VBufferSliceCount,
                                                  float4 VBufferDepthEncodingParams,
                                                  float4 VBufferDepthDecodingParams)
 {
-                             VBufferScaleAndSliceCount,
+                             VBufferSliceCount,
-#else
-    // Perform biquadratic reconstruction in XY, linear in Z, using 4x trilinear taps.
-
-    // Account for the visible area of the V-Buffer.
-    float2 xy = positionNDC * (VBufferResolution.xy * VBufferScaleAndSliceCount.xy);
+#else // Perform biquadratic reconstruction in XY, linear in Z, using 4x trilinear taps.
+    float2 uv = positionNDC;
+    float2 xy = uv * VBufferResolution.xy;
     float2 ic = floor(xy);
     float2 fc = frac(xy);
 
     float w = d;
 #else
     // Adjust the texture coordinate for HW trilinear sampling.
-    float w = ComputeLerpPositionForLogEncoding(z, d, VBufferScaleAndSliceCount, VBufferDepthDecodingParams);
+    float w = ComputeLerpPositionForLogEncoding(z, d, VBufferSliceCount, VBufferDepthDecodingParams);
 #endif
 
     float2 weights[2], offsets[2];

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

     // Since a single voxel corresponds to a tile (e.g. 8x8) of pixels,
     // the VBuffer can potentially extend past the boundaries of the viewport.
     // The function returns the fraction of the {width, height} of the VBuffer visible on screen.
+    // Note: for performance reasons, scale is unused (implicitly 1). The error is typically under 1%.
     static Vector2 ComputeVBufferResolutionAndScale(VolumetricLightingPreset preset,
                                                     int screenWidth, int screenHeight,
                                                     ref int w, ref int h, ref int d)
         cmd.SetGlobalFloat( HDShaderIDs._Global_Asymmetry,  asymmetry);
 
         int w = 0, h = 0, d = 0;
-        Vector2 scale = ComputeVBufferResolutionAndScale(preset, (int)camera.screenSize.x, (int)camera.screenSize.y, ref w, ref h, ref d);
+        ComputeVBufferResolutionAndScale(preset, (int)camera.screenSize.x, (int)camera.screenSize.y, ref w, ref h, ref d);
 
         VBuffer vBuffer = FindVBuffer(camera.GetViewID());
         Debug.Assert(vBuffer != null);
-        cmd.SetGlobalVector( HDShaderIDs._VBufferScaleAndSliceCount,  new Vector4(scale.x, scale.y, d, 1.0f / d));
+        cmd.SetGlobalVector( HDShaderIDs._VBufferSliceCount,          new Vector4(d, 1.0f / d));
         cmd.SetGlobalVector( HDShaderIDs._VBufferDepthEncodingParams, ComputeLogarithmicDepthEncodingParams(m_VBufferNearPlane, m_VBufferFarPlane, k_LogScale));
         cmd.SetGlobalVector( HDShaderIDs._VBufferDepthDecodingParams, ComputeLogarithmicDepthDecodingParams(m_VBufferNearPlane, m_VBufferFarPlane, k_LogScale));
         cmd.SetGlobalTexture(HDShaderIDs._VBufferLighting,            vBuffer.GetLightingIntegralBuffer());
             }
 
             int w = 0, h = 0, d = 0;
-            Vector2 scale = ComputeVBufferResolutionAndScale(preset, (int)camera.screenSize.x, (int)camera.screenSize.y, ref w, ref h, ref d);
-            float   vFoV  = camera.camera.fieldOfView * Mathf.Deg2Rad;
+            ComputeVBufferResolutionAndScale(preset, (int)camera.screenSize.x, (int)camera.screenSize.y, ref w, ref h, ref d);
-            // Compute it using the scaled resolution to account for the visible area of the VBuffer.
-            Vector4   scaledRes = new Vector4(w * scale.x, h * scale.y, 1.0f / (w * scale.x), 1.0f / (h * scale.y));
-            Matrix4x4 transform = HDUtils.ComputePixelCoordToWorldSpaceViewDirectionMatrix(vFoV, scaledRes, camera.viewMatrix, false);
+            float     vFoV       = camera.camera.fieldOfView * Mathf.Deg2Rad;
+            Vector4   resolution = new Vector4(w, h, 1.0f / w, 1.0f / h);
+            Matrix4x4 transform  = HDUtils.ComputePixelCoordToWorldSpaceViewDirectionMatrix(vFoV, resolution, camera.viewMatrix, false);
 
             camera.SetupComputeShader(m_VolumetricLightingCS, cmd);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

     float3 _Global_Scattering;
     float  _Global_Extinction;
     float4 _VBufferResolution;          // { w, h, 1/w, 1/h }
-    float4 _VBufferScaleAndSliceCount;  // { fracVisW, fracVisH, count, 1/count }
+    float4 _VBufferSliceCount;          // { count, 1/count, 0, 0 }
     float4 _VBufferDepthEncodingParams; // See the call site for description
     float4 _VBufferDepthDecodingParams; // See the call site for description
 CBUFFER_END

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/AtmosphericScattering/AtmosphericScattering.hlsl

 	float4 volFog = SampleInScatteredRadianceAndTransmittance(TEXTURE3D_PARAM(_VBufferLighting, s_trilinear_clamp_sampler),
 															  posInput.positionNDC, posInput.linearDepth,
 															  _VBufferResolution,
-															  _VBufferScaleAndSliceCount,
+															  _VBufferSliceCount.xy,
 															  _VBufferDepthEncodingParams,
 															  _VBufferDepthDecodingParams);
 	fogColor = volFog.rgb;