Bedrock Edition animation documentation

This is the animation documentation for Bedrock Edition 1.16.210.

States
Each state has an optional variables section, listing any number of variables that referenced animations can use. Each state also has one or more animations, using the name given in the entity's definition json.

State Variables
Variables have their value set by a Molang Expression. They can also have their value remapped via a linearly-interpolated curve.

For Example:
the animation controller for that frame. It will take the value of, then remap it to between 0.2 and 0.7 based on the value of   going from 0.0 to 1.0. It will play one animation walk that will blend from 0.0 to 1.0 as the ground speed increases from stopped to   The remap curve can have any number of entries. The animation controller will then play the entity-referenced  animations, followed by the   animation, scaling the latter by the value of.

In definitions\entity\tiger.json:
from 0 to -1 to 0 where only "base_pose" will play and then an equal amount of time where Walk will play on top of base_pose as foo goes from 0 to 1 back to 0. will have a blend value of 1.0.

State Transitions
Each transition has a target state to switch to, and a script for whether it should switch or not. For each transition in order, evaluate the script, and if it returns non-zero, switch to the specified state immediately.

For example:

State Blending
to the time you would like the system to take in blending between the two states. This is done as a simple lerp between the two states over the time specified.

For example:

Channels (Rotation, Position, Scale)
The engine tracks the animation of rotation, position, and scale separately. Within a channel, one or more key frames are specified at arbitrary times, in seconds, from the start of the animation. If no key frames are specified, a single key frame is created at  and all channel data is stored within that key frame.

Entity Animation Format Examples
The json format for an animation is as follows. Note Matching the geometry format, units are in 1/16ths of meters.

Upgrade from v1.7 Beta to v1.8
To upgrade previous scripts, you'll want to do the following steps to all of your Molang scripts in the order listed:
 * 1) entity.flags.foo --> query.foo
 * 2) entity.member.foo --> query.foo
 * 3) entity.foo --> variable.foo
 * 4) params.foo --> global.foo
 * 5) The general rule is that query represents read-only values from the entity the script is running on, and variable represents read-write data created by the user.
 * 6) We've adopted snake_case for all names of things.  You are welcome to use upper-case letters if you wish as we are case-insensitive, however we recommend snake_case in general.
 * 7) Several variables previously set on mobs have been changed to use the query.foo format.  Look through the updated list below to see what has been added and changed.

Upgrade from v1.8 Beta to v1.10

 * the ability to have animations reference other animations in an arbitrarily deep hierarchy.
 * the parameters section of animation controllers has been replaced with the  section.
 * in the entity definition file, animation controllers are now listed in the  section, and a   section has been added to define which root animations to play.

The v1.8 file format is backwards-compatible with v1.10 so you don't _need_ to change anything (although we recommend refactoring your files in the spirit of v1.10 as there is a slight performance win with the new format, as well as it being simpler to understand.

Entity Definition
This means you will not see the move animation in the pig.json animation file either. If you would like to make a custom pig walk you can change this line to point to your custom animation. Animations are specified as a short name, followed by their full resource name. The short name is used in animation controllers and the  list, while the long name is used in the animations file. In the `scripts/animate` section, you list the animations to play and in which order. You can either specify an animation directly, or specify a blend expression.

Animation Controller
While a lot of this can be managed in the entity definition  section, animation controllers give you the functionality of a state machine into states and control them as a block. Animations in an animation controller state can be animation controllers themselves, allowing for arbitrarily complex animation hierarchies.

Here's a sample animation controller:

Animations
Note that the channels (x, y, and z) are added separately across animations first, then converted to a transform once all animations have been cumulatively applied.

Animation data can be either raw data:
By default, rotations are in degrees, in euler X-then-Y-then-Z format

or a run-time interpreted script:
Here is an example from quadruped.animation.json in the vanilla resource pack's animation folder:

Key Frames
A key frame defines two values for a channel-specific transform to a specific bone at a specified time, one as time approaches the key frame time, and the second from that key frame time onwards. As such, when interpolating between two key frames, one can define the slope of the animation curve in either a continuous or discontinuous manner.

Interpolation

 * Continuous Example:


 * Discontinuous Example:

This example scales the bone "head":
 * 1) From 0 to 0.5 seconds, the head bone is set to its normal scale of 1 in all dimensions [X, Y, Z];
 * 2) At 0.5 seconds, the bone will instantly scale up to 2 times its normal size;
 * 3) From 0.5 to 1 second ("post"), the bone will re-scale back to its normal size of scale of 1 in all dimensions.

Names
All names: animations, bones, states, etc, must all start with a letter and contain only alphanumerics, underscore, or period. It is recommended to use names in all lower-case.

Overview
The follows the current Minecraft JSON paradigms:
 * Fields should be lower-case and use underscores (no spaces).
 * All JSON files in the definitions directory and subtree will be read into and interpreted by the animation system.

Render Controllers
The Render Controller needs an identifier and needs to follow the format of. This name needs to match the name set in the Client Entity Definitions JSON.

Render Controllers are a way for the player to determine what renders on the entity. Players can set the geometry, materials, textures, and part visibility of the entity. In addition to setting the keys directly, players can use arrays to have the entity choose between different options.

Getting Started
To begin create a new folder named  in the root of the Resource Pack you want to add the new Render Controller JSON inside.

Example render controllers JSON for the ocelot:

Examples
Example Array for geometry from the sheep JSON:

Example Array for materials from the spider JSON:

Example Array for textures from the villager JSON:

Example with color for tinting of parts from Armor 1.0 render controller JSON:

Example with is_hurt_color from Creeper render controller JSON:

Example with on_fire_color from Fireball render controller JSON:

Example with overlay_color from Wither Boss render controller JSON:

Example with part_visibility for turning on and off visibility of parts from Llama JSON: Material array example from Horse render controllers. Saddle will override Mane, which will override TailA, etc.:

Transforms

 * Order of operations: vertices are translated, rotated, then scaled.
 * Animation data is assumed to be hierarchical, and is applied to a bone by name matching the bone name in the animation data to the targeted geometry's skeleton.
 * Not every bone needs to be animated.
 * You can animate bones that don't exist in the targeted geometry (missing bones are ignored).
 * For each of scale, rotation, position, one can set the fields individually or uniformly with a single value. For example, these are equivalent.