skydome_device: Dynamic Skies for Any Atmosphere

Overview

The skydome_device represents a placed Skydome Device in your UEFN level. Each Skydome Device holds a full sky configuration — sun angle, cloud density, fog color, star visibility, and more — all set up in the device's property panel in the editor. At runtime you control which sky is active by calling Enable or Disable on one or more skydome devices.

When to reach for it:

• You want a day/night cycle driven by game events (round start, timer, player action).
• Different game phases need radically different atmospheres (calm lobby → stormy match → eerie overtime).
• You want to reward or punish players with a visual sky shift (storm rolls in when the circle closes).

Note: skydome_device is marked @deprecated in the live API digest, meaning Epic may replace it in a future release. It still compiles and runs correctly today — just keep an eye on release notes.

API Reference

skydome_device

Controls how the sky looks, as well as giving you options for changing the sun, clouds, stars or other objects in the sky above your island. You can control the sun and moon, and add other atmospheric elements like stars, fog and clouds. You can change the color of your light source, and blend different colors for your island's sky to create the perfect atmosphere for your game.

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

skydome_device<public> := class<concrete><final>(creative_device_base):

Methods (call these to make the device act):

Walkthrough

Scenario: A survival island has two skydomes placed in the level — a bright daytime sky and a dark stormy sky. When the match begins, the daytime sky is active. After 60 seconds, the storm rolls in: the day sky disables and the storm sky enables. A trigger_device lets the host manually trigger the storm early.

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

# Place this creative_device in your level alongside two skydome_devices
# and one trigger_device (the "early storm" trigger).
sky_manager_device := class(creative_device):

    # Drag your "Day Sky" Skydome Device here in the Details panel.
    @editable
    DaySky : skydome_device = skydome_device{}

    # Drag your "Storm Sky" Skydome Device here in the Details panel.
    @editable
    StormSky : skydome_device = skydome_device{}

    # Drag a Trigger Device here — stepping on it forces the storm early.
    @editable
    EarlyStormTrigger : trigger_device = trigger_device{}

    # How many seconds before the storm rolls in automatically.
    @editable
    StormDelaySeconds : float = 60.0

    OnBegin<override>()<suspends> : void =
        # Start with the day sky active, storm sky hidden.
        DaySky.Enable()
        StormSky.Disable()

        # Subscribe to the trigger so a host can force the storm early.
        EarlyStormTrigger.TriggeredEvent.Subscribe(OnEarlyStormTriggered)

        # Wait the configured delay, then switch to storm automatically.
        Sleep(StormDelaySeconds)
        ActivateStorm()

    # Called when the timer expires — swap the skies.
    ActivateStorm() : void =
        DaySky.Disable()
        StormSky.Enable()

    # Called when a player steps on the early-storm trigger.
    OnEarlyStormTriggered(Agent : ?agent) : void =
        ActivateStorm()

Line-by-line breakdown:

Common patterns

Pattern 1 — Toggle sky on a button press

A button in a hub area lets players preview the night sky. Press again to return to day.

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

sky_toggle_device := class(creative_device):

    @editable
    DaySky : skydome_device = skydome_device{}

    @editable
    NightSky : skydome_device = skydome_device{}

    @editable
    ToggleButton : button_device = button_device{}

    # Track which sky is currently showing.
    var IsNight : logic = false

    OnBegin<override>()<suspends> : void =
        DaySky.Enable()
        NightSky.Disable()
        ToggleButton.InteractedWithEvent.Subscribe(OnButtonPressed)

    OnButtonPressed(Agent : agent) : void =
        if (IsNight?):
            # Switch back to day.
            NightSky.Disable()
            DaySky.Enable()
            set IsNight = false
        else:
            # Switch to night.
            DaySky.Disable()
            NightSky.Enable()
            set IsNight = true

Pattern 2 — Cycle through multiple sky presets on a timer

A cinematic island cycles through three sky moods — dawn, noon, dusk — every 30 seconds.

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

sky_cycle_device := class(creative_device):

    @editable
    DawnSky : skydome_device = skydome_device{}

    @editable
    NoonSky : skydome_device = skydome_device{}

    @editable
    DuskSky : skydome_device = skydome_device{}

    @editable
    CycleIntervalSeconds : float = 30.0

    OnBegin<override>()<suspends> : void =
        # Disable all first, then start the cycle.
        DawnSky.Disable()
        NoonSky.Disable()
        DuskSky.Disable()
        loop:
            DawnSky.Enable()
            Sleep(CycleIntervalSeconds)
            DawnSky.Disable()

            NoonSky.Enable()
            Sleep(CycleIntervalSeconds)
            NoonSky.Disable()

            DuskSky.Enable()
            Sleep(CycleIntervalSeconds)
            DuskSky.Disable()

Pattern 3 — Disable the sky when a player enters a cave zone

A capture area marks the cave entrance. When a player enters, the outdoor sky is disabled (the interior lighting takes over). When they leave, it re-enables.

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

cave_sky_controller := class(creative_device):

    @editable
    OutdoorSky : skydome_device = skydome_device{}

    @editable
    CaveEntrance : capture_area_device = capture_area_device{}

    OnBegin<override>()<suspends> : void =
        OutdoorSky.Enable()
        CaveEntrance.ZoneOccupiedEvent.Subscribe(OnPlayerEnteredCave)
        CaveEntrance.ZoneEmptiedEvent.Subscribe(OnPlayerLeftCave)

    OnPlayerEnteredCave(Agent : agent) : void =
        # Hide the outdoor sky while someone is in the cave.
        OutdoorSky.Disable()

    OnPlayerLeftCave(Agent : agent) : void =
        # Restore the outdoor sky when the cave is empty again.
        OutdoorSky.Enable()

Gotchas

1. You must wire the device in the editor — bare construction fails. Declaring @editable MySky : skydome_device = skydome_device{} and then not dragging a real placed device into the Details panel means your calls hit a default no-op object. Always assign every @editable skydome field in the UEFN Details panel before playtesting.

2. Enable/Disable are the entire API — there is no SetPreset or SetTimeOfDay. All sky configuration (sun angle, fog color, cloud density, star visibility) is done in the device's property panel in the editor, not in Verse. To switch between two looks, place two separate Skydome Devices with different settings and toggle between them.

3. Only one Skydome Device should be enabled at a time. Having two skydomes enabled simultaneously produces undefined blending behavior. Always Disable the outgoing sky before (or at the same time as) you Enable the incoming one.

4. skydome_device is marked @deprecated. The live API digest marks this class deprecated. It compiles and runs today, but Epic may introduce a replacement in a future release. Check the UEFN release notes when upgrading your project.

5. Sleep requires a <suspends> function. If you use Sleep in a helper method (like ActivateStorm), that method must also be marked <suspends> and called with spawn or from another suspending context. In the walkthrough above, ActivateStorm does not sleep — it's a plain void method — so no <suspends> annotation is needed there.

6. TriggeredEvent passes ?agent, not agent. When subscribing to trigger_device.TriggeredEvent, your handler signature must be (Agent : ?agent). If you need to use the agent (e.g., to teleport the triggering player), unwrap it first: if (A := Agent?) { ... }. In the walkthrough we ignore the agent entirely, which is fine.