gameplay_camera_first_person_device: Eyes on the Horizon

Overview

The Gameplay Camera First Person device is a placeable UEFN device that overrides the default Fortnite third-person camera with a first-person viewpoint rendered from the player character's eye position. It lives on a camera stack: you push it on with AddTo / AddToAll and pop it off with RemoveFrom / RemoveFromAll, so the previous camera automatically resumes when you remove it — no manual restore needed.

When to reach for it:

• Tactical or horror moments where immersion matters (scanning a foggy cove for enemy ships).
• Minigame phases that need a different feel from the surrounding island (a first-person archery challenge on a clifftop).
• Cinematic beats — push first-person at the climax, pop it when the cutscene ends.

The device also exposes Enable / Disable to gate whether it can be added to any camera stack at all, giving you a master on/off switch independent of individual players.

API Reference

camera

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

camera<native><public> := class(collision_channel):

gameplay_camera_first_person_device

Used to update the camera's viewpoint from the perspective of the player character.

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

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

Methods (call these to make the device act):

vector3

3-dimensional vector with float components.

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

vector3<native><public> := struct<concrete><computes><persistable><uht_comparable>:

Walkthrough

Scenario — The Clifftop Lookout

Your cel-shaded pirate island has a wooden dock jutting out over a sun-bright lagoon. When a player walks onto a trigger plate at the dock's edge, the world snaps to first-person so they can scan the horizon for enemy sails. When they step off, the familiar third-person view returns.

Place in your island:

1. A trigger_device (the dock pressure plate).
2. A gameplay_camera_first_person_device (configure FOV, head-bob, etc. in its Details panel).

Then wire them together with the Verse device below.

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

# Clifftop lookout — steps onto dock → first-person; steps off → back to third-person.
clifftop_lookout_device := class(creative_device):

    # Wire this to the trigger plate at the dock edge.
    @editable
    DockTrigger : trigger_device = trigger_device{}

    # Wire this to the Gameplay Camera First Person device placed on the island.
    @editable
    FirstPersonCam : gameplay_camera_first_person_device = gameplay_camera_first_person_device{}

    # Wire this to a second trigger that marks the "off" zone (back of the dock).
    @editable
    DockExitTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Make sure the device is active and ready to be pushed onto camera stacks.
        FirstPersonCam.Enable()

        # Subscribe to both triggers.
        DockTrigger.TriggeredEvent.Subscribe(OnDockEntered)
        DockExitTrigger.TriggeredEvent.Subscribe(OnDockExited)

    # Called when a player steps onto the dock plate.
    OnDockEntered(Agent : ?agent) : void =
        if (A := Agent?):
            # Push first-person onto this player's camera stack.
            FirstPersonCam.AddTo(A)

    # Called when a player steps off the dock.
    OnDockExited(Agent : ?agent) : void =
        if (A := Agent?):
            # Pop first-person — the previous camera resumes automatically.
            FirstPersonCam.RemoveFrom(A)

Line-by-line breakdown:

Common patterns

Pattern 1 — Global first-person for all players at round start

Some game modes (a pirate ship boarding sequence) want everyone in first-person the moment the round begins, then back to normal at round end.

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

# Pushes first-person for every player when the round starts,
# removes it when the round ends.
round_firstperson_device := class(creative_device):

    @editable
    FirstPersonCam : gameplay_camera_first_person_device = gameplay_camera_first_person_device{}

    @editable
    RoundStartTrigger : trigger_device = trigger_device{}

    @editable
    RoundEndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        FirstPersonCam.Enable()
        RoundStartTrigger.TriggeredEvent.Subscribe(OnRoundStart)
        RoundEndTrigger.TriggeredEvent.Subscribe(OnRoundEnd)

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

    OnRoundEnd(Agent : ?agent) : void =
        # Pop first-person from every player at once.
        FirstPersonCam.RemoveFromAll()

Key call: AddToAll() / RemoveFromAll() — one call, every player affected simultaneously. Ideal for phase transitions in party games.

Pattern 2 — Disable the camera device mid-game to lock players out

