Motion Vector Buffer Costs in Game Post-Processing

Full-resolution motion vector buffers (velocity buffers) are critical for temporal post-processing techniques such as Temporal Anti-Aliasing (TAA), temporal upscaling (DLSS, FSR, XeSS), and camera motion blur. However, generating and sampling these buffers at native resolution imposes measurable performance overheads on both compute and memory pipelines. This article breaks down the primary costs of running full-resolution motion vector passes, focusing on memory footprint, bandwidth saturation, shader execution, and cache competition.

1. High Memory Bandwidth Consumption

The most significant cost of a full-resolution motion vector buffer is memory bandwidth. A typical velocity buffer uses a 16-bit floating-point format per channel (RG16F) to prevent precision artifacts, requiring 4 bytes per pixel.

  • At 1080p (1920x1080), a single buffer occupies roughly 8.3 MB.
  • At 4K (3840x2160), this increases to roughly 33.2 MB per frame.

Because post-processing involves both writing to this buffer during the geometry/velocity pass and sampling it repeatedly across subsequent passes (e.g., TAA, depth of field, motion blur), the memory read/write cycles scale aggressively. At 4K 60 FPS, reading and writing this buffer across three distinct temporal passes can easily demand several gigabytes per second of raw memory bandwidth, starving other memory-bound stages like lighting and compute-based volumetric rendering.

2. Increased G-Buffer Footprint and Fill-Rate Pressure

In deferred rendering pipelines, velocity can either be integrated directly into the G-Buffer or rendered in a separate pre-pass/post-pass.

  • Integrated G-Buffer (MRT): Appending velocity to the G-Buffer increases the Multiple Render Target (MRT) write count. This directly increases the memory bus payload during the base pass, reducing overall fill rate and degrading performance in scenes with high overdraw.
  • Separate Velocity Pass: If rendered separately, dynamic meshes must be submitted to the GPU twice (once for base/depth and once for velocity). This increases draw calls, CPU command buffer overhead, and vertex-processing bottlenecks.

3. Vertex Processing and Transform Overhead

To calculate per-pixel motion vectors accurately, the GPU must evaluate an object’s transformation in both the current frame and the previous frame.

  • Static Geometry: Camera movement alone determines motion, which can be evaluated cheaply using a reprojection formula based on the depth buffer and the inverse view-projection matrix.
  • Dynamic Geometry: Skinned characters, foliage with wind simulation, and destructible meshes cannot rely on simple camera reprojection. They require storing and transforming the previous frame's bone matrices or vertex offsets alongside the current frame's data. Evaluating dual-matrix skinning routines doubles the vertex shader arithmetic for animated models, significantly impacting the vertex pipeline.

4. Cache Pollution and Latency

Reading full-resolution velocity buffers during post-processing passes can evict critical data from the GPU's L1 and L2 caches. Because velocity vectors often point across large screen-space distances (such as during fast camera rotations or whipping melee attacks), texture sampling patterns become non-coherent. Non-contiguous memory reads cause frequent cache misses, increasing frame latency as the compute units wait on high-latency VRAM fetches.

The Mitigation Trade-Off: Half-Resolution Buffers

To avoid these full-resolution penalties, some rendering pipelines calculate motion vectors at half resolution (quarter the pixel count). While this reduces bandwidth and storage overhead by 75%, it introduces notable artifacts:

  • Masking errors around thin geometry edges (e.g., wires, foliage).
  • Velocity bleeding, where static backgrounds incorrectly pick up foreground movement.
  • Smearing and ghosting in temporal upscalers, which strictly rely on sub-pixel velocity precision.

Consequently, while half-resolution motion vectors conserve memory bandwidth, high-end titles targeting modern temporal reconstruction techniques largely accept the performance overhead of full-resolution buffers to preserve visual fidelity.