[UE5] Spring Arm Basics: A Third-Person Camera That Avoids Walls, Plus an Over-the-Shoulder View

You want the camera showing your character's back a bit closer. You want it shifted right, over the shoulder. But if it clips into a wall, all that tuning becomes unreadable.

The Spring Arm Component handles those third-person camera positions together. It inserts an "extendable arm" between the character and the camera, keeping distance normally and pulling in when there is a wall.

This article tunes distance, lateral offset, and body facing in order, using the Third Person template's camera. Finally we build a camera that pulls into an over-the-shoulder view while right-click is held and confirm it stays natural near walls and on rapid re-presses.

What You'll Learn

• What Spring Arm and Camera do, and when to use distance versus Offset
• The mechanism that pulls the camera in around walls
• Settings that separate camera facing from character body facing
• Smoothly switching between normal and over-the-shoulder views with a Timeline

First, find the "arm" and the "camera"

Use the Blueprint Third Person template to practice. Play first and confirm you can walk with the movement keys and turn the view with the mouse. This article adjusts the camera using that input logic.

Once stopped, find and open BP_ThirdPersonCharacter in the Content Browser. CameraBoom in "Components" is the Spring Arm, and the FollowCamera attached to it is the Camera component.

CameraBoom decides where the camera sits and FollowCamera renders the scene from that position. The arm is a metaphor for understanding the mechanism; no rod is drawn during play.

To confirm camera follow, check that FollowCamera is a child of CameraBoom . A child moves with its parent's position and orientation. Placing the camera directly under the character skips this arm-based position adjustment.

Set FollowCamera's "Transform" relative Location and Rotation both to (0, 0, 0) and Scale to (1, 1, 1) . "Relative" means values measured from the parent's attachment point. Even for lateral offsets, we adjust the CameraBoom side later.

Adjust distance and on-screen position

Change distance: Target Arm Length

Select CameraBoom and find Target Arm Length in "Details". It is the arm length you want when nothing is in the way . In UE's default unit, 400 is 400 cm, or 4 m.

Set it to 400 and Play, then stop, change it to 180 , and Play again. Comparing in an open area, 180 puts the camera closer and the character appears larger. Set it back to 400 afterwards.

The numbers from here are for practice, to make differences visible. They need not match the template's initial values; just set them and continue.

Shift the position: two kinds of Offset

An Offset is how far to shift from a reference position. A Spring Arm has two Offsets that shift different places. Read "the direction the arm points" below as the direction the camera looks.

Setting	Where it shifts, and from what	How we use it here
Socket Offset	The arm's tip. Shifts relative to the arm's facing	Move the camera right, opening space beside the character
Target Offset	The arm's base. Shifts relative to world axes	Raise the arm's pivot

To try over-the-shoulder, set CameraBoom's Socket Offset to (X=0, Y=55, Z=30) . With a level camera, that shifts 55 cm right and 30 cm up. Because the camera moves right, the character appears toward the left of the screen.

That "right" is right as seen from the arm's facing, not the character's body . With settings where only the camera rotates, it is not always above the character's right shoulder. Tilting the arm up or down tilts Socket Offset's vertical direction with it.

Setting Target Offset 's Z to 50 , meanwhile, moves the arm's base 50 cm along the world's up direction. "World up" is the game space's up, unchanged by camera rotation. That alone does not make it look down. Changing the pivot height and pointing the camera downward are separate adjustments.

Moving both at once mixes the effects, so try one at a time. Once you see the difference, set both back to (0, 0, 0) .

How close does the camera get with a wall?

When you want a 4 m arm and there is a wall along the way, what happens? The Spring Arm's Do Collision Test checks for obstacles from the arm's base to where the camera wants to be and pulls the camera in front of the wall.

The test uses an invisible small sphere. That stops it with more clearance around the camera than testing a single point would.

CameraBoom setting	Value for practice	Meaning
Do Collision Test	On	Tests the camera's path
Probe Size	12	Radius of the test sphere. 12 cm here
Probe Channel	Camera	The channel asking walls "do you stop the camera?"

