Compare all eight elements / Unity version of this element

What you will build

Build Swirl, dark clouds that spiral inward, shrink and fade. Each particle starts 100 cm from the center and reaches a radius of 28 cm after 0.9 seconds. Use translucent dark-purple images to cover and darken the background; adding black light with Additive blending would not create this effect.

Swirl’s dark-purple clouds rotate and move inward. Layer translucent images to darken and cover the background.
Swirl’s dark-purple clouds rotate and move inward. Layer translucent images to darken and cover the background.

Preparation: coordinates and a test level

Use Niagara, Unreal Engine 5.8’s particle-effects editor. An Emitter emits particles; a System combines emitters into one effect. Choose a regular Niagara emitter, rather than Lightweight Emitters or Niagara Fluids. Other Unreal Engine versions may show different creation dialogs or control names. The instructions retain the English control names so you can find them in the editor.

  1. Open a 3D project using the Blank template. Save a practice Level: the scene where you place and test the effect. In the Content Browser, the panel listing your assets, create a VFX/Dark folder. If Niagara is missing, open Edit → Plugins and check that Niagara is enabled.
    Keep the practice scene and its assets together
    Keep the practice scene and its assets together
  2. Add a standard cube for the floor. Set Location to (0,0,-5) and Scale to (4,4,0.1). Unreal uses Z-up and centimeters; the original cube is 100 cm wide, so its top surface is now at Z=0. Add a second cube at (200,0,50), scale one, as a size reference.
    Scale reference
    Scale reference
  3. Right-click an empty area in the Content Browser and choose FX → Niagara System. Create a system containing the Simple Sprite Burst emitter template and name it NS_Dark. If your Unreal Engine version first creates an empty system, choose Add Emitter and add Simple Sprite Burst.
    Inspect the parent and child roles separately
    Inspect the parent and child roles separately
  4. Drag NS_Dark from the Content Browser into the Level. This placed object is an Actor. Set its Rotation to zero and Scale to one. Double-click NS_Dark to open it, rename the first emitter Swirl (the inward-spiraling dark clouds), and set Emitter Properties → Sim Target to CPUSim so the CPU calculates its particles.
    Inspect the parent and child roles separately
    Inspect the parent and child roles separately
  5. Open System State and set Loop Behavior to Infinite, with Loop Duration 2 seconds. Open Emitter State and choose Self, Infinite, a two-second duration and Inactive Response Complete. Infinite repeats the effect. Self uses the emitter’s own timing; Complete lets existing particles finish after emission stops.
    Set timing for the whole effect and each emitter
    Set timing for the whole effect and each emitter

Preview is the playback window inside the Niagara Editor. Its repeat-playback button is separate from the emitter’s own loop settings above. Keep the camera still and use a light-gray floor. If automatic exposure keeps changing the screen brightness, lock exposure with a Post Process Volume before comparing the effect.

Read Niagara inputs and execution groups

Select an emitter in System Overview, the effect’s structure panel. Add a Module, a block that performs a task such as setting speed or size, using a group’s + button. The dropdown beside an input lets you choose a fixed Direct Set value, a Random Range between minimum and maximum, or a Float from Curve graph. Initialize Particle sets starting values. Lifetime is how many seconds a particle remains alive; choose Direct Set for a fixed duration or Random for a range. Select a mode before entering values if it currently says Unset.

Emitter Update decides when and how many particles to emit. Particle Spawn runs once when each particle appears, setting its initial position and speed. Particle Update runs every update while that particle is alive, changing its movement and appearance. Modules within a group run from top to bottom. A Renderer draws particles as flat images (Sprites), 3D shapes (Meshes), or connected strips (Ribbons).

A curve changes a value over time. With Float from Curve, link Curve Index to the specified time variable. Particles.NormalizedAge is progress through the particle’s lifetime: zero when it appears and one when it disappears. It is not a time in seconds. Add keys, the points on the graph, and enter their horizontal Time and vertical Value. Start with Linear interpolation, which connects keys with straight lines. RGB controls color; Alpha, or A, controls how strongly the particle is visible. Set these separately.

Rotate dark particles inward toward the center, then fade them out.
Rotate dark particles inward toward the center, then fade them out.

1. Make and import a grayscale mask

  1. Create a 512×512 RGB, 8-bit Photoshop image on black and draw coverage in white on a separate layer.
    RGB / 8 bit
    RGB / 8 bit
  2. Paint an irregular soft white clump and cut two or three gaps with black. Keep image edges black and central coverage white/gray.
    Keep black margins
    Keep black margins
  3. Do not paint the mask entirely black. White defines visible coverage; the material Tint supplies the dark-purple color.
    Connect image brightness to opacity: black disappears
    Connect image brightness to opacity: black disappears
  4. Keep the PSD, export T_DarkClump.png and import it. Disable sRGB, use Masks (no sRGB) compression and Clamp addressing for X/Y; save the texture.
    Connect image brightness to opacity: black disappears
    Connect image brightness to opacity: black disappears

