vfx_creator_device: Custom Visual Effects on Demand

Overview

The vfx_creator_device is a creative device that plays a fully customizable visual effect you design in the UEFN editor. You configure the effect's appearance (particles, materials, scale, color) through the device's Detail panel, then use Verse to control when and where it plays.

When to reach for it:

• A boss arena that erupts with fire VFX when the round begins.
• A victory aura that follows the winning player around the map.
• An environmental hazard (toxic gas, magical fog) that pauses when a puzzle is solved and resumes when it resets.
• Any situation where you need VFX that respond to game events, not just a static looping effect.

Key capability groups:

• Lifecycle control — Begin, End, Toggle start and stop the effect at the device location.
• Player-attached VFX — Begin(Agent), End(Agent), SpawnAt(Agent), Remove(Agent) and their ForAll variants attach/detach the effect to specific players (requires Stick to Player enabled in the device settings).
• Pause/resume — TogglePause freezes the effect mid-animation, useful for dramatic slow-motion moments.
• Enable/Disable — Enable / Disable / ToggleEnabled gate whether the device can respond at all.

API Reference

vfx_creator_device

Used to create and customize your own visual effects. This is more flexible than the vfx_spawner_device, which gives you a selection of pre-made visual effects to choose from but limits how much you can customize or change those effects.

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

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

Methods (call these to make the device act):

Walkthrough

Scenario: A boss arena. When the round starts, a massive fire VFX erupts at the device location. When a player steps on a pressure plate (the "boss defeated" trigger), the effect freezes (pauses) for dramatic effect, then ends after 2 seconds. A new VFX aura then attaches to the winning player.

Place a vfx_creator_device (configured as your fire effect), a second vfx_creator_device (configured as a victory aura with Stick to Player enabled), and a trigger_device (the boss-defeated plate) in your level. Wire them to this device.

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

# Boss arena VFX controller.
# Place this device in your level alongside a fire vfx_creator_device,
# a victory-aura vfx_creator_device (Stick to Player ON), and a trigger_device.
boss_arena_vfx_controller := class(creative_device):

    # The large fire effect that plays at the arena center.
    @editable
    FireVFX : vfx_creator_device = vfx_creator_device{}

    # A victory aura effect configured with "Stick to Player" ON.
    @editable
    VictoryAuraVFX : vfx_creator_device = vfx_creator_device{}

    # Trigger the player steps on when the boss is defeated.
    @editable
    BossDefeatedTrigger : trigger_device = trigger_device{}

    # Called when the game session begins.
    OnBegin<override>()<suspends> : void =
        # Start the arena fire effect immediately at the device location.
        FireVFX.Begin()

        # Subscribe to the boss-defeated trigger.
        # TriggeredEvent sends ?agent, so the handler receives an optional agent.
        BossDefeatedTrigger.TriggeredEvent.Subscribe(OnBossDefeated)

    # Handler called when a player steps on the boss-defeated plate.
    # Agent is ?agent because TriggeredEvent sends an optional agent.
    OnBossDefeated(Agent : ?agent) : void =
        # Freeze the fire effect mid-animation for dramatic effect.
        FireVFX.TogglePause()

        # Attach the victory aura to the winning player if we have one.
        # Unwrap the optional agent before using it.
        if (A := Agent?):
            VictoryAuraVFX.SpawnAt(A)

        # Wait 2 seconds, then end the fire effect entirely.
        # We use a spawn so the handler (non-suspending) can fire-and-forget.
        spawn { CleanupFireVFX() }

    # Waits 2 seconds, then ends the fire VFX.
    CleanupFireVFX()<suspends> : void =
        Sleep(2.0)
        FireVFX.End()

Line-by-line breakdown:

Common patterns

Pattern 1 — Toggle a hazard VFX on and off with a button

A toxic gas cloud toggles on/off each time a player presses a button. Uses Toggle() — the simplest way to flip between playing and stopped.

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

# Toggles a hazard VFX on/off when a button is pressed.
toggle_hazard_vfx_device := class(creative_device):

    # The toxic gas VFX device placed in the level.
    @editable
    HazardVFX : vfx_creator_device = vfx_creator_device{}

    # A button_device the player interacts with to toggle the hazard.
    @editable
    HazardButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # The hazard starts disabled — enable it so it can be toggled.
        HazardVFX.Enable()

        # Subscribe to the button's interaction event.
        HazardButton.InteractedWithEvent.Subscribe(OnButtonPressed)

    # Each press flips the VFX between playing and stopped.
    OnButtonPressed(Agent : agent) : void =
        HazardVFX.Toggle()

Pattern 2 — Attach a speed-boost aura to every player at round start

When a countdown timer ends, a speed-boost aura VFX spawns on every player simultaneously using BeginForAll(). Requires Stick to Player enabled on the device.

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

