AMD cut ray-tracing BVH memory from up to 80 GB to 1.7 GB by animating the cage, not the mesh

The result is a memory story before it is a triangle story

AMD's new terrain demo contains about 25,000 independently animated plants. At maximum level of detail, those plants represent about 2.8 billion triangles. After level-of-detail selection, the renderer traces roughly 500 million animated plant triangles per frame, using primary and shadow rays at more than 60 frames per second at 1080p on a Radeon RX 9070 XT.

Those numbers are striking, but AMD identifies the real result as the cost of keeping all that moving geometry searchable by rays. Its tetrahedral-cage representation uses about 1.7 GB of bounding-volume-hierarchy memory and about 3.3 milliseconds for all BVH updates per frame. AMD says conventional dense-triangle bottom-level acceleration structures for the same independently animated scene would require up to 80 GB and take more than 300 milliseconds per frame to update on the same GPU.

This is a measured result from one AMD research demo, with its assets, level-of-detail policy, ray workload and hardware. It is not a universal multiplier for every game. It does establish why animation representation can matter as much as raw ray-tracing throughput when a scene contains thousands of dense objects that must all move differently.

Why ordinary animated ray tracing becomes expensive

A rasteriser can draw a deformed mesh after a vertex shader has moved its vertices. A ray tracer needs more. Before a ray can test individual triangles, it normally traverses a spatial index called a bounding volume hierarchy, or BVH. The hierarchy lets the GPU reject large empty regions instead of testing every triangle.

For static geometry, that structure can be built once and reused. For an independently deforming mesh, the triangle positions change, so the bottom-level acceleration structure, commonly called a BLAS, must be refitted or rebuilt. A small deformation may allow a relatively cheap refit of the existing tree. Larger or less coherent changes can weaken the tree's quality and make traversal slower, or require a more expensive rebuild. Either way, unique animation also creates unique state that must be stored.

Consider 10,000 copies of one detailed plant. Instancing is cheap while every copy is rigid: all copies can reference the same mesh and BLAS while carrying different object transforms. Once local wind bends each plant differently, that simple reuse breaks. The renderer now faces millions of changing vertices and thousands of changing acceleration structures. Triangle detail, instance count and animation diversity multiply into a memory and update problem.

The method moves a compact cage and keeps the dense mesh in its rest pose

The paper by Holger Gruen, Carsten Benthin, Michael Kern and David McAllister inserts an indirection layer between animation and dense geometry. During preprocessing, a low-resolution volume made of tetrahedra is constructed around the mesh. The original triangles are split into disjoint sets associated with those tetrahedra, and a small static acceleration structure is built for the geometry belonging to each cell. AMD calls these structures mini-BLASes.

At runtime, the renderer animates the much smaller cage. When a ray enters a deformed tetrahedron, the method maps that ray back into the tetrahedron's undeformed reference space. The ray can then intersect the original static triangles and their reusable mini-BLAS. The detailed mesh appears to bend because the coordinate system around each piece bends; the renderer does not have to rewrite every dense vertex and rebuild a dense BLAS for every instance.

The per-frame animation cost therefore follows the number of cage vertices and tetrahedra, rather than the full triangle count. Multiple plants can share the same rest-pose geometry and mini-BLAS data while each plant carries its own small animated cage.

One ray through the tetrahedral-cage pipeline

Stage	What happens	Why it saves work
Preprocess	Enclose the rest-pose mesh in a tetrahedral cage and partition its triangles	The expensive organisation of dense geometry is done ahead of time
Build	Create a static mini-BLAS for the triangles associated with each tetrahedron	The detailed acceleration data can be shared across animated instances
Animate	Move the small cage for each plant, creature or character instance	Per-frame vertex work follows cage resolution rather than mesh density
Traverse	Find the deformed tetrahedron entered by a ray	Only the compact cage-level structure needs dynamic maintenance
Transform	Map the ray into the tetrahedron's rest-pose coordinate system	Static reference geometry remains valid
Intersect	Test the transformed ray against the cell's static triangles	The renderer reuses the prebuilt mini-BLAS instead of rebuilding a dense one

A small wind example shows why the saving can grow so quickly

