UE5 Weapon System Aiming Retarget Blend Upper Body and Switch Cameras

What You Will Build

• A retargeted animation set for the UE5 Manny character
• An Animation Blueprint updated with aiming logic
• Two new locomotion states called Aiming and Aim Walking
• Upper and lower body animation blending using Layered Blend Per Bone
• Transition rules driven by IsAiming and ShouldMove
• An input action for aiming on the right mouse button
• A second camera for shoulder aim view
• Blueprint logic that switches cameras and updates the animation state correctly

This is the point where your weapon system starts feeling like an actual game system instead of just a pickup demo.

Why This Step Matters in a UE5 Weapon System

Aiming is where weapon systems start exposing whether your setup is clean or garbage. If the character cannot switch animation states correctly, if the upper body and lower body do not blend properly, or if the camera logic feels disconnected from the animation logic, the whole system feels cheap.

This tutorial matters because it connects three pieces that beginners often treat separately:

• Animation assets
• Animation Blueprint logic
• Character Blueprint input and camera control

In a real game, those parts must work together. That is exactly what you are building here.

Step 1: Import an Animation Pack

To build the aiming system, you first need suitable animations. In this tutorial, the Animation Starter Pack from Fab is used.

If you are using a recent Unreal Engine version like 5.6 or newer, one practical workaround is to enable Show All Projects, select your project, then choose an earlier compatible version such as 5.2 when adding the pack.

The animation pack link referenced in the video is:

Animation Starter Pack on Fab

You could also use Mixamo animations, but that usually adds more setup and cleanup steps. For this workflow, the Starter Pack is the faster route.

Step 2: Retarget Older Animations to the UE5 Manny Skeleton

Once the pack is imported, open the Content Drawer and go into the animation pack folder. Pick one animation or blend space asset, such as:

BS_Jog

Right-click it and choose:

Retarget Animations

In the Retarget Animations window, the source skeletal mesh should already be the older Unreal Engine 4 mannequin. For the target, choose your UE5 character skeleton, in this case Manny Simple.

Preview one animation to make sure it looks reasonable, then press:

Ctrl + A

to select all animations and click Export Animations.

Save them into a dedicated folder such as:

Content/Anim

This gives you a clean retargeted set that actually matches your current character skeleton.

Brutal truth: if you skip proper retargeting and just mash old assets into a new character setup, you are asking for bad poses and ugly motion.

Step 3: Open and Prepare the Animation Blueprint

Open your character blueprint:

ThirdPerson > Blueprints > BP_ThirdPersonCharacter

In the Details panel, under Animation, locate the current Anim Class. In the tutorial this is:

ABP_Unarmed

You can duplicate it if you want a separate aiming-specific version, but the tutorial works directly inside the existing animation blueprint.

Open the Anim Blueprint and switch to the AnimGraph. Inside, you will find the locomotion logic. The main work happens inside the Locomotion state machine.

Step 4: Create the IsAiming Variable

Before adding states, create a new Boolean variable:

IsAiming

Compile the blueprint and make sure its default value is false.

This variable will not be driven from inside the Anim Blueprint itself. It will be updated from the character blueprint when the player presses or releases the aiming input.

That separation matters. The character handles player input. The Anim Blueprint reacts to state.

Step 5: Add the Aiming State

Inside the Locomotion state machine, add a new state named:

Aiming

Open the state and add two animations:

• MM_Idle
• Idle Rifle Hip

The goal is to use the normal lower-body idle while blending the upper body into the rifle-ready pose.

To do that, add a:

Layered Blend Per Bone

node between the animations and the final state output.

Configure the blend so:

• Base Pose uses MM_Idle
• Blend Pose 0 uses Idle Rifle Hip

Then in the node details, under Layer Setup, add a Branch Filter with:

Bone Name: spine_01

Leave the blend depth at 0.

This tells Unreal to keep the lower body from the base pose and start applying the aiming pose from spine_01 upward.

Why spine_01 Is the Right Split Point

If you are not sure where spine_01 comes from, inspect the skeleton tree on the character mesh. Under the pelvis, you will find the spine hierarchy, and spine_01 is a sensible split point for dividing lower-body locomotion from upper-body weapon handling.