The Camera channel is the collision category deciding "does this object block the camera?". A wall set to Block for Camera shortens the arm; Ignore lets it pass. It can be handled separately from what stops the character.

Make a practice wall by stretching a Cube in the level and setting "Collision Presets" to BlockAll . If your own wall has no effect, check whether Camera is Block, whether the wall has a collision shape, and whether Collision Enabled is Query Only or Query and Physics . Query here means "check whether something is there" rather than physically pushing objects (Collision profiles and channels).

Even when a wall pulls the camera in, Target Arm Length stays 400.

That value is "the length you want". The collision logic changes where the camera is actually placed. Once the wall is gone, the arm can extend back to the configured length.

Also, we use Socket Offset for lateral offsets so the shifted position is included in the obstacle test . Moving FollowCamera's own relative position would desync the tested position from the real camera position.

Separate camera facing from body facing

When you look around with the mouse, should the character's body stay facing its original direction? Or turn with the view, as in a shooter? That is decided separately from camera distance.

The thing to know first is Control Rotation . It represents "which way the player wants to look" and updates with mouse input in the Third Person template. It is held separately from the character's body facing.

CameraBoom's Use Pawn Control Rotation makes the arm use that view rotation. The name Pawn refers to what a player controls, and our Character is one of them.

Face the body toward movement

This suits action games where you run while looking around. We use this combination as our foundation.

Where to set it	Setting	Value
CameraBoom	Use Pawn Control Rotation	On
FollowCamera	Use Pawn Control Rotation	Off. It takes facing from the arm
"Class Defaults" at the top of the Blueprint	Use Controller Rotation Yaw	Off
Character Movement	Orient Rotation to Movement	On
Character Movement	Use Controller Desired Rotation	Off

Yaw is left-right rotation. We turn off matching the body directly to the view's Yaw and let Character Movement handle "face the direction of intended movement".

Play and move the mouse while standing still. The camera circles but the body keeps its original facing. Press a movement key and the body turns toward the movement direction.

Face the body the same way as the view

For a TPS where you strafe while aiming forward, change the settings above so Use Controller Rotation Yaw is on and Orient Rotation to Movement is off. Leave the rest as is.

Now looking left and right with the mouse turns the body the same way. It matches the body to the direction the camera looks, not to where the camera sits . To make strafing and backing up look right, prepare matching animations too (Anim BP and Blend Space).

Rather than enabling both rotation styles at once, standardize on one of these two patterns. After trying both, return to pattern A for the hands-on.

On a custom Pawn, ticking a box does not add mouse input. You need logic calling Add Controller Yaw Input / Add Controller Pitch Input from your look input to update Control Rotation. The template already has that input logic to reuse.

Tune the follow with Camera Lag

Once position and facing are set, look at how it moves when starting to run and stopping. If a camera locked to the character feels stiff, Camera Lag makes it follow with a slight delay.

Turn on CameraBoom's Enable Camera Lag , try Camera Lag Speed at 10 , then change it to 5 and run the same route. 5 catches up more slowly. Watching how the scene moves after you stop makes the difference easier to spot.

Property	How to think about tuning it
Camera Lag Speed	Above 0, larger catches up faster. 0 is the exception, meaning no lag
Camera Lag Max Distance	How far positional lag is allowed. Try 100 cm first. 0 is unlimited
Enable Camera Rotation Lag	Delays view rotation too. Leave it off at first

Stronger lag does not automatically play better. Check whether a sudden direction change leaves you waiting for what you want to see. In games with fine aiming, no rotation lag often fits the controls better.

For the hands-on we turn both positional and rotation lag off, so we compare only the view switching. Add them back to taste afterwards.

Hands-On: pull into an over-the-shoulder view on right-click

Normally it shows a wide surrounding view; hold right-click and it pulls into a closer view. Release and it returns, and pressing again mid-switch turns around from that position.

The diagram illustrates the framing change. Here we build the framing switch. Body facing stays on pattern A, so when comparing the finished shots, walk forward a little to align the character and view, then stop. Weapon aiming and strafing animations can be combined after the camera works.

