Class AnimationMixer

The armed or playing clip, or undefined on a fresh mixer.

Length of one iteration in seconds: the clip's own duration (§17), frozen at play. 0 while nothing is armed.

Total played time in seconds, across loop iterations.

Whether an advance carried playback to AnimationMixer.totalDuration.

A playback fact, not a time fact: AnimationMixer.seek never sets or clears it, exactly as on a tween or a timeline, so scrubbing a finished mixer inspects values without pretending it is running again.

Zero-based index of the loop iteration currently playing.

Clip-local position inside the current iteration, in seconds (§9).

Total iterations set by AnimationMixer.loop; 1 by default.

The AnimationMixer.speed multiplier.

Current playback state.

The object every track path is resolved against.

duration × loop — the elapsed time at which playback finishes. Infinity for loop(Infinity), and 0 for a zero-length clip (where 0 × Infinity would otherwise be NaN).

Advances playback by deltaSeconds × speed and writes the resulting pose. Called by the fixed-step AnimationSystem (plan P4-1) with the simulation's fixed delta; a mixer never advances itself and never reads a clock (§33).

Clip events in the crossed range fire in time order, once each — including one exactly at the end of the range and excluding one exactly at its start, so consecutive advances neither miss an event nor repeat one. A delta that spans an iteration boundary fires the rest of that iteration's events, re-arms them, and continues into the next.

A no-op unless the mixer is "running" and unfinished. The advance that reaches AnimationMixer.totalDuration clamps to it, writes the final pose, and releases the property claims (a finished mixer can still be scrubbed, exactly as a finished tween can).

Sets the number of total iterations: loop(1) is the default single pass, loop(3) plays the clip three times, loop(Infinity) never ends. Clip events re-arm on every wrap, so a marker on a loop(3) playback fires three times.

Legal mid-playback, like AnimationMixer.speed: it only changes AnimationMixer.totalDuration, which the next advance reads.

Suspends advancing. A no-op unless the mixer is "running".

Resolves every track's binding, claims the properties (§16), and starts playback at clip time 0 — writing the pose for time 0 immediately, so the clip's first keyframes are visible without waiting for an advance.

play(clip, options) is prepare(clip, options).play(). Calling it with no clip plays whatever AnimationMixer.prepare armed, which is the form Timeline uses.

A no-op on a mixer that is not "idle" — replaying would have to re-resolve bindings that §16 says are resolved once. Build a new mixer, or seek(0).

No event fires here, not even one at clip time 0: the cursor starts below zero and the first advance (even advance(0)) crosses it.

Arms the mixer with a clip and its per-playback options without starting it, so something else can own its playback — a Timeline, which requires an "idle" child and calls play() itself, or a caller that wants to seek a pose before running.

The same relationship tween(...) has to animate(...).play(): nothing is bound, captured, or claimed here.

Resumes advancing. A no-op unless the mixer is "paused".

Positions playback at timeSeconds of elapsed time and writes the pose for it — §16's scrubbing, and the positioning half of a snapshot restore (§34).

Pure: seeking twice to the same time writes identical values, and seeking backwards is as valid as forwards. Neither AnimationMixer.state nor AnimationMixer.finished changes, so a seek is an evaluation and never a playback decision.

The time is clamped to [0, totalDuration] — elapsed time, spanning every loop iteration, not one iteration's clip time. It therefore differs from Timeline.seek, which clamps to a single iteration: a mixer is placed on a timeline by its total duration, so a looping mixer driven by a timeline has to be addressable across its loops, and scrubbing a three-loop clip through all three loops is meaningful in a way that scrubbing a timeline "into iteration 2" is not. With the default loop(1) the two conventions coincide.

Events are suppressed unless the playback opted in with { replayOnSeek: true }, in which case a forward seek fires the events it crosses (§16). A backward seek fires nothing and re-arms the events it rewound past, so replaying forwards crosses them again — which is exactly what "restoring a mid-clip snapshot positions playback without re-firing markers already crossed" needs.

Root motion (§19, P7-5) is repositioned and not applied: a seek moves the clip clock, never the character (see MixerRootMotionOptions).

Sets the playback speed multiplier — legal at any time, including mid-playback, because §107 lists it as a playback control.

Must be positive and finite. Reverse playback is deliberately not speed(-1): §16 gives reversing to Timeline, and a negative multiplier here would make "the advance that finishes playback" ambiguous and event crossing (a forward notion) meaningless. Scrub backwards with AnimationMixer.seek.

Stops playback and releases every §16 property claim, leaving all animated values exactly where the last write put them.

A stopped mixer never writes again — even a later AnimationMixer.seek is inert — and the properties it held are free for another writer to claim without a conflict warning. A no-op on an "idle" mixer, which holds nothing.