Unreal Engine's Sequencer is a powerful cinematic tool. It's also designed for linear, pre-authored content — trailers, cinematics rendered to video, and tightly scripted moments. When you need cutscenes that respond to gameplay state, trigger dynamically, and transition seamlessly from player control, Sequencer starts working against you rather than for you.

This tutorial shows you how to build in-game cutscenes using a real-time spline-based camera system. We'll cover everything from basic setup to skippable cinematics, dialogue integration, and the performance considerations that come with running camera systems during live gameplay.

Why Not Just Use Sequencer?

Let's be fair to Sequencer first. It's excellent for what it's designed to do:

• Trailers and marketing content — pre-rendered output at fixed resolution and frame rate
• Non-interactive cinematics — opening cutscenes, end credits, recap sequences
• Complex multi-camera edits — cuts between many angles with precise timing

But Sequencer has friction points for in-game cutscenes:

• Linear timeline — Sequencer plays from start to end. Branching based on gameplay state requires significant workaround
• Blueprint integration overhead — triggering Sequencer from gameplay code means managing Level Sequences, bindings, and playback state
• Transition gaps — moving from player-controlled camera to Sequencer camera and back often produces visible hitches or pops
• Iteration cost — every change means opening the Sequencer editor, adjusting keyframes, and previewing the full sequence
• Skip handling — making a Sequencer cutscene skippable while cleanly restoring gameplay state takes careful setup

None of these are bugs. They're consequences of Sequencer being a timeline-based authoring tool rather than a runtime camera system. For in-game cinematics, you want something built for real-time from the ground up.

Real-Time vs Pre-Rendered: What Changes

When you switch from Sequencer to a real-time camera system, a few things fundamentally change:

You Gain

• Seamless transitions — the camera system can blend smoothly between gameplay and cutscene cameras with no hard cuts or binding swaps
• Gameplay awareness — the camera can react to player position, NPC state, or world conditions in real time
• Runtime flexibility — branching, skipping, and interrupting cutscenes is trivial because the system is designed to be controlled frame-by-frame
• Faster iteration — adjustments happen in the viewport, not in a separate timeline editor

You Lose

• Frame-precise editing — Sequencer lets you place keyframes at exact frames. Spline-based systems work in curves and durations instead
• Multi-track orchestration — Sequencer can simultaneously control cameras, lights, particle effects, skeletal animations, and audio on separate tracks. A real-time system handles camera only; other elements need separate coordination
• Render-to-video — if you need to output a video file, Sequencer with Movie Render Queue is still the right choice

The trade-off is clear: if your cutscene needs to exist within gameplay, real-time wins. If your cutscene is a standalone piece of video content, Sequencer wins.

Setting Up Spline-Based Cutscenes

The Cinematic Spline Tool provides the foundation for real-time camera work. Here's how to set up your first in-game cutscene.

Creating the Camera Path

1. Place a Cinematic Spline Actor in your level
2. Define the camera's path by adding and positioning spline points in the viewport
3. Set the duration (how long the camera takes to travel the full spline)
4. Configure the look-at target — either a fixed point, an actor reference, or a forward-facing mode

The spline defines where the camera goes. The duration defines how fast. The look-at target defines what the camera watches along the way.

Setting Camera Properties Along the Path

At each spline point, you can define camera properties that interpolate smoothly between points:

• Field of view — start wide and push to telephoto for a reveal, or vice versa for a pull-back
• Filmback preset — the tool ships with 17 filmback presets (Super 35, IMAX, anamorphic, and more) that you can switch between for different aesthetic feels
• Shake intensity — add or remove Perlin noise shake at different points along the path. Useful for transitioning from stable establishing shots to handheld-style close-ups
• Depth of field — adjust aperture and focus distance per point to shift focus during the shot

These per-point properties are what turn a simple camera rail into a cinematic shot. A single spline can start as a wide, stable establishing shot, push into a close-up with shallow depth of field, and end with subtle handheld shake — all in one continuous motion.

Multi-Shot Cutscenes

Most cutscenes aren't a single shot. You'll want multiple camera angles with cuts between them. The approach is straightforward:

1. Create multiple Cinematic Spline Actors, each representing one shot
2. Define the shot order and cut timing in a Blueprint or data asset
3. Use the camera switching functions to cut between shots at the right moments