Preparation: decide the normal and shoulder values

Set BP_ThirdPersonCharacter 's CameraBoom to the normal values below. FollowCamera's relative Location and Rotation are 0 and the rotation style is pattern A.

Property	Normal	Over-the-shoulder
Target Arm Length	400	180
Socket Offset	(0, 0, 0)	(0, 55, 30)
Target Offset	(0, 0, 0)	Unchanged
Do Collision Test	On	Unchanged
Probe Size / Probe Channel	12 / Camera	Unchanged

Prepare the right-click input too.

1. Create an Input Action from "Input" in the Content Browser and name it IA_Aim . "Value Type" is Digital (Bool) , the type handling whether something is held.
2. Open the Input Mapping Context the template actually uses and bind Right Mouse Button to IA_Aim. A Mapping Context maps keys to action names. Add it to the existing context used for movement and jumping, such as IMC_Default .
3. Leave "Triggers" empty on both IA_Aim and the binding. Do not add hold conditions.

If you create a new context, it also needs registering with the player. Editing the one already in use avoids forgetting that. To confirm creating and registering input, see Enhanced Input Basics.

Step 1: build a Timeline going from 0 to 1

A Timeline changes values over time. Here we make one number that goes from 0 to 1 over 0.25 seconds. 0 is normal, 1 is over-the-shoulder, and 0.5 is halfway.

1. Right-click in the Character's Event Graph, choose "Add Timeline", and name it AimBlend .
2. Double-click to open it, add a "Float Track", and name it Alpha . Float is a number type handling decimals.
3. Right-click on the track and add two keys. A key marks "at this time, this value". Select each and set Time / Value to (0, 0) and (0.25, 1) .
4. Select both keys, right-click, and set interpolation to "Linear", which changes at a constant rate between keys. Set "Length" to 0.25 , with "Loop" and "AutoPlay" off.

Back in the Event Graph, right-click and add the IA_Aim event. Connect Started to AimBlend's Play and Completed to Reverse . Connect Canceled to the same Reverse.

For a button with no special Trigger like ours, Started is the press and Completed is the release. Canceled is the fallback when the input evaluation is cancelled partway.

Play and Reverse both continue from the current playback position. Play from Start would jump to the normal-view value when you press again mid-return. We want a smooth reversal, so we use Play.

Step 2: change distance and offset from the same Alpha

Alpha is how far the switch has progressed. We convert that 0-to-1 value into an arm length and a Socket Offset. Lerp does that: it produces a value between A and B, returning A at Alpha 0, B at 1, and exactly halfway at 0.5.

First create two calculation nodes. The Float version appears as "Lerp" in search results. The diagrams write it as Lerp (Float) to distinguish it from the Vector version. Do not create extra variables; type the numbers straight into the A and B fields.

Node	A: normal	B: over-the-shoulder	Alpha
Lerp (Float)	400	180	AimBlend's Alpha output
Lerp (Vector)	(0, 0, 0)	(0, 55, 30)	The same Alpha output

A Vector groups X, Y, and Z into one value. Vector Lerp changes all three together. At Alpha 0.5, arm length is 290 and Socket Offset is (0, 27.5, 15) .

Next, apply those results to CameraBoom. The wiring diagrams split into length and offset, but they are continuations of the same Event Graph .

1. Drag CameraBoom from Components into the Event Graph to place a reference node. It specifies "which arm to change".
2. Drag from its blue output and create Set Target Arm Length and Set Socket Offset . Connect CameraBoom to Target on both.
3. Connect the Float Lerp's Return Value to Set Target Arm Length's value input. Connect the Vector Lerp's Return Value to Set Socket Offset's value input.
4. Wire white exec in the order AimBlend's Update → Set Target Arm Length → Set Socket Offset. Update is when the Timeline refreshes its values.

The AimBlend and Set Target Arm Length on the second diagram's left are the same nodes as in the first. Do not recreate them; pull another wire from the Alpha output and chain the first Set's exec output into the next Set. The "continued from 1" and "continues to 2" labels mark the connection points.

