gameplay_camera_orbit_device: Swap a Player's View on Cue

Overview

The gameplay_camera_orbit_device (the Camera: Orbit device in UEFN) updates a player's viewpoint so the camera follows a target and can be rotated manually. It inherits its whole Verse surface from the abstract gameplay_camera_device, so everything below applies to the other gameplay camera devices too.

The key mental model is the camera stack. Every player has a stack of cameras. AddTo(Agent) pushes this camera onto that agent's stack and makes it the active view. RemoveFrom(Agent) pops it off, restoring whatever camera was underneath (usually the default gameplay camera). Because it's a stack, you can layer cameras and peel them back in order.

Reach for this device when you want to temporarily change what a player sees: a wide establishing shot when entering a new zone, a top-down view while solving a puzzle, a tight first-person view in a horror experience (set Distance to 0 and tweak the offsets), or a dramatic orbit around a vault door after a cinematic finishes. By configuring the device's Distance/Offset/Speed values in the Details panel and driving AddTo/RemoveFrom from Verse, you control exactly when the swap happens.

API Reference

gameplay_camera_orbit_device

Used to update the camera's viewpoint to follow the target and be rotated manually.

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

gameplay_camera_orbit_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

The scenario: A player steps on a pressure plate in front of a vault door. We play a short cinematic of the door opening, and the moment the cinematic stops we push an orbit camera onto that player so they smoothly settle into a dramatic orbiting view of the open vault. When they step on a second "leave" plate, we pop the camera and hand control back to the normal view.

We need three placed devices: the orbit camera, a cinematic sequence device, and two trigger devices (enter + leave). Configure the orbit camera's Distance/Offset in the Details panel; Verse only decides who sees it and when.

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

vault_reveal_device := class(creative_device):

    # The orbit camera placed in the level. Distance/Offset are set in Details.
    @editable
    OrbitCamera : gameplay_camera_orbit_device = gameplay_camera_orbit_device{}

    # Plays the door-opening cinematic.
    @editable
    DoorCinematic : cinematic_sequence_device = cinematic_sequence_device{}

    # Plate the player steps on to start the reveal.
    @editable
    EnterPlate : trigger_device = trigger_device{}

    # Plate the player steps on to leave the reveal.
    @editable
    LeavePlate : trigger_device = trigger_device{}

    # Runs once when the game starts.
    OnBegin<override>()<suspends>:void =
        # Make sure the camera starts disabled so nobody sees it early.
        OrbitCamera.Disable()
        # When the door cinematic finishes, push the orbit camera.
        DoorCinematic.StoppedEvent.Subscribe(OnCinematicStopped)
        # Subscribe both plates.
        EnterPlate.TriggeredEvent.Subscribe(OnEnterPlate)
        LeavePlate.TriggeredEvent.Subscribe(OnLeavePlate)

    # The enter plate fires this. We play the cinematic for the instigating agent.
    OnEnterPlate(Agent : ?agent):void =
        if (Player := Agent?):
            # Re-enable the camera so it can be pushed once the cinematic ends.
            OrbitCamera.Enable()
            DoorCinematic.Play(Player)

    # StoppedEvent hands us a tuple(), not an agent — so we can't target a
    # single player from here. Push the camera to everyone who is watching.
    OnCinematicStopped():void =
        OrbitCamera.AddToAll()

    # The leave plate fires this. Pop the orbit camera for that one player.
    OnLeavePlate(Agent : ?agent):void =
        if (Player := Agent?):
            OrbitCamera.RemoveFrom(Player)

Line by line:

