Animation
Look up the skeleton, clip, pose, and sampling model, the blend and inertialization rules, root motion, the animation graph and its spaces, animators and their updates and data stream, the look chain, the clip pool, and flipbooks.
Animation turns clips baked from glTF, GLB, and FBX files into poses that the renderer skins with. This page specifies the data model, how a clip is sampled and blended, what the animation graph guarantees, how animators play graphs and post their updates, and the limits of the clip pool. To author the source files, follow Author assets; the importer rules are in the asset formats reference.
Skeletons and clips
A skeleton is a list of nodes in parent-before-child order. Each node has an optional name, an optional parent index, and a rest local transform. A local transform is a translation in the parent's space, a rotation, and a scale; the identity transform has zero translation, identity rotation, and unit scale.
A clip holds:
| Field | Value |
|---|---|
name | Optional. |
skeleton | The skeleton the clip was authored for. |
duration | Seconds. Finite and zero or more. |
frame_rate | Optional. Frames per second when the source format records one; glTF records none. Finite and positive when present. |
tracks | One track per animated node, in strictly ascending node order. A track has at least one of a translation curve, a rotation curve, and a scale curve. |
A curve is one of three kinds: step, linear, or cubic spline with in and out
tangents. A rotation curve's tangents are quaternion derivatives. Every curve
has the same number of times and values, at least one key, times in [0, duration] that strictly increase, and finite values; a cubic curve has one
tangent pair per key.
Sampling
Sampling a clip at a time in seconds produces a local pose for every node of the skeleton:
| Rule | Behavior |
|---|---|
| Missing curve | The node keeps its rest local value for that channel. |
| Before the first key | The first key's value. |
| After the last key | The last key's value. |
| Step curve | The value of the last key at or before the time. |
| Linear curve | Translation and scale interpolate linearly. Rotation uses normalized linear interpolation along the shorter arc. |
| Cubic curve | Hermite interpolation with tangents scaled by the span between the two keys. A span of zero length yields the lower key. |
| Looping | Not part of sampling. The animation graph loops by phase. |
A global pose is the list of matrices for every node, where a node's global matrix is its parent's global matrix times its local matrix, and a local matrix applies scale, then rotation, then translation.
A pose map remaps a clip onto another skeleton by node name. Target nodes with no source keep the target's rest pose. Mapped target nodes start from the source rest pose. When several source nodes map to one target, the last one wins.
Blending
| Operation | Rule |
|---|---|
| Two poses | The factor clamps to [0, 1]. Translation and scale interpolate linearly; rotation uses normalized linear interpolation. |
| Several poses | Weights must be finite and zero or more, and at least one must be positive. They normalize by their sum. Rotations flip to the hemisphere of the first positively weighted pose before mixing. |
| 1D blend space | At least one position, finite and strictly ascending. A value interpolates linearly between its two neighbors and clamps to the end samples outside the range. |
| 2D blend space | At least three positions and one non-degenerate triangle. A value takes the barycentric weights of the first triangle that contains it; outside every triangle, the closest point on any triangle edge or vertex. Weights clamp to [0, 1] and renormalize. |
Inertialization
An inertializer carries the pose that was on screen into a new destination without a visible discontinuity. It starts from a source pose and its previous frame, a destination pose and its previous frame, the sample delta between those frames, and a duration.
| Rule | Behavior |
|---|---|
| Sample delta | Finite and positive. |
| Duration | Finite and zero or more. A zero duration applies the destination at once. |
| At the start | The output equals the source pose. |
| At the end | The output equals the destination exactly, with zero velocity and acceleration. |
| Offset | Settles along a quintic curve that leaves the source without acceleration. |
| Velocity difference | Decays so that one thousandth remains at the end of the duration. |
| Rotation | Offsets are rotation vectors composed onto the destination rotation. |
Root motion
Root motion is the movement of one named node, taken out of the visual pose so that the owning object moves instead. A root motion delta is a translation and a rotation; deltas compose by adding translations and composing rotations, and blend by linear and normalized linear interpolation. Scale is never part of root motion.
| Setting | Value |
|---|---|
| Node | By name. The name must exist exactly once in the skeleton. |
| Translation | Any subset of the X, Y, and Z axes, or none. |
| Rotation | None or full. |
The delta is measured between the node's previous and current sampled poses, with the unselected channels replaced by the node's rest values, in object space. When a looping clip wraps, the delta covers the remainder to the clip's end, any whole loops, and the start to the current time. In a blend, each positively weighted clip contributes its own delta, mixed as a weighted mean. In a transition, the source and destination deltas blend by the transition factor. The visual pose keeps the rest values on the extracted channels.
A step in which a one-shot hands over to its target with a hand-over turn rotates by the turn at the hand-over moment, whatever the rotation setting: the delta's rotation composes the motion before the hand-over, the turn, and the motion after it. The motion after the hand-over is in the turned frame, so its translation rotates by the turn before it adds.
Animation graph
A graph is a state machine built in code. Its states can be grouped into spaces that share one blend position. Any number of animators can play one graph, and each keeps its own playback.
States
| State | Holds | Playback |
|---|---|---|
| Clip | One clip, looping or played once. | |
| Round robin | One or more clips, in order. | Plays one clip at a time, as a clip state. Each time the animator enters the state, it plays the next clip, starting with the first and wrapping after the last. |
| Linear blend | Clips at scalar positions, as a 1D blend space. | Its space's position picks the weights. |
| Planar blend | Clips at 2D positions, as a 2D blend space with explicit or fan triangulation. | Its space's position picks the weights. |
Every clip in a blend or a round robin shares one playback mode. A blend's duration is the weighted sum of its clips' durations, so all its clips share one phase.
Each animator keeps its own turn for each round robin, so animators that play one graph don't advance each other's turns. Entering a round robin takes a turn whether the animator enters it through a route, a hand-over, or a redirect. A blend position never changes which clip a round robin plays, and a route point on a round robin names one of its clips, as on a blend.
Spaces
A space is a named group of states that share one blend position. A linear space's position is a scalar; a planar space's position is a 2D point.
| Rule | Behavior |
|---|---|
| Membership | A state belongs to at most one space. A clip state may belong to one. A blend state always belongs to one: a blend state built outside a space forms a space of its own, named after the state, that holds only it. |
| Kind | Every blend state of a linear space is a linear blend, and every blend state of a planar space is a planar blend. |
| Samples | Each blend state of a space has its own clips and positions. Two blends of one space need not share positions or a clip count. |
| Position | Each animator keeps one position for each space. A request for a state of the space that carries a position sets it. Before any request sets it, the position is the origin. |
| Weights | A blend weighs its clips at its space's position every step, whether it loops or plays once, until a blend played once finishes and holds its last pose. |
| Nesting | A space can't hold another space. |
| Other spaces | A space's position never changes the weights of another space's blends. |
Routes
A route leads from a source state to a target state.
| Route | Behavior |
|---|---|
| Direct, taken when the source settles | Waits until the source has reached its wait point, or its end for a clip played once, then inertializes into the target over the route's duration. A zero duration switches at once. |
| Direct, taken anytime | Also cuts short a blend into the source or a one-shot leading to it. |
| Through a one-shot clip | Plays a clip once between source and target, then inertializes into the target over the exit duration. The one-shot either must complete or may be interrupted, as Routes resolve describes. |
| Through a one-shot blend | Plays a blend of clips once between source and target, like a one-shot clip. The blend belongs to the target's space, or to the source's when the target belongs to no space or to a space of the other kind. It weighs its clips at that space's position and follows the position while it plays, so a start re-aimed by a new request heads where the request points. |
| From a space | A route every state of a space can take, considered after the state's own routes. |
| From any state | A route every state can take, considered after the state's own routes and its space's routes. |
A route through a one-shot can carry a hand-over turn: an angle in radians about +Y, by the right-hand rule. It suits a one-shot that turns the body in its pose into a target whose pose faces where the one-shot started, like a turn in place into an idle. When the one-shot completes and hands over to its target, the entity takes over the turn through root motion, so the pose and the entity together keep the body where the one-shot left it. A one-shot cut short by another route hands over no turn.
A route through a one-shot plays a state of its own, named after the route's
source and target, as in Walk -> Stop. The second one-shot between the same
source and target, in the order the graph is built, is named Walk -> Stop 2;
each later one takes the next number.
A wait point is a frame on the source clip, frames on one or more clips of a blend, or a time. When a route names frames on several clips of a blend, it waits for the frames of the named clip that weighs the most; between clips of equal weight, the first named wins. Frames count at the clip's authored frame rate; a clip without a frame rate never reaches a frame point. A route can also enter the target at a frame instead of its start. When it names frames on several clips of a blend, the named clip that weighs the most where the target starts picks the frame, by the same rule.
Routes resolve in this order. A persistent state ignores a request for itself, then takes the first of its own routes to the requested state, then its space's routes, then any-state routes. A one-shot takes its own routes first. While a one-shot that may be interrupted plays, a request other than its completion may take the anytime routes of the completion state or its space, or any-state routes. While a one-shot that must complete plays, such a request may take only any-state routes; otherwise the request holds and the one-shot plays to its end. Once a one-shot finishes, it takes its completion route, and the request that held resolves from the completion state. A blend in progress can only be redirected along anytime routes, of its destination state or that state's space, and any-state routes, and never toward a one-shot.
A route can be a fitted alternative: one of several routes from a state to the same destination, each fitting the source clips it names wait frames in. When the first route from the state to the requested destination is a fitted alternative, the alternatives compete:
| Rule | Behavior |
|---|---|
| Eligibility | An alternative is eligible when it fits every source clip that contributes more than 0.001 weight and that any alternative fits. Clips that no alternative fits don't restrict the choice. |
| Choice | The eligible alternative whose next wait frame comes first wins. Equal times keep the order the graph is built in. |
| Blending in | While the source blends in, fitted alternatives wait for it to settle instead of falling back to a route from its space. |
| One-shots | While a one-shot plays, a request resolved from its completion state's alternatives takes the first one without waiting, since their frames name moments of a state that isn't playing. |
Building a graph
Building validates the graph and reports the first problem:
| Error | Cause |
|---|---|
InitialStateOutOfRange, TransitionSourceOutOfRange, TransitionTargetOutOfRange, TransitionStateCompletionOutOfRange | A state index names no state. |
EmptyStateName, DuplicateStateName | A state has no name, or two share one. |
EmptySpaceName, DuplicateSpaceName | A space has no name, or two share one. |
EmptyResourceId | A clip has no resource ID. |
TransitionStateMustPlayOnce | A one-shot transition clip, or a clip of a one-shot transition blend, loops. |
NegativeTransitionDuration | A route or exit duration is negative. |
InvalidBlend, MixedBlendPlayback | A blend space is invalid, or the clips of a blend or a round robin mix looping and once. |
EmptyRoundRobin | A round robin has no clips. |
SpaceKindMismatch | A blend state's kind differs from its space's. |
BlendOutsideSpace | A one-shot transition blend's source and target belong to no space of its kind. |
RoutePointClipMissing, RoutePointNeedsClip | A wait or entry point names a clip its state lacks, or a point on a blend names no clip. |
Animators
An animator plays one graph for one entity. The animation system steps every animator of the world scope it's created on, and posts each animator's pose and root motion to the world.
Creating and removing
An animator is created through the world's animator factory under the handle of the entity it poses, usually a skinned renderable.
| Field | Value |
|---|---|
| Graph | The graph to play. Any number of animators can play one graph. |
| Root motion | Optional. The settings in Root motion. |
| Look chain | Optional. The settings in Look chain. |
| Rule | Behavior |
|---|---|
| System | The application creates one animation system on a world scope, with the clip pool it plays from, and steps it once per frame from its own tick. The system belongs to the animators of that scope. |
| Adoption | The system adopts animators created after the system, at the start of its next step. It never adopts one created before it. |
| Replacement | An animator created again under the same handle replaces the previous one and starts over at its graph's initial state. |
| Removal | A deletion of the handle removes the animator at the start of the next step. Nothing more is posted for that handle. |
| Canonical skeleton | The skeleton of the first clip of the graph's initial state. Every animator of a graph shares it. Every clip an animator samples maps onto it, and the root motion and look chain node names resolve against it once it's resident. |
| Rejection | An animator whose settings don't resolve against the canonical skeleton is rejected. The system reports the error and posts nothing for the handle. |
Requests
A request is a targeted message on an animator's handle. It names a state and whether a position change is inertialized. A request for a blend state can also carry a position of its space's kind.
| Rule | Behavior |
|---|---|
| Latest wins | A step applies the last request posted for each handle since the previous step. |
| Persistence | A request holds until another replaces it. Before its first request, an animator plays its graph's initial state. |
| Other graph | A request for a state of another graph is discarded and reported as StateFromDifferentGraph. The previous request holds. |
| No animator | A request for a handle without an animator is discarded. |
Playback
Each step advances every animator by the step's delta toward its latest request, through the routes of its graph.
| Rule | Behavior |
|---|---|
| Phase | Advances by the delta divided by the clip's duration. A looping clip wraps; a clip played once stops at its end. A clip of zero duration stays at its start. |
| Clips sampled per step | At most three per motion: the triangle of a planar blend, the pair of a linear blend, or one clip, which for a round robin is the clip of its current turn. Only positive weights are sampled. |
| Transition | The destination is sampled at its start phase, both motions advance, and the inertializer carries the pose until the route's duration elapses. |
| Hand-over at a wait point or a one-shot's end | The time left in the step plays on the next state in the same step. |
| Redirect | A blend in progress can be redirected along an anytime route once the animator has posted a pose, from the pose and velocity it posted last. |
| Position change on a blend | An inertialized request blends the playing blend from its current weights to the new ones, from the pose posted last. A blend played once blends this way while it has at least the request's duration left to play, and moves its weights at once otherwise, so its end is never held back by the blend. A request without a position leaves every blend's weights as they are. While a blend to a new position plays, later requests move only the position it heads to; the weights it left stay until it ends, so its root motion ramps across the blend. |
| Prefetch | Entering a state requests the clips of every state its own routes and its space's routes can reach. A round robin needs all its clips resident before the animator enters it. |
| Initial clip not resident | The animator posts nothing. |
| Other clip not resident | The animator holds and posts its previous pose, with an identity root motion delta. |
Stepping
The system steps once per frame, with the frame's delta. A step adopts new animators and removes deleted ones; applies the latest requests and look targets; admits the clips that finished loading; then evaluates every animator: it takes its routes, phases, and hand-overs for the delta, samples, blends, and inertializes its pose, extracts its root motion, applies its look chain, builds its global pose, and posts its updates. Evaluation only reads the clip pool, so an animator that needs a clip the pool doesn't hold lists it, and once every animator is evaluated, the pool requests the listed clips.
| Rule | Behavior |
|---|---|
| Lanes | A step spreads its animators over the alley's lanes in balanced shares: one lane for each 16 animators, and never more lanes than the processor's fastest cores have hardware threads. Fewer than 32 animators stay on the calling thread. |
| Missing clips | The pool requests a clip that an animator needs but the pool lacks after the step, so the next step is the earliest that can play it. |
| Independence | An animator's pose, root motion, and state don't depend on the lane count or on the other animators, whatever graphs they play. |
| Completion | Every update of a step is posted before the step returns. |
| Order | Animators post in no particular order. |
Updates
Every step posts two updates for every animator whose initial clip is resident.
| Update | Route | Carries |
|---|---|---|
| Pose update | The world's pose route, in headed builds only. | The global transform of every canonical skeleton node, in node order, after the look chain: an affine matrix of three rows and four columns, scale applied first, then rotation, then translation. |
| Root motion update | The world's root motion route. | The step's root motion delta, in the entity's object space, and the state playing after the step. An animator without root motion settings carries the identity delta. |
The system never moves an entity: applying root motion to a transform is up to the code that owns the entity.
| Rule | Behavior |
|---|---|
| Same tick | A step posts its updates before it returns, so code that steps the system and then reads the root motion route in the same tick moves the entity by the delta of the pose that frame draws. Reading the route a tick later shows the pose one frame ahead of the transform. |
| Order of a tick | Post requests and look targets, step the system, apply the root motion updates to transforms, then step the systems that read transforms, such as physics. |
| Fixed-step simulation | The system steps with the frame, since poses are drawn every frame; a fixed-step physics then reads the transform root motion last moved at its next step. |
Queries
Between steps, the system answers these for each animator, as of the last step:
| Query | Answer |
|---|---|
| Playing state | The state playing, or none before the initial clip is resident. |
| Waiting for | The requested state whose route waits for the playing state to reach one of its wait points, or none. A new request cancels the wait. |
| Time until a route | How long the playing state plays on before its route to a given state starts: zero for a route that doesn't wait, and the time to the nearest wait point for one that does. None when the playing state has no route to that state, a one-shot has played past every wait point, the animator is blending, or the initial clip isn't resident. |
The system answers them through the animator's player, which it lends out between steps; the queries are the player's.
Data stream
An animator given a debug data stream (DDS) writes one
record to it each time it advances, after the advance, with stream set to
animation. An animator without a stream writes nothing. Times in data are
seconds. A clip is named by its resource ID's file name, without its directory
or extension; when the ID's fragment picks a clip by name or index, as in
#animations/Walk, a # and that name or index follow, as in character#Walk.
| Field | Type | Meaning |
|---|---|---|
status | loading, ready, or rejected | Whether the animator waits for its initial clip, plays, or never plays because it was rejected. |
error | String or null | Why the animator was rejected; null otherwise. |
missing | Array of strings | The clips the advance needed but the pool didn't hold, by resource ID. The pool requests them. |
request | Request | The latest request. |
motion | Motion or null | The state playing, or the state a blend moves to. Null until the initial clip plays. |
transition | Transition or null | The blend in progress; null when one state plays alone. |
pending | Pending or null | A route the animator selected but hasn't started; null when there's none. |
root_motion | Root motion | The motion the advance extracted for the entity to apply. |
look | Look or null | What the look chain measured and turned in the advance; null without a look chain or while it's released. |
A request:
| Field | Type | Meaning |
|---|---|---|
state | String | The requested state's name. |
position | Null, number, or array of two numbers | The requested blend position: null for none, a number on a line, or a point on a plane. |
inertialization | Number | How long the request blends to its position; zero changes the weights at once. |
A motion:
| Field | Type | Meaning |
|---|---|---|
state | String | The state's name. |
playback | loop or once | Whether the state's clips repeat or hold their last pose. |
phase | Number | Progress through the clips, from 0 at their start to 1 at their end. |
time | Number | The phase in seconds: the phase times the duration. |
duration | Number | One cycle: the clips' durations weighed by how much each plays. |
clips | Array of clip weights | The clips that contribute to the pose, at most three. Their weights sum to one. |
A clip weight:
| Field | Type | Meaning |
|---|---|---|
clip | String | The clip's resource ID. |
weight | Number | How much the clip contributes, above 0 and at most 1. |
A transition:
| Field | Type | Meaning |
|---|---|---|
from | Motion | The state the blend leaves, which keeps playing until the blend ends. |
route | Route | Why the blend started. |
elapsed | Number | How far the blend has progressed. |
duration | Number | How long the blend takes. |
A pending route:
| Field | Type | Meaning |
|---|---|---|
requested | String | The state the application requested. |
target | String | The state the route enters first, which is requested or a one-shot state on the way to it. |
blend | Number or null | How long the route blends from the playing state; null starts the target with nothing to blend from. |
route | Route | Where the route came from. |
wait | Wait or null | The moment of the playing state the route waits for; null when the route doesn't wait for one, which starts it as soon as its target's clips load. |
A route:
| Field | Type | Meaning |
|---|---|---|
kind | state, space, any-state, completion, position, or initial | Which list the route came from: the routes of a state, of a space, or of every state; a one-shot's completion; a position change of the playing blend, which takes no route; or the start of the initial state. |
owner | String or null | The state or space whose routes held it, or the one-shot that completes. A one-shot that takes its completion state's routes names that state. Null for any-state, position, and initial. |
A wait:
| Field | Type | Meaning |
|---|---|---|
clip | String | The named clip whose wait points the route follows: the one that weighs the most, as Routes specifies. |
weight | Number | That clip's weight in the playing state, which is 0 for a clip that doesn't play. |
point | Point or null | The wait point of that clip the playing state reaches next; null when it reaches none, like a one-shot past all of them. A point is {"frame": n} or {"seconds": s}, as authored. |
starts_in | Number or null | How long the playing state plays before it reaches point; null with it. |
Root motion:
| Field | Type | Meaning |
|---|---|---|
translation | Array of three numbers | The translation, in the skeleton root's parent space. |
rotation | Array of four numbers | The rotation quaternion, as x, y, z, w. |
A look, in radians about +Y in the entity's object space:
| Field | Type | Meaning |
|---|---|---|
target | Number | The target's yaw the advance looked toward, after any hand-over turn. |
body | Number | The body node's animated yaw. |
end | Number | The end node's animated yaw before the chain turns it. |
clamped | Number | The target's yaw clamped around body. |
eased | Number | The eased yaw the chain looks along. |
turn | Number | How far the chain turns the end node: eased minus end. |
The key, which changes-only streams
compare, is status, missing, the request's state, the motion's state
and clips, the transition's from state and route, and the pending route's
requested, target, route, and wait clip. Phases, times, the request's
position, a blend's elapsed, the wait's point and starts_in, root
motion, and the look aren't part of it.
Look chain
A look chain turns a chain of nodes toward a direction on top of the graph's pose, before the global pose is built.
| Setting | Value |
|---|---|
| Nodes | One or more node names with a share each, from the chain's base to its end. Each name must exist exactly once in the canonical skeleton, and each node must descend from the node before it. |
| Shares | Finite and positive. They normalize by their sum. |
| Body node | A node name that must exist exactly once. Its animated yaw centers the yaw limit. |
| Yaw limit | Radians, from 0 to π. |
| Up and down limits | Radians, from 0 to π/2 each. |
| Response | Per second, finite and positive, or none for no easing. |
A look target is a targeted message on an animator's handle with a yaw and a pitch in the entity's object space, or none to release the chain. The latest target holds until another replaces it; before the first one, the chain is released.
| Rule | Behavior |
|---|---|
| Angles | Yaw turns about +Y and pitch about +X, by the right-hand rule, in object space. The object faces -Z, so a positive pitch looks up. A turn pitches first, then yaws. |
| Animated yaw | For a node, the angle about +Y from -Z to -Z turned by the node's object-space rotation times the inverse of its rest object-space rotation, projected onto the XZ plane. |
| Clamping | The target yaw clamps to within the yaw limit of the body node's animated yaw, and the target pitch to the up and down limits. |
| Unreachable yaw | A target yaw beyond the limit clamps toward the side the eased yaw already lies on when that side is more than half the limit from the body node's yaw, and toward the target's own side otherwise, so a target passing behind the body doesn't swing the chain across. |
| Easing | The eased yaw and pitch start at the clamped target. Each step, they move the fraction 1 − e^(−response × delta) of the way to it, yaw along the shorter way around. Without a response, they equal the clamped target. |
| Turn | The chain turns by the eased yaw minus the end node's animated yaw, and by the eased pitch. |
| Distribution | The turn is one rotation, the pitch then the yaw. Each node, from base to end, turns by its share of that rotation's angle about its axis, in object space after its animated object-space rotation, so the shares compose to the whole turn at the end node. Its descendants turn with it. |
| Entity turn | A target may say how far the application turned the entity about +Y since the last step. The eased yaw turns the other way by that much before it eases, so the chain holds its direction in the world. The turn applies to one step. Turns the step's root motion carries aren't part of it. |
| Hand-over turn | A step whose one-shot hands over with a hand-over turn turns the eased yaw and the target's yaw the other way by the turn, before the chain eases, so the chain holds its direction in the world once the entity applies the step's root motion. The target stays turned until another replaces it. |
| Steps | The chain turns once a step, on the step's last pose, after any hand-over within it. |
| Release | The chain stops turning at once. The next target starts the easing over. |
| Root motion | The look chain never changes the root motion delta. |
Errors
| Error | Cause | Result |
|---|---|---|
RootMotionNodeNotFound, DuplicateRootMotionNodeName | The root motion node name is absent or ambiguous. | The animator is rejected. |
LookNodeNotFound, DuplicateLookNodeName | A look chain or body node name is absent or ambiguous. | The animator is rejected. |
LookChainOutOfOrder | A look chain node doesn't descend from the node before it. | The animator is rejected. |
InvalidLookChain | The chain is empty, or a share, limit, or response is out of range. | The animator is rejected. |
StateFromDifferentGraph | A request names a state of another graph. | The request is discarded. |
Clip pool
The animation system owns one pool, and every animator samples clips from it. The pool keeps packed clips in one arena sized by a byte budget that the application chooses, and loads clips on a worker.
| Request result | Meaning |
|---|---|
Ready | The clip is resident. |
Loading | The load is queued or in flight. |
WaitingForCapacity | The load queue holds 64 requests, or no room could be made. Request again later. |
Failed | The load failed or the clip is larger than the whole budget. |
The pool admits loaded clips and evicts clips only before and after animators
are evaluated, never while they sample. When a clip doesn't fit, the pool
evicts the clips whose last sampling step is the oldest first; clips that one
step sampled are equally recent. Up to 64
loaded clips can wait for room; further ones are dropped. The pool reports LoadFailed, Oversized, and
Evicted events, keeping the latest 64.
Flipbooks
A flipbook selects one image of a sequence by elapsed time. It needs at least one image and a positive frame rate. The frame index is the floor of the elapsed time times the frame rate, wrapped to the image count, so playback loops and a negative time wraps backward. Selection is stateless: the caller owns the clock, and skipped updates don't slow playback. The file format is in the asset formats reference.
Limits
| Limit | Value |
|---|---|
| Clip loads in flight, pool events kept, clips waiting for room | 64 each |
| Clips sampled per step per motion | 3 |
| Remembered blend positions | One per space per animator |
| Requests and look targets applied per step | The last of each per animator |
| Animators | No fixed limit |
| Animators for each lane a step adds | 16 |
| Blend space samples | At least 1 for 1D, at least 3 for 2D |
| Skeleton nodes, clips, states, spaces | No fixed limit; node indices are 32-bit |
| Engine time resolution | 28,224,000 ticks per second |