gameplay_camera_fixed_point_device: Cinematic Fixed Cameras in UEFN

Overview

The gameplay_camera_fixed_point_device is a UEFN Creative device that locks the camera to a single world-space position while still allowing it to pivot toward a configurable look-at target. Unlike a follow camera, the device never moves — it only rotates. That makes it ideal for:

• Cutscene moments — a vault door swings open and every player watches from a dramatic angle.
• Boss arenas — players enter a room and the camera snaps to a cinematic overhead view.
• Conversation cameras — an NPC speaks and the camera frames them from a fixed spot.
• Tutorial spotlights — direct a new player's attention to a specific prop or zone.

The device inherits from gameplay_camera_device and exposes six methods: Enable, Disable, AddTo, AddToAll, RemoveFrom, and RemoveFromAll. Cameras are stacked per player — pushing a new camera does not destroy the old one; popping it restores the previous view automatically.

API Reference

gameplay_camera_fixed_point_device

Used to update the camera’s current viewpoint and rotation based on a fixed point.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse). Inherited members are merged from gameplay_camera_device.

gameplay_camera_fixed_point_device<public> := class<concrete><final>(gameplay_camera_device):

Methods (call these to make the device act):

gameplay_camera_device

Used to update the camera's current viewpoint and rotation based on current camera mode.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse).

gameplay_camera_device<public> := class<abstract><epic_internal>(creative_device_base):

Methods (call these to make the device act):

Walkthrough

Scenario: The Vault Reveal

A player steps on a pressure plate. A fixed camera snaps to a dramatic angle showing the vault door opening. After 4 seconds the camera is removed and the player regains their normal view.

Place in your level:

• One trigger_device (the pressure plate)
• One gameplay_camera_fixed_point_device (aimed at the vault door)
• One gameplay_camera_fixed_point_device (a second angle for all players — optional, shown in Common Patterns)

using { /Fortnite.com/Devices }
using { /Fortnite.com/Characters }
using { /Verse.org/Simulation }

# vault_reveal_device — steps on a plate → fixed camera → auto-restore after 4 s
vault_reveal_device := class(creative_device):

    # Wire this to the pressure-plate trigger in the UEFN Details panel
    @editable
    PressurePlate : trigger_device = trigger_device{}

    # Wire this to the Fixed Point Camera device aimed at the vault door
    @editable
    VaultCamera : gameplay_camera_fixed_point_device = gameplay_camera_fixed_point_device{}

    # How long (seconds) the cinematic camera holds before restoring the player view
    @editable
    CameraHoldSeconds : float = 4.0

    OnBegin<override>()<suspends> : void =
        # Make sure the camera device is active before we use it
        VaultCamera.Enable()
        # Subscribe: whenever the plate fires, run OnPlateTriggered
        PressurePlate.TriggeredEvent.Subscribe(OnPlateTriggered)

    # Called by the trigger — Agent is ?agent so we must unwrap it
    OnPlateTriggered(RawAgent : ?agent) : void =
        if (A := RawAgent?):
            # Push the vault camera onto THIS player's stack only
            VaultCamera.AddTo(A)
            # Spawn a concurrent task to remove it after the hold time
            spawn { RemoveCameraAfterDelay(A) }

    RemoveCameraAfterDelay(A : agent)<suspends> : void =
        # Wait for the cinematic hold duration
        Sleep(CameraHoldSeconds)
        # Pop the vault camera — the player's default camera resumes
        VaultCamera.RemoveFrom(A)

Line-by-line explanation:

Common Patterns

Pattern 1 — Broadcast to All Players (Boss Entrance)

When a boss spawns, every player on the island should see the same dramatic angle simultaneously. Use AddToAll and RemoveFromAll.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

# boss_entrance_camera_device — shows a fixed camera to ALL players for 5 seconds
boss_entrance_camera_device := class(creative_device):

    # Wire to the trigger that fires when the boss spawns
    @editable
    BossSpawnTrigger : trigger_device = trigger_device{}

    # The Fixed Point Camera framing the boss spawn point
    @editable
    BossCamera : gameplay_camera_fixed_point_device = gameplay_camera_fixed_point_device{}

    @editable
    HoldSeconds : float = 5.0

    OnBegin<override>()<suspends> : void =
        BossCamera.Enable()
        BossSpawnTrigger.TriggeredEvent.Subscribe(OnBossSpawned)

    OnBossSpawned(RawAgent : ?agent) : void =
        # Push the boss camera onto EVERY player's stack at once
        BossCamera.AddToAll()
        spawn { RestoreAllCameras() }

    RestoreAllCameras()<suspends> : void =
        Sleep(HoldSeconds)
        # Pop the boss camera from every player simultaneously
        BossCamera.RemoveFromAll()

