As part of my university project, which involved building a custom engine, I implemented a particle system. I found it to be a particularly satisfying feature to develop, so I decided to share my approach. ## The result Let's run it from the back and look at the final result first. This is how the particle system looked in the editor. % video(../assets/particle-system/particles-showcase.mp4, Particle system in the editor of my custom engine) The particle system can also be seen in the game I developed using this engine. It significantly improved the visual appeal, even with a simple particle system like this. % video(https://youtu.be/BmpE42d4nyY, Particle system in game) ## The approach One of the primary goals of the entire project was accustomization to the entity-component-system architecture, which has heavily reflected on the approach I took. My goal with this feature was to support tens of thousands of particles running seamlessly at 60+ FPS. ### Particles Let's start at the root with a **particle**. An individual particle is a very simple entity, which defines only a few values: its `age`, its `lifetime`, and its `velocity`. Generally speaking, we define an entity that has a direction of travel and a ticking timer before it dies. I will be omitting velocity, since that has been handled in my `RigidbodyComponent`, therefore this is how a simple `ParticleComponent` looked like: ```cpp struct ParticleComponent { float age = 0.0f; float lifetime = 1.0f; }; ``` We will return to particles a bit later, but this simple explanation is enough for now. ### Particle Profiles The next concept I want to touch upon is a **particle profile**. In my particle system, I used particle profiles to modify the behaviour of individual particles. In other words, it was a set of properties that change the color, initial velocity, or size. The important point is that multiple particle systems can **share** one particle profile. These are all the properties I found useful while creating all effects for my game. Most of them are self-explanatory, but I will explain a few of them: - `Looping` - defines whether the profile is one-shot or infinitely looping - `Duration` - if `Looping` is false, the effect will last for `Duration` seconds - `Emission Rate` - how many particles a second to emit - `Lifetime` - `Lifetime Variance` - `Initial Velocity` - `Velocity Variance` - `Start Scale` - `End Scale` - `Scale Variance` - `Start Color` - `End Color` - `Color Variance` - `Start Rotation` - `Rotation Variance` - `Angular Velocity` - `Angular Velocity Variance` - `Use Gravity` In my engine, I treated particle profiles as a resource, which meant they were serialized on disk in a `.particle_profile` file. The contents of this JSON file looked like this: ```json { "m_looping": false, "m_duration": 3.0, "m_emissionRate": 2500.0, "m_lifetime": 10.0, "m_lifetimeVariance": 4.0, "m_initialVelocity": [0.0, 18.0, 0.0], "m_velocityVariance": [35.0, 18.0, 35.0], "m_startScale": [0.8, 0.8, 0.8], "m_endScale": [8.0, 8.0, 8.0], "m_scaleVariance": [2.5, 2.5, 2.5], "m_startColor": [1.0, 0.5, 0.1], "m_endColor": [0.03, 0.03, 0.03], "m_colorVariance": [0.5, 0.4, 0.2], "m_startRotation": [0.0, 0.0, 0.0], "m_rotationVariance": [6.28318, 6.28318, 6.28318], "m_angularVelocity": [0.0, 0.0, 0.0], "m_angularVelocityVariance": [12.0, 12.0, 12.0], "m_useGravity": true, "m_material": 12185720181781197242, "m_mesh": 1797231269285335481 } ``` There are two fields included that are missing in my earlier list of properties: `m_mesh` and `m_material`. When spawning a particle, we have to decide on how the particle is going to look like, which is exactly why these two values exist. In all of the particle effects I have shown earlier, I used a cube mesh and a basic material. However, there is one more issue. If we look at the properties again, we have many **start** and **end** properties (start scale, end scale, start color, end color). These are generally fine, since we can use linear interpolation for them. We can divide the `particle.age` by `particle.lifetime`, which gives us a number in the range of 0 to 1. If we feed this to a linear interpolation of the `Start Color` and `End Color`, we get the correct particle color at this stage of its lifetime. %image(../assets/particle-system/start-end-color-lerp.png, Lerp, Linear interpolation of colors) The issue comes with variance. If the properties are not uniform across the whole system, we have to store particle-specific properties in the `ParticleComponent`. Variant lifetime is already solved, since we store the `lifetime` field. Variant velocity only takes an effect when spawning, so that is also solved. With variant color, I only offset the startColor and then move towards a same color, so that is also solved. This is not per se optimal, but it was enough for my effects. However scale variance requires some more work: I would like particles to start at a different scale and also end at a different scale, so that's data I had to add to the `ParticleComponent`. While we're at it, let's also store a reference to the parent system of the spawned particle, we will need it later: ```cpp struct ParticleComponent { UUID systemId = UUID::null; float age = 0.0f; float lifetime = 1.0f; vec3 startScale = vec3(1.0f); vec3 endScale = vec3(1.0f); }; ``` ### Particle System Connecting these concepts together is the **particle system**. The `ParticleSystemComponent` is the component that you attach to an entity, select a particle profile, hit play, and see the particles spawning. Let's start with the code: ```cpp struct ParticleSystemComponent { UUID id; ResourceHandle profile; bool worldSpace = false; // Runtime float r_emissionAccumulator = 0.0f; float r_durationAccumulator = 0.0f; }; ``` We store a reference to the profile, which acts as the data template to create individual particles. We define whether the particle should operate in **local-space** or **world-space**. This flag plays a role when spawning the particles, but we will get to that later. Finally, we store a few runtime variables that are used in the ECS system. With all this out of the way, we can get into the actual implementation of the Particle System Class. ### Particle System Class What I mean by `Particle System Class` is the actual ECS system that simulates particles. There is sadly a big ambiguity around the word *system* when it comes to working with an ECS. In theory, this system has a simple task: ``` foreach system in particleSystems if (ShouldSpawnParticle(system)) SpawnParticle(system) foreach particle in system.particles Simulate(particle) ``` This is heavily oversimplified and also sort of anti-ECS, but it conveys the main idea. % info(The primary benefit of an ECS is efficient iteration due to contiguous memory layout of components. Implementing the approach above disregards the particle data’s memory layout\, leading to poor cache locality and frequent cache misses.) That is why I chose a bit of a different approach: ``` systemIdToProfile = [] foreach system : particleSystems systemIdToProfile[system.id] = system.profile foreach particle : particles profile = systemIdToProfile[particle.systemId] Simulate(particle, profile) ``` I loop through all of the systems to cache their corresponding profiles. After that, I resolve the simulation of all particles in one pass, with referring back to the cached profile for simulation data. When spawning: I create a new entity, decide whether to create in world-space or local-space, and then apply all the starting properties from the profile. %image(../assets/particle-system/particle-profile.png, ParticleProfile, Particle profile properties applied to particles) This is the implementation of my particle system, with some details being omitted and added comments for clarity: %codeDropdown(ParticleSystem::Update Implementation, cpp)``` void ParticleSystem::Update(float deltaTime) { std::unordered_map idToProfile; auto& scene = /* ... */ // Loop through all particle system components auto systems = scene.View(); for (auto entity : systems) { auto& system = systems.get(entity); auto& profile = /* ... */ idToProfile[system.id] = &profile; if (!profile.m_looping) { system.r_durationAccumulator += deltaTime; if (system.r_durationAccumulator >= profile.m_duration) continue; } system.r_emissionAccumulator += deltaTime * profile.m_emissionRate; while (system.r_emissionAccumulator >= 1.0f) { SpawnParticle(profile, entity, system); system.r_emissionAccumulator -= 1.0f; } } // Loop through all particle components auto particles = scene.View(); for (auto entity : particles) { auto& particle = particles.get(entity); auto& meshRenderer = particles.get(entity); auto& transform = particles.get(entity); auto* profile = idToProfile[particle.systemId]; particle.age += deltaTime; if (particle.age >= particle.lifetime) { scene.DestroyEntity(entity); continue; } if (profile == nullptr) { continue; } float t = particle.age / particle.lifetime; meshRenderer.color = mix(profile->m_startColor, profile->m_endColor, t); transform.localScale = mix(particle.startScale, particle.endScale, t); quat deltaRotation = quat(particle.angularVelocity * deltaTime); transform.localRotation = transform.localRotation * deltaRotation; } } ``` %codeDropdown(ParticleSystem::SpawnParticle Implementation, cpp)``` void bee::ParticleSystem::SpawnParticle(const ParticleProfile& profile, Entity systemEntity, const ParticleSystemComponent& system) { auto& scene = /* ... */ Entity newParticle = scene.CreateEntity("Particle"); if (system.worldSpace) { auto& systemTransform = scene.GetComponent(systemEntity); auto& particleTransform = scene.GetComponent(newParticle); particleTransform.localPosition = systemTransform.GetPosition(); particleTransform.localRotation = systemTransform.GetRotation(); scene.AddChild(m_holderEntity, newParticle, false); } else { scene.AddChild(systemEntity, newParticle, false); } auto& particleComponent = scene.AddComponent(newParticle); particleComponent.systemId = system.id; particleComponent.lifetime = profile.m_lifetime + GetRandomNumber(-m_lifetimeVariance, m_lifetimeVariance); vec3 scaleOffset = GetRandomVector(-m_scaleVariance, m_scaleVariance); particleComponent.startScale = profile.m_startScale + scaleOffset; particleComponent.endScale = profile.m_endScale + scaleOffset; auto& transform = scene.GetComponent(newParticle); transform.localScale = particleComponent.startScale; transform.localRotation = profile.m_startRotation + GetRandomVector(-m_rotationVariance, m_rotationVariance); auto& meshRendererComponent = scene.AddComponent(newParticle); meshRendererComponent.color = profile.m_startColor + GetRandomVector(-m_colorVariance, m_colorVariance); meshRendererComponent.lit = false; meshRendererComponent.mesh = profile.m_mesh; meshRendererComponent.material = profile.m_material; auto& rb = scene.AddComponent(newParticle); vec3 velocityOffset = GetRandomVector(-m_velocityVariance, m_velocityVariance); rb.velocity = profile.m_initialVelocity + velocityOffset; rb.angularVelocity = profile.m_angularVelocity + GetRandomVector(-m_angularVelocityVariance, m_angularVelocityVariance); rb.useGravity = profile.m_useGravity; } ``` ## Conclusion and improvements In the end, I had about three days of work allocated for the whole particle system. It turned out to be a very good decision for the engine, as it made the game more engaging. In regards of the performance, it ran quite nice, though I did get into performance issues with huge particle effects. However, the primary reason was the lack of instancing, as a particle system is something that would benefit greatly from that. If I had more time to work on this, I would definitely implement the following: - GPU instancing - More emitter shapes - Billboards - Support easing curves and color gradients Thanks for reading. Until next time,
Seb

Blog Posts

AngelScript Scripting - Introduction

Particle System in a custom engine