🌳 Lesson 1.3: Blend Trees

Why Blend, Not Switch?

Picture the Idle ⇄ Run machine from Lesson 1.2. The moment Speed crossed 0.1, the character flipped from a still pose to a full run. Even with a short transition duration smoothing the cut, there's no walk in between — no jog, no gentle acceleration. The character has two gears: parked and sprinting.

Humans (and robots like Timmy) have infinite gears. As you push a thumbstick further, the character should ease from standing to strolling to jogging to sprinting, matching the exact input. Wiring a separate state and transition for every speed band would be a nightmare of arrows. A blend tree collapses all of that into a single state.

What a Blend Tree Is

A blend tree lives inside a single state. From the outside — on the main Animator canvas — it looks like any other state box (often named Locomotion or Idle Walk Run Blend). Transitions still enter and leave it exactly as you learned last lesson. Double-click it, though, and you drop into the blend tree editor, a second graph showing the motions it mixes.

The key idea: one parameter drives a smooth mix. Instead of "if Speed > 0.1 go to Run," a blend tree says "at every value of Speed, here's the exact recipe of clips to blend." You give it the ingredients (clips) and the value each one is strongest at (its threshold), and Unity interpolates everything in between.

💡 Blend trees vs. transitions. Transitions are for distinct actions — idle, jump, attack, die. A blend tree is for a continuous spectrum of one action — how fast you move, or which direction you strafe. Most controllers use both: a blend tree for locomotion, plain states around it for jumps and hits.

Creating a 1D Blend Tree

Let's replace the old Idle/Run pair with one blended locomotion state:

1. In the Parameters panel, make sure you have a Float parameter named Speed (the same one from Lesson 1.2).
2. Right-click the Animator canvas ▸ Create State ▸ From New Blend Tree. Name the state Locomotion and set it as the default state.
3. Double-click Locomotion to enter the blend tree editor.
4. In the Inspector, set Blend Type to 1D and the Parameter to Speed.
5. Under Motion, click the + ▸ Add Motion Field three times and assign your Idle, Walk, and Run clips.
6. Set each motion's Threshold — the Speed value at which it plays at full strength. For example Idle = 0, Walk = 2, Run = 6.

That's it — no transitions between the three motions. The blend tree handles the mixing internally; from the main canvas Locomotion behaves like one tidy state.

Reading the Blend Graph

Here is the 1D blend tree editor for our Locomotion state, drawn exactly as Unity lays it out. The bar at the top is the Speed parameter; the little red diamond is the current value, and the graph below shows how much each clip contributes as Speed changes.

Notice there are no arrows inside the blend tree. The thresholds replace transitions entirely: wherever the red line falls, Unity reads how close it is to each threshold and mixes the clips in that proportion. Move it smoothly and the character accelerates smoothly.

Driving It from Code

Here's the payoff: driving a whole locomotion blend takes one line. You feed the same Speed float you used for transitions, and the blend tree does the rest. This uses the new Input System's InputAction to read a move vector (we cover the Input System fully in Module 3):

using UnityEngine;
using UnityEngine.InputSystem;

[RequireComponent(typeof(Animator))]
public class LocomotionDriver : MonoBehaviour
{
    [SerializeField] InputActionReference moveAction; // a Vector2 "Move" action
    [SerializeField] float maxSpeed = 6f;             // matches the Run threshold

    Animator animator;
    static readonly int SpeedHash = Animator.StringToHash("Speed");

    void Awake() => animator = GetComponent<Animator>();

    void OnEnable()  => moveAction.action.Enable();
    void OnDisable() => moveAction.action.Disable();

    void Update()
    {
        Vector2 move = moveAction.action.ReadValue<Vector2>();
        float speed = move.magnitude * maxSpeed;   // 0 when still, up to maxSpeed

        // One call feeds the entire Idle/Walk/Run blend.
        animator.SetFloat(SpeedHash, speed, 0.1f, Time.deltaTime);
    }
}

Two touches worth copying: we cache the parameter name as a hash with Animator.StringToHash (the fragile-strings tip from Lesson 1.2), and we use the damped overload of SetFloat — the extra 0.1f and Time.deltaTime arguments ease the value toward its target so a sudden stick flick doesn't snap the blend.

2D Blend Trees: Adding Direction

A 1D tree blends along a single axis — great for "how fast." But what about "which way"? A top-down shooter or a strafing third-person character needs to blend forward, backward, and sideways motion at once. That's a 2D blend tree: two parameters (say MoveX and MoveY) place each clip at a point on a plane, and Unity blends by how close the input is to each point.

When you set Blend Type to a 2D mode, the graph becomes a square field instead of a line, and each motion gets a 2D Position instead of a single threshold:

• 2D Simple Directional — one clip per direction (forward, back, left, right). Best when motions point clearly outward.
• 2D Freeform Directional — directions plus different magnitudes (walk-forward and run-forward together).
• 2D Freeform Cartesian — arbitrary positions when the two parameters aren't really "directions" (e.g. Speed and Turn).

The workflow is identical to 1D — add motions, position them, feed the parameters from code — just with an X and a Y. For most character controllers a 1D Speed blend plus a couple of plain states is plenty; reach for 2D only when direction genuinely matters.

Figure 2: A 1D tree blends along one parameter; a 2D tree blends across two.

The Real Thing: Timmy's Blend

Remember the run render back in Lesson 1.2 — the one where Timmy leaned naturally into his stride rather than snapping to a pose? That lean is a blend tree at work. Timmy's actual controller from the Starter Assets - ThirdPerson package doesn't have separate Idle and Run states at all. It has a single 1D blend tree state named Idle Walk Run Blend, driven by the same Speed float, mixing an idle, a walk, and a run exactly like Figure 1.

🔎 Look for yourself: open Assets ▸ …ThirdPersonController ▸ Character ▸ Animations ▸ StarterAssetsThirdPerson.controller and double-click the Idle Walk Run Blend state. You'll see the 1D graph, the Speed parameter, and the three motions with their thresholds — the production version of everything you just built.

Hands-on Challenge

Summary

🚀 What's Next?

Your character now moves smoothly, but animation can do more than pose a mesh — it can trigger events at exact frames (a footstep sound, a hit check) and even move the character itself. In Lesson 1.4: Animation Events & a Character Controller we tie the whole module together into a small playable demo.