How to Retarget Any Animation in Unreal Engine: Mixamo, CC3, Daz3D, and Metahuman Workflow Guide

Retargeting animations in UE5 allows reusing animations across different skeletons, like a Mixamo dance on a MetaHuman. UE5.3+ uses the IK Rig and IK Retargeter system to simplify this for varied skeletons. The guide covers workflows for Mixamo, CC3/CC4, Daz3D, and MetaHumans, including basic setup, advanced techniques (e.g., Control Rig blending, custom PixelHair on MetaHumans), instructions, best practices, tables, and troubleshooting, suitable for beginners and advanced users.

How do I retarget animations in Unreal Engine 5?

Retargeting in UE5 uses the IK Rig and IK Retargeter system to adapt animations from one character’s skeleton to another, even if they differ in bone structure or orientation, preserving key contacts like feet and hands via inverse kinematics. This allows animation sharing between diverse characters (e.g., Mixamo rig to MetaHuman).

Key Components:

• IK Rig Asset: Defines a skeleton’s retargeting “chains” (bone groups) and optional IK goals (e.g., hand/foot effectors). One is created for the source skeleton (original animation) and one for the target skeleton (new character).
• IK Retargeter Asset: Links source and target IK Rigs, mapping bone chains to transfer or preview animations, with tools to adjust poses and root motion.

Workflow:

1. Import source animation and skeleton (e.g., Mixamo FBX or CC3 character) into UE5.
2. Create IK Rigs for source and target skeletons, defining Retarget Chains (spine, arms, legs, etc.).
3. (Optional) Add IK Goals (e.g., foot effectors) in IK Rigs for precise contact handling.
4. Create an IK Retargeter, selecting the source IK Rig, then assign the target IK Rig in the editor.
5. Map chains in the IK Retargeter and adjust retarget poses (e.g., A-pose to T-pose) if skeletons differ.
6. Preview animations in the IK Retargeter, then export as a new Animation Sequence for the target skeleton.

The exported animation can be used in Animation Blueprints or Sequencer like any other asset. Retargeting involves defining IK Rigs, linking them via the IK Retargeter, tweaking offsets, and exporting the result.

What is the IK Retargeter in Unreal Engine and how does it work?

The IK Retargeter in UE5 transfers animation data between skeletons using IK Rigs. It employs:

• Chain-Based Mapping: Maps sequences of bones (e.g., spine chains) instead of individual bones, allowing flexibility for skeletons with different bone counts (e.g., 3 spine bones to 5).
• IK Solvers for End-Effectors: Uses inverse kinematics to maintain contacts (e.g., feet on ground) by setting IK goals for chains like hands or feet, adjusting motion to prevent sliding.
• Retarget Poses: Adjusts base poses (e.g., A-pose vs. T-pose) for proper animation alignment, with options to save, reuse, or import poses.
• Root Motion and Scaling Options: Adjusts root movement and scale (e.g., small vs. tall characters) with modes like “Globally Scaled” and vertical/horizontal tweaks for natural spacing.
• Auto-Setup in UE5.4+: Offers one-click auto-retargeting for similar skeletons (e.g., Mixamo to UE5 Manny), though manual knowledge remains key for precision.

The IK Retargeter excels at bridging rigs with differing structures (e.g., MetaHumans vs. Daz3D), ensuring accurate motion transfer.

What’s the process of setting up a target and source rig in Unreal Engine?

Here’s a summarized and shortened version of the text, preserving all key details and structure:

1. Import Characters/Skeletons: Import source (e.g., Mixamo Y Bot) and target (e.g., MetaHuman) as Skeletal Meshes with skeletons into UE5. For MetaHuman, download via Quixel Bridge.
2. Create IK Rig for Source: In Content Browser, Add > Animation > IK Rig, select source Skeletal Mesh (e.g., YBot_SK). Define Retarget Chains:
   • Spine: pelvis to last spine bone before neck.
   • Left Arm: left clavicle to hand.
   • Right Arm: same for right.
   • Left Leg: left thigh to foot (toe if present).
   • Right Leg: same for right.
   • Head: neck base to head.
   • Fingers: chain per finger or group hand bones.
   • Name chains clearly (e.g., “Arm_L”). Multi-select bones for chains. Skip twist bones if they follow parents.
3. (Optional) IK Goals on Source: Add IK goals (e.g., “Foot_L” for left foot, “Hand_R” for right hand) to preserve foot/hand placement.
4. Create IK Rig for Target: Repeat for target (e.g., MetaHuman Quinn). Define similar chains:
   • Group bones logically (e.g., MetaHuman spine_01-03 in one “Spine” chain or split upper/lower).
   • Match source chains (e.g., “Arm_L” for shoulder to hand). Add IK goals if used on source.
5. Create IK Retargeter: Right-click > Animation > IK Retargeter, select source IK Rig, then assign target IK Rig. Map target chains to source chains in Chain Mapping (e.g., “Spine” to “Spine”). Auto-Map may work if names match.
6. Adjust Retarget Pose: In Retarget Pose tab, align poses (e.g., raise MetaHuman A-pose arms to match Y Bot T-pose). Save pose for reuse.
7. Finalize Chain Settings (Optional): Configure chains (FK for rotations, IK for goals like feet/hands). Enable Retarget Root for root motion, FK for most chains, IK for end-position accuracy.
8. Test and Export: Select animation (e.g., Mixamo run), test on target. Adjust pose/chains if needed. Export via “Export Selected Animations” to save as new Animation Sequence for target.

Note: Set up IK Rigs and Retargeter once per source-target pair for reuse. For multiple sources to one target, create separate IK Rigs for each source, reuse target IK Rig, and make unique IK Retargeters per pair.Here’s a summarized and shortened version of the text, preserving all key details and structure:

1. Import Characters/Skeletons: Import source (e.g., Mixamo Y Bot) and target (e.g., MetaHuman) as Skeletal Meshes with skeletons into UE5. For MetaHuman, download via Quixel Bridge.
2. Create IK Rig for Source: In Content Browser, Add > Animation > IK Rig, select source Skeletal Mesh (e.g., YBot_SK). Define Retarget Chains:
   • Spine: pelvis to last spine bone before neck.
   • Left Arm: left clavicle to hand.
   • Right Arm: same for right.
   • Left Leg: left thigh to foot (toe if present).
   • Right Leg: same for right.
   • Head: neck base to head.
   • Fingers: chain per finger or group hand bones.
   • Name chains clearly (e.g., “Arm_L”). Multi-select bones for chains. Skip twist bones if they follow parents.
3. (Optional) IK Goals on Source: Add IK goals (e.g., “Foot_L” for left foot, “Hand_R” for right hand) to preserve foot/hand placement.
4. Create IK Rig for Target: Repeat for target (e.g., MetaHuman Quinn). Define similar chains:
   • Group bones logically (e.g., MetaHuman spine_01-03 in one “Spine” chain or split upper/lower).
   • Match source chains (e.g., “Arm_L” for shoulder to hand). Add IK goals if used on source.
5. Create IK Retargeter: Right-click > Animation > IK Retargeter, select source IK Rig, then assign target IK Rig. Map target chains to source chains in Chain Mapping (e.g., “Spine” to “Spine”). Auto-Map may work if names match.
6. Adjust Retarget Pose: In Retarget Pose tab, align poses (e.g., raise MetaHuman A-pose arms to match Y Bot T-pose). Save pose for reuse.
7. Finalize Chain Settings (Optional): Configure chains (FK for rotations, IK for goals like feet/hands). Enable Retarget Root for root motion, FK for most chains, IK for end-position accuracy.
8. Test and Export: Select animation (e.g., Mixamo run), test on target. Adjust pose/chains if needed. Export via “Export Selected Animations” to save as new Animation Sequence for target.

Note: Set up IK Rigs and Retargeter once per source-target pair for reuse. For multiple sources to one target, create separate IK Rigs for each source, reuse target IK Rig, and make unique IK Retargeters per pair.

How do I import Mixamo animations into Unreal Engine for retargeting?

Here’s a summarized and shortened version of the text with key details preserved, links removed, and numbering, list, and sub-lists retained:

Mixamo provides free character animations that can be imported into UE5 for retargeting. Here’s the process:

1. Download from Mixamo: Log into Mixamo.com, choose an animation, and match it to a character skeleton already in UE (e.g., Y Bot). You can upload your UE character to Mixamo for a perfect match or use a standard Mixamo character like Y Bot (most Mixamo humanoid skeletons share the same hierarchy).
   • Mixamo Download Settings: Select Download, set Format to FBX Binary, Frames per Second to 30, and Skin to “Without Skin” (for animation data and skeleton only, assuming the mesh is already imported). Leave pose at default (T-pose included if selected separately).
   • Save the FBX file.
2. Import the animation FBX to Unreal: In UE5, drag the FBX into a folder (e.g., Content/Mixamo) or use Add > Import. In the FBX Import Options:
   • Set the Skeleton to an existing Mixamo skeleton asset (e.g., YBot_Skeleton) to avoid creating a new skeleton.
   • Keep other settings default (imports as Animation since no mesh is included).
   • Click Import to create an Animation Sequence (e.g., “YBot@Running”).
   • Troubleshooting: If an error like “Mesh contains root bone but animation doesn’t” occurs, it’s due to a root bone mismatch. Fix by using a no-root skeleton, adding a dummy root to the FBX, or retargeting from a no-root to a rooted version. The Mixamo UE5 plugin can help.
3. Prepare the Mixamo skeleton for retargeting: Import a T-pose animation or character in bind pose from Mixamo using the same skeleton. Open the T-pose animation, save it as a pose asset if needed, and use it in the IK Retargeter. Ensure the skeleton’s retarget pose and orientation are correct (UE5 usually handles this, but adjust settings if the character faces the wrong way).

After this, you’ll have:

• A Mixamo Skeleton asset (e.g., YBot_Skeleton).
• A Skeletal Mesh (if imported).
• Several Animation Sequences on that skeleton.

Next, create IK Rigs for the Mixamo skeleton and target (e.g., MetaHuman) and use the IK Retargeter to transfer animations. Mixamo animations can be retargeted to MetaHumans or other UE5 characters, with the Mixamo-to-MetaHuman workflow covered later.

Can I retarget Mixamo animations to Metahuman characters in UE5?

You can retarget Mixamo animations to MetaHuman characters in UE5 using the IK Retargeter system. MetaHumans use the Unreal MetaHuman Base Skeleton, while Mixamo has its own 65-bone rig. IK retargeting maps these skeletons to reuse Mixamo animations on MetaHumans.

Workflow for Mixamo to MetaHuman retargeting:

• Import Mixamo animations and character (e.g., Y Bot) into UE5, alongside a MetaHuman (e.g., MetaHuman Quinn) with its skeleton (metahuman_base_skel).
• Create IK Rigs for Mixamo (source) and MetaHuman (target), setting up chains like:
  • Mixamo “Spine” (Hips -> Spine -> Spine1 -> Spine2) vs. MetaHuman “Spine” (pelvis -> spine_01 -> spine_02 -> spine_03).
  • Arms, legs, neck/head, and fingers if needed.
  • Add foot and hand IK goals for contact preservation.
• Use the IK Retargeter: Set Mixamo as source, MetaHuman as target, and map chains (e.g., MetaHuman “Leg_L” to Mixamo “LeftUpLeg”).
• Match poses: Adjust MetaHuman’s A-pose (arms at 45°) to Mixamo’s T-pose by editing the Retarget Pose, aligning arms and checking leg stance.
• Retarget and refine: Preview the animation, fixing issues like:
  • Raised shoulders (adjust clavicle rotation).
  • Sliding feet (enable IK goals).
  • Facial animations won’t transfer (Mixamo lacks them).
• Export the retargeted animation for the MetaHuman skeleton (e.g., “YBot_Dance_retarg->MetaHuman”).

The UE5 retargeter handles skeleton differences, enabling Mixamo’s animation library (dancing, fighting, etc.) for MetaHumans. For best results, some suggest using Mixamo’s “Passive Marker Man” character.

