What Are Animation Layers?
Animation layers are one of the most powerful and widely misunderstood tools in a game animator's arsenal. At their core, they let you run multiple animations simultaneously on a single character — layering breathing on top of locomotion, an aim pose on top of a combat idle, or a facial expression on top of everything else — without needing to create a separate animation asset for every possible combination.
Without layering, a character with ten movement states, three combat stances, four aim directions, and two emotional expressions would need 10 × 3 × 4 × 2 = 240 unique animation clips. With a proper layering system, you need roughly 10 + 3 + 4 + 2 = 19. That's not just a workflow improvement — it's the difference between a manageable animation pipeline and an unshippable one.
In this guide we'll break down every major layering concept: additive vs override layers, bone mask splits, per-bone weight blending, slot nodes in Unreal Engine, layer blending in Unity, the order of operations stack, and the performance cost of each layer type.
Additive vs Override Layers
There are two fundamentally different ways a layer can combine with the layers below it: additive and override.
Override Layers
An override layer completely replaces the pose coming from the layers beneath it. If you have a locomotion layer at the bottom and an override layer on top playing a death animation, the death animation wins entirely — the character's legs, spine, arms, and head all snap to the death pose. Override is the default behavior in most engines and the simplest to reason about.
Override layers are ideal for cinematics, hit reactions that need to take full control, and any situation where the incoming animation is self-contained and complete. A full-body idle-to-sit transition, for example, should be an override — you don't want the locomotion system trying to blend in underneath it.
Additive Layers
An additive layer doesn't replace the pose below — it adds a delta on top of it. The delta is computed as the difference between a reference pose (usually a T-pose or an idle) and the additive animation frame. That delta is then applied on top of whatever pose is already playing.
The classic use case: breathing. You capture (or hand-animate) a gentle breathing animation. You subtract the reference idle from it to get a delta — the slight chest rise and spine sway. You play that delta additively on top of locomotion, combat, aim, or anything else. The character breathes no matter what state they're in, without needing separate versions of every animation.
Other additive use cases: subtle head turns toward points of interest, slight lean into a corner, eye blink layers, ambient fidget animations, a shiver when the character enters a cold zone.
The key thing to understand about additive layers: they respond to the base pose. If the base already has the spine rotated 30 degrees left (say, because the character is running around a corner), the additive breathing delta rotates on top of that 30-degree offset. This usually looks correct because the delta is small, but it can cause artifacts if the base pose is extreme.
Bone Mask Layers (Upper/Lower Body Split)
A bone mask restricts a layer to operate on a subset of the skeleton's bones. The most universal example in game animation is the upper/lower body split: the upper half of the character (spine, arms, hands, head) is controlled by one layer, while the lower half (pelvis, legs, feet) is controlled by another.
This lets you do things like:
- Play a reloading animation on the upper body while locomotion continues uninterrupted on the lower body
- Have the character wave at an NPC while still running
- Apply an aim offset to the spine and arms while keeping the feet planted by a foot IK system
The split point is typically the spine_01 or pelvis bone — everything from the first spine bone upward is "upper body," everything below is "lower body." The exact split depends on your skeleton hierarchy.
Defining Bone Masks in Unreal Engine
In Unreal, bone masks are created through the Layered Blend Per Bone node in the Animation Blueprint. You define which bone is the root of the mask and set a blend depth — a depth of -1 blends the entire branch below that bone. You can have multiple slots in the same node, one for upper body and one (with no mask) for lower body, letting two separate animations drive different parts of the skeleton simultaneously.
Defining Bone Masks in Unity
Unity uses Avatar Masks, which you create as an asset in the Project window. You can paint the mask on a humanoid rig using the muscle group interface (arms, head, left leg, right leg, etc.) or define it bone-by-bone for a generic rig. The mask is then applied to a layer in the Animator Controller via the layer settings.
Full Body Override for Cinematics
When a cutscene or cinematic moment plays, you typically want to completely surrender control to the cinematic animation and ignore the game's locomotion, combat, and procedural systems entirely. This is the full body override use case.
In practice, this means:
- All lower-priority layers (locomotion, combat idle, aim) are blended out to zero weight
- The cinematic animation plays at full weight on every bone
- Procedural systems (foot IK, spine sway, look-at) are disabled
- After the cinematic ends, the game layers blend back in over a transition window (typically 0.2–0.5 seconds)
A common mistake is forgetting to disable procedural systems during cinematics. The foot IK will try to stick the feet to geometry even as the character's root lifts off the ground during an animated jump, causing the legs to stretch grotesquely.
Per-Bone Weight Blending
Beyond binary bone masks (on/off), most modern engines support continuous per-bone weight blending — each bone can have its own blend weight between 0 (fully base layer) and 1 (fully override layer).
This is particularly useful for smooth upper/lower body transitions. Rather than a hard cut at spine_01, you can have spine_01 at 0.3 weight, spine_02 at 0.6, spine_03 at 0.9, and spine_04 at 1.0. The override layer fades in gradually up the spine, which eliminates the visible seam you sometimes see with binary bone masks.
Per-bone weights can also be driven at runtime by gameplay variables. A character who is heavily wounded might have higher blend weights on the damage layer across more bones. A character who is very tired might have higher weights on the fatigue additive layer.
Slot System in Unreal Engine (Slot Nodes)
Unreal Engine's Animation Blueprint has a dedicated concept called Slots for handling layered animation injection. A Slot is a named point in the Animation Blueprint graph where a Montage can inject its animation.
How Slots Work
You place a Slot node in your Animation Blueprint and give it a name (e.g., "DefaultSlot," "UpperBody," "FullBody"). When a Montage plays, it targets a specific slot. The Montage animation replaces or blends with whatever is coming through the graph at that Slot node's position.
A typical setup:
- State machine → Layered Blend Per Bone → output. The state machine drives locomotion.
- A "UpperBody" Slot node sits between the Layered Blend Per Bone node and the output. Upper-body Montages (reloads, gestures) inject here.
- A "FullBody" Slot node sits after everything else. Full-body Montages (death, hit reactions, finishers) inject at the very top.
The blend weight of the slot is controlled by the Montage's own blend in/out curves, so you get smooth transitions automatically.
Slot Groups
Slots are organized into Slot Groups. All slots in the same group cannot play simultaneously — only one Montage per group can play at a time. This prevents conflicts where two Montages both try to control the same bones. If you need to support simultaneous upper body and lower body Montages, put them in separate Slot Groups.
Layer Weight Blending in Unity
Unity's Animator Controller supports layer weight blending via the Animator.SetLayerWeight() API and the layer's built-in weight parameter. Each layer has a weight from 0 to 1 that you can drive at runtime.
Combined with Avatar Masks and blending modes (Override vs Additive), you get a flexible layering stack:
- Layer 0: Base locomotion, weight always 1, no mask
- Layer 1: Combat idle / upper body actions, weight driven by IsInCombat boolean, Avatar Mask = upper body only, mode = Override
- Layer 2: Aim offset, weight driven by IsAiming, Avatar Mask = spine + arms, mode = Additive
- Layer 3: Breathing, weight always 1, Avatar Mask = chest + spine, mode = Additive
- Layer 4: Facial expressions, weight driven by emotion state, Avatar Mask = head + neck, mode = Override
- Layer 5: Damage/pain, weight driven by Health, Avatar Mask = full body, mode = Override, transitions back to 0 after hit
SetLayerWeight() lets you smoothly ramp layers in and out from gameplay code without needing Animator.CrossFade() calls everywhere.
Additive Animation for Breathing on Top of Locomotion
This is the canonical additive use case. Here's the setup:
- Capture or hand-animate a breathing cycle from a neutral idle reference pose. The animation should loop cleanly (typically 2–4 seconds per breath).
- In your engine, configure this animation as an additive pose relative to the reference pose (T-pose or the same idle that is your reference frame).
- Place it in a layer above locomotion, with mode set to Additive and blend weight typically in the range 0.5–1.0.
- At runtime, scale the weight based on exertion: after sprinting, crank it toward 1.0 (heavy breathing). During a slow walk, drop it toward 0.3 (calm breathing).
Because the layer is additive, the breathing motion adds on top of whatever the locomotion layer is doing. The character breathes whether they're walking, running, crouching, or standing still.
Aim Overlay on Combat Idle
The aim overlay pattern is another foundational layering technique. The character has a base combat idle that loops (weight shifting, weapon ready, scanning). On top of that, an additive aim offset rotates the spine and arms to point the weapon toward the crosshair target.
Aim offsets are typically stored as a 2D blend space (horizontal angle × vertical angle), with each point in the blend space being an additive delta from the reference idle. As the player moves their crosshair, the blend coordinates update in real time, and the spine/arm rotation blends smoothly to track the target.
The aim overlay layer targets only the spine and arm bones (via bone mask), leaving the legs free to continue locomotion and foot IK corrections uninterrupted.
Facial Layer on Top of Body
Facial animation in games often runs in its own layer, entirely separate from body animation. The facial layer drives blendshapes (morphs) or face bones (jaw, eyelids, brows, cheeks) to express emotion, sync lip movement to audio, and react to gameplay events (wince when hit, grimace when exhausted).
Common facial layer structure:
- Lip sync sublayer: driven by audio phoneme analysis or hand-keyed to dialogue
- Emotion sublayer: blends between expression presets (neutral, happy, angry, fearful)
- Blink sublayer: procedural random blink with occasional double-blink
- Eye look sublayer: procedural eye targeting to track nearest point of interest
These sublayers are stacked within the facial system and the combined result drives the face bones, which are then in a bone-masked layer above the body animation.
Damage/Pain Layer on Top of Everything
Hit reactions and pain responses need to temporarily override all other layers to convey immediate feedback. This is achieved with a high-priority override layer.
When a character takes damage, a Montage or one-shot animation plays in the top-most slot. It blends in quickly (0.05–0.1 seconds), plays for its duration (typically 0.2–0.5 seconds), then blends back out as the underlying locomotion and combat layers resume.
The key design decision: should the hit reaction be full-body override, or upper-body only? A light hit from a bullet might only affect the upper body (the character stumbles their torso briefly but keeps their footwork). A heavy knockdown must be full-body. Most games implement both: a light hit montage with an upper-body bone mask, and a heavy hit montage as full-body override.
Order of Operations: What Goes on Top?
A typical production-quality layer stack, ordered from bottom (lowest priority) to top (highest priority):
- Locomotion / State Machine — base movement: walk, run, crouch, jump
- Combat Idle / Stance — readiness pose based on equipped weapon and combat state
- Breathing / Fatigue Additive — continuous ambient motion, additive
- Aim Offset — weapon direction tracking, additive on spine/arms
- Upper Body Actions — reload, equip, gesture (override, upper body bone mask)
- Facial Animation — emotion, lip sync, blink (override, face bone mask)
- Hit Reactions / Pain — damage response (override, may be full body)
- Cinematic / Full Body Override — cutscenes, scripted sequences
The general principle: higher-priority layers are placed higher in the stack, and they can be override (for complete control) or additive (for subtle modification). A layer should only be as high in the stack as it needs to be. Putting hit reactions below locomotion means the player never sees them. Putting locomotion above cinematics breaks cutscenes.
Performance: More Layers = More Cost
Animation layering is not free. Each layer that evaluates animation data costs CPU time to sample and blend. Key performance considerations:
Evaluation Cost
Every layer with a non-zero weight evaluates its animation (sampling the curve data at the current time). If your character has 15 layers and all 15 are at non-zero weight, all 15 are being sampled every frame. Layers at zero weight typically skip evaluation (most engines do lazy evaluation), so transition layers that are not currently in use are essentially free.
Bone Count
The cost of blending is proportional to the number of bones being blended. A full-body layer on a 250-bone skeleton costs more than an upper-body layer on 80 bones. Using appropriately tight bone masks reduces the blend cost for layers that only affect a small portion of the skeleton.
Additive Layer Cost
Additive layers require an extra subtraction step (base pose → reference pose) before the blend. For simple additive layers with small bone masks (breathing on 5 spine bones), this is negligible. For full-body additive layers on complex skeletons, the cost adds up.
Practical Budget
For a AAA character on current hardware, a budget of 6–10 active layers is reasonable. For a mobile game, aim for 3–5. Profile early and often — the Animation budget on your target hardware determines how deep your stack can be.
LOD-Based Layer Disabling
A common optimization: disable expensive layers (facial, additive breathing, per-bone aim) when the character is far from the camera. At LOD2 and beyond, the character is a small blip on screen — the breathing additive is invisible, so skip evaluating it entirely.
Frequently Asked Questions
What's the difference between an animation layer and an animation blend tree?
A blend tree selects and blends between animations within a single layer — like smoothly transitioning between a walk and a run based on speed. Layers stack vertically, with each layer operating on the output of the layers below it. Blend trees work horizontally within a layer; the layer stack works vertically across multiple animation systems.
Can I have too many additive layers?
Yes. Each additive layer costs CPU to evaluate and blend. More importantly, multiple additive layers can interact in unexpected ways — if your breathing, lean, and aim offset all add rotation to the same spine bones, the cumulative result can push the spine into an unnatural extreme. Audit your additive layers for bone overlap and make sure the combined effect is still within the character's range of motion.
Should upper body reloads be additive or override?
Almost always override. The reload animation needs to precisely control the hands, wrists, and arms — an additive reload would add the reload delta on top of whatever the base layer is doing, which might be a combat crouch or a turn. The hand positions would be wrong. Use an override layer with an upper-body bone mask.
How do I handle the pelvis transition between upper and lower body layers?
The pelvis (or hip bone) is typically shared between upper and lower body systems. If your upper body layer moves the pelvis (as many aim animations do), it will fight with the lower body's pelvis movement from locomotion. The standard solution is to set the bone mask split at spine_01 (above the pelvis) and let the pelvis be driven entirely by the lower body locomotion layer. Aim offsets should not translate or rotate the pelvis — they should affect only the spine and above.
Can I use animation layers for procedural motion (IK, look-at)?
Yes — procedural systems like foot IK and look-at constraints are often implemented as the highest-priority layers in the stack. The underlying animation layers provide the base pose, and the procedural layer makes final corrections (pinning feet to the ground, rotating the head toward a target). This is standard architecture in both Unreal's Animation Blueprint and Unity's Playable API.
Conclusion
Animation layers transform a flat, combinatorially explosive animation problem into a clean, maintainable stack of composable systems. Whether you're layering breathing on top of locomotion, overlaying an aim offset on combat idle, or slamming a full-body hit reaction on top of everything — understanding additive vs override modes, bone masks, and the order of operations gives you full creative control over your characters.
The best layer stacks are invisible to players. They just see a character who breathes, aims, reacts to damage, and transitions smoothly between states — all simultaneously, all feeling natural.
Ready to fill your animation layers with high-quality motion capture data? Browse our complete animation library at MoCap Online — professional motion capture packs for Unreal Engine, Unity, Blender, and more.