Imagine a cove where first-person is only available during the scouting phase. Outside that window, you want to prevent any new additions to the stack — even if a trigger fires late.

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

# Enables first-person only during the scouting phase;
# disables it (and clears all stacks) when the phase ends.
scout_phase_device := class(creative_device):

    @editable
    FirstPersonCam : gameplay_camera_first_person_device = gameplay_camera_first_person_device{}

    @editable
    ScoutPhaseStart : trigger_device = trigger_device{}

    @editable
    ScoutPhaseEnd : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Start disabled — no player can enter first-person yet.
        FirstPersonCam.Disable()
        ScoutPhaseStart.TriggeredEvent.Subscribe(OnScoutStart)
        ScoutPhaseEnd.TriggeredEvent.Subscribe(OnScoutEnd)

    OnScoutStart(Agent : ?agent) : void =
        # Arm the device; subsequent AddTo / AddToAll calls will now work.
        FirstPersonCam.Enable()
        # Immediately push for everyone entering the scouting phase.
        FirstPersonCam.AddToAll()

    OnScoutEnd(Agent : ?agent) : void =
        # Remove from all stacks first, then disable.
        FirstPersonCam.RemoveFromAll()
        # Disable prevents any straggler triggers from re-adding it.
        FirstPersonCam.Disable()

Key calls: Enable() and Disable() act as a master gate. Disable() after RemoveFromAll() ensures no late-firing trigger can sneak the camera back in.

Pattern 3 — Per-player toggle (button press switches view back and forth)

A lagoon exploration mode lets each player personally toggle first-person on and off via a button device.

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

# Each press of the toggle button switches the player between
# first-person and default camera.
view_toggle_device := class(creative_device):

    @editable
    FirstPersonCam : gameplay_camera_first_person_device = gameplay_camera_first_person_device{}

    @editable
    ToggleButton : button_device = button_device{}

    # Track which agents currently have first-person active.
    var ActiveAgents : []agent = array{}

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

    OnToggle(Agent : agent) : void =
        # Check if this agent is already in first-person.
        if (Index := ActiveAgents.Find[Agent]):
            # They are — remove first-person and drop them from the list.
            FirstPersonCam.RemoveFrom(Agent)
            set ActiveAgents = ActiveAgents.RemoveElement[Index]
        else:
            # They aren't — push first-person and track them.
            FirstPersonCam.AddTo(Agent)
            set ActiveAgents = ActiveAgents + array{Agent}

Key calls: AddTo(Agent) and RemoveFrom(Agent) used conditionally based on local state. Note that button_device.InteractedWithEvent delivers a concrete agent (not ?agent), so no unwrap is needed.

Gotchas

1. TriggeredEvent delivers ?agent, not agent

A trigger_device's TriggeredEvent is typed listenable(?agent). Your handler signature must be (Agent : ?agent) and you must unwrap with if (A := Agent?): before passing A to AddTo or RemoveFrom. Passing the ?agent directly is a compile error.

2. Enable / Disable vs. AddTo / RemoveFrom — they are not the same

Disable() prevents the device from being used at all — it does not automatically pop the camera from existing stacks. Always call RemoveFromAll() before Disable() if you want players to return to the default view.

3. Camera stack order matters

The stack is LIFO. If you push Camera A then Camera B, removing B restores A — not the default. If you push the same gameplay_camera_first_person_device twice for the same player (e.g., two triggers fire in quick succession), you'll need two RemoveFrom calls to fully unwind it. Guard against double-pushes with a tracking array (see Pattern 3).

4. The device must be placed in the viewport

You cannot instantiate gameplay_camera_first_person_device in Verse code. It must be dragged from the Content Browser into your island and then referenced via an @editable field. A bare gameplay_camera_first_person_device{} default in the field declaration is just a compile-time placeholder — the real device is the one you wire up in the Details panel.

5. This is an Experimental feature

As of the 31.30 release notes, the First Person Camera Mode device is marked Experimental. The API surface may change before it reaches Beta, and islands built with it cannot be published until the feature graduates. Pin your UEFN version and re-test after each engine update.