The tool handles the camera possession and depossession cleanly, so cuts between shots don't produce frame glitches or stale render targets. Each shot can have its own duration, look-at target, and camera properties.

Trigger Volume Integration

Cutscenes need to start somewhere. The most common trigger is a volume in the world — walk into this area, and the cutscene plays.

Basic Trigger Setup

1. Place a Box Collision or Trigger Volume where you want the cutscene to activate
2. In the trigger's Blueprint (or Level Blueprint), bind the OnActorBeginOverlap event
3. On overlap, call the cutscene start function, which:
   • Saves the current player camera state
   • Disables player input (movement, camera, actions)
   • Blends to the first cutscene camera over a configurable duration
   • Begins playing the first spline shot

The blend from gameplay camera to cutscene camera is critical. A hard cut can work stylistically, but a smooth blend (typically 0.5 to 1.0 seconds) feels more polished and avoids disorienting the player.

One-Shot vs Repeatable Triggers

Some cutscenes should only play once — the first time you enter an area, see a vista reveal, or meet an NPC. Others might replay (a recurring environmental event, for instance).

Track trigger state with a simple boolean. After the cutscene plays, set bHasPlayed = true and check it in the overlap event. For persistent state across sessions, hook this into your save system. If you're using the Blueprint Template Library, the Save/Load system handles this kind of per-actor state naturally.

Trigger Variations

Beyond simple overlap volumes, consider these trigger types:

• Interaction triggers — player presses a button near an object to start the cutscene. Good for optional content like lore discoveries or NPC conversations
• Gameplay triggers — cutscene fires when a gameplay condition is met (boss health reaches zero, all objectives complete, a key item is collected)
• Timed triggers — cutscene plays after the player has been in an area for a set duration. Useful for idle cameras or ambient storytelling
• Line-of-sight triggers — cutscene starts when the player looks at a specific point. More immersive than volume triggers for vista reveals

Each trigger type just needs to call the same cutscene start function. The camera system doesn't care how it was activated.

Camera Techniques for In-Game Cinematics

The technical setup is one thing. Making cutscenes that actually feel good is another. Here are camera techniques that work particularly well for in-game cinematics.

The Contextual Establishing Shot

Before focusing on the subject of the cutscene, briefly show the player where they are in relation to the world. Start with a wide shot that includes recognizable landmarks from the gameplay space, then push into the cutscene's focal point.

This technique grounds the cutscene in the game world. The player understands that the cutscene is happening here, in this place they've been exploring, not in some disconnected cinematic space.

Set this up with a spline that starts high and wide, then curves down and in toward the subject. Use the dolly zoom feature to maintain the subject's screen size while the background expands during the approach — it creates a subtle but effective "this matters" feeling.

The Follow Shot

For cutscenes involving character movement (an NPC walking to a destination, a vehicle arriving, a creature emerging), use a tracking spline that parallels the subject's path.

Configure the camera to track the moving actor as a look-at target. The Cinematic Spline Tool handles the rotation smoothly, and you can set framing offsets to keep the subject at a rule-of-thirds position rather than dead center.

The Reaction Shot

Cut from the action to the player character's face to show their reaction. This is where multiple spline shots shine — one shot on the event, one shot on the character, cut between them.

For the reaction shot, use a longer focal length (tight telephoto) with shallow depth of field. This isolates the character from the background and puts full visual focus on their expression. The tool's filmback presets make this easy to dial in.

The Environmental Reveal

For moments where the environment itself is the star — entering a vast cavern, seeing a city for the first time, a weather change sweeping across the landscape — use a crane-style shot.

The Cinematic Spline Tool includes crane and jib arm simulation. Start low and behind the player character, then crane up and over to reveal the vista. The physical simulation of the crane arm adds natural acceleration and deceleration that linear keyframe interpolation can't match.

Controlled Shake for Intensity

During action cutscenes — explosions, earthquakes, combat sequences — add Perlin shake to sell the impact. The tool lets you control shake amplitude and frequency independently per axis, so you can create:

• Impact shake — short burst of high-amplitude, high-frequency shake that decays quickly
• Rumble — sustained low-frequency motion for earthquakes or heavy machinery
• Breathing — very low amplitude, very low frequency for intimate close-ups

