Two Niagara features connect particle systems to Gaussian Splats:
| Feature | What it does |
|---|---|
Splat Renderer | Draws each particle as a soft, oriented 3D Gaussian. |
Gaussian Splat Reader | A data interface that reads splat positions, shapes, opacities, and colors from a Gaussian Splat asset. |
Particles drawn with the Splat Renderer render the same way as Gaussian Splat actors: they are unlit, don't cast shadows, and are drawn before depth of field and tone mapping. For details, see Gaussian Splats Technical Reference.
What You Can Do
Render particles as splats. Add a Splat Renderer to a CPU or GPU emitter to draw its particles as splats instead of sprites or meshes.
Build effects from a Gaussian Splat asset. Use a Gaussian Splat Reader to spawn particles from an asset's splats, then animate them to create effects such as dissolves, reveals, explosions, and morphs.
Requirements
The Gaussian Splats experimental setting must be enabled for your project. See Enable Gaussian Splats.
Splat Renderer
The Splat Renderer draws each particle as a 3D Gaussian with a flat color. It works with CPU and GPU simulations and doesn't use materials.
To add it, select an emitter, click + next to Render in the emitter stack, and choose Splat Renderer.
| Parameter | Description |
|---|---|
| Splat Rendering | |
Splat Scale | Multiplies the size of every splat. Default: 1.0. |
Opacity Scale | Multiplies the opacity of every splat. Default: 1.0. |
| Visibility | |
Renderer Visibility | If particles have a visibility tag, only particles whose tag matches this value are drawn. Default: 0. |
| Bindings | |
Position Binding | The center of each splat. Uses Particles.Position by default. If unbound, uses (0, 0, 0). |
Scale Binding | The size of each splat on each axis, as a standard deviation in simulation units, before Splat Scale is applied. Uses Particles.Scale by default. If unbound, uses (1, 1, 1). |
Rotation Binding | The orientation of each splat. Uses Particles.MeshOrientation by default. If unbound, or if the value is zero or unnormalized, uses no rotation. |
Color Binding | The splat's color (RGB) and opacity (alpha). Uses Particles.Color by default. If unbound, uses white. |
Renderer Visibility Tag Binding | The value compared against Renderer Visibility. Uses Particles.VisibilityTag by default. |
Because scale is a standard deviation rather than a radius, a splat is visible out to about two to three times its scale on each axis. With the default scale of (1, 1, 1), splats are only a few units across, so set Scale or Splat Scale to suit your effect.
Keep the following in mind when you use the Splat Renderer:
Flat color. Each splat has a single color. View-dependent color from a Gaussian Splat asset isn't preserved.
No level of detail. Unlike Gaussian Splat actors, particles drawn with the Splat Renderer don't use level of detail or Min LOD. Every particle is processed every frame.
Gaussian Splat Reader
The Gaussian Splat Reader data interface reads splat data from a Gaussian Splat asset. It works in CPU and GPU simulations.
| Parameter | Description |
|---|---|
Gaussian Splat | The Gaussian Splat asset to read. If no asset is set, the Reader reports zero splats. |
Functions
| Function | Inputs | Outputs | CPU | GPU | Description |
|---|---|---|---|---|---|
Get Num Splats | — | NumSplats | Yes | Yes | Returns the number of splats that can be read. |
Get Bounds | — | BoundsMin, BoundsMax | Yes | Yes | Returns the asset's bounds. |
Get Base Data | Index | Position, Rotation, Scale, Opacity | Yes | Yes | Returns a splat's position, rotation, scale, and opacity, in the asset's local space. Scale is the standard deviation on each axis. |
Get SHDegree | — | SHDegree | Yes | Yes | Returns the asset's spherical harmonics (SH) degree. |
Get SHCoefficient | Index, Coefficient | Coefficient | Yes | Yes | Returns one SH coefficient. Coefficient 0 is the base color, and coefficients 1 through (degree + 1)² − 1 are the higher bands. Out-of-range coefficients return 0. |
Calculate Color | Index, Direction | Color | Yes | Yes | Returns a splat's linear color for a viewing direction. To get the base color without view-dependent shading, pass (0, 0, 0). |
CalculateSpriteSizeRotation | Position, Rotation, Scale | IsVisible, SpriteSize, SpriteRotation | No | Yes | Returns the size and rotation of a sprite that matches the splat's on-screen shape, for drawing splats with a sprite renderer. IsVisible is false when the splat is behind the camera. |
The Reader reads only the asset's full-resolution splats, not its coarser levels of detail. When a Gaussian Splat asset is reimported or rebuilt in the editor, Niagara systems that read it are updated automatically.
Examples
These examples use only the Gaussian Splat Reader, the Splat Renderer, standard Niagara modules, and Scratch Pad modules.
In UEFN, splat logic is built with Scratch Pad modules. Each splat is a Niagara particle, so the number of splats an effect can show is limited by Niagara's particle limits. For large Gaussian Splat assets, spawn particles for a subset of the splats, as shown in Morph Between Two Splats with Niagara.
Draw an Existing Emitter as Splats
The simplest integration doesn't use a Reader. Replace an emitter's Sprite Renderer with a Splat Renderer. Particles are then drawn as splats, using Particles.Position, Particles.Scale, Particles.MeshOrientation, and Particles.Color.
Because scale is a standard deviation, set the particle scale or the renderer's Splat Scale so that the splats are large enough to see.
Read Splats in a Scratch Pad module
The following examples use the same steps to read splats from a Gaussian Splat asset:
Expose the Reader as a user parameter. In the system's User Parameters, add a Gaussian Splat Reader (for example, User.Reader) and set its Gaussian Splat asset. When the system is placed in a level, you can change the asset on the Niagara actor without editing the system.
Pass the Reader into the module. Add a module input of type Gaussian Splat Reader and bind it to User.Reader in the stack. In the module graph, read it with a Map Get node.
Call Reader functions. From the Reader pin, call functions such as Get Num Splats, Get Base Data, Get Bounds, and Calculate Color. See Functions.
Write the results to particle attributes. Use a Map Set node to write Particles.Position, Particles.Scale, Particles.MeshOrientation, and Particles.Color. These are the Splat Renderer's default bindings.
Each particle needs a splat index to read. The examples use Particles.UniqueID, which counts up from 0 as particles spawn, so particle N reads splat N, or a scaled index.
To get a splat's base color, call Calculate Color with a direction of (0, 0, 0). Opacity comes from Get Base Data and goes in the alpha channel of Particles.Color.
Morph Between Two Splats
This effect continuously morphs one object splat into another and back. Each particle reads one splat from each of two Gaussian Splat assets and blends between them, so the morph spans both assets while staying within particle limits.
For step-by-step instructions to build this effect, see Morph Between Two Splats with Niagara.
Blow a Splat Apart and Reassemble It
This example explains how the effect works, for creators who are familiar with Scratch Pad modules. For a step-by-step introduction to the techniques it uses, see Morph Between Two Splats with Niagara.
This effect lifts a splat's individual splats into a spinning vortex and sets them back down. A single user parameter, User.Amount, controls the effect. At 0, the splat is intact. As Amount increases, splats leave their original positions at staggered times.
| Stack section | Contents |
|---|---|
User Parameters | User.Reader: the Gaussian Splat asset. User.Amount: 0 is intact, and about 1 is fully in the vortex. |
Emitter | A Scratch Pad module sets Emitter.SplatCount from the Reader's Get Num Splats, and the emitter spawns that many particles. This spawns one particle per splat, so it works only with assets within Niagara's particle limits. |
Particle Spawn | An Init From Splat module, described below. |
Particle Update | A chain of Scratch Pad modules that build the vortex, described below. |
Render | Splat Renderer with the default bindings. |
Init From Splat (Particle Spawn)
For each new particle, this module reads splat UniqueID with Get Base Data and Calculate Color (direction 0, 0, 0). It then:
Writes the splat's position, rotation, scale, and color to the particle, so the splat appears intact on the first frame.
Stores copies as home attributes: Particles.HomePosition, Particles.HomeRotation, and Particles.HomeScale, along with Particles.Opacity and Particles.SplatIndex.
Every later step animates away from the home attributes, so setting Amount back to 0 restores the splat exactly.
Particle Update chain
The modules run in order. Most of them calculate a Transient.* value that later modules use.
| Order | Value | Calculation | Effect |
|---|---|---|---|
1 | Center | Midpoint of the Reader's Get Bounds. | Places the vortex axis through the middle of the splat. |
2 | R0 | Horizontal (XY) distance from the home position to the center. | Each splat's starting distance from the axis. |
3 | Height | Bounds height (Z), at least 1. | Scales the effect to the splat's size. |
4 | H1 | Home height as a 0–1 fraction of Height. | Lifts higher splats higher. |
5 | Phase | A pseudo-random 0–1 value from the splat index: frac(sin(index) × 12.9898 × 43758.5). | Gives each splat its own timing offset. |
6 | t | x = clamp(1.5 × Amount − 0.5 × Phase, 0, 1), then smoothstep: x² × (3 − 2x). | How far each splat is into the vortex. The phase offset staggers when splats leave. |
7 | Spin | Time × 6 / (1 + 0.02 × R0) × t | Rotation speed. Splats near the axis spin faster, and spin returns to 0 as t returns to 0. |
8 | Radius | lerp(R0, 0.8 × Height × H1 + 0.3 × R0, t) | Pulls splats into a funnel that is wider at the top. |
9 | Angle | Home angle around the axis (atan2) plus Spin. | Position around the funnel. |
10 | Z | Home height plus t × (1.5 × H1 × Height + 10 × sin(2π × Phase + 3 × Time)). | Lifts splats and adds vertical motion for each splat. |
11 | TornadoPos | Center + (Radius × cos(Angle), Radius × sin(Angle)), at height Z. | The splat's position in the vortex. |
12 | Final values | Particles.Position = lerp(HomePosition, TornadoPos, t) and Particles.Scale = HomeScale × lerp(1, 0.6, t). | Blends from the home position to the vortex, and shrinks splats by up to 40% while they're in the air. |
To customize the effect:
Animate User.Amount from 0 to about 1 and back to break the splat apart and reassemble it. Because of the phase offset in step 6, the last splats leave when Amount reaches 1.
To make the effect adjustable, replace the fixed values in steps 7, 8, and 10 (6, 0.02, 0.8, 0.3, 1.5, and 10) with module inputs bound to user parameters.
The logic is split into several small modules so that each step is easy to inspect in the stack. You can also combine them into a single module.
Run the Examples on All Platforms
The example effects use GPU simulations, which handle large particle counts but don't currently run on Android, where Niagara GPU simulations are disabled. To run an effect on all platforms, create a CPU version. The modules don't change. The simulation target and the number of particles do.
Every emitter has a Sim Target setting in its Emitter Properties:
GPUCompute Sim updates particles in parallel on the GPU, and handles hundreds of thousands of particles or more.
CPU Sim updates particles on the CPU. It runs on all platforms, but its cost grows much faster with particle count.
The Splat Renderer and all of the Reader functions used in the examples work in CPU simulations. CalculateSpriteSizeRotation is GPU only. GPU emitters require Fixed bounds, while CPU emitters can also use Dynamic bounds.
To create a CPU version:
Select the emitter and open Emitter Properties.
Set Sim Target to CPU Sim.
Reduce the number of particles:
Draw an existing emitter as splats: Standard emitters usually work in CPU simulations without changes.
Morph between two splats: Lower User.MaxSplats (see Morph Between Two Splats with Niagara). The morph still spans the whole asset, with fewer, more widely spaced splats.
Blow a splat apart and reassemble it: This effect spawns one particle per splat. Change it to spawn a subset instead:
Add an Emitter.MaxSplats parameter, and spawn that many particles instead of Emitter.SplatCount.
In Init From Splat, calculate the splat index as UniqueID × NumSplats / MaxSplats (using Get Num Splats on the Reader), and use it in place of UniqueID for Get Base Data, Calculate Color, and Particles.SplatIndex.
The Particle Update chain uses Particles.SplatIndex and the home attributes, so it doesn't change.
Compile and save the system.
With fewer particles, splats look sparser while the effect plays.
To use the best version on each platform, a system can contain both a GPU emitter and a CPU emitter, with each enabled for different platforms in its Scalability settings.
Tips
Expose Readers as user parameters so that you can change the Gaussian Splat asset on the placed Niagara actor.
Store the splat index and home transform at spawn, then animate relative to them in Particle Update.
Spawn a subset of splats from large assets, and scale the index, to stay within particle limits.
Match the effect to placed splats. Reader values are in the asset's local space, so give the Niagara system the same transform as the Gaussian Splat actor that it replaces or reveals.
Platforms and Performance
Niagara splats render on all platforms where Gaussian Splats are supported. Niagara GPU simulations are currently disabled on Android, so effects that need to run on Android must use CPU simulations. See Run the examples on all platforms.
Particles drawn with the Splat Renderer don't use level of detail, so every particle is processed every frame on every platform. To manage cost on lower-end platforms:
Use Niagara scalability settings, such as spawn count scaling and emitter culling, to reduce particle counts.
For effects built with the Reader, spawn particles for fewer splats on lower-end platforms.
Maximum Particle Counts
Each splat in a Niagara effect is a particle. Niagara supports the following maximum particle counts:
| Parameter | Maximum |
|---|---|
Particles per CPU emitter | 1,000,000 |
Particles spawned per frame by a GPU emitter | 2,000,000 |
Splats drawn per emitter by the Splat Renderer | 4,194,304 |
For Gaussian Splat assets with more splats than this, spawn particles for a subset of the splats, as shown in Morph Between Two Splats with Niagara.
Lower quality levels limit the number of particles per emitter further. When an effect that reads splats spawns more particles than the limit allows, part of the object is missing, rather than the whole object looking sparser, because particles read splats in spatial order. Test your effects at the lowest quality level you target, and reduce the particle count until the whole object appears.
The number of particles that performs well depends on the platform, whether the emitter uses a CPU or GPU simulation, and the work done by its modules. Choose particle counts for each platform you target.
See Also
Gaussian Splats
Niagara in UEFN
Niagara Reference
These pages are written for Unreal Engine. Most of the content applies to UEFN, but some features aren't available in UEFN.