Jeff Molofee - NeHe's OpenGL Tutorials

We clear the screen and depth buffer and then set the color to bright red (full red intensity, 50% green, 50% blue). at 50 on the x axis and 16 on the y axis we write teh word "Renderer". We also write "Vendor" and "Version" at the top of the screen. The reason each word does not start at 50 on the x axis is because I right justify the words (they all line up on the right side).

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

{

char *token; // Storage For Our Token

int cnt=0; // Local Counter Variable

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

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

glPrint(50,16,1,"Renderer"); // Display Renderer

glPrint(80,48,1,"Vendor"); // Display Vendor Name

glPrint(66,80,1,"Version"); // Display Version

Now that we have text on the screen, we change the color to orange, and grab the renderer, vendor name and version number from the video card. We do this by passing GL_RENDERER, GL_VENDOR & GL_VERSION to glGetString(). glGetString will return the requested renderer name, vendor name and version number. The information returned will be text so we need to cast the return information from glGetString as char. All this means is that we tell the program we want the information returned to be characters (text). If you don't include the (char *) you will get an error message. We're printing text, so we need text returned. We grab all three pieces of information and write the information we've grabbed to the right of the previous text.

The information we get from glGetString(GL_RENDERER) will be written beside the red text "Renderer", the information we get from glGetString(GL_VENDOR) will be written to the right of "Vendor", etc.

I'd like to explain casting in more detail, but I'm not really sure of a good way to explain it. If anyone has a good explanation, send it in, and I'll modify my explanation.

After we have the renderer information, vendor information and version number written to the screen, we change the color to a bright blue, and write "NeHe Productions" at the bottom of the screen :) Of course you can change this to anything you want.

glColor3f(1.0f,0.7f,0.4f); // Set Color To Orange

glPrint(200,16,1,(char *)glGetString(GL_RENDERER)); // Display Renderer

glPrint(200,48,1,(char *)glGetString(GL_VENDOR)); // Display Vendor Name

glPrint(200,80,1,(char *)glGetString(GL_VERSION)); // Display Version

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

glPrint(192,432,1,"NeHe Productions"); // Write NeHe Productions At The Bottom Of The Screen

Now we draw a nice white border around the screen, and around the text. We start off by resetting the modelview matrix. Because we've been printing text to the screen, and we might not be at 0,0 on the screen, it's a safe thing to do.

We then set the color to white, and start drawing our borders. A line strip is actually pretty easy to use. You tell OpenGL you want to draw a line strip with glBegin(GL_LINE_STRIP). Then we set the first vertex. Our first vertex will be on the far right side of the screen, and about 63 pixels up from the bottom of the screen (639 on the x axis, 417 on the y axis). Then we set the second vertex. We stay at the same location on the y axis (417), but we move to the far left side of the screen on the x axis (0). A line will be drawn from the right side of the screen (639,417) to the left side of the screen (0,417).

You need to have at least two vertices in order to draw a line (common sense). From the left side of the screen, we move down, right, and then straight up (128 on the y axis).

We then start another line strip, and draw a second box at the top of the screen. If you need to draw ALOT of connected lines, line strips can definitely cut down on the amount of code required as opposed to using regular lines (GL_LINES).

glLoadIdentity(); // Reset The ModelView Matrix

glColor3f(1.0f,1.0f,1.0f); // Set The Color To White

glBegin(GL_LINE_STRIP); // Start Drawing Line Strips (Something New)

glVertex2d(639,417); // Top Right Of Bottom Box

glVertex2d( 0,417); // Top Left Of Bottom Box

glVertex2d( 0,480); // Lower Left Of Bottom Box

glVertex2d(639,480); // Lower Right Of Bottom Box

glVertex2d(639,128); // Up To Bottom Right Of Top Box

glEnd(); // Done First Line Strip

glBegin(GL_LINE_STRIP); // Start Drawing Another Line Strip

glVertex2d( 0,128); // Bottom Left Of Top Box

glVertex2d(639,128); // Bottom Right Of Top Box

glVertex2d(639, 1); // Top Right Of Top Box

glVertex2d( 0, 1); // Top Left Of Top Box

glVertex2d( 0,417); // Down To Top Left Of Bottom Box

glEnd(); // Done Second Line Strip

Now for something new. A wonderful GL command called glScissor(x,y,w,h). What this command does is creates almost what you would call a window. When GL_SCISSOR_TEST is enabled, the only portion of the screen that you can alter is the portion inside the scissor window. The first line below creates a scissor window starting at 1 on the x axis, and 13.5% (0.135…f) of the way from the bottom of the screen on the y axis. The scissor window will be 638 pixels wide (swidth-2), and 59.7% (0.597…f) of the screen tall.

In the next line we enable scissor testing. Anything we draw OUTSIDE the scissor window will not show up. You could draw a HUGE quad on the screen from 0,0 to 639,480, and you would only see the quad inside the scissor window, the rest of the screen would be unaffected. Very nice command!

The third line of code creates a variable called text that will hold the characters returned by glGetString(GL_EXTENSIONS). malloc(strlen((char *)glGetString(GL_EXTENSIONS))+1) allocates enough memory to hold the entire string returned +1 (so if the string was 50 characters, text would be able to hold all 50 characters).

The next line copies the GL_EXTENSIONS information to text. If we modify the GL_EXTENSIONS information directly, big problems will occur, so instead we copy the information into text, and then manipulate the information stored in text. Basically we're just taking a copy, and storing it in the variable text.

glScissor(1, int(0.135416f*sheight), swidth-2, int(0.597916f*sheight)); // Define Scissor Region

glEnable(GL_SCISSOR_TEST); // Enable Scissor Testing

char* text=(char*)malloc(strlen((char *)glGetString(GL_EXTENSIONS))+1); // Allocate Memory For Our Extension String

strcpy (text, (char *)glGetString(GL_EXTENSIONS)); // Grab The Extension List, Store In Text

Now for something new. Lets pretend that after grabbing the extension information from the video card, the variable text had the following string of text stored in it… "GL_ARB_multitexture GL_EXT_abgr GL_EXT_bgra". strtok(TextToAnalyze,TextToFind) will scan through the variable text until it finds a " " (space). Once it finds a space, it will copy the text UP TO the space into the variable token. So in our little example, token would be equal to "GL_ARB_multitexture". The space is then replaced with a marker . More about this in a minute.

Next we create a loop that stops once there is no more information left in text. If there is no information in text, token will be equal to nothing (NULL) and the loop will stop.

We increase the counter variable (cnt) by one, and then check to see if the value in cnt is higher than the value of maxtokens. If cnt is higher than maxtokens we make maxtokens equal to cnt. That way if the counter hits 20, maxtokens will also equal 20. It's an easy way to keep track of the maximum value of cnt.