Compare all eight elements / Unity version of this element
What you will build
Build a short wind trail that follows a circle. Emit new points around the circle and connect them with a Ribbon, a strip joining the points. Each point stays where it was emitted and disappears after 0.25 seconds. Only the emission position moves, leaving a short arc rather than a complete ring.
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.
- 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/Wind folder. If Niagara is missing, open Edit → Plugins and check that Niagara is enabled.
Keep the practice scene and its assets together - 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 - 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_Wind. 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 - Drag NS_Wind 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_Wind to open it, rename the first emitter Ribbon (the curved wind trail), and set Emitter Properties → Sim Target to CPUSim so the CPU calculates its particles.
Inspect the parent and child roles separately - 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
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.
1. Make and import a grayscale mask
- Create a 512×512 RGB, 8-bit Photoshop image on black and draw coverage in white on a separate layer.
RGB / 8 bit - Paint a full-width white band about 160 pixels tall, softening its upper/lower edges and retaining black top/bottom margins.
Fill the width; keep black margins above and below - Keep the PSD, export T_WindBand.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
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
- Create a Material in the Content Browser, name it M_Wind, 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 Ribbons for this renderer.
Used with Niagara Ribbons - 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 - 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 - Click Apply, then Save. Right-click M_Wind in the Content Browser and choose Create Material Instance. Name it MI_Wind, open it and set Tint to pale gray-green. An instance reuses the original wiring while letting you adjust values such as color. Assign MI_Wind to the Niagara renderer’s Material input.
Save, then assign it to the renderer that draws the effect
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 Ribbon
Select Ribbon. A Sprite Renderer draws separate image cards; a Ribbon Renderer connects particle positions into a strip. Emit 100 points per second and keep each for 0.25 seconds.
| Setting | Value | Purpose / check |
|---|---|---|
| Level / NS_Wind Location | (0,0,70) cm | Lift the ribbon above the floor. |
| Emitter Properties / Local Space | On | On: measure positions relative to the effect’s center; moving the Actor also moves existing particles. |
| Emitter State / Loop Duration | 2 s (Infinite) | Match the two-second revolution. |
| Emitter Update / Spawn Rate | 100 /s | Emit 100 particles each second. Remove or disable the burst, which emits a group at once. |
| Initialize Particle / Lifetime; Color | 0.25 s; White A=1 | Retain a short history. |
| Initialize Particle / Ribbon Width | 8 cm | Enable ribbon attributes. |
| Ribbon Renderer / Facing | Screen | A screen-facing strip. |
| Ribbon Renderer / Material | MI_Wind | Remove the sprite renderer. |
| Ribbon Renderer / Ribbon Link Order Binding | Particles.RibbonLinkOrder | Set the birth-order attribute below. |
Omit shape, velocity, gravity and the integration solver. Existing points remain at birth positions while new births move around the circle. Update needs Particle State and the fade described below.
4. Set birth positions and order in a Scratch Pad
A Scratch Pad lets you build your own Niagara processing block with nodes. Create SpawnOrbitPoint 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.
- Create SpawnOrbitPoint after Initialize Particle in Particle Spawn. Add Emitter.LoopedAge as a Float, a decimal number, and Particles.UniqueID as an Integer, a whole number, to Map Get. LoopedAge counts seconds in the current emitter loop; UniqueID gives each new particle a different number.
Read time and each particle’s unique number - Multiply LoopedAge by 3.14159265 to make the angle θ. The angle uses radians, where π is half a turn. This produces half a turn each second and a full turn every two seconds. Connect the same θ to Sin and Cos.
Half a turn in 1 s; a full turn in 2 s - Use Make Vector with X=Cos(θ)×60, Y=Sin(θ)×60 and Z=0. This gives a point on a circle of radius 60 cm. Connect it to Map Set → Particles.Position. Keep any Position-type conversion. With Local Space enabled, these coordinates are relative to the effect’s center.
60 cm - Add a Float named Particles.RibbonLinkOrder to Map Set. Convert Particles.UniqueID to Float and connect it. RibbonLinkOrder tells the renderer which point to connect next. All points belong to one strip, so do not create a different RibbonID for each point.
Join the points in order to form one Ribbon - Click Apply & Save, compile the System, and check that Ribbon Link Order Binding reads Particles.RibbonLinkOrder. Keep this calculation in Particle Spawn so each point stays where it appeared. Moving it to Particle Update would move older points too.
Set position and order when each new point is emitted
θ = Emitter.LoopedAge × π
Position = (60 cosθ, 60 sinθ, 0)
RibbonLinkOrder = float(Particles.UniqueID)
5. Fade the old tail and compare history length
- Add Scale Color in update: RGB scale one and normalized-age alpha from one at birth to zero at death. New points stay stronger than old points.
Age = seconds / NormalizedAge = lifetime progress - Temporarily use red-to-blue RGB to identify new/old ends, then restore white. After about 0.25 s of preview, inspect the short arc.
Age = seconds / NormalizedAge = lifetime progress - Compare lifetime 0.1 and 0.4 s for history extent. Restore 0.25 before comparing rates 50 and 100 to separate extent from sampling density.
Age = seconds / NormalizedAge = lifetime progress
0.25 s×180 deg/s gives a 45-degree baseline. Individual points stay still; their birth location circulates. Local-space history moves with the actor, unlike a world-space trail.
Check ordering separately from history
UniqueID increments with births. Store it as float RibbonLinkOrder and use that same renderer binding. This is not an event/persistent-ID scheme or a separate ribbon ID for every point.
LoopedAge wrapping 2→0 maps 2π→0 to the same location. If changing duration, preserve the relationship with a full revolution. A fresh initialization should also clear old points.
First playback, restarting and saving
Inspect the short arc after 0.25 s and look for jumps at the two-second boundary. At low frame rate multiple points can spawn on one tick; raising rate alone does not guarantee finer temporal sampling.
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
| Symptom | First check | Comparison |
|---|---|---|
| A long connecting line | Order and angular period | Check UniqueID order, the two-second period and radian angles. |
| Points but no strip | Renderer and width | Check ribbon renderer, width eight and ribbon material usage. |
| A complete ring | Particle lifetime | Restore 0.25 s; shorten history before reducing rate. |
Completion checks
- New points advance while the old tail fades.
Points stay in place; the spawn position travels around the circle - No diagonal jump appears at the two-second boundary.
Points stay in place; the spawn position travels around the circle - Lifetime changes extent; rate primarily changes point density.
Points stay in place; the spawn position travels around the circle - The strip reads as narrow airflow from an angled view.
Points stay in place; the spawn position travels around the circle
Compare the Unity version and continue
Unity records a moving trail tip. This Niagara version adds points at moving birth locations and expires old points; it does not move existing points around the circle in update.
Compare with the Unity workflow while checking axes, units and execution order. Continue with another Niagara element.