9.3. PARTICLE SYSTEMSDevelopment of a particle system

QUESTION CLINIC: FAQIn lecture exploration of answers to frequently asked student questions

PARTICLE SYSTEMSDevelopment of an XNA/Java deployable particle system

A particle system can be used to simulate phenomena such as fire, smoke, explosions, moving water (e.g. fountains, waterfalls), sparks, dust, snow, rain, bullet casings, etc.

Particle Systems

Particle systems can also be used to provide special effects for spells, etc. or provide a model of fur and grass.

Particle effects are widely used within games.

A particle system is typically controlled by an emitter. The emitter acts as the source for generated particles. Particles may be emitted at a constant rate or in sudden bursts.

Each update/draw can be defined in terms of a simulation stage and a rendering stage.

Particle Systems

Each generated particle can have a number of defined parameters, e.g. velocity, direction, lifetime, colour, etc.

Typically each parameter value is randomly selected from within some defined range.

Simulation Stage

New particles are spawned if needed (alongside particle parameter selection/randomisation).

Any particles that exceed their lifetime are removed from the simulation.

All other particles properties are updated as needed (e.g. position, rotation, etc.) based on some simulation rules.

Particle Systems

The particles may also be tested for collision against other objects, with suitable interactions introduced

Rendering stage

Each particle is rendered (if in 3D typically using a textured billboard)

We will explore the XNA ParticleSample tutorial.

Particle Systems (example)Based upon the XNA

ParticleSample tutorial

Particle System

Explosion Particle System

Explosion Smoke Particle System

Smoke Plume Particle System

Particle

Particle ParticleAside: The tutorial uses a SpriteBatch to render the particles –a GPU point sprite based approach is explored in a later lecture.

Each particle system comprises a number of particles. Each particle is defined with properties such as position, velocity, acceleration, rotation, lifetime, etc.

When drawn each particle will display a common image that is layered on top of other particles (using either normal or additive blending).

The particle properties are controlled to provide the desired effect.

Particle Systems (particles)

public bool isActive{ get { return timeSinceStart < lifetime; } }

public void Initialize( Vector2 position, Vector2 velocity, Vector2 acceleration,

float lifetime, float scale, float rotationSpeed) {

// Store passed values// Set time since start to zero// Randomly select rotation (0-2π

radians)}

public void Update(float dt) {velocity += acceleration * dt;position += velocity * dt;rotation += rotationSpeed * dt;timeSinceStart += dt;

}}

Particle

Definition position, velocity, rotation acceleration, and rotation speed

Define how long this particle will ‘live’ before it is removed/rebornAnd how long it has been alive

Define the scale of this particle (i.e. how close/far from the camera)

