Hi,
For our project we have thousands of particle effects — most of them originating from impacts, explosions, muzzle flashes, tracers (trails), and projectiles. Spawning and updating an entire Niagara System for each one is obviously not an option due to performance, so we’ve converted most of our effects to use Niagara Data Channels (NDCs). The difference in CPU performance is massive — probably more than 50×.
For effects that don’t move from their original location, or for effects like tracers where we spawn a new ribbon segment every frame and track by ID, this works great. (Small caveat: the very expensive ribbon allocations still show up occasionally!)
Now, the next step for me is to address performance for moving projectile effects. We often have hundreds of these, and at the moment we handle them naively by attaching a Niagara System to each moving object. This is extremely expensive and not a realistic long-term approach.
I’d like to do something similar to the NDC setup for these — ideally transforming the particles on the GPU during the update phase. This is proving tricky, since the Data Channel data is frame-transient and connecting a CPU driven projectile with a specific execution index during update seems difficult.
I have a few ideas on how to approach this, but they feel a bit over-engineered (for example, writing projectile positions to a texture from the render thread at index offsets and then reading that in the emitter update).
I’ve seen a few posts online where others have asked similar questions, but there doesn’t seem to be a clear solution to the “moving particles with a projectile” problem.
Surely someone has achieved good performance for a large number of moving projectiles using Niagara.
Any ideas or recommended approaches would be much appreciated.
Thanks!