The Perlin noise approach avoids the mechanical, repetitive feel of sine-wave shake. Each shake instance is unique, which reads as more organic on screen.

Dialogue and Gameplay Integration

Cutscenes rarely exist in isolation. They usually need to play alongside dialogue, trigger gameplay events, or respond to player choices.

Dialogue Sync

If you're using a dialogue system — whether custom-built or from the Blueprint Template Library's Branching Dialogue module — you need camera shots to sync with dialogue lines.

The approach that works best for real-time cutscenes is event-driven shot switching rather than time-based:

1. Define each shot with a dialogue line ID rather than a fixed timestamp
2. When the dialogue system advances to a new line, it fires an event
3. The cutscene system receives the event and switches to the appropriate camera shot
4. The camera blends to its new position while the new dialogue line begins

This decouples shot timing from fixed durations. If the player reads slowly (or if dialogue lines have different audio lengths), the shots naturally stretch and compress to match. No manual timing adjustment needed.

Gameplay Events During Cutscenes

Sometimes you need things to happen in the game world during a cutscene: doors opening, lights changing, particles firing, NPCs moving to new positions. The camera system handles camera only — it doesn't try to be a general-purpose sequencing system.

Instead, fire gameplay events at specific points along the spline using distance-based or time-based callbacks:

• At 30% through the shot: trigger the door animation
• At the cut to shot 3: start the particle effect
• When the camera reaches spline point 4: move the NPC to their mark

These callbacks are simple Blueprint events. You can bind any gameplay logic to them without the camera system needing to know or care about what's happening in the game world.

Branching Cutscenes

If your game has player choices that affect cutscene content, real-time camera systems have a major advantage over Sequencer: branching is just conditional logic.

Before starting a shot, check a gameplay variable. Based on the result, play shot sequence A or shot sequence B. Since each shot is an independent spline actor, branching is just a matter of which splines you activate and in what order.

A conversation cutscene where different dialogue choices lead to different camera angles is straightforward:

1. Player selects dialogue option
2. Dialogue system fires event with the selected option
3. Cutscene controller evaluates the option and selects the corresponding shot sequence
4. Camera blends to the next shot

No timeline duplication. No separate Level Sequences for each branch. Just conditional Blueprint logic.

Skippable and Interruptible Cutscenes

Players skip cutscenes. It's a fact. Your cutscene system needs to handle this gracefully, especially on second playthroughs or when players are replaying sections.

Basic Skip Implementation

The skip flow looks like this:

1. Player presses the skip button (typically a held press to prevent accidental skips)
2. Show a brief "hold to skip" UI indicator
3. If held long enough, the cutscene system:
   • Stops the current camera shot
   • Fires all remaining gameplay events immediately (doors that were supposed to open still need to open)
   • Teleports all relevant actors to their end-of-cutscene positions
   • Blends the camera back to the gameplay camera
   • Re-enables player input

Step 4 is the crucial one. If a cutscene moves an NPC from point A to point B, skipping the cutscene needs to place that NPC at point B, not leave them mid-path. Track "end state" for every actor involved in the cutscene and apply those states on skip.

Interruptible Cutscenes

Some cutscenes shouldn't just be skippable — they should be interruptible by gameplay. An ambush cutscene that gets interrupted when an enemy spots the player. A conversation that ends abruptly when an explosion occurs nearby.

For interruptible cutscenes, the same skip logic applies, but triggered by a gameplay event rather than player input. The camera system blends back to gameplay, remaining events fire, and actors snap to their end states.

The blend-back duration matters here. For a player-initiated skip, a 0.3-second blend feels snappy and responsive. For a gameplay interruption, a slightly longer 0.5 to 0.8 second blend feels more natural, like the camera is reacting to the surprise.

Pause During Cutscenes

If the player pauses the game during a cutscene, the camera system should pause too. Since the spline camera runs in real time, it naturally respects the game's time dilation. When the game is paused (time dilation = 0), the camera stops. When unpaused, it resumes from where it left off.

If you have any logic tied to real time rather than game time, make sure it also respects pause state. Audio, in particular, needs to pause alongside the camera.

Performance Considerations

Real-time camera systems have performance characteristics that differ from Sequencer. Here's what to watch for.

CPU Cost

