Rotation and Interpolation Basics in UE5: Rotator, Interp To, and Lerp

You wrote the code to make an enemy face the player, and it snapped around in a single frame. You tried to swivel a turret smoothly and it spun the long way around, away from the target. You reached for Lerp and nothing moved at all.

Rotation is one of the first places people get stuck in UE. The cause isn't hard math. It's the fact that angles wrap around, plus similar-looking nodes that exist for different purposes. This article covers what a Rotator actually is, why the long-way spin happens, and when to use Interp To vs. Lerp, ending with a turret that smoothly swivels to track the player.

What You'll Learn

• Rotator is three angles; Quaternion is the orientation itself
• Why rotating from 350 to 10 degrees goes the long way
• Building a rotation (Find Look at Rotation / Make Rotator)
• RInterp To / VInterp To / FInterp To and what Interp Speed does
• Lerp and Interp To are different tools (blend vs. approach)
• Hands-on: a turret that smoothly swivels to track the player

---

Rotator Is Three Angles, Quaternion Is the Orientation

Whenever rotation is visible in UE, it's almost always a Rotator. The Rotation field in the details panel and the rotation pins in Blueprint are all Rotators.

A Rotator is three angles bundled together.

Component	Axis	What it looks like
Roll	Around X	A plane banking sideways
Pitch	Around Y	Looking up and down
Yaw	Around Z	Turning left and right

A character turning left or right is Yaw; aiming up or down is Pitch. Those two will carry you for a long time.

A Quaternion is the form UE stores rotations in internally. Where a Rotator is three separate angles, a Quaternion holds the orientation as a single unit.

You almost never need to touch Quaternions directly in normal Blueprint work. Rotators and the interpolation nodes in this article are enough. They come up when you compose rotations yourself, or when interpolation visibly misbehaves.

Why have both? Rotators are easy for humans to read and write, but they're bad at interpolating and combining. Quaternions are the reverse: meaningless to read, but exact to interpolate and combine. UE splits the roles — Rotators for showing, Quaternions for computing.

---

The Accident of Wrapping Angles

The first thing rotation does to you is spin the long way.

Say your turret is at 350 degrees and the target is at 10 degrees. To your eye that's "20 more degrees to the right." Numerically, though, 350 and 10 are 340 apart.

Blend Rotator values directly and you get the far path: 340 degrees all the way around instead of the near 20.

That's what "it spun away from the target" actually is. Not a bug — just the ordinary fact that angles wrap at 360 while the numbers representing them don't.

The fix is simple: use the rotation-specific interpolation nodes. RInterp To picks the shorter way internally, so this never happens there. The long-way spin only shows up when you subtract and blend angles yourself.

---

Three Tools for Building a Rotation

Before you can interpolate, you need a target rotation. Three nodes cover most cases.

Node	What it does	When
Find Look at Rotation	Returns the rotation that points A at B	An enemy facing the player, a turret aiming
Make Rotator	Builds one from Roll / Pitch / Yaw values	Fixed orientations like "straight up"
Get Actor Rotation	Reads your current rotation	As the starting point for interpolation

Find Look at Rotation is by far the most used. Feed your position into Start and the other object's position into Target, and you get back a Rotator pointing at them. No angle math on your side.

Positions come from Get Actor Location. Remember it as: two positions are all you need to build a rotation.

When you don't want it tilting. Find Look at Rotation also tilts Pitch when the target is above or below you. For something like a turret base that should only rotate horizontally, run the result through Break Rotator, take just the Yaw, and rebuild it with Make Rotator (Roll = 0, Pitch = 0).

---

The Interp To Nodes

Knowing the target rotation isn't enough. Feed it straight into Set Actor Rotation and it snaps in a single frame. The Interp To family is what smooths it out.

Node	Type	When
RInterp To	Rotation (Rotator)	An enemy turning, a turret swiveling
VInterp To	Position (Vector)	A camera trailing, UI sliding in
FInterp To	Number (Float)	A health bar draining, FOV shifting

All three share the same pins.

Pin	What goes in
Current	The current value (Get Actor Rotation, etc.)
Target	The goal value (the result of Find Look at Rotation, etc.)
Delta Time	Delta Seconds from Event Tick
Interp Speed	How fast it closes in. Bigger is faster

Always wire up Delta Time. Without it, the speed of the motion changes with the machine's frame rate. Feeding Delta Seconds from Event Tick straight in is the standard form.

The other property worth internalizing: Interp To slows down as it gets close. It doesn't move at a constant rate.

That built-in deceleration is why picking a single Interp Speed gives you a natural, weighted motion. Rough guide:

• Around 2.0: Slow. A heavy turret, a large boss turning
• Around 5.0: Standard. A humanoid enemy turning around
• 10.0 and up: Snappy. Player aim, camera follow

---

Lerp and Interp To Are Different Tools

"I used Lerp and nothing happened" is the other classic. The reason is that Lerp and Interp To exist for different jobs.

	Lerp	Interp To
What it does	Blends A and B by Alpha	Steps from current toward target
Alpha / progress	You drive it 0 → 1	The node advances it for you
Where it lives	Off a Timeline curve	Event Tick
Good for	Fixed-duration motion	Chasing motion

