gameplay_camera_first_person_device: First-Person Camera Control in Verse

Overview

The gameplay_camera_first_person_device is a concrete subclass of gameplay_camera_device that renders the world from the player character's own viewpoint. Drop it into your UEFN level, wire it to Verse, and you can:

• Switch a single player to first-person when they step on a pressure plate, enter a trigger volume, or pick up an item.
• Force all players into first-person simultaneously for a cinematic reveal or a game-mode rule.
• Stack cameras — because the device uses a camera stack, removing it restores whatever camera was active before, so you never have to track "what was the old camera?" yourself.

Reach for this device any time you want a per-player or global first-person moment that can be toggled on and off cleanly at runtime.

API Reference

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: A horror map has a narrow vent the player must crawl through. The moment they enter a trigger at the vent entrance, the view snaps to first-person. When they exit the other end (a second trigger), the camera is removed and the default view returns.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# Drop this creative_device into your level alongside:
#   - EnterTrigger : trigger_device  (placed at the vent entrance)
#   - ExitTrigger  : trigger_device  (placed at the vent exit)
#   - VentCamera   : gameplay_camera_first_person_device
vent_camera_manager := class(creative_device):

    # The first-person camera device placed in the level.
    @editable
    VentCamera : gameplay_camera_first_person_device = gameplay_camera_first_person_device{}

    # Trigger at the entrance of the vent.
    @editable
    EnterTrigger : trigger_device = trigger_device{}

    # Trigger at the exit of the vent.
    @editable
    ExitTrigger : trigger_device = trigger_device{}

    # Called when the level starts.
    OnBegin<override>()<suspends> : void =
        # Make sure the camera device is active so it can be pushed onto stacks.
        VentCamera.Enable()

        # Subscribe to both triggers. The trigger_device fires listenable(?agent).
        EnterTrigger.TriggeredEvent.Subscribe(OnEnterVent)
        ExitTrigger.TriggeredEvent.Subscribe(OnExitVent)

    # Handler: player steps into the vent entrance.
    OnEnterVent(MaybeAgent : ?agent) : void =
        # Unwrap the optional agent before using it.
        if (Agent := MaybeAgent?):
            # Push the first-person camera onto this player's camera stack.
            # Their current camera is preserved underneath.
            VentCamera.AddTo(Agent)

    # Handler: player steps out of the vent exit.
    OnExitVent(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            # Pop the first-person camera off this player's stack.
            # The previously active camera automatically becomes current again.
            VentCamera.RemoveFrom(Agent)

Line-by-line explanation:

Common patterns

Pattern 1 — Force all players into first-person at round start, restore at round end

Useful for a tactical shooter where every player must be in first-person for the entire round.

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

# Requires:
#   - RoundCamera : gameplay_camera_first_person_device
#   - RoundStartButton : button_device  (host presses to begin the round)
#   - RoundEndButton   : button_device  (host presses to end the round)
round_fp_camera := class(creative_device):

    @editable
    RoundCamera : gameplay_camera_first_person_device = gameplay_camera_first_person_device{}

    @editable
    RoundStartButton : button_device = button_device{}

    @editable
    RoundEndButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        RoundCamera.Enable()
        RoundStartButton.InteractedWithEvent.Subscribe(OnRoundStart)
        RoundEndButton.InteractedWithEvent.Subscribe(OnRoundEnd)

    # Push first-person onto every connected player's camera stack.
    OnRoundStart(MaybeAgent : ?agent) : void =
        RoundCamera.AddToAll()

    # Pop first-person off every player's camera stack simultaneously.
    OnRoundEnd(MaybeAgent : ?agent) : void =
        RoundCamera.RemoveFromAll()

Key call: AddToAll() / RemoveFromAll() — no need to iterate players; the device handles every current player in one call.

Pattern 2 — Disable the device to prevent any new additions

Sometimes you want to lock the camera system during a cutscene so no trigger can accidentally push a new camera. Disable() prevents the device from being added to any new stacks until Enable() is called again.

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

# Requires:
#   - FPCamera      : gameplay_camera_first_person_device
#   - CutsceneTrigger : trigger_device  (fires when cinematic starts)
#   - CutsceneEnd     : trigger_device  (fires when cinematic ends)
cutscene_camera_lock := class(creative_device):

    @editable
    FPCamera : gameplay_camera_first_person_device = gameplay_camera_first_person_device{}

    @editable
    CutsceneTrigger : trigger_device = trigger_device{}

    @editable
    CutsceneEnd : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        FPCamera.Enable()
        CutsceneTrigger.TriggeredEvent.Subscribe(OnCutsceneStart)
        CutsceneEnd.TriggeredEvent.Subscribe(OnCutsceneFinish)

    # Cinematic begins: remove first-person from everyone and lock the device.
    OnCutsceneStart(MaybeAgent : ?agent) : void =
        # Remove the FP camera from all players so the cinematic camera can take over.
        FPCamera.RemoveFromAll()
        # Disable the device so no stray trigger can re-add it mid-cinematic.
        FPCamera.Disable()

    # Cinematic ends: re-enable and push first-person back to all players.
    OnCutsceneFinish(MaybeAgent : ?agent) : void =
        FPCamera.Enable()
        FPCamera.AddToAll()

Key calls: Disable() locks the device; Enable() + AddToAll() restores gameplay.

Pattern 3 — Per-player toggle (add if not active, remove if active) using a single button

A button in a lobby lets each player opt into first-person mode individually.

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

# Requires:
#   - ToggleCamera : gameplay_camera_first_person_device
#   - ToggleButton : button_device
fp_toggle_device := class(creative_device):

    @editable
    ToggleCamera : gameplay_camera_first_person_device = gameplay_camera_first_person_device{}

    @editable
    ToggleButton : button_device = button_device{}

    # Track which players currently have the FP camera active.
    var ActivePlayers : []agent = array{}

    OnBegin<override>()<suspends> : void =
        ToggleCamera.Enable()
        ToggleButton.InteractedWithEvent.Subscribe(OnToggle)

    OnToggle(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            # Check if this agent is already in the active list.
            if (Index := ActivePlayers.Find[Agent]):
                # Already in FP — remove the camera and drop from tracking list.
                ToggleCamera.RemoveFrom(Agent)
                set ActivePlayers = ActivePlayers.RemoveElement[Index]
            else:
                # Not in FP — add the camera and track the agent.
                ToggleCamera.AddTo(Agent)
                set ActivePlayers = ActivePlayers + array{Agent}

Key calls: AddTo(Agent) / RemoveFrom(Agent) for fine-grained per-player control.

Gotchas

1. Always Enable() before AddTo() / AddToAll()

A disabled gameplay_camera_first_person_device silently ignores stack-push calls. Call Enable() in OnBegin (or before any push) to ensure the device is armed. If players report the camera not switching, a missing Enable() is the first thing to check.

2. The camera stack is per-player — RemoveFrom only removes YOUR device

RemoveFrom(Agent) only pops this specific device from the player's stack. It does not clear other cameras that were pushed by other devices. If you have multiple camera devices active, each must be removed individually.

3. RemoveFromAll() affects players currently in the session

RemoveFromAll() only operates on agents connected at the moment of the call. Players who join after the call will not have the camera removed from their stack (because it was never added to them post-join). If you need late-joiners handled, subscribe to a player-joined event and call AddTo / RemoveFrom accordingly.

4. ?agent unwrap is mandatory

Trigger and button events fire listenable(?agent). Passing a ?agent directly to AddTo() is a compile error — AddTo expects agent, not ?agent. Always unwrap: if (A := MaybeAgent?): before calling any camera method.

5. gameplay_camera_first_person_device is <epic_internal> at the base class

The base class gameplay_camera_device is marked <epic_internal> and <abstract> — you cannot instantiate it directly or subclass it yourself. Always use the concrete gameplay_camera_first_person_device{} as your @editable field type and drag the matching placed device into the slot in the Details panel.

6. This feature was Experimental at launch

The First Person Camera Mode device launched as an Experimental feature. APIs may evolve between UEFN versions. Pin your project's engine version and re-test camera behaviour after any engine update.