# Attaches a speed-boost aura to ALL players when a timer expires.
speed_boost_aura_device := class(creative_device):

    # The aura VFX — must have "Stick to Player" enabled in device settings.
    @editable
    SpeedAuraVFX : vfx_creator_device = vfx_creator_device{}

    # A timer_device set to count down to round start.
    @editable
    RoundTimer : timer_device = timer_device{}

    # How long the aura lasts (seconds).
    @editable
    AuraDuration : float = 10.0

    OnBegin<override>()<suspends> : void =
        RoundTimer.SuccessEvent.Subscribe(OnTimerExpired)

    OnTimerExpired(Agent : ?agent) : void =
        # Attach the aura to every player in the session.
        SpeedAuraVFX.BeginForAll()
        # Remove it after the duration.
        spawn { RemoveAuraAfterDelay() }

    RemoveAuraAfterDelay()<suspends> : void =
        Sleep(AuraDuration)
        # Detach from all players and resume playing at device location.
        SpeedAuraVFX.RemoveFromAll()
        # Stop the effect at the device location too.
        SpeedAuraVFX.End()

Pattern 3 — Pause and resume a ritual VFX when a player enters/leaves a zone

A ritual circle VFX plays continuously. When a player steps into a trigger zone, the effect freezes (pauses). When they leave, it resumes. Uses TogglePause(Agent) for per-player control.

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

# Pauses a ritual VFX for a specific player when they enter a zone,
# and resumes it when they leave.
ritual_vfx_pause_device := class(creative_device):

    # The ritual circle VFX — "Stick to Player" ON for per-agent pause.
    @editable
    RitualVFX : vfx_creator_device = vfx_creator_device{}

    # Trigger zone — player enters to pause, exits to resume.
    @editable
    RitualZoneEnter : trigger_device = trigger_device{}

    @editable
    RitualZoneExit : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Start the ritual effect looping at the device location.
        RitualVFX.Begin()

        RitualZoneEnter.TriggeredEvent.Subscribe(OnPlayerEnter)
        RitualZoneExit.TriggeredEvent.Subscribe(OnPlayerExit)

    # Freeze the effect for the entering player.
    OnPlayerEnter(Agent : ?agent) : void =
        if (A := Agent?):
            # TogglePause(Agent) pauses the effect at this agent's location.
            RitualVFX.TogglePause(A)

    # Resume the effect for the exiting player.
    OnPlayerExit(Agent : ?agent) : void =
        if (A := Agent?):
            # Calling TogglePause again on a paused effect resumes it.
            RitualVFX.TogglePause(A)

Gotchas

1. Stick to Player must be enabled in the device settings for agent-specific methods

Begin(Agent), End(Agent), SpawnAt(Agent), Remove(Agent), BeginForAll(), EndForAll(), RemoveFromAll(), TogglePause(Agent), and their ForAll variants only work if the Stick to Player option is checked in the vfx_creator_device's Details panel in UEFN. Calling these methods without that setting enabled will silently do nothing — no compile error, no runtime error, just no effect.

2. TriggeredEvent sends ?agent, not agent

The trigger_device.TriggeredEvent is a listenable(?agent). Your handler signature must be OnMyHandler(Agent : ?agent), and you must unwrap it before passing to any agent-expecting method:

# CORRECT
OnTriggered(Agent : ?agent) : void =
    if (A := Agent?):
        FireVFX.SpawnAt(A)

# WRONG — will not compile
OnTriggered(Agent : agent) : void =
    FireVFX.SpawnAt(Agent)

3. Event handlers cannot suspend — use spawn for timed sequences

Subscribed event handlers are not <suspends> functions, so you cannot call Sleep() directly inside them. Use spawn { MyAsyncFunction() } to launch a concurrent task:

# WRONG — Sleep in a non-suspending handler
OnSomething(Agent : ?agent) : void =
    Sleep(2.0)  # compile error
    FireVFX.End()

# CORRECT — spawn a suspending helper
OnSomething(Agent : ?agent) : void =
    spawn { DelayedEnd() }

DelayedEnd()<suspends> : void =
    Sleep(2.0)
    FireVFX.End()

4. Enable/Disable vs Begin/End — they are different things

Enable and Disable control whether the device can respond to API calls at all (like a power switch). Begin and End control whether the visual effect is currently playing. A disabled device will ignore Begin() calls. Always call Enable() first if you've previously disabled the device.

5. TogglePause is a toggle — calling it twice resumes the effect

TogglePause() flips between paused and unpaused. If you call it twice in quick succession (e.g., from two rapid events), the effect will pause then immediately resume. Guard against this with a boolean flag if your game logic can fire the event multiple times.

6. vfx_creator_device has no events — it is output-only

Unlike many creative devices, vfx_creator_device exposes no events (TriggeredEvent, CompletedEvent, etc.). It only receives commands. If you need to know when an effect finishes, you must manage timing yourself with Sleep() in a suspending function.