As we learn each concept, we will actually write code to demonstrate each point. Speaking of points, we will write code to plot points using OpenGL.

We are going to set this project up as a separate project from the actual game. We will use this project to demonstrate how to code basic OpenGL tasks. To keep this thing as simple as possible, this project will be created as a console project in Visual Studio. A console project doesn't have many of the features of a full-blown Windows project and therefore, the setup code is much smaller.

Start Visual Studio and create a new project. For the project template, choose Win32 Console Application from the Visual C++ group of templates. Name the project OpenGLFun, and click OK. Click Finish to complete the project wizard.

Once you have the project created, type following the code into the code window:

#include "stdafx.h"
#include <windows.h>
#include "glut.h"

void initGL() {
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
}

void drawPoints()
{
  glBegin(GL_POINTS);
  
  glColor3f(1.0f, 1.0f, 1.0f);
  glVertex2f(0.1f, -0.6f);
  glVertex2f(0.7f, -0.6f);
  glVertex2f(0.4f, -0.1f);
  
  glEnd();
}

void update()
{
  glClear(GL_COLOR_BUFFER_BIT);
  drawPoints();
  glFlush();
}

int _tmain(int argc, _TCHAR* argv[])
{
  glutCreateWindow("GL Fun");
  glutInitWindowSize(320, 320);
  glutInitWindowPosition(50, 50);
  glutDisplayFunc(update);
  initGL();
  glutMainLoop();
  return 0;
}

As we will be using the code to demonstrate the fundamentals of OpenGL, we will look at it in detail so that you understand what the code is doing.

glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

Now that you have entered your code, it's time to see it in action. When you run the program (Debug | Start Debugging), here is what you will see:

You'll have to look at it closely, but if all went well, you should see three white points in the lower-right area of the screen. Congratulations! You have rendered your first OpenGL objects!

Hopefully, you have been able to follow the code. Think of _tmain as a manager that controls the program by setting everything up and then calling the main loop (just like we will do in our game). Then GLUT takes over and calls the update function every frame. The update function initializes the render buffer, draws objects to the render buffer, and then transfers the contents of the render buffer to the screen. In a game running at 60 frames per second, this entire operation will happen 60 times a second!

Let's see how easy it will be to modify GLFun to draw other objects. This time we will draw two lines. Add the following function to your code just under the drawPoints function:

void drawLines()
{
  glBegin(GL_LINES);
  
  glColor3f(1.0f, 1.0f, 1.0f);
  glVertex2f(0.1f, -0.6f);
  glVertex2f(0.7f, -0.6f);
  
  glVertex2f(0.7f, -0.6f);
  glVertex2f(0.4f, -0.1f);
  
  glEnd();
}

Next, go to the update function and replace drawPoints with a call to drawLines. The new update function will look like this:

void update() 
{
  glClear(GL_COLOR_BUFFER_BIT);
  drawLines();
  glFlush();
}

You will notice that there are four glVertex calls. Each pair of vertices sets the beginning and ending points of a line. As there are four points defined, the result is that two lines are drawn.

Have you ever seen a geodesic dome? Although the dome appears to be spherical, it is actually built out of a combination of triangles. It turns out that triangles are very easy to put together in such a way that you can add a slight amount of curvature to the object. Each triangle can be attached at a slight angle to the others, allowing you to create a dome made out of flat triangles. Also, consider this: the smaller the triangle, the more convincing the end result!

The basic unit that is used to draw all modern graphics is the humble triangle. Graphic cards have been specifically engineered to be able to draw triangles—really small triangles—really fast. A typical graphics card can draw millions of triangles every second. Higher end cards reach billions of triangles per second.

Remember when we drew points and lines earlier? Each point had one vertex, and each line had two vertices. Of course, each triangle has three vertices.

It's time to take a look at some code in action. Add the following code after the drawLines function in the GLFun project:

void drawSolidTriangle()
{
  glBegin(GL_TRIANGLES);
  
  glColor3f(0.0f, 0.0f, 1.0f);
  glVertex2f(0.1f, -0.6f);
  glVertex2f(0.7f, -0.6f);
  glVertex2f(0.4f, -0.1f);
  
  glEnd();
}

Then change the middle line of the update function to call drawSolidTriangle:

void update()
{
  glClear(GL_COLOR_BUFFER_BIT);
  drawSolidTriangle();
  glFlush();
}

Run the program, and you will see the following output:

You may notice a similarity between the code for drawSolidTriangle and drawPoints. Look closely at the code, and you will see that the three glVertex functions define the same three points. However, in this case we told OpenGL to draw triangles, not points. You should also take a look at the code and make sure you understand why the triangle is rendered blue.

Let's take one more example. Add the following code below the drawSolidTriangle function:

void drawGradientTriangle()
{
  glBegin(GL_TRIANGLES);
  
  glColor3f(1.0f, 0.0f, 0.0f);
  glVertex2f(0.3f, -0.4f);
  
  glColor3f(0.0f, 1.0f, 0.0f);
  glVertex2f(0.9f, -0.4f);
  
  glColor3f(0.0f, 0.0f, 1.0f);
  glVertex2f(0.6f, -0.9f);
  
  glEnd();
}

Be sure to change the middle line in update to call drawGradientTriangle:

void update()
{
  glClear(GL_COLOR_BUFFER_BIT);
  drawGradientTriangle();
  glFlush();
}

Run the program, and this is what you will see:

You will immediately notice that this triangle is filled with a gradient instead of a solid color. If you look closely at the code, you will see that a different color is being set for each vertex. OpenGL then takes care of interpolating the colors between each vertex.

Triangles can be put together in an infinite number of ways to form almost any shape imaginable. It is important to understand that triangles are just geometry. Triangles are used to build the shape of your object. We call these shapes models.

Building a model using a single triangle at a time would be very time consuming, so 3D graphics programs, such as Maya and Blender, allow you to create models out more complex shapes (which are themselves built out of triangles). These models can then be loaded into your game and rendered by OpenGL. OpenGL literally sends a the list of points to form these triangles directly to the video card, which then creates and image out of them on the screen. We will see this process in action when we begin to deal with 3D game design.