This is one of the biggest reasons Layered Blend Per Bone is useful. You do not need to replace the whole body animation just because the character is aiming.

Step 6: Add the Aim Walking State

Back inside the Locomotion state machine, add another state named:

Aim Walking

This state uses blend spaces instead of single idle animations.

Add these two blend spaces:

• BS_Idle_Walk_Run
• BS_Jog

Depending on your engine version, some variable names may differ. In newer UE5 versions, what used to be called Direction may now appear as Strafe, while forward motion is usually driven by Ground Speed.

Connect:

• Strafe to the directional input where needed
• Ground Speed to the speed or forward input

Then add another Layered Blend Per Bone node.

Configure it exactly like the Aiming state:

• Base Pose = BS_Idle_Walk_Run
• Blend Pose 0 = BS_Jog
• Branch Filter Bone Name = spine_01

This gives you normal lower-body locomotion while the upper body stays in a weapon-ready aiming motion.

Step 7: Create All State Transitions

At this point, your Locomotion state machine should contain four states:

• Idle
• Walk and Run
• Aiming
• Aim Walking

Create these six transitions:

• Idle to Aiming
• Aiming to Idle
• Walk and Run to Aim Walking
• Aim Walking to Walk and Run
• Aiming to Aim Walking
• Aim Walking to Aiming

If you miss one, the animation flow will feel broken or get stuck.

Step 8: Configure Transition Rules with IsAiming and ShouldMove

Now assign the logic for each transition.

Idle to Aiming

Use:

IsAiming

directly as the condition. If aiming becomes true, the character enters the Aiming state.

Aiming to Idle

Use:

NOT IsAiming

If the player stops aiming, the system returns to Idle.

Walk and Run to Aim Walking

Again, use:

IsAiming

If the character is moving and the player starts aiming, the state switches to Aim Walking.

Aim Walking to Walk and Run

Use:

NOT IsAiming

If aiming stops during movement, go back to normal locomotion.

Aiming to Aim Walking

Use an AND condition:

ShouldMove AND IsAiming

This means the player is still aiming and has started moving.

Aim Walking to Aiming

Use:

NOT ShouldMove AND IsAiming

This means the player is still aiming but has stopped moving, so the state should go back to aiming idle.

This is clean logic. No nonsense, no overcomplication. Two booleans control the whole aiming flow.

Step 9: Create the Aiming Input Action

Open your Input folder, go into the Actions subfolder, and create a new Input Action named:

IA_Aiming

Open the asset and make sure its Value Type is set to:

Digital

That is the correct type because aiming here is a simple pressed-or-not-pressed state.

Then open your Input Mapping Context, usually:

IMC_Default

Add a new mapping for IA_Aiming and bind it to:

Right Mouse Button

Step 10: Add an Aiming Camera to the Character

Open BP_ThirdPersonCharacter again.

Select the Camera Boom, add a new Camera component, and rename it:

AimingCamera

Then position it in the viewport where you want your shoulder aiming view. Usually this means slightly above and behind the shoulder, closer than the normal follow camera, and angled to feel more focused.

At this point, the character has two cameras:

• The default Follow Camera
• The new Aiming Camera

This is the right setup for a simple aim-view switch system.

Step 11: Build the Aiming Logic in the Character Blueprint

In the Event Graph of BP_ThirdPersonCharacter, add the input action event for:

IA_Aiming

Before letting the character aim, check whether the character is armed. Pull the existing:

Armed

Boolean into the graph and use it in a Branch after the Started pin.

If the player is not armed, do nothing. That part matters. Aiming without a weapon makes no sense unless your game specifically wants that behavior.

Step 12: Activate the Aiming Camera and Update the Animation State

On the True branch of the armed check:

1. Set AimingCamera active = true
2. Set FollowCamera active = false
3. Set Use Controller Rotation Yaw = true
4. Get the Mesh component
5. Get Anim Instance
6. Cast to ABP_Unarmed
7. Set IsAiming = true

This handles the pressed state properly. The camera changes, the character now rotates with the controller while aiming, and the Anim Blueprint is told to enter aiming mode.

Step 13: Reverse the Logic When Aiming Stops

