How to author optional first-person body meshes and held pose animations

Use this optional guide when your project uses Motion's native first-person body and held pose system. It covers the artist brief, the checks to make before buying animation packs, and the Unreal import path.

By the end, you will have optional native first-person presentation assets:

• a first-person upper-body mesh assigned to a component named FirstPersonUpperBody
• a first-person lower-body mesh assigned to a component named FirstPersonLowerBody
• a small held pose animation set that can drive a held item through MotionNativeFirstPersonItemConfig
• a checklist you can hand to an artist or use when evaluating Fab animation packs

Use this guide before adding a production native first-person item. If you already have compatible body meshes and held pose animations, continue with How to add a first-person item end to end.

Start with the Motion skeleton contract

1. Open the character Blueprint that uses Motion.
2. Select the main character mesh returned by GetMesh().
3. Note the skeletal mesh, skeleton, and Animation Blueprint.
4. Open the skeleton asset.
5. Confirm that the skeleton has a socket or bone named weapon_r.
6. Confirm that the full-body skeleton has MotionCamera for Stable presentation. If the profile selects Socket mode with another pivot, confirm that configured socket too.
7. Confirm that the skeleton has the bones used by Motion's default upper-body solve:

Purpose	Default names
HeldPose branch	pelvis
Pitch distribution	spine_01, spine_02, spine_03, spine_04, spine_05, neck_01, neck_02, head
Hand IK	VB Hand_R to hand_r, VB Hand_L to hand_l

If your project skeleton uses different names, keep going, but plan to tune UpperBodySolveSettings on each item config later.

Write the artist brief

Give the artist the exact character skeleton and the item role. The important point is that Motion does not need a separate viewmodel skeleton. It expects first-person body meshes and held pose animations that remain compatible with the full-body skeleton.

Use this brief:

We need Motion-compatible first-person assets for Unreal Engine 5.6.

Use the supplied character skeleton without renaming bones, deleting bones, changing hierarchy, changing rest pose, or creating a viewmodel-only skeleton.

Deliver:
- first-person upper-body skeletal mesh, no head, no item geometry, with enough chest and shoulder coverage for the supported downward view range
- first-person lower-body skeletal mesh, no arms or head
- world/full-body item mesh and first-person item mesh as separate item assets
- loopable held pose animation for the basic held pose
- optional held pose variants for crouch, sprint, jump, ADS, or gameplay tags from your project

Attachment:
- held items attach to `weapon_r`
- right-hand grip should be stable around `weapon_r`
- left hand may use the supplied hand IK or virtual bones
- preserve the configured camera pivot socket only if the project uses Socket mode

Camera-facing mesh boundaries:
- do not leave open neck, shoulder, arm, or waist cross-sections visible from the supported first-person pitch and FOV range
- overlap upper- and lower-body coverage enough to avoid gaps during standing, crouch, slide, vault, and held poses
- hide or cap interior cut surfaces; Stable camera clearance uses the capsule as a body proxy and cannot infer custom mesh holes

Animation:
- use the same skeleton as the character body
- keep locomotion/root motion out of basic held pose clips
- make held pose clips loop cleanly
- keep the item hold readable at first-person camera distance
- do not bake weapon meshes into the character body mesh

Evaluate an animation pack before buying it

When browsing Fab or another marketplace, check the pack against this list before you buy it:

1. It must be retargetable to your character skeleton.
2. It should include idle or held poses for the item type, not only fire/reload/action clips.
3. It should include movement-state variants you actually need, such as crouch, sprint, jump, ADS, or injured.
4. The hands should hold a consistent item origin or grip point.
5. The right hand should not wander far from the intended socket.
6. The left hand should either stay believable without IK or give you enough reference to configure hand IK.
7. The animation should not depend on a separate first-person-only arm rig unless you are ready to retarget and validate it.

Export the source character mesh

INFO

If your Motion purchase includes the optional Blender source files for the partial meshes, open the Motion listing on Fab and use its Additional files section.

If you don't use the default mannequin, or don't have source files for your character available:

1. In Unreal, find the full-body skeletal mesh used by GetMesh().
2. Right-click it and choose Asset Actions > Export.
3. Save an FBX outside the project content folder, such as D:/MotionMeshWork/SKM_Character_SourceForFP.fbx.
4. Export the skeletal mesh only.

This FBX is the body source you will split into meshes for the local player's view. Keep the original Unreal asset unchanged.

Create the first-person upper body

1. Open Blender.
2. Import the exported FBX.
3. Leave automatic bone reorientation disabled if your Blender version offers it.
4. Duplicate the body mesh object.
5. Rename the duplicate SKM_Character_FP_UpperBody.
6. Delete the head, face, hair, eyes, helmet, legs, and feet from the duplicate.
7. Keep shoulders, clavicles, arms, hands, and enough torso geometry for clean deformation.
8. Remove loose vertices and hidden interior pieces.

Shape the mesh for first-person framing without changing the skeleton:

1. Add a temporary camera near eye height.
2. Add a simple blockout item near the right hand.
3. Adjust mesh vertices for a good first-person silhouette.
4. Keep the hands aligned with the original hand bones and weapon_r.
5. Do not rotate bones to force the final held pose.

Use mesh edits for the visible body silhouette. Use held pose animations, item transforms, and item solve settings for held-item posture.

Create the first-person lower body

1. Duplicate the original body mesh again.
2. Rename the duplicate SKM_Character_FP_LowerBody.
3. Delete the head, arms, hands, and upper torso.
4. Keep pelvis, hips, legs, knees, ankles, feet, and enough waist geometry to hide the body split.
5. Remove loose vertices and geometry the owner camera will never see.