• The four @editable fields are how Verse gets a handle on the devices you placed in the level. Without declaring the orbit camera as an @editable field, calling OrbitCamera.AddTo(...) would fail with Unknown identifier.
• OnBegin<override>()<suspends>:void = is the entry point. We disable the camera first so it never flickers on before we want it.
• DoorCinematic.StoppedEvent.Subscribe(OnCinematicStopped) wires the cinematic's end to our handler. StoppedEvent is a listenable(tuple()), so the handler takes no agent.
• EnterPlate.TriggeredEvent.Subscribe(OnEnterPlate) connects the plate. TriggeredEvent is a listenable(?agent), so the handler receives (Agent : ?agent).
• In OnEnterPlate we unwrap with if (Player := Agent?): before using the player, then Enable() the camera and Play(Player) the cinematic just for them.
• OnCinematicStopped calls AddToAll() — pushing the orbit camera onto every player's stack as the active view. Because StoppedEvent gives no agent, AddToAll is the natural choice here.
• OnLeavePlate unwraps the agent and calls RemoveFrom(Player) to pop the orbit camera off just that player, restoring their previous view.

Common patterns

Push the camera to a single player on a trigger

When you want a specific player swapped (e.g. they entered a puzzle room), use AddTo(Agent) with the instigating agent.

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

puzzle_camera_device := class(creative_device):

    @editable
    PuzzleCam : gameplay_camera_orbit_device = gameplay_camera_orbit_device{}

    @editable
    RoomEntry : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        RoomEntry.TriggeredEvent.Subscribe(OnEnterRoom)

    OnEnterRoom(Agent : ?agent):void =
        if (Player := Agent?):
            # Top-down puzzle view for just this player.
            PuzzleCam.AddTo(Player)

Pop the camera off everyone at once

When a zone-wide event ends, restore everyone's view with RemoveFromAll().

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

zone_camera_device := class(creative_device):

    @editable
    WideShotCam : gameplay_camera_orbit_device = gameplay_camera_orbit_device{}

    @editable
    EndZoneTimer : timer_device = timer_device{}

    OnBegin<override>()<suspends>:void =
        # When the zone timer completes, drop the wide-shot camera for all.
        EndZoneTimer.SuccessEvent.Subscribe(OnTimerDone)

    OnTimerDone(MaybeAgent : ?agent):void =
        # Pops the camera off every player's stack, restoring their normal view.
        WideShotCam.RemoveFromAll()

Enable/Disable to gate the camera entirely

A disabled camera won't activate even if you try to add it. Use Enable/Disable to turn the whole feature on or off — e.g. only allow the cinematic camera after a teleport.

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

arrival_camera_device := class(creative_device):

    @editable
    ArrivalCam : gameplay_camera_orbit_device = gameplay_camera_orbit_device{}

    @editable
    ArrivalTeleporter : teleporter_device = teleporter_device{}

    OnBegin<override>()<suspends>:void =
        # Off until someone actually arrives.
        ArrivalCam.Disable()
        ArrivalTeleporter.TeleportedEvent.Subscribe(OnArrived)

    OnArrived(Agent : agent):void =
        # Turn the camera on, then push it onto the arriving player.
        ArrivalCam.Enable()
        ArrivalCam.AddTo(Agent)

Gotchas

• You must Enable before Add does anything useful. A camera left disabled won't become active. Call Enable() (or leave it enabled in the Details panel) before AddTo/AddToAll.
• It's a stack — push and pop must balance. Every AddTo should eventually have a matching RemoveFrom (and AddToAll/RemoveFromAll). If you push twice and pop once, the player is still stuck in the camera. Don't mix AddTo(Player) with RemoveFromAll() expecting them to cancel cleanly.
• StoppedEvent hands you tuple(), not an agent. The cinematic's StoppedEvent is listenable(tuple()), so its handler takes no parameters. You cannot target one player from it — use AddToAll/RemoveFromAll, or stash the agent earlier from the trigger that started the cinematic.
• Unwrap ?agent before use. Trigger and timer events deliver (Agent : ?agent). You must write if (Player := Agent?): before passing it to AddTo. A raw ?agent is not an agent.
• Declare the device as an @editable field. Calling methods on a device variable that isn't an @editable field of your creative_device class produces Unknown identifier. Then bind it to the placed device in the Details panel.
• First-person via orbit is a settings trick, not a Verse call. To simulate first-person, set Distance to 0 and tweak Offset X/Z in the Details panel. Verse only controls when the camera is added — the look is configured on the device.