Now use the Canceled and Completed outputs from the same input action event.

Feed them into another Branch that also checks Armed. On the True path:

1. Set AimingCamera active = false
2. Set FollowCamera active = true
3. Set Use Controller Rotation Yaw = false
4. Get the Mesh component
5. Get Anim Instance
6. Cast to ABP_Unarmed
7. Set IsAiming = false

That fully restores the normal movement state when the right mouse button is released.

How the Full Aiming System Works

Once everything is connected, the aiming flow works like this:

1. The player picks up the weapon and becomes armed
2. The player presses the right mouse button
3. The character blueprint verifies that the character is armed
4. The aiming camera becomes active
5. The normal follow camera is disabled
6. The character begins rotating with controller yaw
7. The Anim Blueprint receives IsAiming = true
8. The locomotion state machine switches into Aiming or Aim Walking depending on movement
9. When the button is released, the system reverses everything cleanly

That is how camera control, input, and animation logic stay synchronized.

Why Layered Blend Per Bone Is the Right Choice Here

Without layered blending, you would need fully separate full-body aim animations for every movement state, and even then your system would be less flexible. Layered Blend Per Bone is the smarter option because it lets lower-body locomotion continue while the upper body handles aiming.

That is exactly what a third-person combat system usually needs. The character can still walk, strafe, and move naturally while keeping the weapon ready in the upper body.

Common Problems and Ugly Results

The tutorial also points out something important: some of the motion may look a little stiff or off. That is normal when using older animation packs retargeted from previous mannequin generations.

The system can still work correctly while some poses look less polished. Functional first, refinement after. That is the right order.

Common causes of bad results include:

• Using poorly retargeted animations
• Splitting the body at the wrong bone
• Forgetting to update IsAiming from the character blueprint
• Switching cameras but not updating controller yaw
• Forgetting to gate aiming behind the Armed variable
• Mixing up movement transition logic between ShouldMove and IsAiming

Why This Setup Is a Strong Foundation for Shooting

This aiming system is not the final goal. It is the foundation for the next weapon features. Once aiming works, the next steps are line tracing, muzzle logic, hit detection, recoil, and actual shooting.

If you try to add shooting before aiming is structured properly, the system gets ugly fast. By handling retargeting, animation states, blending, and camera switching first, the next episode has a stable base to build on.

Conclusion

In this Unreal Engine 5 weapon system tutorial, you built a full aiming setup by retargeting older animations to the UE5 Manny skeleton, rebuilding the Animation Blueprint, adding Aiming and Aim Walking states, blending upper and lower body motion with Layered Blend Per Bone, configuring transition rules with IsAiming and ShouldMove, creating an aiming input action, and switching between two cameras for a shoulder aim view.

That gives you a playable aiming system that already feels like part of a real combat framework instead of a half-baked prototype.

Watch the full tutorial on YouTube: UE5 Weapon System Aiming Retarget Blend Upper Body and Switch Cameras

Subscribe for more Unreal Engine tutorials: Subscribe to Rambod on YouTube

Frequently Asked Questions

How do I retarget UE4 animations to UE5 Manny?

Use the Retarget Animations option on an existing animation asset, choose the older mannequin as the source skeleton, select Manny as the target, preview the result, then export the animations into a new folder.

Why use Layered Blend Per Bone for aiming?

Because it lets the lower body keep locomotion animations while the upper body switches into weapon aiming poses, which is ideal for third-person shooter movement.

What bone should I use to split upper and lower body animation in UE5?

In this setup, spine_01 is used as the split point, which is a practical choice for separating lower-body movement from upper-body aiming.

Why does my character not switch to aiming animations?

Usually because the IsAiming Boolean is not being updated correctly from the character blueprint, the Anim Instance cast is failing, or the transition rules are wired incorrectly.

Why add a second aiming camera instead of just changing FOV?

A separate aiming camera gives you direct control over shoulder framing, distance, and view angle, making it easier to create a proper third-person aim view.

Why does the aiming animation still look a little stiff?

Because older retargeted animation packs do not always match the proportions and motion style of the newer UE5 Manny skeleton perfectly. The system can still function correctly even if some poses need refinement later.