Jeff Molofee - NeHe's OpenGL Tutorials

{

The next three variables x, y and z are temporary variables that we'll use to hold the particles x, y and z position. Notice we add zoom to the z position so that our scene is moved into the screen based on the value stored in zoom. particle[loop].x holds our x position for whatever particle we are drawing (particle loop). particle[loop].y holds our y position for our particle and particle[loop].z holds our z position.

float x=particle[loop].x; // Grab Our Particle X Position

float y=particle[loop].y; // Grab Our Particle Y Position

float z=particle[loop].z+zoom; // Particle Z Pos + Zoom

Now that we have the particle position, we can color the particle. particle[loop].r holds the red intensity of our particle, particle[loop].g holds our green intensity, and particle[loop].b holds our blue intensity. Notice I use the particles life for the alpha value. As the particle dies, it becomes more and more transparent, until it eventually doesn't exist. That's why the particles life should never be more than 1.0f. If you need the particles to burn longer, try reducing the fade speed so that the particle doesn't fade out as fast.

// Draw The Particle Using Our RGB Values, Fade The Particle Based On It's Life

glColor4f(particle[loop].r, particle[loop].g, particle[loop].b, particle[loop].life);

We have the particle position and the color is set. All that we have to do now is draw our particle. Instead of using a textured quad, I've decided to use a textured triangle strip to speed the program up a bit. Most 3D cards can draw triangles alot faster than they can draw quads. Some 3D cards will convert the quad to two triangles for you, but some don't. So we'll do the work ourselves. We start off by telling OpenGL we want to draw a triangle strip.

glBegin(GL_TRIANGLE_STRIP); // Build Quad From A Triangle Strip

Quoted directly from the red book: A triangle strip draws a series of triangles (three sided polygons) using vertices V 0, V 1, V 2, then V 2, V 1, V 3(note the order), then V 2, V 3, V 4, and so on. The ordering is to ensure that the triangles are all drawn with the same orientation so that the strip can correctly form part of a surface. Preserving the orientation is important for some operations, such as culling. There must be at least 3 points for anything to be drawn.

So the first triangle is drawn using vertices 0, 1 and 2. If you look at the picture you'll see that vertex points 0, 1 and 2 do indeed make up the first triangle (top right, top left, bottom right). The second triangle is drawn using vertices 2, 1 and 3. Again, if you look at the picture, vertices 2, 1 and 3 create the second triangle (bottom right, top left, bottom left). Notice that both triangles are drawn with the same winding (counter-clockwise orientation). I've seen quite a few web sites that claim every second triangle is wound the opposite direction. This is not the case. OpenGL will rearrange the vertices to ensure that all of the triangles are wound the same way!

There are two good reasons to use triangle strips. First, after specifying the first three vertices for the initial triangle, you only need to specify a single point for each additional triangle. That point will be combined with 2 previous vertices to create a triangle. Secondly, by cutting back the amount of data needed to create a triangle your program will run quicker, and the amount of code or data required to draw an object is greatly reduced.

Note: The number of triangles you see on the screen will be the number of vertices you specify minus 2. In the code below we have 4 vertices and we see two triangles.

glTexCoord2d(1,1); glVertex3f(x+0.5f, y+0.5f, z); // Top Right

glTexCoord2d(0,1); glVertex3f(x-0.5f, y+0.5f, z); // Top Left

glTexCoord2d(1,0); glVertex3f(x+0.5f, y-0.5f, z); // Bottom Right

glTexCoord2d(0,0); glVertex3f(x-0.5f, y-0.5f, z); // Bottom Left

Finally we tell OpenGL that we are done drawing our triangle strip.

glEnd(); // Done Building Triangle Strip

Now we can move the particle. The math below may look strange, but once again, it's pretty simple. First we take the current particle x position. Then we add the x movement value to the particle divided by slowdown times 1000. So if our particle was in the center of the screen on the x axis (0), our movement variable (xi) for the x axis was +10 (moving us to the right) and slowdown was equal to 1, we would be moving to the right by 10/(1*1000), or 0.01f. If we increase the slowdown to 2 we'll only be moving at 0.005f. Hopefully that helps you understand how slowdown works.

That's also why multiplying the start values by 10.0f made the pixels move alot faster, creating an explosion.

We use the same formula for the y and z axis to move the particle around on the screen.

particle[loop].x+=particle[loop].xi/(slowdown*1000); // Move On The X Axis By X Speed

particle[loop].y+=particle[loop].yi/(slowdown*1000); // Move On The Y Axis By Y Speed

particle[loop].z+=particle[loop].zi/(slowdown*1000); // Move On The Z Axis By Z Speed

After we've calculated where to move the particle to next, we have to apply gravity or resistance. In the first line below, we do this by adding our resistance (xg) to the speed we are moving at (xi).

Lets say our moving speed was 10 and our resistance was 1. Each time our particle was drawn resistance would act on it. So the second time it was drawn, resistance would act, and our moving speed would drop from 10 to 9. This causes the particle to slow down a bit. The third time the particle is drawn, resistance would act again, and our moving speed would drop to 8. If the particle burns for more than 10 redraws, it will eventually end up moving the opposite direction because the moving speed would become a negative value.

The resistance is applied to the y and z moving speed the same way it's applied to the x moving speed.

particle[loop].xi+=particle[loop].xg; // Take Pull On X Axis Into Account

particle[loop].yi+=particle[loop].yg; // Take Pull On Y Axis Into Account

particle[loop].zi+=particle[loop].zg; // Take Pull On Z Axis Into Account

The next line takes some life away from the particle. If we didn't do this, the particle would never burn out. We take the current life of the particle and subtract the fade value for that particle. Each particle will have a different fade value, so they'll all burn out at different speeds.

particle[loop].life -= particle[loop].fade; // Reduce Particles Life By 'Fade'

Now we check to see if the particle is still alive after having life taken from it.

if (particle[loop].life < 0.0f) // If Particle Is Burned Out

{

If the particle is dead (burnt out), we'll rejuvenate it. We do this by giving it full life and a new fade speed.

particle[loop].life=1.0f; // Give It New Life

particle[loop].fade=float(rand()%100)/1000.0f+0.003f; // Random Fade Value

We also reset the particles position to the center of the screen. We do this by resetting the x, y and z positions of the particle to zero.

particle[loop].x=0.0f; // Center On X Axis

particle[loop].y=0.0f; // Center On Y Axis

particle[loop].z=0.0f; // Center On Z Axis

After the particle has been reset to the center of the screen, we give it a new moving speed / direction. Notice I've increased the maximum and minimum speed that the particle can move at from a random value of 50 to a value of 60, but this time we're not going to multiply the moving speed by 10. We don't want an explosion this time around, we want slower moving particles.