gameplay_camera_fixed_angle_device: Top-Down & Side-Scroller Cameras

Overview

The Fixed Angle Camera device (gameplay_camera_fixed_angle_device) follows a player through the world while holding a constant rotation. You configure its pitch, yaw, FOV, distance, and follow speeds in the Details panel — Verse's job is to decide who sees it and when.

Use this device when you want:

• A top-down view (Angle Pitch ≈ 90°) for a dungeon or battle-royale zone.
• A side-scroller view (Angle Yaw ≈ 90°) for a platformer.
• A cinematic isometric perspective for a strategy mini-game.

The camera lives on a stack per player. AddTo pushes it to the top (making it active); RemoveFrom pops it and restores whatever was underneath. AddToAll / RemoveFromAll do the same for every player simultaneously. Enable / Disable control whether the device can be pushed at all.

API Reference

gameplay_camera_fixed_angle_device

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

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

gameplay_camera_fixed_angle_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: A top-down dungeon room. When a player steps on a pressure plate the room's fixed-angle camera activates for that player. When they leave the room (step on an exit plate) the camera is removed and they return to the default view.

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

# Place this device in your UEFN level, then wire up the @editable fields
# in the Details panel.
dungeon_camera_controller := class(creative_device):

    # The fixed-angle camera placed above the dungeon room.
    @editable
    DungeonCamera : gameplay_camera_fixed_angle_device = gameplay_camera_fixed_angle_device{}

    # Pressure plate at the room entrance.
    @editable
    EnterPlate : trigger_device = trigger_device{}

    # Pressure plate at the room exit.
    @editable
    ExitPlate : trigger_device = trigger_device{}

    # Called when the level starts.
    OnBegin<override>()<suspends> : void =
        # Make sure the camera device is active and ready to be pushed.
        DungeonCamera.Enable()

        # Subscribe to both plates.
        EnterPlate.TriggeredEvent.Subscribe(OnPlayerEntered)
        ExitPlate.TriggeredEvent.Subscribe(OnPlayerExited)

    # Handler: player stepped onto the entrance plate.
    # TriggeredEvent sends ?agent, so we must unwrap it.
    OnPlayerEntered(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            # Push the dungeon camera onto this player's camera stack.
            # It immediately becomes their active view.
            DungeonCamera.AddTo(Agent)

    # Handler: player stepped onto the exit plate.
    OnPlayerExited(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            # Pop the dungeon camera — the player's previous camera
            # (usually the default third-person view) is restored.
            DungeonCamera.RemoveFrom(Agent)

Line-by-line breakdown:

Common patterns

Pattern 1 — Activate the camera for ALL players at once (boss fight intro)

When a boss spawns, cut every player to the dramatic top-down view simultaneously, then restore normal cameras when the boss dies.

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

boss_intro_camera_manager := class(creative_device):

    # Fixed-angle camera positioned above the boss arena.
    @editable
    BossCamera : gameplay_camera_fixed_angle_device = gameplay_camera_fixed_angle_device{}

    # A trigger_device wired to fire when the boss spawns
    # (e.g., from a creature spawner's OnSpawnedEvent or a cinematic cue).
    @editable
    BossSpawnTrigger : trigger_device = trigger_device{}

    # A trigger_device wired to fire when the boss is defeated.
    @editable
    BossDefeatedTrigger : trigger_device = trigger_device{}

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

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

    OnBossDefeated(MaybeAgent : ?agent) : void =
        # Pop the boss camera from EVERY player's stack.
        BossCamera.RemoveFromAll()

Pattern 2 — Disable the camera device entirely (safe-room exemption)

Some players are in a safe room and should never receive the fixed-angle view. Disable the device before the event fires so AddToAll cannot push it, then re-enable it afterward.

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

safe_room_camera_guard := class(creative_device):

    # The fixed-angle camera for the main arena.
    @editable
    ArenaCamera : gameplay_camera_fixed_angle_device = gameplay_camera_fixed_angle_device{}

    # Trigger fires when the round begins.
    @editable
    RoundStartTrigger : trigger_device = trigger_device{}

    # Trigger fires when the round ends.
    @editable
    RoundEndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Start disabled — no one gets the camera until the round begins.
        ArenaCamera.Disable()
        RoundStartTrigger.TriggeredEvent.Subscribe(OnRoundStart)
        RoundEndTrigger.TriggeredEvent.Subscribe(OnRoundEnd)

    OnRoundStart(MaybeAgent : ?agent) : void =
        # Re-enable the device so subsequent AddTo / AddToAll calls work.
        ArenaCamera.Enable()
        # Push to all players now that the device is live.
        ArenaCamera.AddToAll()

    OnRoundEnd(MaybeAgent : ?agent) : void =
        # Remove from all players first, then disable the device.
        ArenaCamera.RemoveFromAll()
        ArenaCamera.Disable()

Pattern 3 — Per-player camera swap on item pickup

A player picks up a special item (simulated by a trigger) and gets a unique side-scroller view. Picking up a second item restores their camera.

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

item_camera_swap := class(creative_device):

    # Side-scroller fixed-angle camera (Angle Yaw set to 90 in Details).
    @editable
    SideScrollerCamera : gameplay_camera_fixed_angle_device = gameplay_camera_fixed_angle_device{}

    # Trigger placed on the special item pickup location.
    @editable
    PickupTrigger : trigger_device = trigger_device{}

    # Trigger placed on the "return" item location.
    @editable
    ReturnTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        SideScrollerCamera.Enable()
        PickupTrigger.TriggeredEvent.Subscribe(OnPickup)
        ReturnTrigger.TriggeredEvent.Subscribe(OnReturn)

    OnPickup(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            # Give just this player the side-scroller perspective.
            SideScrollerCamera.AddTo(Agent)

    OnReturn(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            # Restore this player's previous camera.
            SideScrollerCamera.RemoveFrom(Agent)

Gotchas

1. Enable / Disable vs AddTo / RemoveFrom — they are different things. Enable / Disable control whether the device itself is operational. A disabled device silently ignores AddTo calls — the camera never appears. Always call Enable() before you intend to push the camera. Disable() after RemoveFromAll() is a clean teardown pattern.

2. The camera stack is per-player — order matters. If you call AddTo(Agent) twice (e.g., from two different systems), the camera is on the stack twice. You must call RemoveFrom(Agent) twice to fully pop it. Design your logic so each system adds and removes exactly once, or guard with a flag.

3. TriggeredEvent sends ?agent, not agent — always unwrap. Forget the if (Agent := MaybeAgent?) guard and your handler silently does nothing when the payload is false. This is the #1 silent bug with trigger subscriptions.

4. RemoveFromAll does not call Disable. After RemoveFromAll() the device is still enabled. Any subsequent AddTo will push it again. If you want to lock the camera out entirely, explicitly call Disable() after removing.

5. Details-panel settings are baked at edit time. Pitch, Yaw, FOV, Distance, and follow speeds cannot be changed from Verse at runtime — configure them in the UEFN Details panel before publishing. If you need multiple angles, place multiple gameplay_camera_fixed_angle_device instances and swap between them with AddTo / RemoveFrom.

6. @editable is mandatory. You cannot construct a gameplay_camera_fixed_angle_device{} in Verse and expect it to control a placed device. Declare it @editable and assign the placed device in the Details panel — otherwise your variable points to a disconnected default instance and nothing happens in-game.