Character Rigging for Games: Skeleton Setup, Skinning, and Animation-Ready Rigs

Character Rigging for Game Development

Character rigging is the process of creating the underlying skeletal structure that drives a 3D character model. The rig is the framework that animation data attaches to — whether that animation is hand-keyed, procedurally generated, or sourced from a professional motion capture library. Without a properly built rig, even the highest-quality animation data produces broken or distorted results.

For game developers, character rigging has specific requirements that differ from film and VFX rigging. A game character rig must be optimized for real-time performance, use bone naming conventions that game engines can read, and follow joint hierarchy structures compatible with retargeting and animation blending systems. This guide covers the essentials: skeleton setup, skinning, naming conventions, and making a rig ready for mocap animation imports.

Character rigging for game dev requires balancing skeleton complexity with runtime performance budgets.

What you'll learn: How a game character rig is structured, bone naming conventions for UE5 and Unity, how to do skinning in Blender, how to prepare a character rig for motion capture, and the difference between control rigs and game rigs.

What a Game Character Rig Consists Of

A game character rig has two main components:

The Skeleton (Bone Hierarchy)

A hierarchy of bones that defines the character's anatomy. Each bone has a position (where in 3D space it sits), a rotation (which way it points), and a parent (the bone it's attached to in the hierarchy).

The hierarchy flows from the root bone (typically at the pelvis or at world origin) downward through the spine and outward through the limbs. Rotations are relative to the parent — when the upper arm rotates, the forearm, hand, and fingers all move with it because they're children in the hierarchy.

Standard humanoid hierarchy for a game character rig:

Root → Pelvis → Spine_01 → Spine_02 → Spine_03 → Clavicle_L → UpperArm_L → LowerArm_L → Hand_L → Fingers / Clavicle_R (mirror) / Neck → Head / Thigh_L → Calf_L → Foot_L → Ball_L / Thigh_R (mirror)

The Skin Weights (Skinning)

The skin weight data defines which bones influence which vertices of the character's mesh, and by how much. A vertex at the elbow joint is typically influenced by both the upper arm bone and the lower arm bone — the weight split determines how the mesh deforms when those bones rotate.

Good skinning is what makes a character look natural when animated. Poor skinning causes "candy wrapper" twisting, mesh collapsing at joint bends, and sharp creases rather than organic deformation.

Bone Naming Conventions for Game Engines

Game engines use bone names to map animation data to character skeletons. If your bone names don't match the conventions, animation retargeting and engine-native features (like UE5's IK Retargeter auto-mapping) require extensive manual configuration. Getting naming right during character rigging saves significant time downstream.

Character Rig for Unreal Engine

The character rig unreal engine uses — the UE5 Mannequin skeleton — follows this naming convention (partial list):

The _l / _r suffix convention (lowercase) is important — mismatched capitalization ("UpperArm_L" vs "upperarm_l") can prevent auto-mapping in some tools. When building a character rig for Unreal Engine, using Mannequin-compatible bone names gives you immediate compatibility with UE5's IK Retargeter, Control Rig templates, and professional animation packs like MoCap Online's library.

Unity Humanoid Avatar Naming

Unity's Humanoid avatar system uses its own internal mapping. The system tries to auto-detect bones from common name patterns. Bones named with "Hip", "Spine", "Chest", "UpperArm", "Forearm", "Hand", "Thigh", "Leg", "Foot" (and their common variants) are typically auto-detected.

Unity is more forgiving than UE5 about non-standard names — its Humanoid mapper attempts to find the bones regardless of exact naming, with manual override available. However, standard naming makes the Configure Avatar step trivial.

Mixamo Naming

Mixamo uses its own naming: "mixamorig:Hips", "mixamorig:LeftUpLeg", "mixamorig:LeftLeg", etc. This is why Mixamo FBX files require a specific retargeting step for UE5 — the bone names don't match the Mannequin convention at all.

Building a Game Character Rig in Blender

Blender's native rigging toolset is sufficient for building game-ready character rigs. The character rigging workflow in Blender covers both skeleton setup and skinning.

Setting Up the Armature

In Object Mode, Add → Armature to create the first bone. Enter Edit Mode and extrude bones to build the hierarchy. Use Alt+P to set parent relationships and Ctrl+P for Keep Offset parenting. Mirror the limb bones: select spine and left-side bones, Armature → Symmetrize to generate the right side automatically.

Rest pose: The rest pose should match the animation format you plan to import. UE5 animations use an A-pose rest position (arms at ~45° from horizontal). If your rig uses a T-pose, importing A-pose animations will have arm offsets.

Bone roll: Each bone has a "roll" — a rotation around the bone's long axis that determines which way "up" and "forward" point. Consistent bone roll across the hierarchy prevents unexpected rotation behavior. In Blender, select all bones in Edit Mode and Ctrl+N → "Recalculate Roll" to normalize.

Skinning Character in Blender

Skinning character in Blender uses the Weight Paint workflow:

1. Select the mesh, then shift-click the armature, then Ctrl+P → With Automatic Weights
2. Blender calculates initial skin weights based on bone proximity — these are a starting point, not a finished result
3. Select the mesh alone, enter Weight Paint mode
4. Use the gradient and blur brushes to refine weights at joints: elbow, knee, shoulder, hip, and wrist are the joints that need the most manual attention
5. Check your weights at extremes: full rotation at each joint should produce natural deformation, not collapse or intersect

