> For the complete documentation index, see [llms.txt](https://finite-machine-studio.gitbook.io/vatmachine-documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://finite-machine-studio.gitbook.io/vatmachine-documentation/vatmachine-documentation.md).

# VATMachine Documentation

### VATMachine Overview

VATMachine is a Unity toolset for baking skeletal or mesh-based animation into Vertex Animation Textures, then playing those animations back on the GPU using a lightweight runtime animator and URP/HDRP playback shader.

Instead of relying on a SkinnedMeshRenderer and bone hierarchy at runtime, VATMachine samples the animated mesh in the Unity Editor and stores each frame of vertex motion inside texture arrays. At runtime, a normal MeshRenderer displays the character, and the shader moves each vertex by reading the baked animation textures.

This makes VATMachine especially useful for animated crowds, background characters, NPCs, repeated props, creatures, and other cases where many animated objects need to play efficiently without the CPU cost of traditional skinning.

<figure><img src="/files/jz20J3aliYXavbX9JnTl" alt=""><figcaption></figcaption></figure>

### What does VATMachine do?

VATMachine takes a normal animated Unity character and converts it into a GPU-playback version. The generated prefab can then be controlled with a VAT Animator Graph which is much similar to the Unity Animator Controller.

### Why use VATMachine?

Traditional skeletal animation is flexible, but it has runtime costs. Every animated SkinnedMeshRenderer requires bone transforms and skinning work. This is usually fine for a few important characters, but it can become expensive when many animated characters are visible at once.

VATMachine moves the deformation work to the GPU.

The CPU no longer needs to skin the mesh every frame. Instead, the CPU only updates playback parameters such as the current frame, next frame, blend value, transition weight, and active textures. The shader handles vertex playback.

This is useful when you want:

* Many animated characters on screen
* Crowd scenes
* Background NPCs
* Repeated animated props
* Lightweight enemy or creature playback
* Characters that do not need full skeletal interaction at runtime
* Animation playback without keeping a complete bone hierarchy
* Baked animation that can still use transitions, blend trees, events, and sockets

### Features

These are some of the main features of VATMachine:

* Bake skinned mesh animations into GPU-ready Vertex Animation Textures
* Play animated characters without runtime Skinned Mesh Renderers
* Removes CPU skinning and bone update cost for crowds and repeated characters
* Supports multiple animation clips
* Supports multi-part characters with several renderers
* Built-in **LOD support** for VAT animations
* Generate ready-to-use VAT animations, VAT prefabs, playback materials, and data automatically using VAT Baker.
* Supports GPU-instancing-friendly playback for repeated VAT characters
* Bake position-only VATs for lightweight distant characters to maximize performance, or bake animated normals and tangents for improved lighting quality.
* Custom VAT Animator Graph included
* Animation states, Entry, Any State, and Exit support
* **1D Blend Tree support** for locomotion-style blending
* **Smooth crossfade** transitions between baked VAT animations
* **Transition duration**, **offset**, **exit time**, **priority**, and **conditions**
* **Transition interruption support**
* **Bool**, **Float**, and **Trigger** parameters
* **State speed control** and **speed multiplier** parameters
* **Animation event system** for footsteps, attacks, sounds, VFX, and gameplay callbacks
* **Bake sockets** from bones or transforms to attach weapons, props, hats, backpacks, and VFX
* Target hardware validation for texture size, array slices, and texture format
* **Runtime scripting API** for gameplay control
* Works well for crowds, background NPCs, repeated enemies, creatures, and animated props
* Supports both **URP** and **HDRP**

### How does VAT Playback Work?

VAT stands for Vertex Animation Texture.

During baking, VATMachine samples the source mesh at many points in time. For each frame, it records where each vertex should be.

Those vertex positions are written into texture arrays. The shader later reads those textures and moves the mesh vertices.

### What Makes VATMachine Different from a Simple VAT Player?

A simple VAT player usually plays one baked clip on one mesh.

VATMachine is more complete than that. It includes a custom animation workflow around the baked data.

VATMachine can:

* Bake multiple animation clips
* Build an animation graph
* Use parameters
* Use transitions
* Use exit times
* Use Any State transitions
* Use 1D blend trees
* Dispatch animation events
* Drive multiple renderer parts
* Drive multiple LODs
* Bake and sample sockets

This makes it closer to a lightweight GPU animation system than a single-clip playback script.

### When Should You Use VATMachine?&#xD;

VATMachine is a good fit when:

* You need many animated characters on screen.
* Characters do not need full skeletal interaction at runtime.
* You want to reduce CPU skinning cost.
* You are building crowd scenes.
* You are animating background NPCs.
* You have repeated animated props.
* You want GPU-driven mesh animation.

Good examples include:

* Crowd pedestrians
* Arena spectators
* Background soldiers
* Low-priority enemies
* Animated decorations
* Dancing characters
* Creatures with repeated animation sets
* Training dummies
* LOD versions of animated characters

### When Should You Not Use VATMachine?&#xD;

You may want to use normal skeletal animation instead when:

* The character needs runtime IK.
* The character needs procedural bone animation.
* The character needs ragdoll physics.
* The character uses complex Animator Controller layers.
* The character needs humanoid retargeting at runtime.
* The character needs additive animation layers.
* The character needs avatar masks.
* The character needs root motion directly from the Animator.

VATMachine is designed for baked playback. It is powerful when the animation set is known and can be prepared in advance.

### Important Compatibility Notes

This package is designed for the Universal and High Definition Render Pipeline.

The current package does not include built-in render pipeline shaders.

The VAT Baker includes target profiles to help validate texture size, array slice count, and format support before baking.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://finite-machine-studio.gitbook.io/vatmachine-documentation/vatmachine-documentation.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
