Fastest way to create a simple particle effect

Question

I am looking to the fastest way to create really simple particle effect that will be spammed like hell on the game...

Basically, my game looks like a vectrex game, made mostly of lines... I want to make some small explosions that will be really common.

There are something faster than just moving around some points and rendering with GL_Point?

Answer 1

There's really no need to store memory for every particle and animate each particle separately. You can do it procedurally by reconstructing the particle position during drawing by using the classic physics equation. s = ut + 1/2.a.t^2

A simple example (without constant acceleration of particles):

void drawExplosion(ExplosionParameters& s)
{
  Random rng;
  rng.seed(s.startSeed);
  glBegin(GL_POINTS);
  for (int i = 0; i < s.numParticles; i++)
  {
    vec3 vel = rng.getRandomVector(-1.0f, 1.0f) * s.explosionSpeed;
    float timeBias = rng.getRandom(0, s.particleTimeBias);
    vec3 pos = s.explosionCentre + (vel * (s.timeElapsed + timeBias));
    glPoint3fv(&pos);
  }
  glEnd();
}

Then you simply increase s.timeElapsed on every iteration of your update loop.

It is also completely amenable to being implemented on the GPU thus freeing up your CPU from having to do any work. A gpu implementation might look like this:

void drawExplosion(ExplosionParameters& s)
{
    //bind Vertex Shader If Not Already Bound();
    ...
    // bindVertexBuffer of Zeroes If Not AlreadyBound();
    glVertexPointer(...)
    //uploadShaderUniformsForExplosion(s);
    glUniform3f(...)
    ...
    glDrawArrays(GL_POINTS, 0, s.numParticles);
} 

The GPU vertex shader would then reconstruct the particle position via the physics equation and the uniforms/constants passed to it - just as the CPU version did.

To add some variance, you can use more simultaneous explosions with slightly differing parameters, animating colors/alpha, choosing differing starting positions. etc.

Answer 2

I made several tests, and the FASTEST way (not the fastest to code) was particles made of GL_LINEs that knew their position and speed, and used that as the points when rendering (so, the faster the particle go, the most "line" it becomes, the slower, it becomes a point).

The effect is REALLY cool (look at any geometry wars video to see it), and REALLY fast too. Kick the crap out of quads (specially because quads would make me need to calculate the double amount of vertexes)

Also, it is better than using a already done particle system, because I wanted a specific and FAST effect, particle systems usually support lots of features, with proportional amount of overhead.

Answer 3

Normally I think you would do particles as texture-mapped quads. Treat them as 2D sprites basically, and fade them out over time, destroying them when invisible. Better still, reuse the old ones when you make new ones so you're not thrashing memory for these things.

If you use premultiplied alpha on the art then you can easily support lights, fire, smoke, and more besides all with one type of blending operation.

Answer 4

With OpenGL ES 2.0, ES 1.X with an extension and OpenGL => 2.1, you can use GL_POINT_SPRITES. GL_POINT_SPRITES are like a quad always in front of camera.

In fragment shaders, you can:

• define sizes of sprite with gl_PointSize in vertex shader
• use gl_PointCoord (uv coordinates) in fragment shader

You can use texture with alpha to draw ball sprites...

A tutorial for Point Sprites

Answer 5

Most particle effect systems I've seen, instead of drawing a huge number of points, draw a relatively smaller number of billboard textures where each textures looks a bit like an explosion. Unless your art style really prevents, you'll likely be happier going down that route. It will minimize the amount of particles you need to individually animate and render while still give a big visual effect.

Answer 6

For a neat little way to handle the spawning/deletion/update of particles, assuming you have a simple array of particles - Particles[MAX_PARTICLES]:

Keep track of the active particles (starting with NumActiveParticles = 0)

New particles are always added at the end of the array:

pNewParticle = &Particles[NumActiveParticles++];

The clever bit - When removing a 'dead' particle - swap it with the last active particle, and decrement NumActiveParticles:

if ( DeadParticle < NumActiveParticles-1 )
{
  Particles[ DeadParticle ] = Particles[ NumActiveParticles-1 ];
}
NumActiveParticles--;

This avoids any searching for 'unused particles' when spawning, and avoids any scanning through an array of MAX_PARTICLES if none are in use.

Note that this only works if the update/render order is unimportant (as is the case for many particle effects, which use additive blending) - as this method of deleting a particle re-orders the array

Answer 7

The fastest way i would assume is to find a particle engine and use that for your effects. Here are a few:

• Tricelpa
• SPARK
• Quagmire