Compare all eight elements / Unity version of this element

What you will build

Build water spray with an expanding ring on the floor. Splash emits drops that rise and fall under gravity. Ripple is one flat ring that grows outward. It appears 0.1 seconds after the effect starts; its timing is set explicitly rather than triggered by a drop hitting the floor.

Splash emits rising drops; Ripple is the expanding ring on the floor. The ring starts after a fixed delay of 0.1 seconds.
Splash emits rising drops; Ripple is the expanding ring on the floor. The ring starts after a fixed delay of 0.1 seconds.

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/Water 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_Water. 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_Water 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_Water to open it, rename the first emitter Splash (the spray), 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 Once, with Loop Duration 3 seconds. Open Emitter State and choose Self, Once, a two-second duration and Inactive Response Complete. Once plays it once. 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.

Make the droplet image and material, then combine falling spray with a floor ripple.
Make the droplet image and material, then combine falling spray with a floor ripple.

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. Draw a roughly 240×90-pixel tapered white drop, soften its edge by two to four pixels and keep black margins.
    Keep black margins
    Keep black margins
  3. Keep the PSD, export T_DropMask.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_WaterDrop, 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_WaterDrop in the Content Browser and choose Create Material Instance. Name it MI_WaterDrop, open it and set Tint to pale cyan. An instance reuses the original wiring while letting you adjust values such as color. Assign MI_WaterDrop 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 Splash

Select Splash. Emit 20 drops together, give them upward velocity, then use downward Gravity Force to make them fall.

SettingValuePurpose / check
Level / NS_Water Location(0,0,5) cmJust above the floor.
Emitter Properties / Local SpaceOffOff: use Level/world coordinates; moving the Actor does not carry already-emitted particles with it.
Spawn Burst Instantaneous / Time; Count0 s; 20Emit 20 particles together 0 seconds after the effect starts. Disable continuous Spawn Rate.
Initialize Particle / Lifetime; MassRandom 0.6–0.9 s; 1A gravity-driven lifetime.
Initialize Particle / Sprite SizeNon-Uniform (8,16) cmAn elongated drop.
Shape Location / Ring-Disk Radius12 cmEmit across the XY plane.
Add Velocity / LinearRandom Range Vector: (-150,-150,200)–(150,150,300) cm/sAlways positive Z with lateral spread.
Particle Update / Gravity Force(0,0,-980) cm/s²Place before the solver.
Sprite Renderer / AlignmentVelocity AlignedAlign the drop with travel.
Sprite Renderer / MaterialMI_WaterDropStart instance opacity at 0.6.

Use Initialize → Shape Location → Add Velocity at spawn; update Particle State → Gravity → Solve Forces and Velocity → Scale Sprite Size → Scale Color. Elongate via Niagara sprite size rather than Unity stretched-billboard settings.

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.
Gravity
Gravity

4. Shape the arc and fade

Use a uniform size curve indexed by normalized age: (0,0.6), (0.3,1), (1,0.3). Alpha keys are (0,0), (0.1,0.8), (0.7,0.6), (1,0), with RGB scale one.

First verify gravity bends the path with collision disabled. Floor contact and lifetime are different; shorten life or add CPU collision as a separate extension if crossing is visible.

Upward velocity and downward gravity curve the drops’ paths. The ring expands while remaining parallel to the floor.
Upward velocity and downward gravity curve the drops’ paths. The ring expands while remaining parallel to the floor.
Age = seconds / NormalizedAge = lifetime progress
Age = seconds / NormalizedAge = lifetime progress

5. Make a floor-parallel Ripple

  1. Make a separate 512-pixel ring from concentric white 400-pixel and black 340-pixel discs; soften about two pixels. Import T_RippleMask and assign it to a separate translucent MI_Ripple at opacity 0.6.
    MI_Ripple / Opacity 0.6
    MI_Ripple / Opacity 0.6
  2. Add another Simple Sprite Burst as Ripple. Enable local space; use Self/Once/two seconds/Complete. Disable Spawn Rate and set a one-particle burst at 0.1 s.
    Delay a one-particle burst
    Delay a one-particle burst
  3. Initialize lifetime 0.7 s, white color/alpha one, uniform sprite size 100 cm and position offset (0,0,-3). With system Z=5 this is two centimeters above the floor. Add no velocity, gravity or shape module.
    Offset slightly above the floor to avoid z-fighting
    Offset slightly above the floor to avoid z-fighting
  4. After Initialize add Set new or existing value directly and set vector attributes Particles.SpriteFacing=(0,0,1) and Particles.SpriteAlignment=(1,0,0).
    After Initialize · Particles.SpriteFacing ·
    After Initialize · Particles.SpriteFacing ·
  5. Set renderer Facing Mode to Custom Facing Vector, its mask to (1,1,1), and Alignment to Custom Alignment. Assign MI_Ripple. This replaces camera-facing geometry with a Z-normal ground sprite.
    Offset slightly above the floor to avoid z-fighting
    Offset slightly above the floor to avoid z-fighting
  6. Grow normalized-age size from 0.2 to 1.8 and fade alpha from 0.6 to zero. Inspect from above and at an angle for a floor-parallel ring.
    Age = seconds / NormalizedAge = lifetime progress
    Age = seconds / NormalizedAge = lifetime progress

Check fall time and sprite orientation

With constant gravity and no drag, vertical speeds 200/300 cm/s reach their apex after about 0.204/0.306 s. Lifetime 0.6–0.9 s is not the floor-contact time.

Check ripple Facing/Alignment bindings against SpriteFacing/SpriteAlignment. Combine +Z normal with zero actor rotation; changing the mode without supplying its attribute is insufficient.

First playback, restarting and saving

Inspect Splash alone, then restore Ripple and restart. In the level its height is system Z=5 plus offset -3, totaling two centimeters. Check orientation against the placed level floor rather than only the editor preview floor.

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.

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
Ripple follows the cameraFacing mode and bindingCheck custom facing, its attribute binding and Z=1.
Straight travel without fallingGravity/solver orderPlace gravity before the solver and compare Z=-980.
Repeated splashesThree loop controlsUse one burst and Self/Once; distinguish preview looping.

Completion checks

  1. Spray alone clearly rises and falls.
    Gravity
    Gravity
  2. The ripple starts at 0.1 s, expands and fades.
    Age = seconds / NormalizedAge = lifetime progress
    Age = seconds / NormalizedAge = lifetime progress
  3. It stays parallel to the floor without z-fighting.
    Offset slightly above the floor to avoid z-fighting
    Offset slightly above the floor to avoid z-fighting
  4. Profile overlapping translucent cards on the target device.
    Change one variable, then remeasure
    Change one variable, then remeasure

Compare the Unity version and continue

Use sprite size and velocity alignment instead of Unity Stretched Billboard. The ripple sets sprite facing/alignment instead of rotating a mesh quad.

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

References