First Person Arms

Export

First-person arms give the close camera a dedicated visible rig and Animator Controller; use them when the full character body is hidden in first person or when weapon handling needs camera-specific animation.

Before you begin

  • Use a character whose Perspective is First or Both.
  • Import the arm model and its clips with a compatible Unity rig. The supplied Demo arms use a Generic rig, so their clips must be authored for that skeleton and cannot be humanoid-retargeted.
  • Prepare an Animator Controller for the arms when they should animate. It must contain every Ultimate Character Controller parameter that its transitions read.
  • When the character carries items, decide which arm hand transforms should be the first-person Item Slots.

Unity’s generic animation import guide explains the model import settings for a non-humanoid rig.

Add the arms with Character Manager

  1. Place the character and arm model in the scene. The character must be a scene object; the First Person Arms field can also accept an arm prefab that Character Manager instantiates.
  2. Open Tools > Opsive > Ultimate Character Controller > Character Manager and assign the character in Character.
  3. Set Perspective to First or Both and select the intended First Person Movement.
  4. Assign the arm root in First Person Arms. In the controller field on the same row, assign the Animator Controller made for that arm rig. Adding another arm root creates another row and another controller choice.
  5. If Items is enabled, select Adjust Slots beside Item Slots. In the Character Item Slots window, find the First Person Arms section and assign the appropriate hand transforms. Use Right for Slot ID 0, Left for Slot ID 1, or Other for a project-specific ID; each parent and ID in that arm model must be unique.
  6. Select Build Character for a new character or Update Character for an existing one.
  7. Inspect the result. Character Manager places the arm root below FirstPersonObjects and adds First Person Base Object. When a controller was assigned, the root also has Animator and Child Animator Monitor.
  8. For every Character Item that should use these arms, configure its First Person Perspective Item to reference the correct arm object or First Person Base Object ID.

Do not add a second Animator Monitor to the arms. The character model keeps Animator Monitor; the arms use Child Animator Monitor to receive the same movement, ability, and item parameters.

Choose an arm and controller setup

Setup Use it when Important tradeoff
Generic arm rig Final first-person animation needs close-up posing tailored to one skeleton. This is the approach used by the supplied Demo arms. Clips cannot be humanoid-retargeted, and the humanoid-only Character IK workflow does not drive the generic arms.
Humanoid arm rig A prototype should reuse a humanoid animation library or the full character rig. Retargeting is convenient, but third-person clips commonly need camera-specific cleanup for hands, weapon framing, and off-screen bones.
Multiple arm roots Different item families or character models need different skeletons or controllers. Each item must select the correct First Person Base Object, and each arm set needs matching Item Slots and controller parameters.
No arm controller The arm object is intentionally static, absent, or all visible motion is handled elsewhere. Character Manager does not add Animator or Child Animator Monitor, so ability and item parameters cannot animate that arm root.

For a quick humanoid prototype, a mesh-isolation tool such as FPS Mesh Tool can create an arms-only mesh while retaining the humanoid rig. The existing FPS Mesh Tool integration video demonstrates that optional third-party workflow. Treat the result as a starting point and review every pose from the gameplay camera.

How the arms run

FirstPersonObjects keeps the first-person hierarchy aligned with the camera and manages which arm base objects are active. By default, a base object is activated when an equipped dominant item references it and is deactivated when no equipped item needs it. Enable Always Active on First Person Base Object only when that arm set should remain visible without an item.

Child Animator Monitor copies the live values from the active character model’s Animator Monitor, including movement, aiming, ability, Movement Set, and supported item-slot parameters. The arm controller can therefore use the same parameter names and values while playing different first-person clips.

The arm Animator does not apply root motion. Locomotion remains controlled by the character, while the arm clips provide visible first-person motion. Animation events raised by a child Animator Monitor are accepted only when its perspective matches the active perspective.

Verify in Play Mode

  1. Start in first person and equip an item mapped to the arm set. Confirm that the intended arms and visible item appear, with no duplicate third-person arms in front of the camera.
  2. Move, look, aim, use, reload, equip, and unequip. Watch the arm Animator and confirm its parameters follow the character and each action enters the expected state.
  3. On the character’s Animator Monitor, expand Editor and enable Log Ability Parameter Changes, Log Item Parameter Changes, or Log Events only while diagnosing a mismatch.
  4. Unequip the item. Confirm the arm base object hides unless Always Active is enabled or another equipped item still references it.
  5. For a Both character, switch to third person and back. First-person arms should be hidden in third person, return in first person, and resume the correct current Animator state.
  6. If multiple character models or arm roots are configured, repeat the equip and perspective checks for every supported combination.
  7. Disable the Animator Monitor logging options after testing.

Troubleshooting

Symptom Check Fix
The arms never appear. Check Perspective, the FirstPersonObjects hierarchy, the item’s arm reference or First Person Base Object ID, and whether the item is equipped. Select First or Both, run Update Character, then map the First Person Perspective Item to the intended base object. Use Always Active only for arms that should not depend on an item.
The arms are visible for the wrong item or remain visible after unequipping. Inspect the item’s Object, First Person Base Object ID, additional control objects, and the arm’s Always Active value. Point each item at the correct base object and remove unintended additional control objects; disable Always Active for item-specific arms.
The arm mesh appears but does not animate. Check the controller field beside First Person Arms, then inspect the root for Animator and Child Animator Monitor. Assign the intended controller and select Update Character. Character Manager adds or removes both components to match that controller field.
The arm Animator logs missing parameters or enters the wrong state. Compare its parameter names, types, Ability Indexes, Item IDs, and Item State Indexes with the character controller. Add the required parameters and matching transition conditions; use Animator Parameters and Default Animator Values as the baseline.
Generic arm clips deform or do not retarget. Check the model and clip Rig import settings and confirm they use the same generic skeleton. Use clips authored for that rig, or deliberately switch both model and clips to a valid humanoid workflow instead of mixing rig types.
An item appears in the wrong hand. In Character Item Slots, compare the arm hand transform and Slot ID with the Character Item’s Slot ID. Assign the correct hand parent and keep the same Slot ID throughout the first- and third-person item setup.
An animation event works in one perspective but not the other. Confirm the active perspective’s clip contains the event or uses the intended duration fallback. Add the event to the first-person clip or configure the matching Animation Event Trigger.

Developer reference

CharacterManager calls ItemBuilder.AddFirstPersonArms when building or adding an arm root. The builder assigns a unique FirstPersonBaseObject ID and moves that hierarchy to the Overlay layer. When the row has a controller, it adds or reuses an Animator, disables root motion, sets culling to Always Animate, assigns the controller, and adds ChildAnimatorMonitor. Updating the row with no controller removes the arm Animator and Child Animator Monitor.

ChildAnimatorMonitor reads from the active character model’s AnimatorMonitor, mirrors the standard character and supported slot parameters, follows the character time scale, and snaps to the current state when enabled or after an immediate transform change. It treats a slot as supported when the arm controller contains that slot’s Slot<ID>ItemID parameter, so keep the full slot parameter group consistent with the controller’s transitions.