Animation

The animator a sprite already has, or null when nothing animates it.

A sprite from a scene file can arrive already moving: the file says which run it starts on, and the scene started it. This is how a behaviour reaches that same animator to change the run, instead of making a second one that fights the first for the same sprite every frame. If more than one was made for a sprite, it is the last.

Makes a loaded model move: plays the movements it came with, and eases between them.

A rigged model is a skin stretched over bones. A movement turns the bones, and the skin follows, which is why one model can walk, run and fall over without three copies of it existing.

It can be asked for a movement before the file has arrived, which is the ordinary case: the model comes back still loading, so play is remembered and honoured the moment it shows up.

fade is what makes it look like a character rather than a demo. Asked to change movement over half a second, it turns the bones from where one has them to where the other does; cutting straight across snaps a leg from behind to in front in a single frame.

Plays a sprite's pictures in order, so it walks, attacks or spins.

A sheet already holds every picture and a sprite already shows one of them: animating is deciding which one, and when. That is all this does, once per frame, so the renderer never learns that animation exists.

The sprite has to come from a sheet (createSprite({ atlas })), since that is where the frames are. Call it while the scene is being built, like every hook, and keep what it returns to change clips later.

Moves a number from one value to another over time, so something can slide in, grow, fade or bounce without you writing the arithmetic for it every frame.

Calling useTween() animates nothing by itself: it gives you back a function that starts tweens. Call that function whenever you want one, while the scene is being built or later from a key press, and it hands you the controls to that particular tween: pause it, resume it, throw it away or send it straight to the end.

What is animated is a plain number. The tween gives it to you every frame in onUpdate and you put it wherever it belongs, which is why the same hook moves a sprite, widens a loading bar or mixes two colours.

Tweens belong to the scene that started them: they freeze while it is paused, they run in slow motion when the game does, and they are gone when it leaves. There is nothing to clean up.

One named run of frames: which pictures, how fast, and whether it starts again at the end.

Something that happens at a point inside a movement, rather than at its end: the moment a sword becomes dangerous, a foot meets the ground, a spell leaves the hand.

It is a cue, not a consequence: the movement says when, and the game decides what that means. That split is what lets the same swing be a hit, a parry or a miss without the animation knowing which, and it is why nothing here names a function.

Used by both halves of the engine. What at counts differs, because the two kinds of movement are measured differently, and each says so where it is taken.

Where one bone sits relative to the bone above it: a move, a turn and a size.

Kept as three separate things rather than one matrix because that is how animation writes it: a clip turns a shoulder without touching where it is, and two poses can only be mixed sensibly one part at a time.

The handle on a model's movement: what it is doing, and how to change it.

What to ask a model's bones to do.

One named movement of a skeleton: walking, running, being hit.

Named apart from a sprite's TAnimationClip, which is a run of pictures. The two are the same idea in the two halves of the engine and share nothing at all.

It is plain data and holds nothing that is running. Two characters playing the same clip at different moments share this and keep their own time, which is what makes a crowd cheap.

The bones of a model, and how they are standing right now.

It comes out of a file that was rigged: the bones themselves, which bone hangs from which, how they stand at rest, and what it takes to undo that rest position. Animation writes pose and nothing else; the graphics card reads jointMatrices and nothing else. That line down the middle is what keeps playing an animation, posing a skeleton and drawing it three separate problems.

Bones are a flat list, parents before their children, so working out where each one ended up is one pass from the front with nothing to recurse into.

The controls for one animated sprite, returned by useSpriteAnimation.

What useSpriteAnimation is asked for.

The controls of one tween that is already running, handed back when you start it.

One trip of a number: where it starts, where it ends, how long it takes and what to do with the value along the way.

A tween animates a number, not an object, and that is on purpose: onUpdate hands you the value and you decide where it goes. Into an x, into a width, into the amount of one colour mixed into another. Anything made of numbers can be animated without the tween knowing it exists.

Starts one tween and hands back its controls. This is what useTween gives you, and you can call it as many times as you like: while the scene is being built, or later from a key press.