A spline-based camera system evaluates a spline position and rotation each frame. This is a trivial calculation — a few microseconds per frame, well under any meaningful performance threshold. Even with multiple splines active, the CPU cost is negligible.

The Perlin noise shake calculation is similarly lightweight. Unless you're running hundreds of simultaneous shake instances (which would be a design problem, not a performance one), it won't register on your profiler.

GPU Cost

The camera system itself has zero GPU cost — it's purely a transform calculation. However, camera angles can dramatically affect rendering performance:

• Wide shots see more geometry, draw more triangles, and stress the GPU harder than close-ups
• Shots looking toward dense foliage or particle effects will be more expensive than shots looking at simple geometry
• Rapid camera movement can defeat occlusion culling, causing momentary frame drops as previously hidden geometry suddenly becomes visible

These are level design considerations, not camera system issues, but they matter for in-game cutscenes because your cutscene runs at the same frame rate as gameplay. A Sequencer cutscene rendered to video can take as long as it needs per frame. A real-time cutscene cannot.

Mitigation Strategies

• Test cutscenes on target hardware — not just your development machine
• Profile with the cutscene active — frame rate during gameplay doesn't guarantee frame rate during cutscene camera angles
• Avoid sudden reveals of dense geometry — if a crane shot is going to reveal a massive vista, make sure the transition is gradual enough for streaming and LODs to keep up
• Use depth of field strategically — background blur isn't just aesthetic, it also hides LOD transitions and reduces visual complexity
• Keep shot count reasonable — each cut between shots creates a frame where two camera positions need to be evaluated for blending. This is cheap, but dozens of rapid cuts can add up

Memory Considerations

Each Cinematic Spline Actor is lightweight in memory — the spline data itself is small. The primary memory concern is the same as any level design question: are the assets visible from your cutscene camera angles already loaded?

If your cutscene camera reveals an area that the gameplay camera wouldn't normally see, make sure those assets are loaded before the cutscene starts. Level streaming and loading screens should account for cutscene requirements, not just gameplay requirements.

Putting It All Together: A Complete Example

Let's walk through a complete in-game cutscene setup. The scenario: the player enters a throne room and meets the king for the first time.

Shot List

1. Establishing shot — wide angle from above, showing the full throne room as the player enters through the doors
2. Push-in — camera moves down and forward toward the throne, narrowing the FOV for a more intimate feel
3. Reaction shot — cut to the player character's face, tight telephoto with shallow DOF
4. The king — low angle looking up at the king on the throne, conveying authority and power

Implementation

• Four Cinematic Spline Actors, one per shot
• A Trigger Volume at the throne room entrance
• Dialogue lines synced to shots 2 through 4
• A "skip" handler that places the player at the audience position in front of the throne
• Gameplay events: throne room doors close on shot 1, ambient NPCs turn to watch on shot 2

The Transition

When the player walks through the trigger volume:

1. Input is disabled
2. Camera blends from the gameplay third-person camera to Shot 1's starting position (0.8-second blend)
3. Shot 1 plays for 4 seconds
4. Hard cut to Shot 2 (push-in begins, first dialogue line plays)
5. Dialogue advance triggers cut to Shot 3 (reaction shot)
6. Dialogue advance triggers cut to Shot 4 (the king speaks)
7. After the king's final line, camera blends back to gameplay camera (1.0-second blend)
8. Input is re-enabled

Total cutscene duration: roughly 20 seconds of camera work plus dialogue time. Setup time in the editor: about 30 minutes once you're familiar with the workflow.

Getting Started

The Cinematic Spline Tool handles all of the camera mechanics described in this tutorial — spline paths, filmback presets, dolly zoom, Perlin shake, crane simulation, and smooth blending. The gameplay integration (triggers, dialogue sync, skip handling) uses standard Blueprint, which means you can connect it to any existing gameplay systems.

If you're also building dialogue and quest content, the Blueprint Template Library includes Branching Dialogue and Quest & Objectives modules that pair naturally with cutscene systems. The event-driven dialogue approach described above works directly with the template library's dialogue events.

For a deeper look at specific camera techniques, check out our post on Hollywood camera tricks in UE5.

Sequencer is the right tool for trailers and pre-rendered content. For in-game cutscenes that need to live inside your gameplay, a real-time camera system gives you the control, flexibility, and responsiveness that a timeline-based tool can't match.