Jeff Molofee - NeHe's OpenGL Tutorials

glEnable(GL_TEXTURE_2D); // Enable Texture Mapping

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

return TRUE; // Initialization Went OK

}

The resize code hasn't changed, but our DrawGLScene code has.

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

{

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

glLoadIdentity(); // Reset The View

Here's our first change. Instead of keeping the object in the middle of the screen, we're going to spin it around the screen using COS and SIN (no surprise). We'll translate 3 units into the screen (-3.0f). On the x axis, we'll swing from –1.1 at far left to +1.1 at the right. We'll be using the rot variable to control the left right swing. We'll swing from +0.8 at top to –0.8 at the bottom. We'll use the rot variable for this swinging motion as well. (might as well make good use of your variables).

// Position The Text

glTranslatef(1.1f*float(cos(rot/16.0f)), 0.8f*float(sin(rot/20.0f)), -3.0f);

Now we do the normal rotations. This will cause the symbol to spin on the X, Y and Z axis.

glRotatef(rot,1.0f,0.0f,0.0f); // Rotate On The X Axis

glRotatef(rot*1.2f,0.0f,1.0f,0.0f); // Rotate On The Y Axis

glRotatef(rot*1.4f,0.0f,0.0f,1.0f); // Rotate On The Z Axis

We translate a little to the left, down, and towards the viewer to center the symbol on each axis. Otherwise when it spins it doesn't look like it's spinning around it's own center. –0.35 is just a number that worked. I had to play around with numbers for a bit because I'm not sure how wide the font is, could vary with each font. Why the fonts aren't built around a central point I'm not sure.

glTranslatef(-0.35f,-0.35f,0.1f); // Center On X, Y, Z Axis

Finally we draw our skull and crossbones symbol then increase the rot variable so our symbol spins and moves around the screen. If you can't figure out how I get a skull and crossbones from the letter 'N', do this: Run Microsoft Word or Wordpad. Go to the fonts drop down menu. Select the Wingdings font. Type and uppercase 'N'. A skull and crossbones appears.

glPrint("N"); // Draw A Skull And Crossbones Symbol

rot+=0.1f; // Increase The Rotation Variable

return TRUE; // Keep Going

}

The last thing to do is add KillFont() to the end of KillGLWindow() just like I'm showing below. It's important to add this line. It cleans things up before we exit our program.

if (!UnregisterClass("OpenGL",hInstance)) // Are We Able To Unregister Class

{

MessageBox(NULL, "Could Not Unregister Class.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);

hInstance=NULL; // Set hInstance To NULL

}

KillFont(); // Destroy The Font

}

Even though I never went into extreme detail, you should have a pretty good understanding on how to make OpenGL generate texture coordinates for you. You should have no problems mapping textures to fonts of your own, or even other objects for that matter. And by changing just two lines of code, you can enable sphere mapping, which is a really cool effect.

* DOWNLOAD Visual C++Code For This Lesson.

* DOWNLOAD Borland C++Code For This Lesson. (Conversion by Patrick Salmons)

* DOWNLOAD DelphiCode For This Lesson. (Conversion by Marc Aarts)

* DOWNLOAD GLutCode For This Lesson. (Conversion by David Phillip Oster)

* DOWNLOAD JavaCode For This Lesson. (Conversion by Jeff Kirby)

* DOWNLOAD Mac OSCode For This Lesson. (Conversion by David Phillip Oster)

* DOWNLOAD Visual BasicCode For This Lesson. (Conversion by Ross Dawson)

This tutorial brought to you by Chris Aliotta…

So you want to add fog to your OpenGL program? Well in this tutorial I will show you how to do exactly that. This is my first time writing a tutorial, and I am still relatively new to OpenGL/C++ programming, so please, if you find anything that's wrong let me know and don't jump all over me. This code is based on the code from lesson 7.

We'll start by setting up all our variables needed to hold the information for fog. The variable fogMode will be used to hold three types of fog: GL_EXP, GL_EXP2, and GL_LINEAR. I will explain the differences between these three later on. The variables will start at the beginning of the code after the line GLuint texture[3]. The variable fogfilter will be used to keep track of which fog type we will be using. The variable fogColor will hold the color we wish the fog to be. I have also added the boolean variable gp at the top of the code so we can tell if the 'g' key is being pressed later on in this tutorial.

bool gp; // G Pressed? ( New )

GLuint filter; // Which Filter To Use

GLuint fogMode[]= { GL_EXP, GL_EXP2, GL_LINEAR }; // Storage For Three Types Of Fog

GLuint fogfilter= 0; // Which Fog To Use

GLfloat fogColor[4]= {0.5f, 0.5f, 0.5f, 1.0f}; // Fog Color

Now that we have established our variables we will move down to InitGL. The glClearColor() line has been modified to clear the screen to the same same color as the fog for a better effect. There isn't much code involved to make fog work. In all you will find this to be very simplistic.

glClearColor(0.5f,0.5f,0.5f,1.0f); // We'll Clear To The Color Of The Fog ( Modified )

glFogi(GL_FOG_MODE, fogMode[fogfilter]); // Fog Mode

glFogfv(GL_FOG_COLOR, fogColor); // Set Fog Color

glFogf(GL_FOG_DENSITY, 0.35f); // How Dense Will The Fog Be

glHint(GL_FOG_HINT, GL_DONT_CARE); // Fog Hint Value

glFogf(GL_FOG_START, 1.0f); // Fog Start Depth

glFogf(GL_FOG_END, 5.0f); // Fog End Depth

glEnable(GL_FOG); // Enables GL_FOG

Lets pick apart the first three lines of this code. The first line glEnable(GL_FOG); is pretty much self explanatory. It basically initializes the fog.

The second line, glFogi(GL_FOG_MODE, fogMode[fogfilter]); establishes the fog filter mode. Now earlier we declared the array fogMode. It held GL_EXP, GL_EXP2, and GL_LINEAR. Here is when these variables come into play. Let me explain each one:

• GL_EXP — Basic rendered fog which fogs out all of the screen. It doesn't give much of a fog effect, but gets the job done on older PC's.

• GL_EXP2 — Is the next step up from GL_EXP. This will fog out all of the screen, however it will give more depth to the scene.

• GL_LINEAR — This is the best fog rendering mode. Objects fade in and out of the fog much better.

The third line, glFogfv(GL_FOG_COLOR, fogcolor); sets the color of the fog. Earlier we had set this to (0.5f, 0.5f, 0.5f, 1.0f) using the variable fogcolor, giving us a nice grey color.

Next lets look at the last four lines of this code. The line glFogf(GL_FOG_DENSITY, 0.35f); establishes how dense the fog will be. Increase the number and the fog becomes more dense, decrease it and it becomes less dense.

The line glHint (GL_FOG_HINT, GL_DONT_CARE); establishes the hint. I used GL_DONT_CARE, because I didn't care about the hint value.

Eric Desrosiers Adds: Little explanation of glHint(GL_FOG_HINT, hintval);

hintval can be : GL_DONT_CARE, GL_NICEST or GL_FASTEST

gl_dont_care — Lets opengl choose the kind of fog (per vertex of per pixel) and an unknown formula.