🧍 Characters & Animation

From Static Mesh to Skeletal Mesh

A Static Mesh is a single rigid shape. You can move, rotate, and scale the whole thing as one piece, but you cannot bend it. That is perfect for a crate, a wall, or a rock, and it is most of what fills a level. A character is different. An arm has to swing while the torso stays put; fingers curl independently of the wrist. For that you need a mesh whose parts can move relative to each other, and that is exactly what a Skeletal Mesh is.

Think of it the way your own body works. Your skeleton is a frame of bones connected at joints. Your skin is painted onto that frame so that when your elbow bends, the skin of your forearm comes along for the ride. A Skeletal Mesh is the same arrangement, built for a computer: bones you can rotate, and a surface weighted to follow them.

Where characters come from

Most characters are not modeled inside Unreal. They are built in a dedicated character tool and imported. In a full Story-to-Screen pipeline, a figure is assembled in Daz Studio, cleaned up and rigged in Blender, and then handed to Unreal as a Skeletal Mesh. The character below, "Kat," is a real Daz Genesis figure sitting in Blender, fully textured and posed, one export away from becoming an Unreal Skeletal Mesh.

Figure: "Kat for Genesis 9," a finished Daz character in Blender, textured and posed. This is the upstream end of the pipeline · the same figure becomes a Skeletal Mesh once it is exported into Unreal.

The moment that character arrives in Unreal it becomes three linked assets: a Skeletal Mesh, a Skeleton it is bound to, and usually a Physics Asset for collision. The import itself is the same FBX workflow you already used for static meshes in Lesson 2.4, with one crucial difference: you import it as a Skeletal Mesh, which tells Unreal to keep the bones and skin weights instead of flattening everything into one rigid shape.

flowchart LR
    A[Daz Studio
assemble figure] --> B[Blender
clean, shade, rig]
    B --> C[Unreal
Skeletal Mesh
+ Skeleton]
    C --> D[Add sockets
attach props]
    C --> E[Play & retarget
animation]
    E --> F[Sequencer
& render]
    style C fill:#e8f5e9,stroke:#4CAF50
                    

The Skeleton and Its Bone Hierarchy

The Skeleton is the heart of a character. It is a separate asset from the mesh, and it holds the bone hierarchy: an ordered tree of bones, each one parented to another. When a parent bone rotates, every bone below it in the tree moves too. Rotate the upper arm and the forearm, hand, and fingers all follow, exactly as they do on a real body.

Open a Skeletal Mesh and Unreal shows you the character in a reference pose alongside its Skeleton Tree. Here is the real "Kat" figure after import, now the Skeletal Mesh SK_Anya in Unreal, with its bone tree on the right and its material slots below:

Figure: The same Daz character as an Unreal Skeletal Mesh (SK_Anya). The Skeleton Tree on the right is the real bone hierarchy; the root bone is even named Kat-for-Genesis-9. Note the count: ~992k vertices and 34 material slots · a production character carries far more than a game prop.

Look closely at the bone names in that tree: hip, pelvis, l_thigh, l_shin, l_foot. Those are Daz-style names, carried over from the character's origin. Hold that thought, because Unreal's own mannequin names its bones completely differently, and that difference is the whole reason retargeting exists (Section 5).

One canonical Skeleton, reused

A Skeleton is meant to be shared. Many meshes can bind to the same Skeleton asset, and every Animation Sequence is authored for a specific Skeleton. This is the single most important habit in character setup: pick one canonical Skeleton per character type and reuse it. Do that and a socket you add once, or an animation you make once, applies to everyone on that Skeleton. Let each import mint its own brand-new Skeleton instead and nothing is shared, so sockets and animation cannot travel between characters.

Bones are also where you read a character's complexity. A simple game character might have 60 to 90 bones. The Kat figure above carries a full facial rig (jaw, tongue, eyelids, brows, lip corners) and even hair-braid bones, on top of the usual arms, spine, and legs, which is why film-grade Daz characters have hundreds of bones and close to a million vertices where a mannequin has a fraction of that.

Sockets: Attach Points for Props

A character rarely acts alone. They hold a sword, carry a torch, wear a backpack, trail a spell effect from one hand. You could try to place those props by hand every frame, but the hand is moving, so the prop would drift instantly. The answer is a socket: a named attach point parented to a bone. Because the socket rides the bone, anything attached to it follows the animation automatically.

You add a socket in the Skeleton or Skeletal Mesh editor: right-click the target bone, choose Add Socket, name it, and nudge its transform so an attached prop sits correctly in the grip. Unreal's own mannequin, for instance, ships with sockets already in place, including weapon_r_muzzle on the gun bone and foot sockets for effects. A weapon socket on the right hand looks like this:

Figure: A socket named prop_r parented to the hand_r bone. Attach a Static Mesh to that socket by name and it inherits the hand's motion automatically. (Adding exactly this socket to the Kat character's r_hand bone is a one-line operation in Unreal.)

Playing Animation: Sequences and Anim Blueprints

A Skeleton can hold a pose, but motion comes from animation data. In Unreal that data lives in a few asset types, and they all reference a Skeleton.

You can preview any Animation Sequence right in the animation editor: open the clip and the character performs it on a loop. That is enough to check a walk cycle or an idle. But a game character needs to choose its animation based on what is happening, and that decision-making is the job of the Anim Blueprint.

The Anim Blueprint: a state machine for motion

An Anim Blueprint has two halves. The Event Graph reads game state (speed, is-falling, is-crouched) into variables, using the same Blueprint skills from Module 5. The Anim Graph then uses those variables to blend poses, most often through a state machine: named states like Idle, Walk, Run, and Jump, with transition rules between them.

stateDiagram-v2
    [*] --> Idle
    Idle --> Walk: Speed > 0
    Walk --> Idle: Speed = 0
    Walk --> Run: Speed > 350
    Run --> Walk: Speed < 350
    Idle --> Jump: IsFalling
    Walk --> Jump: IsFalling
    Run --> Jump: IsFalling
    Jump --> Idle: Landed
                    

You do not have to author every clip yourself. Marketplaces like Fab, and free libraries such as Mixamo or Epic's own animation packs, give you thousands of ready-made sequences. There is only one catch, and it is a big one: those clips were made for their skeleton, not yours. Which brings us to the most valuable idea in the lesson.

Retargeting Animation Across Skeletons

Here is the problem, made concrete with two real characters in one project. The Kat figure (SK_Anya) came from Daz, so its bones use Daz names on its own Skeleton, SK_Anya_Skeleton. Unreal's standard mannequin (SK_Manny) uses Epic's names on a different Skeleton, SK_Mannequin. The same body part has a different name on each:

Figure: The real bone names from both characters in this project. Every row is the same body part under a different name. An animation authored for one Skeleton references names the other simply does not have · so it cannot be applied directly.

If you drop a mannequin walk animation onto Kat, Unreal looks for a bone called hand_l, finds only l_hand, and the motion falls apart. The bones also sit at different proportions: Kat is a different height and build than the mannequin, so even matching names would not place the limbs correctly. This is not a bug. It is the fundamental reason a whole retargeting system exists.

How the IK Rig and IK Retargeter work together

The system works in two steps. First you build an IK Rig for each character. An IK Rig marks up a Skeleton with retarget chains: "these bones are the left arm," "these are the spine," and so on. It is where the machine learns that Kat's l_upperarm → l_forearm → l_hand is the same limb as the mannequin's upperarm_l → lowerarm_l → hand_l.

Then an IK Retargeter connects a source IK Rig to a target IK Rig and maps chain to chain. Point it at any animation on the source Skeleton and it produces a matching animation on the target, respecting the target's proportions. Do this once per character pair and your entire animation library becomes available to that character.

flowchart LR
    A[Mannequin walk
Animation Sequence] --> B[IK Retargeter]
    R1[IK Rig: Mannequin
source chains] --> B
    R2[IK Rig: Kat
target chains] --> B
    B --> C[Kat walk
retargeted animation]
    style B fill:#fff3cd,stroke:#ffc107
    style C fill:#e8f5e9,stroke:#4CAF50
                    

Hands-On: Explore a Character

You do not need a custom character to practice any of this. Every Unreal project can add Epic's mannequins, which come as ready Skeletal Meshes with a full Skeleton, sockets, and an IK Rig already set up. Work through these steps and you will have touched every idea in the lesson.

Knowledge Check

Summary

You crossed the line from static props into moving characters. Here is the arc:

Skeletal Mesh. A character is a mesh plus a Skeleton plus skin weights. Bones move, and the weighted skin follows. Most characters are built elsewhere (like the Daz-to-Blender figure you saw) and imported as Skeletal Meshes.

Skeleton and sockets. The Skeleton is a shared, reusable bone hierarchy. Keep one canonical Skeleton per character type. Add sockets to bones as named attach points, and props ride the animation for free.

Animation and retargeting. Animation Sequences hold motion; Anim Blueprints decide which motion plays through state machines. And because every clip belongs to a specific Skeleton, retargeting (via IK Rigs and an IK Retargeter) is what lets one animation library drive characters from any source.

Where this goes next

Your character can now move and carry props. The next lesson, Cinematics with Sequencer, puts that character on a stage: you will place it in a shot, drive a cine camera, and choreograph the scene on a timeline. From there, Rendering Output turns the finished shot into final frames with the Movie Render Queue. Together these three lessons are the Unreal half of the Story-to-Screen pipeline.