Jeff Molofee - NeHe's OpenGL Tutorials

{

glBindTexture(GL_TEXTURE_2D, texture[loop]);

glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[loop]->sizeX, TextureImage[loop]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[loop]->data);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

}

for (loop=0; loop<3; loop++) // Loop Through 5 Textures

{

if (TextureImage[loop]) // If Texture Exists

{

if (TextureImage[loop]->data) // If Texture Image Exists

{

free(TextureImage[loop]->data); // Free The Texture Image Memory

}

free(TextureImage[loop]); // Free The Image Structure

}

}

}

return Status; // Return The Status

}

A new command called glClearStencil is introduced in the init code. Passing 0 as a parameter tells OpenGL to disable clearing of the stencil buffer. You should be familiar with the rest of the code by now. We load our textures and enable smooth shading. The clear color is set to an off blue and the clear depth is set to 1.0f. The stencil clear value is set to 0. We enable depth testing, and set the depth test value to less than or equal to. Our perspective correction is set to nicest (very good quality) and 2d texture mapping is enabled.

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

{

if (!LoadGLTextures()) // If Loading The Textures Failed

{

return FALSE; // Return False

}

glShadeModel(GL_SMOOTH); // Enable Smooth Shading

glClearColor(0.2f, 0.5f, 1.0f, 1.0f); // Background

glClearDepth(1.0f); // Depth Buffer Setup

glClearStencil(0); // Clear The Stencil Buffer To 0

glEnable(GL_DEPTH_TEST); // Enables Depth Testing

glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do

glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations

glEnable(GL_TEXTURE_2D); // Enable 2D Texture Mapping

Now it's time to set up light 0. The first line below tells OpenGL to use the values stored in LightAmb for the Ambient light. If you remember at the beginning of the code, the rgb values of LightAmb were all 0.7f, giving us a white light at 70% full intensity. We then set the Diffuse light using the values stored in LightDif and position the light using the x,y,z values stored in LightPos.

After we have set the light up we can enable it with glEnable(GL_LIGHT0). Even though the light is enabled, you will not see it until we enable lighting with the last line of code.

Note: If we wanted to turn off all lights in a scene we would use glDisable(GL_LIGHTING). If we wanted to disable just one of our lights we would use glDisable(GL_LIGHT{0-7}). This gives us alot of control over the lighting and what lights are on and off. Just remember if GL_LIGHTING is disabled, you will not see lights!

glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmb); // Set The Ambient Lighting For Light0

glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDif); // Set The Diffuse Lighting For Light0

glLightfv(GL_LIGHT0, GL_POSITION, LightPos); // Set The Position For Light0

glEnable(GL_LIGHT0); // Enable Light 0

glEnable(GL_LIGHTING); // Enable Lighting

In the first line below, we create a new quadratic object. The second line tells OpenGL to generate smooth normals for our quadratic object, and the third line tells OpenGL to generate texture coordinates for our quadratic. Without the second and third lines of code, our object would use flat shading and we wouldn't be able to texture it.

The fourth and fifth lines tell OpenGL to use the Sphere Mapping algorithm to generate the texture coordinates. This allows us to sphere map the quadratic object.

q = gluNewQuadric(); // Create A New Quadratic

gluQuadricNormals(q, GL_SMOOTH); // Generate Smooth Normals For The Quad

gluQuadricTexture(q, GL_TRUE); // Enable Texture Coords For The Quad

glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // Set Up Sphere Mapping

glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // Set Up Sphere Mapping

return TRUE; // Initialization Went OK

}

The code below will draw our object (which is a cool looking environment mapped beach ball).

We set the color to full intensity white and bind to our BALL texture (the ball texture is a series of red, white and blue stripes).

After selecting our texture, we draw a Quadratic Sphere with a radius of 0.35f, 32 slices and 16 stacks (up and down).

void DrawObject() // Draw Our Ball

{

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

glBindTexture(GL_TEXTURE_2D, texture[1]); // Select Texture 2 (1)

gluSphere(q, 0.35f, 32, 16); // Draw First Sphere

After drawing the first sphere, we select a new texture (EnvRoll), set the alpha value to 40% and enable blending based on the source alpha value. glEnable(GL_TEXTURE_GEN_S) and glEnable(GL_TEXTURE_GEN_T) enables sphere mapping.

After doing all that, we redraw the sphere, disable sphere mapping and disable blending.

The final result is a reflection that almost looks like bright points of light mapped to the beach ball. Because we enable sphere mapping, the texture is always facing the viewer, even as the ball spins. We blend so that the new texture doesn't cancel out the old texture (a form of multitexturing).

glBindTexture(GL_TEXTURE_2D, texture[2]); // Select Texture 3 (2)

glColor4f(1.0f, 1.0f, 1.0f, 0.4f); // Set Color To White With 40% Alpha

glEnable(GL_BLEND); // Enable Blending

glBlendFunc(GL_SRC_ALPHA, GL_ONE); // Set Blending Mode To Mix Based On SRC Alpha

glEnable(GL_TEXTURE_GEN_S); // Enable Sphere Mapping

glEnable(GL_TEXTURE_GEN_T); // Enable Sphere Mapping

gluSphere(q, 0.35f, 32, 16); // Draw Another Sphere Using New Texture

// Textures Will Mix Creating A MultiTexture Effect (Reflection)

glDisable(GL_TEXTURE_GEN_S); // Disable Sphere Mapping

glDisable(GL_TEXTURE_GEN_T); // Disable Sphere Mapping

glDisable(GL_BLEND); // Disable Blending

}

The code below draws the floor that our ball hovers over. We select the floor texture (EnvWall), and draw a single texture mapped quad on the z-axis. Pretty simple!

void DrawFloor() // Draws The Floor

{

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

glBegin(GL_QUADS); // Begin Drawing A Quad

glNormal3f(0.0, 1.0, 0.0); // Normal Pointing Up

glTexCoord2f(0.0f, 1.0f); // Bottom Left Of Texture

glVertex3f(-2.0, 0.0, 2.0); // Bottom Left Corner Of Floor

glTexCoord2f(0.0f, 0.0f); // Top Left Of Texture

glVertex3f(-2.0, 0.0,-2.0); // Top Left Corner Of Floor

glTexCoord2f(1.0f, 0.0f); // Top Right Of Texture

glVertex3f( 2.0, 0.0,-2.0); // Top Right Corner Of Floor

glTexCoord2f(1.0f, 1.0f); // Bottom Right Of Texture

glVertex3f( 2.0, 0.0, 2.0); // Bottom Right Corner Of Floor