Use this image as a grayscale mask. R means the red channel; in a grayscale image it also represents brightness. Connecting R to the material’s Opacity makes white visible and black transparent. Importing a black-background image alone does not remove its background.

2. Build a particle-color material

  1. Create a Material in the Content Browser, name it M_Dark, and open it. A Material defines a surface’s color and transparency. Use Surface domain, Translucent blending, which layers a partly transparent image over the background, and Unlit shading, which displays the color without scene lighting. Enable Two Sided to show the back and Used with Niagara Sprites for this renderer.
    Used with Niagara Sprites
    Used with Niagara Sprites
  2. Right-click an empty area of the Material Editor graph and search for Texture Sample Parameter2D. Add that node and name it MaskTex and assign your PNG. Choose Masks as the sampler type. Add a Vector Parameter named Tint for color. Add two Scalar Parameters named Intensity for brightness and Opacity for visibility. Set Tint to white and both scalar defaults to one.
    MaskTex: PNG / Sampler Type = Masks
    MaskTex: PNG / Sampler Type = Masks
  3. Add Particle Color to receive Niagara’s particle color RGB and alpha A.

    Color connection: add two Multiply nodes. Connect Particle Color RGB to A of the first node and Tint RGB to B. Feed that result into A of the second node and Intensity into B. Connect the second result to Emissive Color.

    Transparency connection: add two more Multiply nodes. Feed MaskTex R and Particle Color A into the first. Multiply that result by Opacity in the second. Connect its result to Saturate, which limits values to zero through one, then connect Saturate to the material’s Opacity.

    Top: color path Bottom: opacity clamped to 0–1
    Top: color path Bottom: opacity clamped to 0–1
  4. Click Apply, then Save. Right-click M_Dark in the Content Browser and choose Create Material Instance. Name it MI_Dark, open it and set Tint to dark purple. An instance reuses the original wiring while letting you adjust values such as color. Assign MI_Dark to the Niagara renderer’s Material input.
    Save, then assign it to the renderer that draws the effect
    Save, then assign it to the renderer that draws the effect
Connect the color calculation to Emissive Color, and the mask multiplied by particle alpha to Opacity.
Connect the color calculation to Emissive Color, and the mask multiplied by particle alpha to Opacity.

Including Particle Color A lets Niagara’s Scale Color gradually fade the particle. Alpha zero is invisible; one keeps the original visibility. Intensity adjusts brightness, while Opacity adjusts how strongly the image shows. An emissive-looking particle does not automatically add a Light to illuminate the floor or walls.

For editor basics see the UE material walkthrough.

3. Assemble Swirl

Select Swirl. Emit 16 particles per second, then set their positions directly with Scratch Pad modules to rotate them inward.

SettingValuePurpose / check
Level / NS_Dark Location(0,0,120) cmLift the 100-cm shell above the floor.
Emitter Properties / Local SpaceOnOn: measure positions relative to the effect’s center; moving the Actor also moves existing particles.
Emitter Update / Spawn Rate16 /sEmit 16 particles each second. Remove or disable the burst, which emits a group at once.
Initialize Particle / Lifetime; Color0.9 s; White A=1Keep particle color neutral.
Initialize Particle / Sprite SizeRandom Uniform 25–40 cmPreserve readable clumps.
Shape Location / Sphere Radius100 cmProject samples to the shell below.
Sprite Renderer / MaterialMI_Dark; Opacity 0.55Dark translucent coverage.

Do not add velocity, gravity, vortex force or integration here. Write position directly after Particle State; another motion module would change the baseline.

Particle Spawn sets the initial state. Particle Update changes movement, size and visibility. Each group runs from top to bottom.
Particle Spawn sets the initial state. Particle Update changes movement, size and visibility. Each group runs from top to bottom.
Scale s moves inward; angle θ adds rotation
Scale s moves inward; angle θ adds rotation

4. Store the birth offset

A Scratch Pad lets you build your own Niagara processing block with nodes. Create SaveDarkOffset using the required group’s + menu → New Scratch Pad Module. Right-click an empty graph area and search for a node by name to add it. The white Parameter Map wire carries particle data; connect Input Map → Map Set → Output Module. Branch from Input Map to Map Get to read values. Feed your calculated result into Map Set to save it on the particle. Click Apply & Save, then compile the System. Any formula below describes the nodes to connect; it is not text to paste as code.

  1. Create SaveDarkOffset after Shape Location in Particle Spawn. Read Particles.Position as a Vector. Use Length to find the distance from the center and Normalize to make a direction. If the length is 0.001 or less, use Select to choose (1,0,0) instead.
    Save each particle’s starting position on the outer surface
    Save each particle’s starting position on the outer surface
  2. Multiply the direction by 100. Save this in a new Vector attribute named Particles.StartOffset and in Particles.Position through Map Set. All particles now start 100 cm from the center. Click Apply & Save and Compile. Saving under Particles lets the update module read the starting value later.
    Save each particle’s starting position on the outer surface
    Save each particle’s starting position on the outer surface