Leave a constant 0.5 in Lerp's Alpha and every frame returns the same midpoint between A and B, which looks like nothing is happening. That's the whole story behind "Lerp doesn't work."

Pick between them like this:

• A door that opens over 2 seconds — the duration is fixed → drive Alpha with a Timeline node and Lerp
• An enemy turning to follow the player — the target keeps moving → Interp To

A turret tracking a moving target is the second kind. The goal changes every frame, so it can't be a motion with a fixed end.

---

Hands-On: A Turret That Smoothly Tracks the Player

A tower defense turret, a shoot-'em-up's auto-cannon, a stealth game's security camera. "Slowly aim at a moving target" shows up across genres. We'll build one turret and compare swivel speeds.

What we're building

Create an Actor called BP_Turret with two components.

Component	Role
Base (Static Mesh: Cylinder)	The base. Doesn't move
Head (Static Mesh: Cube)	The barrel. This is what rotates. Child of Base

One variable:

Variable	Type	Default	Purpose
TurnSpeed	Float	2.0	Swivel speed (goes into Interp Speed)

The target is the player. Place one BP_Turret in the level with room to walk around it.

Wiring it up

Four steps on Event Tick.

1. Get Player Pawn, then Get Actor Location for their position
2. Find Look at Rotation with Start = Head's Get World Location and Target = the player's position
3. Run the result through Break Rotator and feed only the Yaw into Make Rotator (Roll = 0.0, Pitch = 0.0), so the barrel stays level
4. RInterp To with Current = Head's Get World Rotation, Target = the result of step 3, Delta Time = Delta Seconds, Interp Speed = TurnSpeed, then feed the result into Set World Rotation (Target: Head)

As read-aloud pseudocode:

BP_Turret (Event Graph)
Event Tick (Delta Seconds)
  → player = GetPlayerPawn(0)
  → targetLoc = player.GetActorLocation()
  → look = FindLookAtRotation(Start = Head.GetWorldLocation(), Target = targetLoc)
  // Keep it level: use only Yaw
  → yawOnly = MakeRotator(Roll = 0.0, Pitch = 0.0, Yaw = BreakRotator(look).Yaw)
  → newRot = RInterpTo(
        Current     = Head.GetWorldRotation(),
        Target      = yawOnly,
        DeltaTime   = Delta Seconds,
        InterpSpeed = TurnSpeed)
  → Head.SetWorldRotation(newRot)

Checking it

Hit Play and walk around the turret. If it's working, the barrel trails slightly behind you, and settles dead on you about a second after you stop. Sprint around to the back and you'll see it fall behind and catch up.

Now change TurnSpeed from 2.0 to 10.0 and walk the same path. It sticks to you with almost no lag. That single number is the difference between a heavy emplacement and a snappy radar.

Troubleshooting:

• It snaps instantly → You're feeding Find Look at Rotation straight into Set World Rotation without RInterp To
• It barely moves, or the speed differs between machines → Delta Seconds isn't wired into Delta Time
• The barrel tilts → The Break Rotator / Make Rotator step that keeps only Yaw is missing
• The whole base rotates → Set World Rotation's Target is the Actor itself (self) instead of Head

Two things to take away.

• Separate "where to aim" from "how fast to get there": Find Look at Rotation answers the first, RInterp To the second. Keeping them in separate nodes means you can tune the feel later without touching the aiming
• Interp Speed is a gameplay knob: slow means "a heavy gun you can flank," fast means "a radar you can't outrun." Since one number changes the difficulty, moving it into a Data Asset lets each enemy carry its own

When you want a fixed-duration motion instead of a chase — a door that opens over two seconds — that's Timeline's job.

---

Bonus: Good to Know for Later

Set replaces, Add accumulates. Set Actor Rotation throws away the current rotation and installs the one you give it. Add Actor Local Rotation adds to the current one. "Spin one degree every frame" wants Add; "face this way" wants Set.

World vs. Relative. Set World Rotation is in world space; Set Relative Rotation is relative to the parent. For a component like the turret's Head that has a parent (Base), Relative feels more natural once the parent itself starts rotating. Build with World first and reach for Relative when the parent moves.

That word, gimbal lock. Push a Rotator's Pitch toward straight up (90 degrees) and Roll and Yaw start overlapping in effect, making rotation behave strangely. That's gimbal lock. You won't meet it if you only rotate horizontally. It's enough to remember it exists when you start building aircraft or free-look cameras.

Character facing can be delegated. You don't have to write the "face the direction of movement" logic yourself. The Character Movement Component has Orient Rotation to Movement and Rotation Rate for exactly that. What's in this article matters when you want to control facing independently of movement: turrets, security cameras, heads that turn.

---

Summary

When rotation misbehaves, it's usually one of these:

• It snaps → No interpolation. Insert RInterp To
• It spins the long way → You're blending angles by hand. Let the rotation nodes do it
• The speed varies by machine → Delta Time isn't wired
• Lerp does nothing → Nobody is driving Alpha. Use a Timeline if the duration is fixed

There isn't much to memorize. Build the rotation with Find Look at Rotation, smooth it with RInterp To, apply it with Set. That three-node run is the basic shape of rotation control.

Change Interp Speed alone and the turret's whole personality changes. How fast should the enemies in your game turn around?