What bone mapping is needed to retarget Mixamo to Metahuman?

When retargeting from Mixamo to MetaHuman or UE5 skeletons using the IK Rig method, understanding bone mapping helps set up chains and troubleshoot, though manual mapping isn’t required. Key bone name differences between Mixamo and MetaHuman/UE5 Mannequin skeletons are:

• Mixamo lacks a root bone; “Hips” acts as the root, while MetaHuman has a root above “pelvis.” Root motion can be handled by the retargeter using “Hips” as the source.
• In IK Rig, assign bones to chains (e.g., Mixamo spine chain: Hips, Spine, Spine1, Spine2; MetaHuman: root, pelvis, spine_01 to spine_03). Pelvis can be separate or part of the spine chain.
• Mixamo bones may have a “mixamorig:” prefix, which UE might drop.
• MetaHuman includes twist bones (e.g., upperarm_twist), absent in Mixamo; these follow parent bone rotations and don’t need separate chains.
• Finger bones exist in both (Mixamo: Index1,2,3; MetaHuman: index_metacarpal, index_proximal, index_distal). One chain per hand (e.g., “LeftHandFingers”) works for gross motion; separate chains per finger offer finer control but require more setup.

The IK Retargeter handles differences if chains are logical. Tools like the Mixamo Animation Retargeting plugin automate mapping, or use the legacy Humanoid rig method for reference. Major bones (hips to pelvis, spine, limbs, head) must align for good results.

What are the common issues when retargeting Mixamo to Metahuman and how do I fix them?

Retargeting Mixamo characters to MetaHumans can present issues, causes, and fixes:

• Misaligned Shoulders/Arms: T-pose (Mixamo) vs. A-pose (MetaHuman) mismatch causes raised, lowered, or twisted arms/shoulders. Fix: Adjust retarget pose to match (e.g., apply T-pose to MetaHuman in IK Retargeter).
• Feet Sliding/Not Planted: Scale differences or lack of IK cause feet to slide or misalign. Fix: Enable foot IK goals, check “Retarget IK,” ensure “Retarget Root” for root motion, and verify “Target Actor Scale” (keep at 1.0, adjust root translation if needed).
• Root Motion/Rotation Issues: Mixamo lacks a separate root bone, causing odd movement or no turning. Fix: Map root in Chain Mapping (often “Hips”), enable “Retarget Root,” and tweak root rotation mode (e.g., Copy or Blend).
• Spine/Posture Issues: Differing spine bone counts (Mixamo: 3, MetaHuman: 4) alter posture. Fix: Adjust spine chain in IK Retargeter, spread motion, or tweak pose/rotation.
• Neck/Head Orientation: Pose or skeleton differences shift gaze. Fix: Adjust neck/head pose in retargeter or split into separate chains for fine-tuning.
• Finger Alignment: Pose or mapping issues twist fingers. Fix: Match thumb/hand pose (e.g., use Mixamo T-pose), adjust roll in skeleton if needed.
• Animation Not Playing/Exploding: Incorrect chain mapping or skeleton target causes mesh issues. Fix: Ensure all major chains (e.g., pelvis) are mapped and target skeleton is correct.
• Minor Foot Sink/Offset: Leg length differences offset feet. Fix: Use “Target Actor Offset” in retargeter or add IK foot placement/adjust animation root.

Most issues (arms/feet) are fixed by matching poses and using IK. Root and scaling problems are resolved via retargeter settings. Iterative tweaking may be needed, but settings can be reused once optimized.

What’s the best way to retarget CC3 animations in Unreal Engine?

Reallusion’s Character Creator 3 (CC3) and Character Creator 4 (CC4) characters can be retargeted in Unreal Engine (UE) for animation use, often with iClone. Here’s how:

1. Using Reallusion’s Auto Setup and Unreal’s Retargeter (Recommended):
   • Use Reallusion’s CC Auto-Setup plugin to import CC3/CC4 characters into Unreal with proper materials and skeleton settings.
   • Export CC3 characters via FBX (or CC4’s Send to Unreal) using the Unreal preset (A-pose matching UE4 Mannequin). CC3 Pipeline’s “Convert Bone Structure to Unreal” option aligns bones with UE’s mannequin for easier retargeting.
   • If converted, the CC3 skeleton may directly use UE mannequin animations in UE4; in UE5, use IK Rigs for one-to-one mapping.
   • If not converted, CC3’s default skeleton (e.g., “CC_Base_Hip”) requires IK Rig setup for retargeting to/from another skeleton (e.g., MetaHuman or UE mannequin).
   • Define IK chains, match poses (CC3’s A-pose aligns with UE’s), and retarget using UE5’s IK Retargeter, works for CC3 as source or target.
2. Using iClone Live Link or Exported Animations:
   • iClone Unreal Live Link streams animations from iClone to Unreal for real-time preview/recording on CC3 characters, with retargeting needed for other skeletons.
   • Export animations from iClone/CC3 as FBX, import into Unreal, and retarget to other characters (e.g., MetaHuman) if required.
   • Advanced users may bake animations onto Unreal’s Control Rig.

Tips for CC3 Retargeting:

• CC4’s “Humanoid” profile simplifies retargeting.
• Hide or adjust CC3’s extra IK bones if present; they typically don’t interfere.
• Exporting with “Convert to UE4 skeleton” allows direct use of UE4 Mannequin skeleton or easy IK Retargeter mapping in UE5.

Example: CC3 to MetaHuman:

• Import CC3 character and animation into UE5 with Auto Setup.
• Create IK Rigs for CC3 (source) and MetaHuman (target), map chains (e.g., “thigh_l” to “thigh_l”), adjust poses if needed (both use A-pose), and retarget.

This method leverages UE5’s IK Retargeter and Reallusion’s tools for compatibility, with the “Convert to Unreal skeleton” option simplifying the process by aligning CC3 with UE’s mannequin.

How do I transfer Daz3D animations to Metahuman in UE5?

Transferring animations from Daz3D characters to MetaHumans in UE5 is possible using retargeting with these steps:

