Jeff Molofee - NeHe's OpenGL Tutorials

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

glColor3f(1.0f,0.5f,1.0f); // Set Color To Purple

glPrint(207,24,0,"GRID CRAZY"); // Write GRID CRAZY On The Screen

glColor3f(1.0f,1.0f,0.0f); // Set Color To Yellow

glPrint(20,20,1,"Level:%2i",level2); // Write Actual Level Stats

glPrint(20,40,1,"Stage:%2i",stage); // Write Stage Stats

Now we check to see if the game is over. If the game is over, the variable gameover will be TRUE. If the game is over, we use glColor3ub(r,g,b) to select a random color. Notice we are using 3ub instead of 3f. By using 3ub we can use integer values from 0 to 255 to set our colors. Plus it's easier to get a random value from 0 to 255 than it is to get a random value from 0.0f to 1.0f.

Once a random color has been selected, we write the words "GAME OVER" to the right of the game title. Right under "GAME OVER" we write "PRESS SPACE". This gives the player a visual message letting them know that they have died and to press the spacebar to restart the game.

if (gameover) // Is The Game Over?

{

glColor3ub(rand()%255, rand()%255, rand()%255); // Pick A Random Color

glPrint(472, 20, 1, "GAME OVER"); // Write GAME OVER To The Screen

glPrint(456, 40, 1, "PRESS SPACE"); // Write PRESS SPACE To The Screen

}

If the player still has lives left, we draw animated images of the players character to the right of the game title. To do this we create a loop that goes from 0 to the current number of lives the player has left minus one. I subtract one, because the current life is the image you control.

Inside the loop, we reset the view. After the view has been reset, we translate to the 490 pixels to the right plus the value of loop1 times 40.0f. This draws each of the animated player lives 40 pixels apart from eachother. The first animated image will be drawn at 490+(0*40) (= 490), the second animated image will be drawn at 490+(1*40) (= 530), etc.

After we have moved to the spot we want to draw the animated image, we rotate counterclockwise depending on the value stored in player.spin. This causes the animated life images to spin the opposite way that your active player is spinning.

We then select green as our color, and start drawing the image. Drawing lines is alot like drawing a quad or a polygon. You start off with glBegin(GL_LINES), telling OpenGL we want to draw a line. Lines have 2 vertices. We use glVertex2d to set our first point. glVertex2d doesn't require a z value, which is nice considering we don't care about the z value. The first point is drawn 5 pixels to the left of the current x location and 5 pixels up from the current y location. Giving us a top left point. The second point of our first line is drawn 5 pixels to the right of our current x location, and 5 pixels down, giving us a bottom right point. This draws a line from the top left to the bottom right. Our second line is drawn from the top right to the bottom left. This draws a green X on the screen.

After we have drawn the green X, we rotate counterclockwise (on the z axis) even more, but this time at half the speed. We then select a darker shade of green (0.75f) and draw another x, but we use 7 instead of 5 this time. This draws a bigger / darker x on top of the first green X. Because the darker X spins slower though, it will look as if the bright X has a spinning set of feelers (grin) on top of it.

for (loop1=0; loop1

{

glLoadIdentity(); // Reset The View

glTranslatef(490+(loop1*40.0f),40.0f,0.0f); // Move To The Right Of Our Title Text

glRotatef(-player.spin,0.0f,0.0f,1.0f); // Rotate Counter Clockwise

glColor3f(0.0f,1.0f,0.0f); // Set Player Color To Light Green

glBegin(GL_LINES); // Start Drawing Our Player Using Lines

glVertex2d(-5,-5); // Top Left Of Player

glVertex2d( 5, 5); // Bottom Right Of Player

glVertex2d( 5,-5); // Top Right Of Player

glVertex2d(-5, 5); // Bottom Left Of Player

glEnd(); // Done Drawing The Player

glRotatef(-player.spin*0.5f,0.0f,0.0f,1.0f); // Rotate Counter Clockwise

glColor3f(0.0f,0.75f,0.0f); // Set Player Color To Dark Green

glBegin(GL_LINES); // Start Drawing Our Player Using Lines

glVertex2d(-7, 0); // Left Center Of Player

glVertex2d( 7, 0); // Right Center Of Player

glVertex2d( 0,-7); // Top Center Of Player

glVertex2d( 0, 7); // Bottom Center Of Player

glEnd(); // Done Drawing The Player

}

Now we're going to draw the grid. We set the variable filled to TRUE. This tells our program that the grid has been completely filled in (you'll see why we do this in a second).

Right after that we set the line width to 2.0f. This makes the lines thicker, making the grid look more defined.

Then we disable anti-aliasing. The reason we disable anti-aliasing is because although it's a great feature, it eats CPU's for breakfast. Unless you have a killer graphics card, you'll notice a huge slow down if you leave anti-aliasing on. Go ahead and try if you want :)

The view is reset, and we start two loops. loop1 will travel from left to right. loop2 will travel from top to bottom.

We set the line color to blue, then we check to see if the horizontal line that we are about to draw has been traced over. If it has we set the color to white. The value of hline[loop1][loop2] will be TRUE if the line has been traced over, and FALSE if it hasn't.

After we have set the color to blue or white, we draw the line. The first thing to do is make sure we haven't gone to far to the right. We don't want to draw any lines or check to see if the line has been filled in when loop1 is greater than 9.

Once we are sure loop1 is in the valid range we check to see if the horizontal line hasn't been filled in. If it hasn't, filled is set to FALSE, letting our OpenGL program know that there is at least one line that hasn't been filled in.

The line is then drawn. We draw our first horizontal (left to right) line starting at 20+(0*60) (= 20). This line is drawn all the way to 80+(0*60) (= 80). Notice the line is drawn to the right. That is why we don't want to draw 11 (0-10) lines. because the last line would start at the far right of the screen and end 80 pixels off the screen.

filled=TRUE; // Set Filled To True Before Testing

glLineWidth(2.0f); // Set Line Width For Cells To 2.0f

glDisable(GL_LINE_SMOOTH); // Disable Antialiasing

glLoadIdentity(); // Reset The Current Modelview Matrix

for (loop1=0; loop1<11; loop1++) // Loop From Left To Right

{

for (loop2=0; loop2<11; loop2++) // Loop From Top To Bottom

{

glColor3f(0.0f,0.5f,1.0f); // Set Line Color To Blue

if (hline[loop1][loop2]) // Has The Horizontal Line Been Traced

{

glColor3f(1.0f,1.0f,1.0f); // If So, Set Line Color To White

}

if (loop1<10) // Dont Draw To Far Right

{

if (!hline[loop1][loop2]) // If A Horizontal Line Isn't Filled

{

filled=FALSE; // filled Becomes False

}

glBegin(GL_LINES); // Start Drawing Horizontal Cell Borders

glVertex2d(20+(loop1*60), 70+(loop2*40)); // Left Side Of Horizontal Line