| Enumerator |
|---|
| None | No special features enabled, which may result in a very basic and limited particle system with minimal GPU usage. This can be useful for simple effects or when you want to minimize GPU overhead, but may not support many common particle behaviors or rendering techniques.
|
| GPUDriven | Particle simulation and update logic runs entirely on the GPU, with minimal CPU involvement. This can allow for very large particle counts and complex behaviors, but may require more careful design of the particle graph and may not support certain CPU-side features such as complex event handling or integration with game logic.
|
| AsyncCompute | Simulation and update passes can be scheduled on an async compute queue, allowing for better performance by overlapping with graphics work. This may require careful handling of resource synchronization and may not be compatible with all GPU features or platforms.
|
| IndirectDraw | Rendering uses indirect draw calls, which can reduce CPU overhead and allow for more dynamic rendering techniques, but may require more complex GPU-side logic for generating draw arguments and may not be supported on all platforms.
|
| GPUCulling | The system performs GPU-based culling of particles, which can improve performance by reducing the number of particles that need to be processed and rendered, but may require additional GPU resources for culling and may not be suitable for all types of particle systems (e.g., those with complex interactions or non-spherical bounds).
|
| SortByDepth | Particles are sorted by depth on the GPU, which can improve rendering quality for transparent particles but may require additional GPU resources for sorting and may not be necessary for all types of particle systems (e.g., opaque particles or those that use order-independent transparency techniques).
|
| StableParticleIds | Particle IDs remain stable across frames, which can allow for more consistent behavior and easier debugging, but may require additional GPU resources for maintaining and sorting particles by ID and may not be necessary for all types of particle systems (e.g., those that don't rely on particle identity or have simple behaviors).
|
| EnableEvents | The system supports emitting and consuming events, which can allow for more complex interactions between particles and with the game engine, but may require additional GPU resources for event queues and may not be necessary for all types of particle systems (e.g., those that don't rely on events or have simple behaviors).
|
| EnableReadback | The system supports asynchronous readback of particle data to the CPU, which can allow for CPU-side processing or integration with game logic, but may require additional GPU resources for staging buffers and may not be necessary for all types of particle systems (e.g., those that are fully GPU-driven and don't require CPU interaction).
|
| Deterministic | The system is designed to produce deterministic results across runs, which can be important for certain types of simulations or for debugging, but may require additional constraints on the particle graph and may limit certain optimizations or features that could introduce non-determinism.
|
| MolecularDynamics | The system is designed to support molecular dynamics simulations, which may have special requirements for data layout, precision, and scheduling. This may require additional GPU resources for neighbor searching and may not be necessary for all types of particle systems (e.g., those that don't rely on particle interactions or have simple behaviors).
|
| NeighborSearch | The system supports GPU-based neighbor searching, which can allow for more complex particle interactions such as collisions or fluid dynamics, but may require additional GPU resources for spatial data structures and may not be necessary for all types of particle systems (e.g., those that don't rely on particle interactions or have simple behaviors).
|
| DoubleBufferedState | The system uses double buffering for particle state, which can help to avoid read-write hazards and allow for more flexible scheduling of simulation and rendering passes, but may require additional GPU resources for maintaining multiple state buffers and may not be necessary for all types of particle systems (e.g., those with simple update logic or that can tolerate some level of read-write contention).
|
1.15.0