White wires say "when and in what order to set"; colored wires say "which value to use". Target is the arm you operate on and Return Value is what Lerp computed. Do not mix those two up.

Finished fires when playback ends, so we do not use it here. We want every intermediate value applied, hence Update. Lerp only computes values and has no white exec pins.

Compile and save. There is no need to pile calculations onto Event Tick, though the Timeline itself does per-frame updates while playing.

Run it and check walls and re-presses

Start in an open area and try this order.

1. Walk forward, stop, and hold right-click. Success is the camera pulling in over 0.25 seconds with the character toward the left of the screen.
2. Release and confirm it returns to the normal distance and framing.
3. Press briefly, release partway, and press again before it finishes returning. Check it does not jump to an end position but switches from where it is.

0.25 seconds is the time to travel end to end , from normal to over-the-shoulder. Reversing partway only covers the remaining span, so it does not always take 0.25 seconds.

Next, stand with your back to the Cube wall. Rotate the camera with the mouse so the wall comes between the character and the camera . Near the wall the camera pulls in, and once the path clears by moving away or rotating the view, the arm extends again. Try the same in the over-the-shoulder state.

"Just entering a narrow corridor" may change nothing, because no wall enters the camera's path. The key is an arrangement where the arm would cross the wall.

Symptom	Where to check
Right-click changes nothing	Whether IA_Aim was added to the Mapping Context in use, and whether you edited the running Character
It snaps at the very end	Whether Sets run from Update rather than Finished
Only distance changes, no lateral shift	Whether white exec reaches the second Set Socket Offset
Framing jumps on a re-press	Whether it connects to Play rather than Play from Start
It does not return on release	Whether Completed connects to Reverse, and whether a Trigger such as Hold is attached
It passes through walls	Do Collision Test, the wall's Block on Camera, Collision Enabled including Query, and the collision shape
It reacts to walls but the screen edge clips	Return FollowCamera's relative location to 0 and compare while raising Probe Size gradually

Raising Probe Size has no effect on a wall whose test is disabled. Adjust in the order "is the wall detected" then "does it stop far enough from the wall", and causes are easier to trace.

Bonus: Good to Know Up Front

Ticking the rotation boxes but nothing moves vertically

CameraBoom's Inherit Pitch / Yaw / Roll decide whether up-down, left-right, and tilt rotation are inherited. Keep all three on for this practice and leave Transform Rotation as Relative. Even with Use Pawn Control Rotation on, the Inherit restrictions still apply.

Leave the Character's Use Controller Rotation Pitch / Roll off. Pointing the camera up should not tilt the character's body.

You can try a near-first-person view too

For a prototype, set Target Arm Length and Socket Offset to 0 and move the arm's base to eye height for a near-first-person arrangement. If the third-person model blocks the view, though, how you show the body needs adjusting too.

Owner No See hides that model from the owning player's view. To build a proper first-person view showing only the arms, design it with dedicated models and animations.

Distance and field of view are separate adjustments

The Camera's Field of View decides how wide an area is shown at once. Changing arm length moves the camera; changing FOV changes how wide the view is from the same position. It works for adding a sense of speed to a sprint, but move one at a time and compare at first.

Summary

With a Spring Arm, you first decide "where you want the camera" using distance and Offsets. Do Collision Test checks whether it can extend there and pulls the actual camera position in when a wall is in the way.

• Target Arm Length is the length you want, not the distance after a wall pulls it in.
• Socket Offset shifts the arm's tip and Target Offset shifts its base.
• Think about camera and body facing separately, and choose facing movement or facing the view.
• The over-the-shoulder switch changes length and Offset from the same Alpha. Play / Reverse lets it turn around mid-transition.

Once the framing works, try walking, stopping, turning suddenly, and operating near a wall in that order. Looking for both a still position you like and a position that reads well while playing gets you closer to the camera your game needs.

Reference: Spring Arm API, Timeline play and reverse, Enhanced Input, Collision Response Reference.