Jeff Molofee - NeHe's OpenGL Tutorials

// Return The Current Time Minus The Start Time Multiplied By The Resolution And 1000 (To Get MS)

return ( (float) ( time – timer.performance_timer_start) * timer.resolution)*1000.0f;

} else {

// Return The Current Time Minus The Start Time Multiplied By The Resolution And 1000 (To Get MS)

return( (float) ( timeGetTime() – timer.mm_timer_start) * timer.resolution)*1000.0f;

}

}

The following section of code resets the player to the top left corner of the screen, and gives the enemies a random starting point.

The top left of the screen is 0 on the x-axis and 0 on the y-axis. So by setting the player.x value to 0 we move the player to the far left side of the screen. By setting the player.y value to 0 we move our player to the top of the screen.

The fine positions have to be equal to the current player position, otherwise our player would move from whatever value it's at on the fine position to the top left of the screen. We don't want to player to move there, we want it to appear there, so we set the fine positions to 0 as well.

void ResetObjects(void) // Reset Player And Enemies

{

player.x=0; // Reset Player X Position To Far Left Of The Screen

player.y=0; // Reset Player Y Position To The Top Of The Screen

player.fx=0; // Set Fine X Position To Match

player.fy=0; // Set Fine Y Position To Match

Next we give the enemies a random starting location. The number of enemies displayed on the screen will be equal to the current (internal) level value multiplied by the current stage. Remember, the maximum value that level can equal is 3 and the maximum number of stages per level is 3. So we can have a total of 9 enemies.

To make sure we give all the viewable enemies a new position, we loop through all the visible enemies (stage times level). We set each enemies x position to 5 plus a random value from 0 to 5. (the maximum value rand can be is always the number you specify minus 1). So the enemy can appear on the grid, anywhere from 5 to 10. We then give the enemy a random value on the y axis from 0 to 10.

We don't want the enemy to move from it's old position to the new random position so we make sure the fine x (fx) and y (fy) values are equal to the actual x and y values multiplied by width and height of each tile on the screen. Each tile has a width of 60 and a height of 40.

for (loop1=0; loop1<(stage*level); loop1++) // Loop Through All The Enemies

{

enemy[loop1].x=5+rand()%6; // Select A Random X Position

enemy[loop1].y=rand()%11; // Select A Random Y Position

enemy[loop1].fx=enemy[loop1].x*60; // Set Fine X To Match

enemy[loop1].fy=enemy[loop1].y*40; // Set Fine Y To Match

}

}

The AUX_RGBImageRec code hasn't changed so I'm skipping over it. In LoadGLTextures() we will load in our two textures. First the font bitmap (Font.bmp) and then the background image (Image.bmp). We'll convert both the images into textures that we can use in our game. After we have built the textures we clean up by deleting the bitmap information. Nothing really new. If you've read the other tutorials you should have no problems understanding the code.

int LoadGLTextures() // Load Bitmaps And Convert To Textures

{

int Status=FALSE; // Status Indicator

AUX_RGBImageRec *TextureImage[2]; // Create Storage Space For The Textures

memset(TextureImage, 0, sizeof(void *)*2); // Set The Pointer To NULL

if ((TextureImage[0]=LoadBMP("Data/Font.bmp")) && // Load The Font

(TextureImage[1]=LoadBMP("Data/Image.bmp"))) // Load Background Image

{

Status=TRUE; // Set The Status To TRUE

glGenTextures(2, &texture[0]); // Create The Texture

for (loop1=0; loop1<2; loop1++) // Loop Through 2 Textures

{

glBindTexture(GL_TEXTURE_2D, texture[loop1]);

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

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

}

for (loop1=0; loop1<2; loop1++) // Loop Through 2 Textures

{

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

{

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

{

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

}

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

}

}

}

return Status; // Return The Status

}

The code below builds our font display list. I've already done a tutorial on bitmap texture fonts. All the code does is divides the Font.bmp image into 16×16 cells (256 characters). Each 16×16 cell will become a character. Because I've set the y-axis up so that positive goes down instead of up, it's necessary to subtract our y-axis values from 1.0f. Otherwise the letters will all be upside down :) If you don't understand what's going on, go back and read the bitmap texture font tutorial.

GLvoid BuildFont(GLvoid) // Build Our Font Display List

{

base=glGenLists(256); // Creating 256 Display Lists

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

for (loop1=0; loop1<256; loop1++) // Loop Through All 256 Lists

{

float cx=float(loop1%16)/16.0f; // X Position Of Current Character

float cy=float(loop1/16)/16.0f; // Y Position Of Current Character

glNewList(base+loop1,GL_COMPILE); // Start Building A List

glBegin(GL_QUADS); // Use A Quad For Each Character

glTexCoord2f(cx,1.0f-cy-0.0625f); // Texture Coord (Bottom Left)

glVertex2d(0,16); // Vertex Coord (Bottom Left)

glTexCoord2f(cx+0.0625f,1.0f-cy-0.0625f); // Texture Coord (Bottom Right)

glVertex2i(16,16); // Vertex Coord (Bottom Right)

glTexCoord2f(cx+0.0625f,1.0f-cy); // Texture Coord (Top Right)

glVertex2i(16,0); // Vertex Coord (Top Right)

glTexCoord2f(cx,1.0f-cy); // Texture Coord (Top Left)

glVertex2i(0,0); // Vertex Coord (Top Left)

glEnd(); // Done Building Our Quad (Character)

glTranslated(15,0,0); // Move To The Right Of The Character

glEndList(); // Done Building The Display List

} // Loop Until All 256 Are Built

}

It's a good idea to destroy the font display list when you're done with it, so I've added the following section of code. Again, nothing new.

GLvoid KillFont(GLvoid) // Delete The Font From Memory

{

glDeleteLists(base,256); // Delete All 256 Display Lists

}

The glPrint() code hasn't changed that much. The only difference from the tutorial on bitmap font textures is that I have added the ability to print the value of variables. The only reason I've written this section of code out is so that you can see the changes. The print statement will position the text at the x and y position that you specify. You can pick one of 2 character sets, and the value of variables will be written to the screen. This allows us to display the current level and stage on the screen.