Ternary VertexCache
Bake a simulation once. Play it a thousand times, for almost nothing.
Crowds. Destruction. Cinematics. VFX. Deterministic physics.
Anything that has to move more often than you can afford to simulate — a hundred debris piles, a crowd of animated characters, a fracture that lands identically on every take. That list is where people start, not where it stops.
A Vertex Animation Texture records motion into a texture at bake time. At runtime there is no skeletal mesh to tick, no simulation to run, and no per-instance CPU cost — just a static mesh and a material that moves its vertices.
That much is true of every VAT tool. Here is what this one does differently.
Everything happens in Unreal
Point the baker at a simulation you already have and press Bake. No Houdini, no export, no re-import, no third-party tool in the pipeline — and nothing to redo when the sim changes.
It is not just deforming meshes
Most VAT tools bake one thing: a mesh that bends. This bakes five kinds of motion, including the ones that usually send you back to a DCC.
| Rigid Body | Fracture and destruction — pieces that travel and rotate, not just stretch |
| Soft Body | Cloth, flags, deforming sims — from a live simulation, an Anim Sequence, or Alembic |
| Fluid | Surfaces whose topology changes every single frame |
| Particle | Point clouds played back through Niagara |
| Instanced | Fracture where every piece shares a mesh, drawn GPU-instanced |
It doesn't smear
The classic VAT complaint: motion looks right until temporal anti-aliasing gets hold of it, then everything trails. That happens because the renderer has no idea where the vertices were last frame.
Ternary VertexCache reports real motion vectors — recorded, not estimated — so TAA and TSR resolve it cleanly. Cuts, loops and scrubbing are detected and reported as cuts rather than as impossible motion.
Sequencer drives it
Playback does not have to be a clock running from level load. Key the frame on a Sequencer track, scrub it in the editor, retime it, pause it, run it backwards. A shot can depend on the animation hitting a mark.
Loops that actually loop
Ask for a seamless loop and the baker searches the baked range for the best one within your tolerance, trims to it, and blends the seam closed. It reports what it found and what it cost, so you can judge the result instead of trusting it.
What you bake is yours
The playback runtime is free. Pay once for the baker; everything it produces plays back forever on the free plugin alone. Teammates, artists and build machines never need a seat.
How it compares
The usual way to make a VAT is to simulate in Houdini and export the textures into Unreal. It works, and if your pipeline already lives in Houdini it works well. The difference is where the work happens.
| Ternary VertexCache | Houdini VAT | |
|---|---|---|
| Extra software | None — an Unreal plugin | Houdini, a separate application and licence |
| Where you author | In the Unreal editor | In Houdini, then export and import |
| Bake an in-editor Chaos or Niagara sim | Directly | Rebuild the sim in Houdini first |
| Bake an Alembic cache | Yes | Yes |
| Bake a Skeletal Mesh + Anim Sequence | Yes, with no simulation at all | Round-trip through Houdini |
| Changing the simulation | Re-bake in place — materials and placed actors keep working | Re-sim, re-export, re-import, re-assign |
| Material setup | One decode node, checked at compile time | Wire the supplied material functions yourself |
| Sequencer-keyed frame, with motion vectors | Built in | Build it yourself |
| Seamless-loop trimming | Automatic, within a tolerance you set | Manual |
| Nanite mesh and LODs | Generated at bake | Manual |
What it can handle
One rule governs every bake: frames x units <= 16,777,216, where a unit is a rigid-body piece, a mesh vertex or a particle. Read it whichever way your content needs.
| At 2 s (60 frames) | At 4 s (120 frames) | At 10 s (300 frames) | |
|---|---|---|---|
| Rigid Body pieces | 279,620 | 139,810 | 55,924 |
| Soft Body vertices | 279,620 | 139,810 | 55,924 |
| Particles | 279,620 | 139,810 | 55,924 |
Turned around: a 10,000-vertex cloth can run 56 seconds, and a 500-piece fracture over 18 minutes, before it reaches the ceiling. Precision does not change any of these numbers — it changes what they cost.
What that costs
| Bake | 24-bit | 64-bit | 128-bit |
|---|---|---|---|
| Destruction, 500 pieces, 4 s | 0.5 MB | 0.9 MB | 1.8 MB |
| Crowd character, 5,000 vertices, 2 s | 2.3 MB | 4.6 MB | 9.2 MB |
| Cloth, 10,000 vertices, 4 s | 9.2 MB | 18.3 MB | 36.6 MB |
| Particles, 20,000 points, 4 s | float only | 18.3 MB | 36.6 MB |
That is the whole runtime cost. There is no per-instance cost on top of it, so the second copy of that 500-piece fracture is free, and so is the five-hundredth.
Pick 24-bit unless you can see stepping; 128-bit is there for long, slow, wide-travelling motion where you can. Particles are float-only by design — they store absolute positions, where 8-bit steps show.
What it needs
| Unreal Engine | 5.6, 5.7 and 5.8. Each is built and tested before release. |
| Baker | Windows editor only. Editor-type modules, so it never ships in a packaged game. |
| Runtime | Ships with your game, at no licence cost. No platform-specific code, so it goes wherever your project does. |
| Engine plugins | Niagara, plus Geometry Cache if you bake from Alembic. Both ship with the engine. |
Rendering
Playback is ordinary material work: a texture sampled in the vertex shader, and a World Position Offset. No compute pass, no custom render pass, and no platform-specific code in the runtime.
| Shader model | Anything Unreal targets. Vertex-shader texture sampling is the only hard requirement. |
| 24-bit textures | Everywhere |
| 64-bit and 128-bit textures | Wherever the platform supports float textures |
| Nanite playback meshes | SM6, which is Nanite's own requirement |
| Instanced (ISM) bakes | Per-instance custom data, so a platform with GPU scene support |
VAT textures are uncompressed and never streamed — that is what keeps the values exact — so memory, not shader capability, is what decides where a given bake fits. See what it costs above.
Start here
- Quick start — a complete bake in a few minutes.
- Bake types — what each type takes as a source, and its limits.
- Materials — wiring the decode node. Read this before your first bake plays back; each type has material settings it requires.
- Driving playback — the two ways to drive Frame: a formula in the material, or a number from Sequencer or Blueprint.
Requires Unreal Engine 5.6, 5.7 or 5.8. Questions: [email protected].