12.8 - Particle Systems¶

The Big Idea¶

A particle system models a physical phenomenon over a time span and is composed of many individual “particles.” Each particle has a “lifetime” that controls how long it is part of an animation. Between frames of an animation new particles might be added while other active particles might “die off”. Various properties of a particle can be modified over its lifespan to affect how it is rendered. The complexity of a particle system is based on 1) the number of active particles in the system, 2) the number of properties of each particle, and 3) the complexity of the property manipulation over time. A simple particle system might define the following properties for each particle:

• location - a particle’s current location in 3D space.
• path - a particle’s path over time. (A single direction vector or perhaps a Bezier curve.)
• speed - a particle’s change in location over time (distance / time).
• size - a particle’s size.
• texture coordinates - a particle’s location in a texture map.
• lifetime - how long a particle is part of a particle system (in animation frames or clock time).

The behaviour of a particle system is defined by a set of “rules” that control how particles are initialized and modified over time. A single “rule” might define how a property changes during the entire lifetime of a particle, or separate “rules” might be used at various stages of a particle’s life. Therefore, a particle system defines particle properties, “rules” for changing those properties, and “rules” for changing the “rules”. The big idea behind a particle system is straightforward, but its implementation can be complex.

A particle system is often implemented with randomness built into its “rules.” Properties and the rules that update them typically define a range of possible values. For example, the size of a particle might be some random value in the range 3.6 to 6.8. Getting a particle system to simulate a particular physical phenomenon requires careful tuning of the property ranges. (To remove all randomness, use the same value for the lower and upper limits of a range.)

Typically the rendering of a particle system is intended to produce a visual representation of a coherent physical phenomenon – not the rendering of a set of disjoint “particles.” Transparency and color blending are often critical parts of a particle system rendering. If a camera is allowed to view a particle system from any angle, transparency requires that the particles be sorted from back-to-front before rendering. If the camera view can be restricted, no sorting of the particles is required as long as the particles are created and organized in an appropriate sorted order.

Implementing a Particle System¶

Real-time rendering of complex scenes is possible because of the speed of GPU’s. To render a triangular mesh, its data is copied into a GPU buffer object once and then rendered under a transformation thousand’s of times using a single call to gl.drawArrays(). This type of rendering is not possible for a particle system where the particles’ properties are changing between each animation frame. Here are some possible scenarios for rendering a particle system:

1. Render each particle using a call to gl.drawArrays(). The properties of a particle are modified and uploaded to a shader program as uniform variables before calling gl.drawArrays(). This is very inefficient and the number of particles that can be rendered in real-time is limited.
   
   
2. Create an array of data for each particle property. For each frame of an animation, update the property values for every particle, copy the arrays to the GPU, and render all of the particles with a single call to gl.drawArrays(). (Sorting of the particles is possible – if needed.)
   
   
3. Create an array of data for each particle property and arrays of data that define how the particles are changing. Use a uniform shader variable to represent a frame number (or time value). Given a specific frame number, the shader program calculates modifications to the particle properties and no data arrays need to be copied to the GPU. The entire particle system can be rendered with a single call to gl.drawArrays(). However, the shader program will be complex and sorting of the particles is not possible because a shader program is not allowed to modify a vertex object buffer.

The example WebGL program in this lesson is implemented using scenario #2.

// Rendering data for particles:
let location            = new Float32Array(max_particles * 3);
let size                = new Float32Array(max_particles);
let texture_coordinates = new Float32Array(max_particles * 2);
let color_alpha         = new Float32Array(max_particles);

// Data to update and manage the particles:
let direction = new Array(max_particles);
let speed     = new Array(max_particles);
let alive     = new Array(max_particles);
let lifetime  = new Array(max_particles);

// Private functions:
function _randomFloat(min, max) { .. }
function _randomInt(min, max) { .. }
function _create() { .. }
function _initializeParticle(index) { .. }
function _deleteParticle(delete_index) { .. }
function _updateParticle(index) { .. }
function _updateBufferObject(buffer_id, data) { .. }
function _updateGPU () { .. }

// Public functions:
self.reset  = function() { .. }
self.update = function() { .. }
self.render = function(transform, camera_space) { .. }

Particle Engines¶

A particle engine is a software system that creates a particle system. Sharing a particle system between computer graphic systems is problematic because the programming logic is a critical part of any particle system and simply storing the parameters that define the particle system are insufficient to re-create the same visual effects.

Blender has an extensive particle engine that is fun to experiment with. To create a particle system in Blender, follow these basic steps:

1. Create any mesh object (e.g., a plane or a cube), to serve as the particle system’s “emitter.”
2. With the “emitter” as the currently selected object, in the property editor, select the “Particles” tab, .
3. Create a new particle system and begin setting its parameters.
4. To visualize a particle system the “Timeline” window must be used to vary the active frame.

For full documentation, see https://docs.blender.org/manual/en/dev/physics/particles/particle_system_panel.html

Glossary¶

particle system

a large collection of geometric primitives (points, lines, or triangles) whose properties vary over time to simulate real-world phenomenon.

particle engine

a software system that facilitates the creation of a particle system.

Self Assessment¶