Pattern 2 — Enable / Disable to Gate Camera Usage

Sometimes you want to prevent a camera from being pushed at all — for example, during a safe zone where no cinematics should interrupt gameplay. Disable blocks future AddTo calls; Enable reopens it.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

# camera_gate_device — two buttons: one enables the cinematic camera, one disables it
camera_gate_device := class(creative_device):

    @editable
    CinematicCamera : gameplay_camera_fixed_point_device = gameplay_camera_fixed_point_device{}

    # Button that re-enables the camera (e.g., "Start Cinematic Zone")
    @editable
    EnableButton : button_device = button_device{}

    # Button that disables the camera (e.g., "End Cinematic Zone")
    @editable
    DisableButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # Start disabled — no cinematics until the designer enables the zone
        CinematicCamera.Disable()
        EnableButton.InteractedWithEvent.Subscribe(OnEnablePressed)
        DisableButton.InteractedWithEvent.Subscribe(OnDisablePressed)

    OnEnablePressed(RawAgent : ?agent) : void =
        # Re-open the camera for use
        CinematicCamera.Enable()

    OnDisablePressed(RawAgent : ?agent) : void =
        # Lock the camera — AddTo calls will have no effect while disabled
        CinematicCamera.Disable()

Pattern 3 — Per-Player Camera with Manual Removal via Button

A player walks into a security booth and a fixed camera activates. They press a button to dismiss it themselves.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

# security_booth_camera_device — enter zone → camera on; press button → camera off
security_booth_camera_device := class(creative_device):

    @editable
    EntryTrigger : trigger_device = trigger_device{}

    @editable
    DismissButton : button_device = button_device{}

    @editable
    BoothCamera : gameplay_camera_fixed_point_device = gameplay_camera_fixed_point_device{}

    OnBegin<override>()<suspends> : void =
        BoothCamera.Enable()
        EntryTrigger.TriggeredEvent.Subscribe(OnPlayerEntered)
        DismissButton.InteractedWithEvent.Subscribe(OnDismissPressed)

    OnPlayerEntered(RawAgent : ?agent) : void =
        if (A := RawAgent?):
            BoothCamera.AddTo(A)

    OnDismissPressed(RawAgent : ?agent) : void =
        if (A := RawAgent?):
            # Player chose to leave the camera view — restore their normal camera
            BoothCamera.RemoveFrom(A)

Gotchas

1. Always unwrap ?agent before calling AddTo / RemoveFrom

Events from trigger_device and button_device deliver ?agent (an optional), not a bare agent. Calling AddTo requires a concrete agent. Always unwrap:

if (A := RawAgent?):
    BoothCamera.AddTo(A)

Skipping the unwrap is a compile error.

2. Enable / Disable ≠ push / pop

Enable and Disable control whether the device is allowed to operate — they do not push or remove the camera from any player's stack. A disabled camera that was already pushed stays visible until you call RemoveFrom. Always call Enable() in OnBegin if you want the camera ready from the start.

3. Camera stacks are per-player

AddTo(A) only affects player A. Other players continue seeing their own cameras. If you want a global cinematic, use AddToAll() — but remember to pair it with RemoveFromAll() or individual players may be stuck in the cinematic view forever.

4. RemoveFrom only pops this device

If you pushed multiple cameras onto a player's stack, RemoveFrom only removes the one you call it on. The stack order matters — the engine restores the next camera below the one you removed, not necessarily the default camera.

5. Sleep requires <suspends> on the enclosing function

Any function that calls Sleep must be marked <suspends>. Use spawn { } to run a suspending function from a non-suspending event handler (like a Subscribe callback).

6. Place and orient the device in the UEFN viewport

The fixed point camera's position and look-at target are configured in the UEFN Details panel — not in Verse. Make sure the device is placed, rotated, and its look-at target is set before playtesting. Verse only controls when and to whom the camera is pushed.