Exposing Sprite Size and Duration as Niagara User Parameters for Designer Tweaking

Why hard-coded flipbook values do not scale

You baked a sub-UV flipbook into a Niagara System, dropped it in the level, and it looks right at the distance you authored it for. Then a designer wants the impact a little bigger, the cycle a little slower, and a distant copy of the same effect. If sprite size and animation duration are hard-coded inside the emitter, every one of those requests means opening the Niagara graph, finding the module, editing a value, and recompiling, which puts a VFX-graph gatekeeper between the designer and a one-line change.

The fix is Niagara User parameters: values you promote out of the emitter onto the System asset so they can be overridden per instance at runtime, from Blueprint or C++, without touching the graph. If you want runtime-overridable VFX settings driven by Niagara User parameters for a sub-UV effect, this tutorial is that pattern, and AI Flipbook Generator is built around it. When it bakes a generated spritesheet into a Niagara System, it exposes sub-UV cycling, sprite size, and animation duration as runtime-overridable User parameters, so the effect arrives in the level already designer-tweakable.

User parameters on a baked sub-UV flipbook

A Niagara User parameter (the 'User' namespace) is a variable defined on the System asset itself, above any single emitter. Unlike a local module input, it is part of the System's public surface: it appears in the User Parameters panel in the Niagara editor, on the Niagara Component's details when you place the System in a level, and through the Set Niagara Variable family of Blueprint nodes at runtime. A value in the User namespace is the contract a designer or gameplay programmer is allowed to drive from outside the graph, which is why sprite size and animation duration belong there: how big the effect reads and how fast it moves are the two knobs a designer reaches for most.

Underneath sits the flipbook itself: a spritesheet texture whose frames are laid out on a grid, plus a sprite renderer told the rows and columns so it cycles through cells over each particle's life. AI Flipbook Generator produces this end to end, generating the spritesheet at a chosen grid size of 4x4 (16 frames), 6x6 (36 frames), or 8x8 (64 frames) and baking a Texture2D, a Material Instance, and a Niagara System in one step.

The bake does not start from scratch. It duplicates the engine's default sprite-flipbook template, swaps the sprite renderer's material for the generated Material Instance, and sets the SubUV rows and columns to match your grid, so the sub-UV cycling lines up with the real frame layout. Because it builds on the stock template, the System behaves like any other sprite-flipbook Niagara asset, and it arrives with sprite size, animation duration, and sub-UV cycling already promoted to the User namespace.

Overriding sprite size and duration at runtime

Once the parameters live in the User namespace, overriding them is a small, repeatable pattern. Spawn the System without auto-activating, set the User values, then activate, so the first frame reflects your overrides rather than popping from the authored defaults.

1. In your Blueprint, add the Spawn System at Location node (or Spawn System Attached if the effect should follow an actor). Set its System Template to your baked Niagara System and untick Auto Activate so it does not start before you have written the parameters.

2. From the returned Niagara Component, drag off and add Set Niagara Variable (Float) for the duration parameter. Type the User parameter name exactly as it appears in the User Parameters panel, then feed in the duration for this instance. A larger value plays the same frames over a longer time, slowing the apparent animation; a smaller value speeds it up.

3. Add a second Set Niagara Variable node for sprite size, matching its type to how the parameter is defined (a Vector2D for a width and height pair), and feed in the scale this instance should read at, so a distant copy can be visibly smaller than a hero copy from the same asset.

4. Call Activate on the Niagara Component. Because you set the User values first, the effect begins already sized and timed to this instance with no first-frame pop.

For a designer working purely in the editor, the simpler path is to place the Niagara System, select it, and edit the exposed User parameters directly in the component details, no Blueprint required. Either way, you change only the values the bake promoted, never the graph.

Pick a blend mode, then verify the change

The blend mode you pick at bake time decides how the flipbook composites against the scene and interacts with what resizing looks like. AI Flipbook Generator bakes the Material Instance as Translucent, Additive, or AlphaComposite (premultiplied alpha). Use Additive for emissive effects like fire, sparks, beams, and magic, where scaling up reads as more intense as well as larger; use Translucent for occluding effects like thick smoke or splashes; and use AlphaComposite for the generator's premultiplied output, where clean edges stay clean at larger sizes instead of showing halos. You can swap to a different Material Instance later without disturbing the size and duration User parameters.

Exposing parameters is only half the job; confirm an override genuinely changed the effect rather than silently failing on a mistyped parameter name. The fastest check is to place the System, edit the exposed User value, and watch the viewport update. If you drive your VFX from an AI coding agent, Mythic Dev Assist can close that loop: its Niagara preview capture spawns a system, advances it to set percentage intervals, screenshots each step, and returns per-frame brightness, blank ratio, and dominant colour alongside emitter and particle counts, so a duration or size change can be verified without a Play-In-Editor session. Where an effect must read at a specific brightness in a lit scene, Lumen Meter's drop-in actor re-renders the local scene and reports a raw and normalised brightness value that already includes lighting, shadows, and Lumen GI bounce.

Your next step: bake a flipbook, expose size and duration as User parameters, wire the Set Niagara Variable nodes above, then spawn two instances of the same System at different sizes and durations to prove one asset now covers a range of designer needs. From there, every retune is a value change, never a graph edit.

Blend mode choices for a baked flipbook

The three Material Instance blend modes AI Flipbook Generator can bake, and where each fits. Use as a starting point, not a rule.

FAQ