🎞️ Lesson 1.1: The Animation System: Clips, Animator & Controllers

The Big Picture: Three Pieces

Unity's animation system can feel like a lot of windows and assets at first. The trick is to realize it's only three moving parts that hand work to each other in a chain:

1. Animation Clips — the raw recorded motion (an Idle, a Run, a chest that opens).
2. Animator Controller — a project asset that organizes those clips into a state machine and decides which one plays.
3. Animator — a component you put on the GameObject that runs the controller and poses the model every frame.

Here is the whole pipeline in one picture. Read it left to right: several clips feed into one controller asset, the controller is assigned to an Animator component on your character, and the result is a model that moves.

Animation Clips: Recorded Motion

An Animation Clip is a recording of how one or more properties change over time. Most often those properties are the rotations and positions of a character's bones, but a clip can animate anything — a light's intensity, a material's colour, a door's hinge angle, even a script's public field.

Clips come from two places:

• Imported with a model. When you drag in an .fbx character, its animations arrive as read-only clips nested under the model file in the Project window. This is how most humanoid motion (idle, walk, run) reaches your project.
• Authored in Unity using the Animation window (Window ▸ Animation ▸ Animation). You record keyframes by hand — perfect for a swinging platform, a UI pop, or a treasure chest lid.

Under the hood a clip is just a set of curves: one per animated property, with keyframes and interpolation between them. You will meet the curve editor properly in Lesson 1.4 when we add an Animation Event to a clip.

The Animator Controller Asset

One clip on its own can't decide when to play. That's the Animator Controller's job. It is a project asset (file extension .controller) that holds a state machine: a set of states — each playing a clip or a blend of clips — plus the transitions and parameters that move between them.

Create one with right-click in the Project window ▸ Create ▸ Animator Controller, then double-click it to open the Animator window and start dragging clips in. That window and its state machine are the whole subject of the next lesson, so here we'll just note what the controller is: the brain that chooses the current animation.

💡 One controller, many characters. Because the controller is a shared asset, ten guards can all point their Animator components at the same GuardController. Each guard keeps its own live state (this one is running, that one is idling) while sharing the one set of rules. Edit the asset once and every guard updates.

The Animator Component

The controller is just an asset sitting in your project until something runs it. That something is the Animator component. Add it to a GameObject (it's added automatically when you import a rigged model), drop your controller into its Controller field, and at runtime the component evaluates the state machine every frame and applies the resulting pose to the model.

Two fields on the component matter most:

• Controller — the .controller asset to run.
• Avatar — the description of this model's skeleton (more on this next). Empty for non-humanoid rigs.

From code you already know how to reach a component. Grabbing the Animator is no different, and it's how every gameplay script talks to the animation system:

using UnityEngine;

public class AnimatorIntro : MonoBehaviour
{
    Animator animator;

    void Awake()
    {
        // The Animator component is what actually plays the controller.
        animator = GetComponent<Animator>();
    }

    void Start()
    {
        // A quick sanity check you can delete later:
        Debug.Log($"Running controller: {animator.runtimeAnimatorController.name}");
    }
}

You won't set parameters yet — that's Lesson 1.2 — but notice the pattern: the component is the runtime handle. The clips and controller are data; the Animator is the engine that turns that data into movement.

Import Rigs: Generic, Humanoid & the Avatar

When you import a rigged model, Unity asks how to interpret its skeleton. You set this on the model's Rig tab in the Import Settings (Animation Type). There are three choices, but two matter day to day:

• Generic — Unity treats the skeleton as an arbitrary hierarchy of bones. Use it for anything not shaped like a person: a dog, a spider, a mechanical arm, a flag. Clips are tied to that exact skeleton.
• Humanoid — Unity maps the skeleton onto a standard human layout (hips, spine, two arms, two legs, a head). This unlocks animation retargeting: a walk recorded on one humanoid model plays on any other humanoid, even one with different proportions.
• Legacy — the old pre-Mecanim system. You'll almost never choose it for new work.

The magic behind Humanoid is the Avatar. It's a small asset Unity generates that says "this model's UpperArm bone is called mixamorig:LeftArm, its Hips bone is called Hips," and so on. Because every Humanoid model has an Avatar describing the same standard rig, Unity can translate motion from one to another.

Setting Up the Module Character

Throughout Module 1 we'll animate Timmy, a rigged robot character. Unity ships a ready-made humanoid you can grab for free so you can follow along even without your own model:

1. Open Window ▸ Package Manager, switch the dropdown to Unity Registry, and install Starter Assets - ThirdPerson (it includes a rigged character and animations). This is the same package we'll lean on for the real controller later in the module.
2. Drag the character prefab into your scene. Because its model is imported as Humanoid, it already carries an Animator component with an Avatar assigned.
3. Look at the Animator component in the Inspector: its Controller field points at an existing .controller asset. Double-click that asset to open the Animator window and peek at the state machine — we'll dissect it next lesson.

That's the entire system on screen at once: imported clips, a controller asset organizing them, and an Animator component running it on Timmy.

Figure 3: How the pieces connect — clips and an Avatar feed the controller and component, which output a posed character.

Hands-on Challenge

Summary

🚀 What's Next?

You now know the players and how they hand off to each other. In Lesson 1.2: States & Transitions we open the Animator window and build the state machine itself — creating states from clips, wiring transitions, and driving them with parameters your code will flip.