Imagine a plant asset with one million triangles and a cage with 200 control vertices. The scene places 5,000 copies across a valley. A wind field gives every copy a slightly different direction and phase.

With direct deformation, the renderer must produce a unique set of moved vertices for every plant and maintain acceleration data that represents each unique pose. Shared source art does not remove that per-instance dynamic state. With a cage, every plant still needs its own 200 animated control vertices and a dynamic structure over its cage, but the million-triangle rest mesh and its static mini-BLASes can be reused.

The numbers in this illustration are deliberately simple, not AMD's measured asset. They expose the scaling rule: when the dense mesh is vastly larger than its deformation cage, moving the control volume can be much cheaper than moving and indexing the surface it controls. If the cage becomes almost as detailed as the mesh, the advantage narrows.

Tetrahedral cages add another point on the quality-versus-cost curve

Where the main approaches spend their budget

Approach	Dynamic state	Strength	Cost or limit
Conventional dense BLAS update	Deformed vertices and dense acceleration structure per unique pose	Highest direct control over every vertex	Memory and update cost scale with dense geometry
Cluster-level acceleration	Unique deforming clusters and their acceleration state	Faster updates and substantial memory savings with high animation quality	Every deforming vertex and unique cluster state still has to be animated and stored
Tetrahedral cage	Compact cage and cage-level acceleration state per pose	Static dense geometry and mini-BLASes can be shared	Animation is an approximation governed by cage resolution
Rigid instancing	Object transform per instance	Very cheap reuse of one mesh and BLAS	Cannot express independent internal deformation

AMD presents cages as a complement to current acceleration methods, not a replacement for all of them. They can coexist with cluster-level acceleration structures and with features in Microsoft's newer DirectX Raytracing work, including partitioned top-level acceleration structures. A practical engine could use rigid instances for solid objects, direct or cluster-based deformation for hero characters, and tetrahedral cages for dense foliage, crowds or distant creatures.

That mixed strategy matters because one visual quality setting rarely fits an entire frame. The useful question is which objects need exact vertex motion and which only need a convincing silhouette, shading response and shadow at their viewing distance.

The technique trades exact deformation for scale

A tetrahedral cage induces a piecewise-linear deformation inside each cell. It is well matched to connectivity-preserving motion: vegetation swaying, grass moving in patches, crowds, distant characters and animation level of detail. It is less attractive when the audience studies small facial motion, sharp folds, fingers, fine muscle deformation or contact details. It also does not naturally solve topology changes such as tearing, cutting or an object exploding into disconnected pieces.

Cage construction is another production cost. The cage must cover the geometry, avoid invalid or degenerate tetrahedra, partition triangles correctly and remain well behaved under the intended animation. The paper discusses invertible transformations and the risk of cracks where neighbouring transformed regions meet. Its implementations mitigate boundary problems through clipping or carefully enlarged tetrahedra and consistent barycentric representations, but this is engineering work rather than a free wrapper around any mesh.

Traversal also gains extra steps. A ray first interacts with the animated cage, then is transformed before it reaches the static detailed geometry. Savings appear when avoided dense updates and memory outweigh that additional indirection. Scenes with few instances, low triangle counts or little deformation may not be bottlenecked in the first place.

What an engine team should measure before adopting it

Why this research matters beyond one forest demo

Real-time graphics has spent years making static detail cheap through instancing, level of detail, compression and increasingly capable ray-tracing hardware. Unique deformation breaks much of that reuse. AMD's work restores reuse by changing the representation: the detailed object stays in a shareable reference state while a compact proxy carries the variation.

That can open a different content budget. A renderer may support denser vegetation that reacts locally to weather, larger crowds with individual motion, or creatures that move independently without allocating a dense BLAS for every pose. The 2026 paper received a joint third-place Wolfgang Straßer Award at High-Performance Graphics, which reflects the technical contribution; production adoption will depend on the promised tooling, integration effort and whether the approximation survives real game assets.

The most useful conclusion is narrower than “500 million animated triangles are solved”. For the right class of connectivity-preserving animation, triangle density no longer has to dictate per-frame animation and acceleration-structure cost. The cage becomes the moving object; the dense mesh becomes reusable data.

Key facts