OpenGL is the Open Graphics Library and it is maintained by the Kronos Group, which is a consortium of top-tier companies that include board members such as ATI nVidia, Apple, IBM, and more. Microsoft used to be on the consortium, but left and decided to make DirectX, a competing closed graphics library that only runs on Windows (at least without some sort of emulation layer or wrapper like Wine or Cedega).

First off, OpenGL is a huge thing to master (and I am nowhere near mastery). I can’t explain everything about it in one post (or even in hundreds), but I strongly encourage you to get the OpenGL “Red Book” to start out. The “Red Book” is the official and definitive guide to OpenGL and is a must have for any graphics programmer. I also recommend the K&R C Programming book and, if you’re interested in the back-end math, the Real-Time Rendering book.

That being said, in our pong clone, we only use a few OpenGL functions. I’m going to list them and tell you what they do, but it may take until the next post to really understand how they work.

First, a word about primitives. OpenGL has only a few key primitives that you can draw with, but that’s okay, because you can use the primitives to draw more complex shapes!

The OpenGL primitives are:

• Points – a simple point in space
• Lines – a 2-dimension line (although it can occupy 3-dimensional space)
• Polygons – a polygon is a simple 2-dimensional shape comprised of 3 or more points. Triangles, or 3-point polygons, deserve special attention, because OpenGL will break up any other polygon into a combination of triangles. For example, a square can be broken up into two triangles along its diagonal. Just about every object you see in OpenGL is comprised of triangles!

So let’s draw a simple quadrilateral! In OpenGL, you draw polygons by calling a function whenever you want to draw a polygon and then creating a bunch of points in space to create that polygon. Once you’re done, you call another function to say you’re done.

Here’s an example for drawing a rectangle (our pong paddle):

glBegin(GL_QUADS);

glVertex2f(-10, -50);

glVertex2f(-10, 50);

glVertex2f(10, 50);

glVertex2f(10, -50);

glEnd();

We start by calling glBegin() and sending it GL_QUADS to indicate we want to draw a quadrilateral. This basically tells OpenGL take every four points I send you and make a quad out of it. We then call glVertex2f() and send it the coordinates of a two-dimensional point. the 2f indicates that this is the glVertex function which takes 2 floating point values as its arguments (or inputs). We then call glVertex2f() once for all four of each of our points and then call glEnd() when we’re done.

We could have optionally set a color before we began to draw that quadrilateral (the default is black on black) by calling this function:

glColor3ub(255, 0, 0); //red

Again we see the OpenGL naming convention of starting off a function with gl and then ending it with letters and numbers that indicate its arguments. In this case the 3ub means 3 unsigned bytes. Each unsigned byte is positive (hence unsigned) and can go from 0 to 255. The order of the bytes indicate the amount of Red, Green, and Blue respectively that will mix to give you your final color. (Color theory is another big subject matter I can post more about in another post, so let me know in the comments!)

Two other functions that are usually called at the beginning of every display function are:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glShadeModel(GL_FLAT);

glClear(), quite simply is a function that clears the screen and uses the values specified as its argument for doing so.

glShadeModel() specifies the shading model for how vertexes (points) are shaded or lit. In this case, we’re going for a simple flat colored 2-d look so we use GL_FLAT. This paints everything on screen with whatever colors specified and doesn’t do anything fancy. It’s sort of like painting in mspaint on Windows.

glPushMatrix();

glPopMatrix();

glTranslatef(30.0f, 10.0f, 0.0f);

glPush and Pop Matrix() are important functions. They allow you to draw something as if you are starting from scratch with a new coordinate system. Think about our pong paddle. When you want to draw it some place else, do you really want to respecify the coordinates for how it’s drawn? You could instead push a matrix (a set of points) on the stack, then translate (or move), to a new location and draw the object as you would anywhere else, and then finally pop the matrix which will draw the set of points translated (moved) by the glTranslatef() function. This is a little hard to understand (and explain), so I’ll give an example.

In Part II we talked about drawing a box that moved across the screen. We could draw our box as a point in a 2-dimensional plane. For example, let’s make a square that is 4 across centered at the origin (0,0). So it’s points are, going counter-clockwise, (1,1), (-1,1), (-1,-1), (1,-1). Rather than figuring out how to move it along for every frame. We can do this.

glPushMatrix();

glColor3ub(255, 0, 0); //red

glTranslatef(x, 0.0f, 0.0f);

glBegin(GL_QUADS);

glVertex2f(1,1);

glVertex2f(-1,1);

glVertex2f(-1,-1);

glVertex2f(1,-1);

glEnd();

glPopMatrix();

So we push a matrix (a set of points) on the stack, switch the drawing color to red, then Translate x units in the x-direction (horizontal) and then set the drawing mode to GL_QUADS and push the points of our square as it is centered at the origin, and finally pop the matrix! This has OpenGL do all the work of moving our square x units to the right.

Okay, that’s enough for now. I encourage you to scour the web and read up more before we get to our next post, where I’ll finally post the code and go through it!