Jeff Molofee - NeHe's OpenGL Tutorials

There is no need to destroy the object, or increase the miss variable. If you miss the object as it's flying into the sky, there's always a chance to hit it as it falls. The falling code will handle the final destruction of the object.

if ((object[loop].y>4.5f) && (object[loop].dir==2)) // If We Are To Far Up And The Direction Is Up

object[loop].dir=3; // Change The Direction To Down

}

}

Next we have the object drawing code. I wanted a quick and easy way to draw the game objects, along with the crosshair with as little code as possible. Object takes 3 parameters. First we have the width. The width controls how wide the object will be when it's drawn. Then we have the height. The height controls how tall the object will be when it's drawn. Finally, we have the texid. The texid selects the texture we want to use. If we wanted to draw a bucket, which is texture 1, we would pass a value of 1 for the texid. Pretty simple!

A quick breakdown. We select the texture, and then draw a quad. We use standard texture coordinates so the entire textue is mapped to the face of the quad. The quad is drawn in a counter-clockwise direction (required for culling to work).

void Object(float width,float height,GLuint texid) // Draw Object Using Requested Width, Height And Texture

{

glBindTexture(GL_TEXTURE_2D, textures[texid].texID); // Select The Correct Texture

glBegin(GL_QUADS); // Start Drawing A Quad

glTexCoord2f(0.0f,0.0f); glVertex3f(-width,-height,0.0f); // Bottom Left

glTexCoord2f(1.0f,0.0f); glVertex3f( width,-height,0.0f); // Bottom Right

glTexCoord2f(1.0f,1.0f); glVertex3f( width, height,0.0f); // Top Right

glTexCoord2f(0.0f,1.0f); glVertex3f(-width, height,0.0f); // Top Left

glEnd(); // Done Drawing Quad

}

The explosion code takes one parameter. num is the object identifier. In order to create the explosion we need to grab a portion of the explosion texture similar to the way we grab each letter from the font texture. The two lines below calculate the column (ex) and row (ey) from a single number (frame).

The first line below grabs the current frame and divides it by 4. The division by 4 is to slow down the animation. %4 keeps the value in the 0-3 range. If the value is higher than 3 it would wrap around and become 0. If the value is 5 it would become 1. A value of 9 would be 0,1,2,3,0,1,2,3,0. We divide the final result by 4.0f because texture coordinates are in the 0.0f to 1.0f range. Our explosion texture has 4 explosion images from left to right and 4 up and down.

Hopefully you're not completely confused. So if our number before division can only be 0,1,2 or 3 our number after we divide it by 4.0f can only be 0.0f, 0.25f (1/4), 0.50f (2/4) or 0.75f (3/4). This gives us our left to right texture coordinate (ex).

Next we calculate the row (ey). We grab the current object frame and divide it by 4 to slow the animation down a little. We then divide by 4 again to eliminate an entire row. Finally we divide by 4 one last time to get our vertical texture coordinate.

A quick example. If our current frame was 16. ey=((16/4)/4)/4 or 4/4/4 or 0.25f. One row down. If our current frame was 60. ey=((60/4)/4)/4 or 15/4/4 or 3/4 or 0.75f. The reason 15/4 isn't 3.75 is because we are working with integers up until we do the final division. With that in mind, the value of ey can only be one of 4 values… 0.0f, 0.25f, 0.50f or 0.75f. Assuming we stay inside our texture (prevent frame from going over a value of 63).

Hope that made sense… it's simple, but intimidating math.

void Explosion(int num) // Draws An Animated Explosion For Object "num"

{

float ex = (float)((object[num].frame/4)%4)/4.0f; // Calculate Explosion X Frame (0.0f – 0.75f)

float ey = (float)((object[num].frame/4)/4)/4.0f; // Calculate Explosion Y Frame (0.0f – 0.75f)

Now that we have the texture coordinates, all that's left to do is draw our textured quad. The vertex coordinates are fixed at –1.0f and 1.0f. You will notice we subract ey from 1.0f. If we didn't, the animation would be drawn in the reverse order… The explosion would get bigger, rather than fade out. The effect wont look right!

We bind the explosion texture before we draw the textured quad. Again, the quad is drawn counter-clockwise.

glBindTexture(GL_TEXTURE_2D, textures[5].texID); // Select The Explosion Texture

glBegin(GL_QUADS); // Begin Drawing A Quad

glTexCoord2f(ex ,1.0f-(ey )); glVertex3f(-1.0f,-1.0f,0.0f); // Bottom Left

glTexCoord2f(ex+0.25f,1.0f-(ey )); glVertex3f( 1.0f,-1.0f,0.0f); // Bottom Right

glTexCoord2f(ex+0.25f,1.0f-(ey+0.25f)); glVertex3f( 1.0f, 1.0f,0.0f); // Top Right

glTexCoord2f(ex ,1.0f-(ey+0.25f)); glVertex3f(-1.0f, 1.0f,0.0f); // Top Left

glEnd(); // Done Drawing Quad

As I mentioned above, the value of frame should not exceed 63 otherwise the animation will start over again. So we increase the value of frame and then we check to see if the value is greater than 63. If it is, we call InitObject(num) which destroys the object and gives it new values to create an entirely new object.

object[num].frame+=1; // Increase Current Explosion Frame

if (object[num].frame>63) // Have We Gone Through All 16 Frames?

{

InitObject(num); // Init The Object (Assign New Values)

}

}

This section of code draws all of the targets (objects) to the screen. We start off by resetting the modelview matrix. We then translate 10 units into the screen and set up a loop from 0 to the players current level.

void DrawTargets(void) // Draws The Targets (Needs To Be Seperate)

{

glLoadIdentity(); // Reset The Modelview Matrix

glTranslatef(0.0f,0.0f,-10.0f); // Move Into The Screen 20 Units

for (int loop=0; loop

{

The first line of code is the secret to picking individual objects. What it does is assigns a name (number) to each object. The first object drawn will be 0. The second object will be 1, etc… If the loop was to hit 29, the last object drawn would be given the name 29. After assigning a name to the object, we push the modelview matrix onto the stack. It's important to note the calls to glLoadName() are ignored if the program is not in selection mode.

We then move to the location on the screen where we want our object to be drawn. We use object[loop].x to position on the x-axis, object[loop].y to position on the y-axis and object[loop].distance to position the object on the z-axis (depth into the screen). We have already translated 10 units into the screen, so the actual distance at which the object will be drawn is going to be object[loop].distance-10.0f.

glLoadName(loop); // Assign Object A Name (ID)

glPushMatrix(); // Push The Modelview Matrix

glTranslatef(object[loop].x,object[loop].y,object[loop].distance); // Position The Object (x,y)

Before we draw the object, we have to check if it's been hit or not. We do this by checking to see if object[loop].hit is TRUE. if it is, we jump to Explosion(loop) which will draw the explosion animation instead of the actual object. If the object was not hit, we spin the object on it's z-axis by object[loop].spin degrees before we call Object().

Object takes 3 parameters. The first one is the width, the second one is the height and the third one is the number of the texture to use. To get the width and height, we use the array size[object[loop].texid].w and size[object[loop].texid].h. This look up the width and height from our predefined object size array at the beginning of this program. The reason we use object[loop].texid is because it represents the type of object we are drawing. A texid of 0 is always the blueface… a texid of 3 is always the coke can, etc.