How game engines animate characters
Characters in video games are not drawn frame by frame. Game engines such as Unity and Godot build a character from a skeleton, store movements as data, and work out every frame as the game runs. Jabbertoon is a simple game engine of its own, and it animates its characters the same way, so it is a gentle place to meet these ideas before opening a professional tool. Each idea below has its name in Unity and in Godot, and a Jabbertoon move that shows it.
The rig: a skeleton inside the character
A rig is a tree of bones inside the character's model. Move a bone and everything attached to it moves too: turn the upper arm and the forearm and hand go with it. In Unity the bones are the Transforms under a character's model and a Skinned Mesh Renderer binds the mesh to them; in Godot they are a Skeleton3D node with the mesh skinned to it. Every one of Jabbertoon's cast is a rig too, and in the Forge you build your own on a skeleton, a bone at a time.
The clip: a movement stored as data
A clip is a recorded movement that can be played on a rig. Unity calls it an Animation Clip; Godot stores an Animation in an AnimationPlayer. In Jabbertoon a clip is a move: a small block program that says how the body parts move over time, such as Wave hello. The difference is that a Jabbertoon move is a program rather than a list of keyframes, so you can read it as text and change one number.
Retargeting: one clip, many bodies
Retargeting plays a clip made for one character on another with different proportions. Unity does it for human characters through its Humanoid Avatar; Godot 4 does it for 3D skeletons with a bone map. Jabbertoon does it for every body, because a move names parts by their role (arm, leg, tail) instead of by drawing. Here is what the engine computes when Wave hello plays on each ready-made character: the person and the kid wave an arm, the dog and the cat answer the arm channel with a front leg, and the bird answers with a wing.
| Character | Moves? | What moves |
|---|---|---|
| Person | yes | arms |
| Kid | yes | arms |
| Dog | yes | turns, front legs |
| Cat | yes | turns, front legs |
| Bird | yes | wings |
| Monster | yes | arms |
And here is the same move playing live on all six, from one program:
Reach: inverse kinematics
Usually a pose sets each joint's angle. Inverse kinematics (IK) works the other way: you say where the hand should be, and the engine works out the angles of the shoulder and elbow to put it there. Unity's Animation Rigging package has a Two Bone IK Constraint, and its 2D IK has a Limb Solver; Godot 4 has a SkeletonModification2DTwoBoneIK. Jabbertoon's reach block is two-bone IK: in Wave and look the right hand is aimed at a spot beside the head, so it stays there as it waves while the head tilts toward it.
Follow-through: parts that lag behind
Ears, tails and hair should keep moving for a moment after the body stops. Engines simulate this with springs: Unity's Animation Rigging has a Damped Transform constraint, and Godot 4 has a SkeletonModification2DJiggle. Jabbertoon's "let the … follow" block is a damped spring too, worked out on a fixed clock so it is the same every time: in Floppy hop the ears and tail flop after every landing. Watch the dog's ears and tail:
Views and turning
A flat, drawn character has to be drawn again to face another way, so game artists keep a drawing for each direction and switch between them. A 3D character simply turns: it is the same model from every side, and the camera can look at it from anywhere. Jabbertoon's cast is in 3D, so a character turns its head to look about and walks round a world in any direction: watch Look around.
What game engines call this
The same five ideas come up in every engine's manual, under its own names. This is where each one stands in Jabbertoon, and what Unity and Godot call it:
| The idea | In Jabbertoon | Unity | Godot |
|---|---|---|---|
| State machine: which animation plays, and when it changes | There are no states yet. The nearest thing is a hat: a script under talk-start or talk-end starts when a line begins or ends. | Animator Controller | AnimationTree with an AnimationNodeStateMachine |
| Blend: two animations at once | Scripts and moves that run at the same time add up: turns, offsets and part angles add, and sizes multiply. | Blend Tree, and additive Animator layers | AnimationNodeBlend2, BlendSpace1D, BlendSpace2D and AnimationNodeAdd2 in an AnimationTree |
| IK: aim a hand or a foot, and the joints follow | The reach block, two bones at a time | IK Manager 2D with a Limb solver (2D IK) | SkeletonModification2DTwoBoneIK |
| Mask: an animation that moves only some parts | A block moves only the part it names, both arms or just the left one, and every part no block names is left free for another script. | Avatar Mask on an Animator layer | Filters on an AnimationTree blend node |
| Retargeting: one animation on many bodies | A move names parts by role (arm, leg, tail), so it plays on every character. | Humanoid Avatar | BoneMap with a SkeletonProfile (3D skeletons) |
What comes next
Of the table's rows, the state machine is the one Jabbertoon does not have: states (idle, walk, jump) and the rules for moving between them are a named future feature, along with responding to keys and collisions inside a cartoon. Until then, Jabbertoon is a place to learn rigs, clips, retargeting, reach and follow-through in a web browser, and the same ideas carry straight over to Unity and Godot.