1. Export from Daz3D:
   • Export the character and animation using the Daz to Unreal Bridge or FBX (File -> Export -> FBX, enable animation baking, use FBX 2014/2015).
   • Daz animations are typically on Genesis 8 or 3 rigs in A-pose.
2. Import into UE5:
   • Use DazToUnreal Bridge for the character (skeletal mesh and skeleton).
   • Import the FBX animation, assigning it to the Daz skeleton.
   • Ensure the character’s A-pose matches the imported pose.
3. Create IK Rigs:
   • Make IK Rigs for Daz (source) and MetaHuman (target) skeletons.
   • Map chains:
     • Spine: Daz hip -> abdomen -> chest to MetaHuman pelvis -> spine.
     • Limbs: Daz thigh -> shin -> foot to MetaHuman thigh -> calf -> foot.
     • Neck/Head: Daz neck -> head.
   • Include twist bones optionally; add IK goals for foot planting if needed.
4. Setup IK Retargeter:
   • Source: Daz IK Rig; Target: MetaHuman IK Rig.
   • Map chains (e.g., Daz “Leg_L” to MetaHuman “Leg_L”).
   • Adjust retarget pose to match Daz A-pose; use “Import Pose from Animation” if available.
5. Retarget Animation:
   • Preview and adjust for minor proportion differences (e.g., arm length).
   • Export the animation for MetaHuman.

Key Notes:

• Facial animations don’t transfer automatically (body only).
• Scale is similar between Genesis 8 and MetaHuman, minimizing issues.
• UE5’s retargeter supports custom skeletons like Genesis 8.
• Example: A fight animation may need minor tweaks (e.g., hand placement) post-retargeting.

This process reuses Daz animations efficiently on MetaHumans.

How do I convert Daz3D characters to work with UE5’s retargeting system?

To make a Daz3D character compatible with UE5’s retargeting, import it correctly and adjust its skeleton if needed. Here’s how:

• Use Daz To Unreal Bridge: Simplest method. Imports Genesis 3, 8, 8.1, or 9 into UE5 with a prepped skeleton for IK retargeting, including a retarget pose asset (e.g., A-pose for UE mannequin compatibility). Handles materials and JCMs too. UE5’s retargeter works well with Daz skeletons directly.
• Ensure Correct Pose: Without the bridge, manually import the Daz figure (default A-pose) via FBX. Apply a T-pose in Daz if matching UE mannequin exactly, though UE5’s retargeter doesn’t require it. Match imported pose to others.
• Root Bone and IK Bones: Daz skeletons (e.g., Genesis 8) use a hip root, have auxiliary bones (e.g., eye bones), and spaces in bone names (replaced by underscores in UE). Include these in IK chains. Adding a root bone or renaming is optional, not required.
• Retargeting Options: In the Skeleton Editor, set the “Humanoid” rig and map bones (e.g., hip to pelvis) if using the old retarget manager, though IK Rig doesn’t need this. Useful for spotting mis-mapped bones.
• Test Retargeting: Retarget a UE mannequin animation (e.g., Quinn’s idle) to the Daz character. Set Source = UE5 Manny/MetaHuman rig, Target = Daz IK Rig. Map chains, adjust pose, export animation, and tweak if needed (e.g., fix odd foot movement).
• Optional Bone Conversion: Advanced users can convert the Daz skeleton to UE’s in Blender (e.g., Auto-Rig Pro) for direct animation sharing, but UE5’s retargeter makes this unnecessary.

In short, import via the bridge (preferred), create an IK Rig, and use UE5’s retargeter. Daz characters (e.g., all Genesis 8 Females) share skeletons, so one IK Rig can be reused efficiently. Once set up, the character integrates with UE5’s animation ecosystem.To make a Daz3D character compatible with UE5’s retargeting, import it correctly and adjust its skeleton if needed. Here’s how:

• Use Daz To Unreal Bridge: Simplest method. Imports Genesis 3, 8, 8.1, or 9 into UE5 with a prepped skeleton for IK retargeting, including a retarget pose asset (e.g., A-pose for UE mannequin compatibility). Handles materials and JCMs too. UE5’s retargeter works well with Daz skeletons directly.
• Ensure Correct Pose: Without the bridge, manually import the Daz figure (default A-pose) via FBX. Apply a T-pose in Daz if matching UE mannequin exactly, though UE5’s retargeter doesn’t require it. Match imported pose to others.
• Root Bone and IK Bones: Daz skeletons (e.g., Genesis 8) use a hip root, have auxiliary bones (e.g., eye bones), and spaces in bone names (replaced by underscores in UE). Include these in IK chains. Adding a root bone or renaming is optional, not required.
• Retargeting Options: In the Skeleton Editor, set the “Humanoid” rig and map bones (e.g., hip to pelvis) if using the old retarget manager, though IK Rig doesn’t need this. Useful for spotting mis-mapped bones.
• Test Retargeting: Retarget a UE mannequin animation (e.g., Quinn’s idle) to the Daz character. Set Source = UE5 Manny/MetaHuman rig, Target = Daz IK Rig. Map chains, adjust pose, export animation, and tweak if needed (e.g., fix odd foot movement).
• Optional Bone Conversion: Advanced users can convert the Daz skeleton to UE’s in Blender (e.g., Auto-Rig Pro) for direct animation sharing, but UE5’s retargeter makes this unnecessary.

In short, import via the bridge (preferred), create an IK Rig, and use UE5’s retargeter. Daz characters (e.g., all Genesis 8 Females) share skeletons, so one IK Rig can be reused efficiently. Once set up, the character integrates with UE5’s animation ecosystem.

Is it possible to use one animation on both CC3 and Metahuman characters?

Yes, one animation can be used on both CC3 and MetaHuman characters through retargeting, allowing a single animation source to be shared across multiple character types. There are two scenarios:

1. Runtime Retargeting (Single Asset): UE5’s IK Retargeter can retarget an animation (e.g., from a CC3 skeleton) to a MetaHuman in real-time using Animation Blueprints. This keeps memory usage low and allows dynamic animation swapping, but requires IK rig setup. Most prefer offline retargeting instead.
2. Offline Retargeting (Separate Assets, Most Common): Using the IK Retargeter, an animation (e.g., from a UE Mannequin) is mapped to both CC3 and MetaHuman skeletons, creating two assets: one for CC3, one for MetaHuman. Both characters can then use these animations, which remain motion-identical if retargeted correctly.

For example, a Marketplace animation for the UE Mannequin can be retargeted to CC3 and MetaHuman skeletons, allowing both characters to use it with slight adaptations. Animations are bound to specific skeletons, so separate assets are needed unless CC3 and MetaHuman share a skeleton (they don’t by default). Retargeting is quick and efficient.

Use Cases:

• Share animations across multiple character types in a game without re-animating.
• Use CC3 for NPCs and MetaHumans for hero characters, retargeting animations between them.
• The IK system adjusts for differing proportions (e.g., tall CC3 vs. short MetaHuman), though slight differences like stride length may occur.

Retargeting ensures one animation can be created and reused across characters, maintaining quality and avoiding redundant work. The UE documentation supports this as a standard studio pipeline.

What’s the process of setting up a target and source rig in Unreal Engine?

1. Create IK Rig for source skeleton and define retarget chains.
2. Create IK Rig for target skeleton and define corresponding chains.
3. Create IK Retargeter asset, select source IK Rig, assign target IK Rig.
4. Map chains in the retargeter.
5. Adjust retarget poses for alignment.
6. Preview and export animation to target.

This outlines the essential IK Rig setup for retargeting in UE5, as detailed earlier in the “What’s the process of setting up a target and source rig in Unreal Engine?” section.

How do I clean up retargeted animations for smoother performance?

After retargeting an animation, you may need to fix issues or optimize it for production. “Cleaning up” involves addressing artifacts and enhancing performance:

1. Smoother Animation Quality (Cleanup):
   • Retargeted animations may show pops or jitter if skeletons differ. Use the Animation Editor to adjust curves/keys, smoothing problematic rotations (e.g., elbow pops) by tweaking tangents or removing outlier keys.
   • Apply Animation Modifiers or filters (e.g., “Smooth Rotation”) in the editor to reduce noisy motion.
   • Bake to a Control Rig in Sequencer (using a MetaHuman rig), edit controls (e.g., fix foot position or hand penetration), then bake back to an Animation Sequence for fine-tuned cleanup.
   • Ensure root motion consistency by checking or editing the root curve to avoid drift.
   • Use IK in AnimBlueprint (e.g., FullBody IK or TwoBone IK) as a runtime fix for foot sliding, locking feet to the ground.
2. Performance Optimization:
   • Remove unused bone tracks in the animation editor to streamline the asset.
   • Apply compression settings in Unreal Engine’s asset details to reduce memory and boost runtime performance.
   • Bake additive layers (e.g., from Control Rig fixes) into a single animation to avoid runtime layering costs.
   • For high-bone-count skeletons (e.g., MetaHuman face), disable motion on unused bones (e.g., facial ones) to save overhead.

Jitter may stem from bone alignment differences; use “Show Retargeting Debug” to spot and smooth twitching bones. Retargeting itself is cost-free at runtime if done offline, but runtime IK Retargeter use adds CPU cost, minimize it if needed. In summary, polish animation data with key edits or Control Rig, fix issues like sliding with IK, and optimize by removing excess data and compressing assets for smooth, production-ready results.

How can PixelHair be used to add custom hair to Metahuman characters animated through retargeted animations?

PixelHair is a product/technique for creating custom realistic hair, often made in Blender, attachable to MetaHumans in Unreal Engine. It enhances MetaHuman characters with unique hairstyles.

Here’s how to use PixelHair with a MetaHuman:

• Create or obtain a PixelHair hairstyle asset: PixelHair offers premade hairstyles (e.g., braids, buns, fades) created in Blender’s particle hair system, exportable as FBX, Alembic (groom), or UE assets.
• Import the hair into Unreal: Import as a Groom asset (Alembic curves for MetaHuman groom system) or static mesh with hair cards. Ensure it displays correctly (strands for Groom).
• Attach the hair to the MetaHuman: MetaHumans use a Blueprint with a hair slot (Groom component on head bone). To attach:
  • In the MetaHuman Blueprint, add a Groom Component, assign the PixelHair asset, parent it to the head bone, and remove/disable default hair.
  • At runtime, attach the hair asset to the MetaHuman skeletal mesh’s head bone via an AttachComponentToComponent node.
• Adjust position/scale: PixelHair includes a hair cap; use Blender’s shrinkwrap modifier to fit it, then tweak in Unreal if needed.
• Animated through retargeted animations: The hair, attached to the head bone, moves with retargeted animations (e.g., locomotion). For Groom assets:
  • It’s weighted to the head bone, following its movement.
  • Enable physics in the Groom settings for hair bounce, or disable for static hair.
• Why PixelHair? Offers unique hairstyles beyond MetaHuman Creator defaults, maintaining realism, compatible with any MetaHuman.
• Using PixelHair in a scene: With a retargeted animation (e.g., Mixamo dance), the MetaHuman moves with the new hair; hide default hair to avoid overlap.
• Consider LODs and Groom settings: Set up LODs for Groom assets or monitor performance due to high strand counts.

In summary, import and attach PixelHair to the MetaHuman’s head bone, replacing default hair. It moves with retargeted animations, combining MetaHuman fidelity, animation convenience, and custom hair creativity for cinematics or games. PixelHair is designed for any MetaHuman, adding flair easily.

Can I retarget animations between different body proportions?

Yes, UE5’s retargeting system retargets animations between characters with different body proportions, like a tall, lanky character and a short, stocky one, using the same animations. Key details:

• Uniform scaling of motion: The IK Retargeter scales movement based on size differences (e.g., a 20% shorter target moves 20% less in Globally Scaled mode) to keep strides proportional, preventing exaggerated leaps.
• IK adjustments for limb length: The IK solver adjusts limb positions (e.g., hands, feet) for differing proportions, like rotating chains for a shorter arm length, with optional pose tweaks or IK targets for precision.
• Examples of proportion differences:
  • Cartoonish long arms retargeted from a human: Motion works, though elbow bends may differ slightly.
  • Child vs. adult rig: Functional, but retarget pose may need tweaking for stance.
  • Non-humanoid (e.g., hunchback, alien legs): Manageable with proper chain setup.
• Root motion scaling options: Options include Globally Scaled (default), Absolute (unscaled, may over-extend smaller characters), or separate horizontal/vertical scaling for fine-tuning jumps vs. strides.
• Testing and tweaking:
  • Foot placement: Adjust “Target Actor Offset” if feet skate or miss the ground.
  • Arm reach: For imprecise contact (e.g., hands not touching), accept minor gaps or use IK/edit animation.
  • Exaggeration: Short limbs may seem “snappy”; smooth keys or use animation blueprint damping.
• One animation, many sizes: A single animation drives varied proportions well, like MetaHuman body types (tall, short, different weights), with Epic’s retargeter handling size differences automatically.
• Non-human proportions: Extreme differences (e.g., digitigrade legs vs. human) require more custom work, but standard humanoid variations are fully supported.

In summary, retargeting across body proportions is a core feature of the IK rig retargeter.

Can I retarget FBX animations to a Metahuman rig?

An “FBX animation” is an animation file or skeletal mesh importable into Unreal, usable with the IK Retargeter to transfer motion to a MetaHuman or any character if a Skeleton asset is obtained. For example, Mixamo FBX animations, as well as those from Maya, MotionBuilder, or other libraries, can be retargeted to MetaHumans. Import the FBX, assign or create a Skeleton asset, then set up IK Rigs for the source and MetaHuman skeletons. The IK Retargeter enables motion transfer, supporting any FBX animation, including mo-cap, across skeletons of varying sizes or naming once chains are defined.

What are the common issues when retargeting Mixamo to Metahuman and how do I fix them?

(This question was answered in detail earlier. See “What are the common issues when retargeting Mixamo to Metahuman and how do I fix them?” for full details on issues like pose mismatch, foot sliding, root rotations, and solutions.)

In short, common issues (like T-pose vs A-pose misalignment or missing root motion) are fixed by aligning reference poses【27†L19-L27】, using IK for feet/hands, and adjusting retargeter settings to resolve most Mixamo→MetaHuman retargeting problems.

How do I retarget facial animations between Daz3D and Metahuman?

Retargeting body animations between MetaHumans and Daz3D characters is simple, but facial animations are challenging due to differing facial rigs:

• MetaHumans use a blendshape-based system with Apple’s ARKit 52 morph targets and a facial control rig.
• Daz3D Genesis characters use facial bones (jaw, eyes) and numerous morphs (e.g., smile, frown, phonemes) with different names and structures from MetaHumans.

Unreal lacks an automated facial retargeter for mapping between these systems, but options exist:

• Using common morph targets: Export Daz animation curves (e.g., via FBX with “Export Morphs” enabled) and import them into Unreal tied to the Daz skeleton/mesh. Map these to MetaHuman morphs (e.g., “EyeBlinkLeft”) by creating a custom name mapping, possibly in an Animation Blueprint.
• Via Live Link or performance capture: Re-capture the original Daz performance for MetaHuman using tools like Live Link Face (iPhone) or Faceware, or manually match simple expressions at keyframes.
• Third-party tools: Some community scripts convert Daz facial animations (e.g., mimic, lip-sync) to ARKit blendshapes, which could then be applied to MetaHumans, though this is complex and not one-click.
• Retargeting bone-based motion: Use Unreal’s IK retargeter to map Daz facial bones (jaw, eyes, tongue) to MetaHuman’s (e.g., jaw rotation, eye gaze), covering basic movements but not morph-driven nuances like cheeks/lips.

Transferring full facial animations from Daz to MetaHuman is complex and often simpler to recreate with MetaHuman tools (Control Rig, Live Link). Extensive Daz data may need custom scripts or manual adjustments. A practical method is combining body retargeting with re-applied facial performance (e.g., via audio or Live Link).

In summary: Facial retargeting is feasible but not automatic, needing morph mapping, re-performance, or manual effort, an advanced task.

Can I use marketplace animations on custom characters like CC3 or Daz3D in UE5?

Yes, marketplace animations, typically designed for Epic’s mannequin (UE4 or UE5 skeleton), can be retargeted to custom characters like CC3, Daz, or MetaHuman using the described methods.

How to do it:

• Import your custom character and set up an IK Rig.
• For UE4 Mannequin assets, use the UE4 to UE5 Manny retargeter asset if converting to UE5 skeleton, then retarget to your custom skeleton.
• Create an IK Retargeter: source = marketplace animation’s skeleton IK Rig (e.g., UE5 Manny), target = your character’s IK Rig.
• Map chains, adjust pose (mannequin uses A-pose; match your character’s pose or adjust if T-pose).
• Export animations.

For example, with a ninja animation pack for UE4 mannequin and a CC3 character:

• Retarget animations to UE5 mannequin if needed.
• Use IK Retargeter from Manny to CC3’s skeleton.
• CC3 can then use the ninja animations.

This workflow lets developers retarget marketplace animations to custom skeletons (Daz, CC, Mixamo, etc.). Some assets provide IK Retargeter setups or documentation, though manual retargeting is possible. This flexibility reuses animations for custom characters, not just the default mannequin, saving time.

What export settings should I use for Mixamo, Daz3D, or CC3 before importing to Unreal Engine?

Here’s a summarized and shortened version of the text, keeping all key details, meaning unchanged, and removing links while preserving the table and lists:

When exporting characters or animations to Unreal, use the correct settings for smooth skeleton and animation import. Below is a quick reference:

Additional Notes:

• Export binary FBX (ASCII may fail).
• Scale: 1 unit = 1 cm. Daz may need bridge scaling; Mixamo/CC3 usually fine.
• Frame rate: 30fps standard; 60fps works but increases key density.
• Up Axis: Mixamo default FBX (Y-Up) works for Unreal. If misoriented, adjust “Force Front XAxis” or rotation.
• Test one export first: Check skeleton hierarchy and animation in Unreal before batch exports.