Skinning character in Blender requires patience at these key joints:

• At a joint, the transition from 100% parent to 100% child should happen over 2–4 finger-widths of mesh distance
• No vertex should have a single-bone weight of 1.0 exactly at a joint — always a blend
• Spine vertices should blend between adjacent spine bones

Preparing a Game Character Rig for Motion Capture

When importing motion capture animations onto a custom game character rig, a few rig properties affect how well the import works.

Rest pose alignment: The game character rig's rest pose should match the rest pose of the animation data. MoCap Online animations use an A-pose rest position. If your rig is in T-pose, arm animations will offset by ~45°. Either adjust your rig to use A-pose, or apply a post-retarget pose correction in your retargeting tool.

Bone orientation consistency: All bones in the same chain should have the same primary and secondary axis orientation. Inconsistencies cause the retargeter to apply rotations in unexpected axes.

No non-uniform scaling: Bones should not have non-uniform scale applied. Non-uniform scale on a bone changes how rotation is expressed and causes deformation errors when animation data is applied.

Uniform root bone position: The root bone should sit at world origin (0, 0, 0) in the rest pose. Offset root positions cause positional errors when root motion is applied from animation data.

Control Rigs vs. Game Rigs

A distinction worth understanding: the rig animators use to animate a character is often different from the rig the game engine uses to play back the animation.

Control rig: Complex, animator-friendly rig with IK handles, custom controllers, and constraints. Used in Maya, Blender, or 3ds Max to author animation. Not suitable for real-time use.

Game rig (deformer rig): Simple, performance-optimized skeleton. Only deformation bones — no IK controls, no custom handles. This is what the rig for game engine playback actually uses.

In a production pipeline: the animator works with the control rig to author animation, the animation is baked from control rig to game rig (bake to deformation bones), and the baked game rig FBX is exported to the engine.

For developers using motion capture libraries, this process is already done — MoCap Online FBX files are already baked to deformation bone rigs. Import directly to your engine skeleton.

Character Rigging Checklist: Before You Import Animation

Before importing motion capture onto your game character rig, verify:

• Rest pose matches the animation source (A-pose for MoCap Online data)
• Bone names follow your target engine convention (Mannequin naming for UE5)
• No non-uniform scale on any bone
• Root bone at world origin (0, 0, 0)
• Skin weights painted and verified at all major joints
• IK Retarget asset created mapping your skeleton to the source skeleton

This checklist catches 90% of character rigging problems before they become animation pipeline problems.

FAQ: Character Rigging

How many bones should a game character have?
A standard humanoid game character rig uses 50–80 bones for the body (without fingers). With fingers, 100–120. Facial bones and blend shapes add another 30–80 depending on the expression range needed. More bones means better deformation but higher runtime cost.

Should I use IK or FK for my game character rig?
Game engine playback uses FK (Forward Kinematics) from baked animation data. IK is applied procedurally at runtime for foot planting, hand placement, and look-at behaviors layered on top of the FK animation. Your export rig should be FK-only; IK is added in the engine as a runtime layer.

How do I import a MoCap Online animation onto my custom character rig?
Import the FBX animation into UE5 with your character's skeleton selected in the FBX import dialog. If bone names don't auto-map, create an IK Retargeter mapping from the MoCap Online skeleton to your skeleton. In Unity, set Animation Type to Humanoid and verify the avatar bone mapping. The free animation pack is a good test set for verifying your rig setup before committing to full packs.

What causes "candy wrapper" twisting on forearm rotations?
The forearm needs two-bone twist distribution — twist joints between the elbow and wrist distribute the rotation to avoid candy-wrapper deformation. If your game character rig lacks twist bones on the forearm, 180° rotation will cause the mesh to collapse. Add 1–3 twist bones between the elbow and wrist and weight the mesh accordingly.

How is skinning character in Blender different from Maya?
The workflow is conceptually identical — both use weight painting to define bone influence per vertex. Blender's Weight Paint mode and Maya's Component Editor handle the same task. Maya offers more robust tools for skin weight copying, mirroring, and normalization at a professional scale, while skinning character in Blender is fully capable for indie and mid-size production rigs.

What's the difference between a character rig for Unreal Engine vs Unity?
The main differences are bone naming convention and avatar setup. A character rig for Unreal Engine benefits from matching the Mannequin naming (lowercase _l/_r suffixes) for IK Retargeter auto-mapping. Unity's Humanoid system is more tolerant of custom naming — it attempts auto-detection and provides a manual Configure Avatar step as a fallback. Both engines use FBX as the exchange format for the rig and animation data.

Animation That Works With Your Rig

Getting your character rigging right is the foundation for everything that follows — animation, retargeting, and real-time performance. Once your game character rig is properly set up, professional motion capture animation integrates cleanly.

Browse the MoCap Online motion capture animation library for packs designed to work with standard game character rigs in UE5 and Unity. The free animation pack gives you real mocap data to test your rig and skinning setup against before committing to a full production set. Engine-specific tutorials and workflow guides are available on the animation blog.