public class Particle{

public Vector2 position;public Vector2 velocity;public Vector2 acceleration;

public float rotation;public float rotationSpeed;

public float lifetime;public float timeSinceStart;

public float scale;

Determine if this particle is alive

Initialise the particle (e.g. upon particle reuse or ‘rebirth’)

Called each frame to update the particle’s position and rotation

Aside: Other properties can be stored within the particle.

The ParticleSystem class manages a collection of particle instances.

• As particles die and are reborn it is important the particle system caches and reuses particle (to reduce garbage collection churn).

• A particle system may have to manage particle load by controlling the number of active particles.

• Often the draw order for particles is important (i.e. particles drawn with normal alpha blending are drawn first before those using additive blending).

Particle Systems (particle management)

Particle System

Explosion Particle System

Explosion Smoke Particle System Smoke

Plume Particle System

• The presented approach uses a generic particle system that is extended/customised for each effect. Other approaches involve having a single manager manage and draw a number of different types of particle.

public abstract class ParticleSystem :

DrawableGameComponent {

private Texture2D texture;private Vector2 origin;

private const int howManyEffects;

Particle[] particles;

Queue<Particle> freeParticles;

Particle SystemAs a DrawableGameComponent, when added to a Game instance, XNA will automatically call the update and draw method

Base texture used by particles in this system, alongside a defined origin for the texture

Variable controlling the maximum number of effects of this type that can be ongoing

Array of particles maintained by this system

Queue from which new particles are born and to which dead particles are moved

protected int minNumParticles;protected int maxNumParticles;

protected float minInitialSpeed;protected float maxInitialSpeed;

protected float minAcceleration; protected float maxAcceleration;

protected float minRotationSpeed;protected float maxRotationSpeed;

protected float minLifetime;protected float maxLifetime;

protected float minScale;protected float maxScale;

protected SpriteBlendMode spriteBlendMode;

Min-max number of particles that are added per effect call

Range of initial speeds, accelerations and rotational speeds.

Range of lifespans – also drives alpha value and scale

Range of scales – also effected by lifespan to avoid particle ‘popping’ on creation

Blendmode to combined particle images

Particle System (construction)protected abstract void

InitializeConstants();

protected override void LoadContent(){

// Load/obtain the texture

// used by the particle system

// Set the origin, i.e. centre,

// of the texture}

Initialise the constants associated with this particle system

protected ParticleSystem( Game game, int

howManyEffects) : base(game) {

this.howManyEffects = howManyEffects; }

public override void Initialize() {InitialiseConstants();

particles = new Particle[howManyEffects *

maxNumParticles];freeParticles = new

Queue<Particle>(howManyEffects *

maxNumParticles);

for (int i = 0; i < particles.Length; i++) {

particles[i] = new Particle();

freeParticles.Enqueue(particles[i]);}

}

Create the particles and add them to the particles array and also to the free particle queue

This method will be overridden by extending classes to providing initial defining values

Particle System (adding)Add the effect offered by this particle system at the specified location

Remove particles from the free queue (where possible) and initialise them

public void AddParticles(Vector2 where)

{int numParticles =

Random.Next( minNumParticles,

maxNumParticles);

for (int i = 0; i < numParticles && freeParticles.Count >

0; i++){

Particle particle =

freeParticles.Dequeue();InitializeParticle(particle,

where); }

}

protected virtual void InitializeParticle(Particle particle, Vector2 where) {

Vector2 direction = PickRandomDirection();

float velocity = Random.Next(min, max);float acceleration = Random.Next(min, max);float lifetime = Random.Next(min, max);float scale = Random.Next(min, max);float rotationSpeed = Random.Next(min, max);

particle.Initialize( where, velocity * direction, acceleration * direction, lifetime,

scale, rotationSpeed);

}

protected virtual Vector2 PickRandomDirection(){

float angle = Random.Next(0, MathHelper.TwoPi);return new Vector2((float)

Math.Cos(angle), (float)Math.Sin(angle));}

Min/max values as defined above, e.g. maxScale, minScale, etc.

Randomise particle properties within defined ranges (can be overridden by extending classes)

Particle System

public override void Draw(GameTime gameTime) {

game.SpriteBatch.Begin(spriteBlendMode);

foreach (Particle p in particles){

if (!p.Active) continue;

float normalizedLifetime = p.TimeSinceStart /

p.Lifetime;

float alpha = 4 * normalizedLifetime * (1 - normalizedLifetime);

Color color = new Color(new Vector4(1, 1, 1,

alpha));

float scale = p.Scale * (.75f + .25f *

normalizedLifetime);

game.SpriteBatch.Draw(texture, p.Position, null,

color, p.Rotation, origin, scale,

SpriteEffects.None, 0.0f);}game.SpriteBatch.End();

}

Determine how long has passed

Consider each particle. This will also consider non-active particles (a performance hit). Other (more complex) approaches can be used to minimise/avoid non-active consideration.

Update the particle and add to free particle queue if needed

public override void Update(GameTime gameTime)

{float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;

foreach (Particle p in particles){

if (p.Active) {p.Update(dt);if (!p.Active)

freeParticles.Enqueue(p);}

}}

Lifetime is normalised to be between 0 (born) and 1 (dead) and is used to calc alpha value (fade-in/out) and scale.

Alpha = 0 at a lifetime of 0 and 1, and a maximum of 1 at a lifetime of 0.5

Particles slowly grow over their lifespan

Three different particle systems are defined:

•SmokePlumeParticleSystem•ExplosionParticleSystem•ExplosionSmokeParticleSystem

The explosion and explosion smoke particle systems are combined to produce a full explosion effect.

Each particle system customises the values within the inherited ParticleSystem class to provide the desired effect.

Particle Systems (particle examples)

public class SmokePlumeParticleSystem : ParticleSystem

{protected override void InitializeConstants() {

textureFilename = "smoke";

minInitialSpeed = 20; maxInitialSpeed = 100;

minAcceleration = 0; maxAcceleration = 0;

spriteBlendMode = SpriteBlendMode.AlphaBlend;

}

Game ClassThe Game class defines three instances of the particle system:ExplosionParticleSystem explosion;explosion

= new ExplosionParticleSystem(this, 1);Components.Add(explosion);

ExplosionSmokeParticleSystem smoke;...SmokePlumeParticleSystem smokePlume;...

const float TimeBetweenExplosions = 2.0f;float timeTillExplosion = 0.0f;

const float TimeBetweenSmokePlumePuffs = .5f;float timeTillPuff = 0.0f;

Repeat times are defined for each particle effect (one explosion every 2 seconds, one puff of smoke every 0.5 seconds).

XNA Aside: As the ParticleSystem instances extend DrawableGame-Component once added to the game, XNA will automatically call their update and draw methods, i.e. the methods do not need to be explicitly called.

Game ClassBased on the currently active particle system, update the system to ensure that new effects are added as needed.protected override void Update(

GameTime gameTime){

switch (currentState) {case State.Explosions:

UpdateExplosions(dt); break;

case State.SmokePlume:

UpdateSmokePlume(dt); break;

}}

private void UpdateExplosions(float dt){

timeTillExplosion -= dt;if (timeTillExplosion < 0)

{Vector2 where = Vector2.Zero;where.X = RandomBetween(0,

graphics.GraphicsDevice.Viewport.Width);where.Y = RandomBetween(0,

graphics.GraphicsDevice.Viewport.Height);

explosion.AddParticles(where);smoke.AddParticles(where);

timeTillExplosion = TimeBetweenExplosions;}

}Update the currently active particle system

Determine if it’s time for another explosion effect

Select a random spawn location

Add the fire and smoke effects

Reset the time

Summary

To do:Complete Question Clinic

Consider if material is of

use within your game.

Complete section in

project document on

alpha hand-in

Submit alpha Hand-in if

desired

Today we explored:

Overview of particle effects

Development of an introductory particle system