Using these settings ensures compatibility with Unreal’s retargeter, aligning poses (A or T) and bone orientations for easier retargeting and fewer fixes.

How do I blend retargeted animations with Metahuman Control Rig?

Blending retargeted animations with a MetaHuman’s Control Rig combines imported animation with custom tweaks. Approaches include:

1. Using Sequencer (Non-destructive editing):
   • Retarget animation to MetaHuman, creating an Animation Sequence.
   • In Sequencer, add the skeletal mesh, an Animation track with the retargeted animation, and a Control Rig track with the MetaHuman Control Rig asset.
   • Set Control Rig to Additive/Blend mode, but bake animation to Control Rig via “Bake to Control Rig” to transfer keyframes.
   • Mute/remove the animation track, then edit Control Rig keys (e.g., tweak arms, fix foot sliding).
   • Optionally layer another Control Rig; save or record the blended result (e.g., enhancing Mixamo animations with finger motions).
2. Using Animation Blueprint (runtime approach):
   • Use an Animation Blueprint with a sequence player and Control Rig Node to adjust poses per frame (e.g., IK for foot or hand).
   • Technical, suited for runtime IK corrections, not animation authoring.
3. Simple Additive Anim Layer:
   • Blend another retargeted animation via Animation Blueprint using Layered Blend per bone or Anim Montage slots (e.g., upper-body wave over walking), without Control Rig.

Sequencer with Control Rig baking is key for blending, allowing fine-tuning (e.g., fixing hand penetration) for a polished MetaHuman animation combining original motion and custom tweaks.

Where can I find retargeting templates for Mixamo, CC3, and Daz3D in Unreal Engine?

Unreal Engine 5 lacks built-in retargeting templates for third-party skeletons like Mixamo, CC3, or Daz (only UE4 Mannequin to UE5 Manny is included). Here are the resources:

• Mixamo: The Mixamo Animation Retargeting plugin on the Marketplace automates setup by adding a root bone and creating IK Rig and Retargeter assets for UE mannequin or MetaHuman skeletons, enabling retargeting in a few clicks. Alternatively, community-shared IK Rig assets or tutorials are available (e.g., search “Mixamo to Unreal IK Rig download”), but the plugin is simplest.
• CC3 (Reallusion Character Creator): Reallusion’s Auto Setup may include a Humanoid rig. UE4 had a CC3 to UE4 retarget asset; UE5 offers documentation and guides on forums or tutorials for retargeting. Exporting CC3 with the “Unreal skeleton” option aligns it with Epic’s skeleton, allowing use of Epic’s retargeter without a custom template.
• Daz3D: No official template exists from Epic or Daz. The Daz To Unreal Bridge imports characters but not IK Rig assets. Community tutorials on Daz forums or YouTube guide IK Rig creation for Genesis 8; some share assets on Unreal forums (search “Daz Genesis retarget asset”). Manual setup is needed otherwise, though it’s a one-time task.
• Official Samples: Epic’s MetaHuman documentation or blog posts (e.g., ICVR tutorial) provide instructions for Mixamo to MetaHuman retargeting, acting as a replicable template without files.
• GitHub or Blender Tools: Blender’s Auto-Rig Pro can convert Mixamo or Daz to UE mannequin bone names, eliminating the need for unique templates, though it requires re-rigging.

Summary of Templates:

• Mixamo: Use the plugin or community IK Rig setups.
• CC3: Use UE skeleton export or Reallusion’s retargeting guide.
• Daz3D: Manual setup or search for shared assets; creating an IK Rig is straightforward.

UE5.4’s one-click retargeter may auto-generate IK Rig chains for imported skeletons (e.g., Mixamo), serving as a refinable starting template if it recognizes humanoid patterns.

What are best practices for a universal animation retargeting workflow in UE5?

Here are best practices for retargeting animations in Unreal Engine 5 across multiple character sources (Mixamo, CC3, Daz, custom rigs):

• Establish a Reference Pose Standard: Use a consistent reference pose (A-pose for MetaHumans/UE mannequins, T-pose for Mixamo) and adjust with Retarget Pose to match them. Keep a library of T-pose and A-pose assets.
• Create Reusable IK Rig Assets: Build and save IK Rig assets for each skeleton (e.g., “RetargetRigs/IKRig_Mixamo”) to reuse without redoing chain setups.
• Use Meaningful Chain Names: Name chains consistently (e.g., Arm_L, Spine) for auto-mapping and clarity.
• Retarget in Stages (if needed): Optionally retarget to a common skeleton (e.g., UE5 Manny) first, then to others, though direct retargeting is also easy.
• Check Root Motion and Orientation: Handle root motion (add if missing, e.g., Mixamo) using Globally Scaled translation; switch to Absolute only for exact copying. Enable “Retarget Root” for movement.
• Leverage IK Goals for Accuracy: Set up IK goals (e.g., feet, hands) to improve retargeting quality, reducing sliding.
• Adjust and Save Retarget Poses: Tweak poses for each pair in the IK Retargeter, save them (e.g., “Mixamo_Tpose”) for reuse.
• Batch Process Animations: Use the IK Retargeter Asset Browser to retarget multiple animations at once efficiently.
• Review and Refine Animations: Check retargeted animations for natural poses, limb popping; polish critical ones with Control Rig.
  • Does the pose look natural? (Adjust pose/chain if not.)
  • Any limb popping? (Tweak pose or clean up.)
• Consistency in Characters: Rig characters similarly (e.g., export CC3 with UE skeleton) to simplify retargeting.
• Documentation and Organization: Note skeleton mappings, quirks (e.g., “Daz – rotate arms 45 down”), and organize in a “RetargetAssets” folder.
• Test Early: Retarget a few animations (e.g., idle, walk) to catch issues before processing many.
• Stay Updated: Use new features (e.g., UE5.4 auto-generated IK Rigs) and watch for community tools.

This workflow ensures animations from any source work on any character efficiently after initial setup.

FAQ