The lower-body mesh is for looking down and seeing the body. It should not include item geometry, gameplay collision, or extra hitboxes.

Check skinning before export

1. Select SKM_Character_FP_UpperBody.
2. Confirm it still has an Armature modifier that targets the imported armature.
3. Confirm its vertex groups still use the original bone names.
4. Repeat for SKM_Character_FP_LowerBody.
5. Enter Pose Mode on the armature.
6. Rotate spine, arm, hand, hip, knee, and ankle bones to check deformation.
7. Reset the pose.

If you created cap faces or changed large mesh areas, weight paint them to nearby existing bones. Do not add a first-person-only skeleton.

Export the two body meshes

Export each body mesh as a separate FBX.

For the upper body:

1. Select the armature and SKM_Character_FP_UpperBody.
2. Choose File > Export > FBX.
3. Enable Selected Objects.
4. Export only Armature and Mesh object types.
5. Disable Add Leaf Bones.
6. Disable animation export.
7. Save SKM_Character_FP_UpperBody.fbx.

For the lower body:

1. Select the same armature and SKM_Character_FP_LowerBody.
2. Use the same export settings.
3. Save SKM_Character_FP_LowerBody.fbx.

Import the body meshes into Unreal

1. Create a folder for first-person body assets.
2. Import SKM_Character_FP_UpperBody.fbx.
3. Enable skeletal mesh import.
4. Set Skeleton to the same skeleton used by GetMesh().
5. Leave animation import disabled.
6. Import the asset.
7. Repeat for SKM_Character_FP_LowerBody.fbx.

Open each imported mesh and verify:

1. The Skeleton field points to the full-body character skeleton.
2. A full-body preview animation animates the visible mesh parts.
3. The upper-body mesh has no head.
4. The lower-body mesh is readable when viewed from the camera angle.
5. The skeleton still has weapon_r and, when Socket mode is used, the configured camera pivot socket.

Assign the meshes to the Motion character

1. Open the Motion character Blueprint.
2. Keep the standard character mesh as the full-body GetMesh() representation.
3. Add or select a skeletal mesh component named exactly FirstPersonUpperBody.
4. Assign your imported upper-body mesh.
5. Add or select a skeletal mesh component named exactly FirstPersonLowerBody.
6. Assign your imported lower-body mesh.
7. Reset both component transforms so they line up with the full-body mesh.
8. Disable collision on both first-person body components.
9. Do not put item meshes on either body component.

On the locally controlled character, when native first-person presentation is enabled and both body components are present, MotionCameraComponent marks them as native FirstPerson primitives, marks the full-body mesh as WorldSpaceRepresentation, and makes the first-person body meshes follow the full-body pose.

Prepare the first held pose animations

Create or retarget a small held pose set on the same character skeleton. Start with one item, such as a pistol or scanner, and make these clips:

Clip	Used for
Baseline held pose	Fallback held pose when no specific gameplay tag wins
Crouch held pose	Optional entry for Motion.State.Crouching
Sprint held pose	Optional entry for Motion.State.Sprinting
Jump held pose	Optional entry for Motion.State.Jumping
Project-specific held poses	Optional entries for ADS, injured, swimming, or other project tags

Each held pose animation can be a short loop or pose-like sequence. Keep the pose stable enough that Motion can layer it over the host locomotion graph through the Motion First Person Item Upper Body Overlay node.

Before importing or accepting the clips:

1. Confirm they are authored on, or retargeted to, the same skeleton as the first-person body meshes.
2. Confirm the right hand holds the item consistently around weapon_r.
3. Confirm the upper body is posed, but locomotion remains the host Animation Blueprint's job.
4. Confirm the clips loop without hand popping.
5. Confirm the configured solve bones exist on the animation skeleton.

Validate in PIE

1. Open a map that uses your Motion character.
2. Press Play as the local player.
3. Watch the Output Log for native first-person warnings.
4. Confirm no warning says FirstPersonUpperBody or FirstPersonLowerBody is missing.
5. Move, sprint, crouch, and jump.
6. Look down and confirm the lower body is visible without the head or torso blocking the camera.
7. Equip a test native first-person item.
8. Confirm the first-person item attaches to FirstPersonUpperBody.weapon_r.
9. Confirm the world item attaches to GetMesh().weapon_r.
10. Sweep the camera up and down and confirm Stable clearance keeps the view outside the body proxy while both body meshes retain their authored transforms.
11. Check the steepest supported pitch while standing, crouched, and item-held. No open cut surface or missing torso coverage should become visible; those are mesh-content defects, not additional camera states.

If the item appears but floats in the wrong place, tune the item config's FirstPersonRelativeTransform. If it cannot attach to the hand at all, check the shared skeleton and weapon_r.

What you have ready

You now have first-person body assets and a starter held pose animation set that match Motion's current native item presentation path:

• body meshes share the full-body skeleton
• item attachment uses weapon_r
• basic held pose comes from item config AutomaticHeldPoseSettings
• movement-state held pose variants are selected by gameplay tags
• custom graphs and linked layers remain optional advanced paths

Next, turn these assets into a finished item presentation.

Add an item end to endCreate the item meshes, config, held pose entries, AnimGraph overlay, tuning, and PIE validation.First-person item configsUnderstand the native item config fields and runtime flow.Motion camera componentLook up Stable and Socket camera behavior and native first-person presentation fields.