Jeff Molofee - NeHe's OpenGL Tutorials

if (texture[0].bpp==24) // Was The TGA 24 Bits

{

type=GL_RGB; // If So Set The 'type' To GL_RGB

}

Now we build our texture, the same way we've always done it. But instead of putting the type in ourselves (GL_RGB or GL_RGBA), we substitute the variable type. That way if the program detected that the TGA was 24 bit, the type will be GL_RGB. If our program detected that the TGA was 32 bit, the type would be GL_RGBA.

After the texture has been built, we return true. This lets the InitGL() code know that everything went ok.

glTexImage2D(GL_TEXTURE_2D, 0, type, texture[0].width, texture[0].height, 0, type, GL_UNSIGNED_BYTE, texture[0].imageData);

return true; // Texture Building Went Ok, Return True

}

The code below is our standard build a font from a texture code. You've all seen this code before if you've gone through all the tutorials up until now. Nothing really new here, but I figured I'd include the code to make following through the program a little easier.

Only real difference is that I bind to textures[0].texID. Which points to the font texture. Only real difference is that .texID has been added.

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

{

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

glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture

for (int 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-0.001f); // Texture Coord (Top Right)

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

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

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

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

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

glEndList(); // Done Building The Display List

} // Loop Until All 256 Are Built

}

KillFont is still the same. We created 256 display lists, so we need to destroy 256 display lists when the program closes.

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

{

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

}

The glPrint() code has only changed a bit. The letters are all stretched on the y axis. Making the letters very tall. I've explained the rest of the code in other tutorials. The stretching is accomplished with the glScalef(x,y,z) command. We leave the ratio at 1.0 on the x axis, we double the size on the y axis (2.0), and we leave it at 1.0 on the z axis.

GLvoid glPrint(GLint x, GLint y, int set, const char *fmt, …) // Where The Printing Happens

{

char text[1024]; // Holds Our String

va_list ap; // Pointer To List Of Arguments

if (fmt == NULL) // If There's No Text

return; // Do Nothing

va_start(ap, fmt); // Parses The String For Variables

vsprintf(text, fmt, ap); // And Converts Symbols To Actual Numbers

va_end(ap); // Results Are Stored In Text

if (set>1) // Did User Choose An Invalid Character Set?

{

set=1; // If So, Select Set 1 (Italic)

}

glEnable(GL_TEXTURE_2D); // Enable Texture Mapping

glLoadIdentity(); // Reset The Modelview Matrix

glTranslated(x,y,0); // Position The Text (0,0 – Top Left)

glListBase(base-32+(128*set)); // Choose The Font Set (0 or 1)

glScalef(1.0f,2.0f,1.0f); // Make The Text 2X Taller

glCallLists(strlen(text),GL_UNSIGNED_BYTE, text); // Write The Text To The Screen

glDisable(GL_TEXTURE_2D); // Disable Texture Mapping

}

ReSizeGLScene() sets up an ortho view. Nothing really new. 0,1 is the top left of the screen. 639,480 is the bottom right. This gives us exact screen coordinates in 640 x 480 resolution. Notice that we set the value of swidth to equal the windows current width, and we set the value of sheight to equal the windows current height. Whenever the window is resized or moved, sheight and swidth will be updated.

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

{

swidth=width; // Set Scissor Width To Window Width

sheight=height; // Set Scissor Height To Window Height

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

glOrtho(0.0f,640,480,0.0f,-1.0f,1.0f); // Create Ortho 640x480 View (0,0 At Top Left)

glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix

glLoadIdentity(); // Reset The Modelview Matrix

}

The init code is very minimal. We load our TGA file. Notice that the first parameter passed is &textures[0]. The second parameter is the name of the file we want to load. In this case, we want to load the Font.TGA file. If LoadTGA() returns false for any reason, the if statement will also return false, causing the program to quit with an "initialization failed" message.

If you wanted to load a second texture you could use the following code: if ((!LoadTGA(&textures[0],"image1.tga")) || (!LoadTGA(&textures[1],"image2.tga"))) { }

After we load the TGA (creating our texture), we build our font, set shading to smooth, set the background color to black, enable clearing of the depth buffer, and select our font texture (bind to it).

Lastly we return true so that our program knows that initialization went ok.

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

{

if (!LoadTGA(&textures[0],"Data/Font.TGA")) // Load The Font Texture

{

return false; // If Loading Failed, Return False

}

BuildFont(); // Build The Font

glShadeModel(GL_SMOOTH); // Enable Smooth Shading

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

glClearDepth(1.0f); // Depth Buffer Setup

glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture

return TRUE; // Initialization Went OK

}

The draw code is completely new :) we start off by creating a variable of type char called token. Token will hold parsed text later on in the code.

We have another variable called cnt. I use this variable both for counting the number of extensions supported, and for positioning the text on the screen. cnt is reset to zero every time we call DrawGLScene.