1. What is animation retargeting in Unreal Engine 5?
   It’s the process of adapting animation data from one skeleton to another, using UE5’s IK Rig and IK Retargeter, to allow animations (like a Mixamo dance) to work on characters with different bone structures, such as MetaHumans or CC3 characters.
2. What are the key components of UE5’s IK Retargeting system?
   The system uses IK Rig Assets to define bone chains (like spine, arms, legs) and optional IK goals for precise control, plus an IK Retargeter Asset that maps the source rig to the target rig while adjusting poses and root motion.
3. How do I set up source and target rigs for retargeting in UE5?
   Import your characters and animations, create an IK Rig for both the source (e.g., Mixamo Y Bot) and target (e.g., MetaHuman) skeletons by defining key chains (spine, arms, legs, head), add IK goals if needed, and then use the IK Retargeter to map the chains between the two.
4. What is the workflow for retargeting Mixamo animations to MetaHuman characters?
   First, import the Mixamo animation and skeleton. Create IK Rigs for both the Mixamo and MetaHuman skeletons, map corresponding chains in the IK Retargeter, adjust the retarget pose (e.g., aligning T-pose with A-pose), preview the result, and export a new animation sequence for the MetaHuman.
5. How can common retargeting issues like pose mismatches or foot sliding be fixed?
   You can resolve misaligned arms or feet by adjusting the retarget pose (e.g., correcting A-pose vs. T-pose differences), enabling IK goals for accurate foot and hand placement, and tweaking root motion and bone mapping settings within the IK Retargeter.
6. Can one animation be used on both CC3 and MetaHuman characters?
   Yes. Using UE5’s IK Retargeter, you can retarget a single animation to different skeletons by mapping the source IK Rig (often from a UE mannequin animation) to both CC3 and MetaHuman rigs, generating separate asset versions that maintain the same motion.
7. What export settings should be used for Mixamo, Daz3D, or CC3 when importing to UE5?
   For Mixamo, export as FBX Binary with a standard T-pose at around 30fps without skin (if just animating) and note that Mixamo uses Y-Up. Daz3D should be exported using FBX (2014/2015) with baked animations and correct units, while CC3/CC4 should be exported with UE-compatible presets (ensure the skeleton is converted to UE4’s humanoid rig when possible).
8. How do I blend retargeted animations with a MetaHuman Control Rig?
   After retargeting, you can use Sequencer to add a Control Rig track alongside the Animation Sequence, adjust blending settings (like additive or layered blend modes), and bake the refined motion back into an animation sequence for smoother, custom-tweaked results.
9. How are facial animations retargeted between Daz3D and MetaHuman?
   Facial retargeting is more challenging, since Daz3D uses bone-based rigs and morphs while MetaHumans rely on blendshapes, you’ll need to map Daz facial curves/morphs manually or with third-party tools, use Live Link for performance capture, or reapply facial performance via MetaHuman tools, as fully automatic facial retargeting isn’t provided yet.
10. What best practices ensure a universal animation retargeting workflow in UE5?
    Establish a consistent reference pose (A-pose or T-pose), create reusable IK Rig assets for each skeleton, name chains clearly for auto-mapping, carefully adjust root motion and IK goals, test early with simple animations (like idle or walk), and document your settings for consistency across different character types.

Conclusion

Unreal Engine 5’s IK Retargeter allows a flexible animation workflow using IK Rigs and Retargeters to adapt animations (e.g., Mixamo dances, iClone motions, Daz3D poses) to characters like MetaHumans, CC3 avatars, or custom heroes. It involves importing animations, mapping skeletal chains, fixing pose mismatches and bone name differences, and refining with Control Rig. Consistent poses and export settings enable a shared animation library using resources (e.g., Marketplace packs, Mixamo). UE5 manages complex cases (e.g., varying proportions, non-standard rigs); facial retargeting is challenging, but body motions apply universally. Mastering this makes animations universal assets, uniting Mixamo, Reallusion, Daz, and MetaHuman characters with setup, tools, and tweaks.

Citations

1. Unreal Engine Documentation – IK Rig Animation Retargeting: Explains the IK Retargeter system and its capability to retarget between skeletons of different bone counts and orientations.
2. UNAmedia Plugin Documentation – Retarget Mixamo to MetaHuman: Notes that the Mixamo to MetaHuman retarget uses standard UE5 workflow and the plugin automates the setup.
3. Epic Developer Community Forum – Mixamo to MetaHuman guidance: Community tutorial emphasizing the versatility of UE5’s retargeter for Mixamo to MetaHuman, and importance of understanding manual setup.
4. UNAmedia Docs – Import Mixamo Animation: Advises exporting from Mixamo in FBX Binary format without skin for animations and describes the root track error fix when a root bone is missing.
5. Epic Developer Forum – Troubleshooting Retargeting Issues: Discusses common problems like pose mismatches (T-pose vs A-pose affecting arms) and suggests solutions (adjusting poses, testing root rotation options).
6. UE Forum – Control Rig Baking in Sequencer: User workflow for blending animations by baking animation to MetaHuman Control Rig for additive adjustments.
7. Reddit – UE5.4 One-Click Retargeting: Mentions UE5.4’s ability to auto-generate retargeting rigs for similar skeletons, simplifying Mixamo retargeting workflow.
8. Reallusion Forum – CC3 to Unreal Retargeting: Community discussion noting that CC4/CC3 characters can be retargeted and even converted to UE skeleton for direct animation use.

Recommended

• How do I create a circular camera animation in Blender?
• How do I make the camera move along a curve in Blender?
• Managing Multiple Camera Settings in Blender with The View Keeper
• How to Auto Retopology in Blender: A Step-by-Step Guide for Clean 3D Meshes
• Can you have multiple cameras in one Blender scene?
• How do I add a background image to the camera view in Blender?
• Capturing Every Angle: Blender Camera Management with The View Keeper
• What Is Gaussian Splatting? A Complete Guide to This Revolutionary Rendering Technique
• Comprehensive Analysis of Blender as a Game Engine
• How do I set up a tracking shot with a camera in Blender?