5. Build inward motion first

Next, make a separate Scratch Pad module named DarkPosition. Use Particle Update’s + menu → New Scratch Pad Module. Connect Input Map → Map Set → Output Module and read the required inputs with Map Get.

Create DarkPosition after Particle State in update. Read StartOffset and Particles.Age; use multiply/subtract/max to calculate s=Max(0,1−0.8×Age). Writing StartOffset×s first gives an inward-only baseline.

Age is in seconds here. At 0.9 s, s=0.28 and radius is 28 cm. NormalizedAge would produce a different speed.

Scale s moves inward; angle θ adds rotation
Scale s moves inward; angle θ adds rotation

6. Combine rotation around Z

  1. Open DarkPosition and multiply Particles.Age by 1.5 to create θ. Connect θ to Sin and Cos. The rate 1.5 is in radians per second, where π radians is half a turn. Over 0.9 seconds this rotates about 77 degrees; it does not mean 1.5 revolutions per second.
    Scale s moves inward; angle θ adds rotation
    Scale s moves inward; angle θ adds rotation
  2. Use Break Vector to separate StartOffset into X/Y/Z. Build the expressions below with Multiply, Add and Subtract nodes. Combine them with Make Vector and write the result to Particles.Position, replacing the earlier inward-only calculation. Apply & Save.
    Scale s moves inward; angle θ adds rotation
    Scale s moves inward; angle θ adds rotation
  3. To inspect rotation alone, temporarily set the inward scale s to one. To inspect inward movement alone, temporarily set the angular rate 1.5 to zero. Restore the original values after both movements work.
    Scale s moves inward; angle θ adds rotation
    Scale s moves inward; angle θ adds rotation
θ = Particles.Age × 1.5
s = max(0, 1 - 0.8 × Particles.Age)
X = (StartOffset.X cosθ - StartOffset.Y sinθ) × s
Y = (StartOffset.X sinθ + StartOffset.Y cosθ) × s
Z = StartOffset.Z × s
Save the starting position, then rotate and scale it inward. Radius decreases from 100 cm to 28 cm over 0.9 seconds.
Save the starting position, then rotate and scale it inward. Radius decreases from 100 cm to 28 cm over 0.9 seconds.

7. Fade while preserving dark coverage

Use RGB scale one and normalized alpha keys (0,0), (0.15,0.8), (0.7,0.8), (1,0). Uniform size goes from one to 0.3 as clumps approach the center.

Place a white cube behind the effect to inspect dark coverage. Retain a small value/purple difference against dark backgrounds. Keep any rim in a separate weak emitter.

Age = seconds / NormalizedAge = lifetime progress
Age = seconds / NormalizedAge = lifetime progress

Check angle, time and color inputs

Sin/Cos take radians. Age 0.9 gives θ=1.35 radians≈77.35 degrees and radius 28 cm. Save StartOffset only at spawn; repeatedly replacing it changes the calculation.

Enter the example Tint using UE floating-point RGB fields. Do not convert directly into hex/0–255 without checking color space. Visible dark color and mask coverage remain separate.

First playback, restarting and saving

First inspect inward motion at zero angular speed, then rotation at s=1, and restore both. Observe one to two seconds for birth jumps or abrupt disappearance at the center.

To test again, stop Preview and move the Timeline playback position back to the start. Choose which emitters are enabled, then play. Enabling another emitter halfway through can give it a different start time, so restart when comparing parts.

After editing a Scratch Pad, click Apply & Save. Compile the System to check its processing graph, fix any errors, then save it. Apply and save the Material too. Test the placed effect in the Level and save the Level. Changes to a placed effect’s Component during Level Play can be temporary; make lasting adjustments in the Niagara System asset.

Troubleshoot one variable at a time

SymptomFirst checkComparison
Black is invisibleBlend mode and mask RRestore translucency and verify nonzero central mask R.
The vortex scattersCurrent versus birth offsetCompute from stored StartOffset, not repeated rotation of current position.
Shrink without rotationRotation axis and cameraInspect rotation alone with s=1 and check the Z axis/camera angle.

Completion checks

  1. Explain rotation-only, inward-only and combined cases.
    Scale s moves inward; angle θ adds rotation
    Scale s moves inward; angle θ adds rotation
  2. End near radius 28 cm without crossing the center.
    Scale s moves inward; angle θ adds rotation
    Scale s moves inward; angle θ adds rotation
  3. Coverage darkens a bright background while preserving silhouette on dark backgrounds.
    Scale s moves inward; angle θ adds rotation
    Scale s moves inward; angle θ adds rotation
  4. The result stays distinct from a bright light vortex at small size.
    Scale s moves inward; angle θ adds rotation
    Scale s moves inward; angle θ adds rotation

Compare the Unity version and continue

This version uses age-based Z rotation and radius shrink instead of Unity orbital/radial modules. Its explicitly defined radian-per-second value has a different meaning from Unity Orbital.

Compare with the Unity workflow while checking axes, units and execution order. Continue with another Niagara element.

References