Jeff Molofee - NeHe's OpenGL Tutorials

{

Status=TRUE; // Set The Status To TRUE

glGenTextures(1, &texture[0]); // Create One Textures

glBindTexture(GL_TEXTURE_2D, texture[0]);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);

}

if (TextureImage[0]) // If Texture Exists

{

if (TextureImage[0]->data) // If Texture Image Exists

{

free(TextureImage[0]->data); // Free The Texture Image Memory

}

free(TextureImage[0]); // Free The Image Structure

}

return Status; // Return The Status

}

The only change I made to the resize code was a deeper viewing distance. Instead of 100.0f, we can now view particles 200.0f units into the screen.

GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window

{

if (height==0) // Prevent A Divide By Zero By

{

height=1; // Making Height Equal One

}

glViewport(0, 0, width, height); // Reset The Current Viewport

glMatrixMode(GL_PROJECTION); // Select The Projection Matrix

glLoadIdentity(); // Reset The Projection Matrix

// Calculate The Aspect Ratio Of The Window

gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,200.0f); ( MODIFIED )

glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix

glLoadIdentity(); // Reset The Modelview Matrix

}

If you're using the lesson 1 code, replace it with the code below. I've added code to load in our texture and set up blending for our particles.

int InitGL(GLvoid) // All Setup For OpenGL Goes Here

{

if (!LoadGLTextures()) // Jump To Texture Loading Routine

{

return FALSE; // If Texture Didn't Load Return FALSE

}

We enable smooth shading, clear our background to black, disable depth testing, blending and texture mapping. After enabling texture mapping we select our particle texture.

glShadeModel(GL_SMOOTH); // Enables Smooth Shading

glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black Background

glClearDepth(1.0f); // Depth Buffer Setup

glDisable(GL_DEPTH_TEST); // Disables Depth Testing

glEnable(GL_BLEND); // Enable Blending

glBlendFunc(GL_SRC_ALPHA, GL_ONE); // Type Of Blending To Perform

glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations

glHint(GL_POINT_SMOOTH_HINT, GL_NICEST); // Really Nice Point Smoothing

glEnable(GL_TEXTURE_2D); // Enable Texture Mapping

glBindTexture(GL_TEXTURE_2D, texture[0]); // Select Our Texture

The code below will initialize each of the particles. We start off by activating each particle. If a particle is not active, it won't appear on the screen, no matter how much life it has.

After we've made the particle active, we give it life. I doubt the way I apply life, and fade the particles is the best way, but once again, it works good! Full life is 1.0f. This also gives the particle full brightness.

for (loop=0; loop

{

particle[loop].active=true; // Make All The Particles Active

particle[loop].life=1.0f; // Give All The Particles Full Life

We set how fast the particle fades out by giving fade a random value. The variable life will be reduced by fade each time the particle is drawn. The value we end up with will be a random value from 0 to 99. We then divide it by 1000 so that we get a very tiny floating point value. Finally we then add .003 to the final result so that the fade speed is never 0.

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

Now that our particle is active, and we've given it life, it's time to give it some color. For the initial effect, we want each particle to be a different color. What I do is make each particle one of the 12 colors that we've built in our color table at the top of this program. The math is simple. We take our loop variable and multiply it by the number of colors in our color table divided by the maximum number of particles (MAX_PARTICLES). This prevents the final color value from being higher than our max number of colors (12).

Some quick examples: 900*(12/900)=12. 1000*(12/1000)=12, etc.

particle[loop].r = colors[loop*(12/MAX_PARTICLES)][0]; // Select Red Rainbow Color

particle[loop].g = colors[loop*(12/MAX_PARTICLES)][1]; // Select Red Rainbow Color

particle[loop].b = colors[loop*(12/MAX_PARTICLES)][2]; // Select Red Rainbow Color

Now we'll set the direction that each particle moves, along with the speed. We're going to multiply the results by 10.0f to create a spectacular explosion when the program first starts.

We'll end up with either a positive or negative random value. This value will be used to move the particle in a random direction at a random speed.

particle[loop].xi = float((rand()%50)-26.0f)*10.0f; // Random Speed On X Axis

particle[loop].yi = float((rand()%50)-25.0f)*10.0f; // Random Speed On Y Axis

particle[loop].zi = float((rand()%50)-25.0f)*10.0f; // Random Speed On Z Axis

Finally, we set the amount of gravity acting on each particle. Unlike regular gravity that just pulls things down, our gravity can pull up, down, left, right, forward or backward. To start out we want semi strong gravity pulling downwards. To do this we set xg to 0.0f. No pull left or right on the x plane. We set yg to –0.8f. This creates a semi-strong pull downwards. If the value was positive it would pull upwards. We don't want the particles pulling towards or away from us so we'll set zg to 0.0f.

particle[loop].xg=0.0f; // Set Horizontal Pull To Zero

particle[loop].yg=-0.8f; // Set Vertical Pull Downward

particle[loop].zg=0.0f; // Set Pull On Z Axis To Zero

}

return TRUE; // Initialization Went OK

}

Now for the fun stuff. The next section of code is where we draw the particle, check for gravity, etc. It's important that you understand what's going on, so please read carefully :)

We reset the Modelview Matrix only once. We'll position the particles using the glVertex3f() command instead of using tranlations, that way we don't alter the modelview matrix while drawing our particles.

int DrawGLScene(GLvoid) // Where We Do All The Drawing

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer

glLoadIdentity(); // Reset The ModelView Matrix

We start off by creating a loop. This loop will update each one of our particles.

for (loop=0; loop

{

First thing we do is check to see if the particle is active. If it's not active, it wont be updated. In this program they're all active, all the time. But in a program of your own, you may want to make certain particles inactive.

if (particle[loop].active) // If The Particle Is Active