#version 400

layout (location = 0) in vec3 VertexPosition;
layout (location = 1) in vec3 VertexNormal;
layout (location = 2) in vec2 VertexTexCoord;

out vec3 FrontColor;
out vec3 BackColor;
out vec2 TexCoord;

struct LightInfo {
  vec4 Position; // Light position in eye coords.
  vec3 La; // Ambient light intensity
  vec3 Ld; // Diffuse light intensity
  vec3 Ls; // Specular light intensity
};
uniform LightInfo Light;

struct MaterialInfo {
  vec3 Ka; // Ambient reflectivity
  vec3 Kd; // Diffuse reflectivity
  vec3 Ks; // Specular reflectivity
  float Shininess; // Specular shininess factor
};
uniform MaterialInfo Material;

uniform mat4 ModelViewMatrix;
uniform mat3 NormalMatrix;
uniform mat4 ProjectionMatrix;
uniform mat4 MVP;

void getEyeSpace( out vec3 norm, out vec4 position )
{
  norm = normalize( NormalMatrix * VertexNormal);
  position = ModelViewMatrix * vec4(VertexPosition,1.0);
}

vec3 phongModel( vec4 position, vec3 norm )
{
  // The ADS shading calculations go here (see: "Using
  // functions in shaders," and "Implementing
  // per-vertex ambient, diffuse and specular (ADS) shading")
  ...
}

void main()
{
  vec3 eyeNorm;
  vec4 eyePosition;

  TexCoord = VertexTexCoord;

  // Get the position and normal in eye space
  getEyeSpace(eyeNorm, eyePosition);

  FrontColor = phongModel( eyePosition, eyeNorm );
  BackColor = phongModel( eyePosition, -eyeNorm );

  gl_Position = MVP * vec4(VertexPosition,1.0);
}

#version 400

in vec3 FrontColor;
in vec3 BackColor;
in vec2 TexCoord;

layout( location = 0 ) out vec4 FragColor;

void main() {
  const float scale = 15.0;
  bvec2 toDiscard = greaterThan( fract(TexCoord * scale),
								 vec2(0.2,0.2) );

if( all(toDiscard) )
	discard;

if( gl_FrontFacing )
	FragColor = vec4(FrontColor, 1.0);
else
	FragColor = vec4(BackColor, 1.0);
}

Since performance is crucial in shader programs, avoiding a conditional statement or a shader swap can be very valuable. With subroutines, we can implement the functionality of a conditional statement or shader swap without the computational overhead.

#version 400

subroutine vec3 shadeModelType( vec4 position, vec3 normal);

subroutine uniform shadeModelType shadeModel;

layout (location = 0) in vec3 VertexPosition;
layout (location = 1) in vec3 VertexNormal;

out vec3 LightIntensity;

struct LightInfo {
  vec4 Position; // Light position in eye coords.
  vec3 La; // Ambient light intensity
  vec3 Ld; // Diffuse light intensity
  vec3 Ls; // Specular light intensity
};
uniform LightInfo Light;

struct MaterialInfo {
  vec3 Ka; // Ambient reflectivity
  vec3 Kd; // Diffuse reflectivity
  vec3 Ks; // Specular reflectivity
  float Shininess; // Specular shininess factor
};
uniform MaterialInfo Material;

uniform mat4 ModelViewMatrix;
uniform mat3 NormalMatrix;
uniform mat4 ProjectionMatrix;
uniform mat4 MVP;

void getEyeSpace( out vec3 norm, out vec4 position )
{
  norm = normalize( NormalMatrix * VertexNormal);
  position = ModelViewMatrix * vec4(VertexPosition,1.0);
}

subroutine( shadeModelType )

vec3 phongModel( vec4 position, vec3 norm )
{
  // The ADS shading calculations go here (see: "Using
  // functions in shaders," and "Implementing
  // per-vertex ambient, diffuse and specular (ADS) shading")
  ...
}

subroutine( shadeModelType )

vec3 diffuseOnly( vec4 position, vec3 norm )
{
  vec3 s = normalize( vec3(Light.Position - position) );
  return
	  Light.Ld * Material.Kd * max( dot(s, norm), 0.0 );
}

void main()
{
  vec3 eyeNorm;
  vec4 eyePosition;

  // Get the position and normal in eye space

  getEyeSpace(eyeNorm, eyePosition);

  // Evaluate the shading equation. This will call one of
  // the functions: diffuseOnly or phongModel.
  LightIntensity = shadeModel( eyePosition, eyeNorm );

  gl_Position = MVP * vec4(VertexPosition,1.0);
}

#version 400

in vec3 LightIntensity;

layout( location = 0 ) out vec4 FragColor;

void main() {
FragColor = vec4(LightIntensity, 1.0);
}

GLuint adsIndex =
glGetSubroutineIndex( programHandle,
					 GL_VERTEX_SHADER,"phongModel" );
GLuint diffuseIndex =
  glGetSubroutineIndex(programHandle,
					   GL_VERTEX_SHADER, "diffuseOnly");

glUniformSubroutinesuiv( GL_VERTEX_SHADER, 1, &adsIndex);
... // Render the left teapot

glUniformSubroutinesuiv( GL_VERTEX_SHADER, 1, &diffuseIndex);
... // Render the right teapot

subroutine vec3 shadeModelType( vec4 position,
					 vec3 normal);

subroutine uniform shadeModelType shadeModel;

subroutine ( shadeModelType )

LightIntensity = shadeModel( eyePosition, eyeNorm );

subroutine( type1, type2 )

• Implementing diffuse, per-vertex shading with a single point light source
  
• Implementing per-vertex ambient, diffuse, and, specular (ADS) shading
  
• Using functions in shaders
  
• Implementing two sided shading
  
• Implementing flat shading
  

In this and the following recipes, light intensities and material reflectivity coefficients are represented by 3-component (RGB) vectors. Therefore, the equations should be treated as component-wise operations, applied to each of the three components separately. Luckily, the GLSL will make this nearly transparent because the needed operators will operate component-wise on vector variables.

• Use the following code for the vertex shader.
  

  	
  #version 400
  	
  	layout (location = 0) in vec3 VertexPosition;
  	layout (location = 1) in vec3 VertexNormal;
  	
  	out vec3 LightIntensity;
  	
  	uniform vec4 LightPosition; // Light position in eye coords.
  	uniform vec3 Kd; // Diffuse reflectivity
  	uniform vec3 Ld; // Light source intensity
  	
  	uniform mat4 ModelViewMatrix;
  	uniform mat3 NormalMatrix;
  	uniform mat4 ProjectionMatrix;
  	uniform mat4 MVP; // Projection * ModelView
  	
  	void main()
  	{
  	  // Convert normal and position to eye coords
  	  vec3 tnorm = normalize( NormalMatrix * VertexNormal);
  	  vec4 eyeCoords = ModelViewMatrix *
  					   vec4(VertexPosition,1.0));
  	  vec3 s = normalize(vec3(LightPosition - eyeCoords));
  	
  	  // The diffuse shading equation
  	  LightIntensity = Ld * Kd * max( dot( s, tnorm ), 0.0 );
  	
  	  // Convert position to clip coordinates and pass along
  	  gl_Position = MVP * vec4(VertexPosition,1.0);
  	}	
  	
  

  
  
• Use the following code for the fragment shader.
  

  	
  #version 400
  	
  	in vec3 LightIntensity;
  	
  	layout( location = 0 ) out vec4 FragColor;
  	
  	void main() {
  		FragColor = vec4(LightIntensity, 1.0);
  	}	
  	
  

  
  
• Compile and link both shaders within the OpenGL application, and install the shader program prior to rendering. See Tips and Tricks for Getting Started with OpenGL and GLSL 4.0 for details about compiling, linking, and installing shaders.
  

The normal matrix is typically the inverse transpose of the upper-left 3x3 portion of the model-view matrix. We use the inverse transpose because normal vectors transform differently than the vertex position. For a more thorough discussion of the normal matrix, and the reasons why, see any introductory computer graphics textbook. (A good choice would be Computer Graphics with OpenGL by Hearn and Baker.) If your model-view matrix does not include any non-uniform scalings, then one can use the upper-left 3x3 of the model-view matrix in place of the normal matrix to transform your normal vectors. However, if your model-view matrix does include (uniform) scalings, you'll still need to (re)normalize your normal vectors after transforming them.

gl_Position = MVP * vec4(VertexPosition,1.0);

The subsequent stage of the OpenGL pipeline expects that the vertex position will be provided in clip coordinates in the output variable gl_Position. This variable does not directly correspond to any input variable in the fragment shader, but is used by the OpenGL pipeline in the primitive assembly, clipping, and rasterization stages that follow the vertex shader. It is important that we always provide a valid value for this variable.

• Use the following code for the vertex shader:
  

  	
  #version 400
  	
  	layout (location = 0) in vec3 VertexPosition;
  	layout (location = 1) in vec3 VertexNormal;
  	
  	out vec3 LightIntensity;
  	
  	struct LightInfo {
  	  vec4 Position; // Light position in eye coords.
  	  vec3 La; // Ambient light intensity
  	  vec3 Ld; // Diffuse light intensity
  	  vec3 Ls; // Specular light intensity
  	};
  	uniform LightInfo Light;
  	
  	struct MaterialInfo {
  	  vec3 Ka; // Ambient reflectivity
  	  vec3 Kd; // Diffuse reflectivity
  	  vec3 Ks; // Specular reflectivity
  	  float Shininess; // Specular shininess factor
  	};
  	uniform MaterialInfo Material;
  	
  	uniform mat4 ModelViewMatrix;
  	uniform mat3 NormalMatrix;
  	uniform mat4 ProjectionMatrix;
  	uniform mat4 MVP;
  	
  	void main()
  	{
  	  vec3 tnorm = normalize( NormalMatrix * VertexNormal);
  	  vec4 eyeCoords = ModelViewMatrix *
  					   vec4(VertexPosition,1.0);
  	  vec3 s = normalize(vec3(Light.Position - eyeCoords));
  	  vec3 v = normalize(-eyeCoords.xyz);
  	  vec3 r = reflect( -s, tnorm );
  	  vec3 ambient = Light.La * Material.Ka;
  	  float sDotN = max( dot(s,tnorm), 0.0 );
  	  vec3 diffuse = Light.Ld * Material.Kd * sDotN;
  	  vec3 spec = vec3(0.0);
  	  if( sDotN > 0.0 )
  		spec = Light.Ls * Material.Ks *
  			   pow( max( dot(r,v), 0.0 ), Material.Shininess );
  	
  	  LightIntensity = ambient + diffuse + spec;
  	  gl_Position = MVP * vec4(VertexPosition,1.0);
  	}	
  	
  

  
  
• Use the following code for the fragment shader:
  

  	
  #version 400
  	
  	in vec3 LightIntensity;
  	
  	layout( location = 0 ) out vec4 FragColor;
  	
  	void main() {
  		FragColor = vec4(LightIntensity, 1.0);
  	}	
  	
  

  
  
• Compile and link both shaders within the OpenGL application, and install the shader program prior to rendering.
  

If we did not check sDotN before computing the specular component, it is possible that some specular highlights could appear on faces that are facing away from the light source. This is clearly a non-realistic and undesirable result. Some people solve this problem by multiplying the specular component by the diffuse component, which would decrease the specular component substantially and alter its color. The solution presented here avoids this, at the cost of a branch statement (the if statement).

• Use the following vertex shader:
  

  	
  #version 400
  	
  	layout (location = 0) in vec3 VertexPosition;
  	layout (location = 1) in vec3 VertexNormal;
  	
  	out vec3 LightIntensity;
  	
  	struct LightInfo {
  	  vec4 Position; // Light position in eye coords.
  	  vec3 La; // Ambient light intensity
  	  vec3 Ld; // Diffuse light intensity
  	  vec3 Ls; // Specular light intensity
  	};
  	uniform LightInfo Light;
  	
  	struct MaterialInfo {
  	  vec3 Ka; // Ambient reflectivity
  	  vec3 Kd; // Diffuse reflectivity
  	  vec3 Ks; // Specular reflectivity
  	  float Shininess; // Specular shininess factor
  	};
  	uniform MaterialInfo Material;
  	
  	uniform mat4 ModelViewMatrix;
  	uniform mat3 NormalMatrix;
  	uniform mat4 ProjectionMatrix;
  	uniform mat4 MVP;
  	
  	void getEyeSpace( out vec3 norm, out vec4 position )
  	{
  	  norm = normalize( NormalMatrix * VertexNormal);
  	  position = ModelViewMatrix * vec4(VertexPosition,1.0);
  	}
  	
  	vec3 phongModel( vec4 position, vec3 norm )
  	{
  	  vec3 s = normalize(vec3(Light.Position - position));
  	  vec3 v = normalize(-position.xyz);
  	  vec3 r = reflect( -s, norm );
  	  vec3 ambient = Light.La * Material.Ka;
  	  float sDotN = max( dot(s,norm), 0.0 );
  	  vec3 diffuse = Light.Ld * Material.Kd * sDotN;
  	  vec3 spec = vec3(0.0);
  	  if( sDotN > 0.0 )
  		  spec = Light.Ls * Material.Ks *
  				 pow( max( dot(r,v), 0.0 ), Material.Shininess );
  	  return ambient + diffuse + spec;
  	}
  	
  	void main()
  	{
  	  vec3 eyeNorm;
  	  vec4 eyePosition;
  	  // Get the position and normal in eye space
  	  getEyeSpace(eyeNorm, eyePosition);
  	  // Evaluate the lighting equation.
  	  LightIntensity = phongModel( eyePosition, eyeNorm );
  	  gl_Position = MVP * vec4(VertexPosition,1.0);
  	}	
  	
  

  
  
• Use the following fragment shader:
  

  	
  #version 400
  	in vec3 LightIntensity;
  	layout( location = 0 ) out vec4 FragColor;
  	void main() {
  		FragColor = vec4(LightIntensity, 1.0);
  	}	
  	
  

  
  
• Compile and link both shaders within the OpenGL application, and install the shader program prior to rendering.
  

• Use the following code for the vertex shader:
  

  	
  #version 400
  	
  	layout (location = 0) in vec3 VertexPosition;
  	layout (location = 1) in vec3 VertexNormal;
  	
  	out vec3 FrontColor;
  	out vec3 BackColor;
  	
  	struct LightInfo {
  	  vec4 Position; // Light position in eye coords.
  	  vec3 La; // Ambient light intensity
  	  vec3 Ld; // Diffuse light intensity
  	  vec3 Ls; // Specular light intensity
  	};
  	uniform LightInfo Light;
  	
  	struct MaterialInfo {
  	  vec3 Ka; // Ambient reflectivity
  	  vec3 Kd; // Diffuse reflectivity
  	  vec3 Ks; // Specular reflectivity
  	  float Shininess; // Specular shininess factor
  	};
  	uniform MaterialInfo Material;
  	
  	uniform mat4 ModelViewMatrix;
  	uniform mat3 NormalMatrix;
  	uniform mat4 ProjectionMatrix;
  	uniform mat4 MVP;
  	
  	vec3 phongModel( vec4 position, vec3 normal ) {
  	  // The ADS shading calculations go here (see: "Using
  	  // functions in shaders," and "Implementing
  	  // per-vertex ambient, diffuse and specular (ADS) shading")
  	  ...
  	}
  	
  	void main()
  	{
  	  vec3 tnorm = normalize( NormalMatrix * VertexNormal);
  	  vec4 eyeCoords = ModelViewMatrix *
  					   vec4(VertexPosition,1.0);
  	
  	  FrontColor = phongModel( eyeCoords, tnorm );
  	
  	  BackColor = phongModel( eyeCoords, -tnorm );
  	
  	  gl_Position = MVP * vec4(VertexPosition,1.0);
  	}	
  	
  

  
  
• Use the following for the fragment shader:
  

  	
  #version 400
  	
  	in vec3 FrontColor;
  	in vec3 BackColor;
  	
  	layout( location = 0 ) out vec4 FragColor;
  	
  	void main() {
  	
  	  if( gl_FrontFacing ) {
  		  FragColor = vec4(FrontColor, 1.0);
  	  } else {
  		  FragColor = vec4(BackColor, 1.0);
  	  }
  	}	
  	
  

  
  
• Compile and link both shaders within the OpenGL application, and install the shader program prior to rendering.
  

Note that there are a few aspects of the shading model that are independent of the orientation of the normal vector (such as the ambient component). One could optimize this code by rewriting it so that the redundant calculations are only done once. However, in this recipe we compute the entire shading model twice in the interest of making things clear and readable.

FragColor = mix( vec4(BackColor,1.0),
				vec4(1.0,0.0,0.0,1.0), 0.7 );

• Use the same vertex shader as in the ADS example provided earlier. Change the output variable LightIntensity as follows:
  

  	
  #version 400
  	
  	layout (location = 0) in vec3 VertexPosition;
  	layout (location = 1) in vec3 VertexNormal;
  	
  	flat out vec3 LightIntensity;
  	
  	// the rest is identical to the ADS shader...	
  	
  

  
  
• Use the following code for the fragment shader:
  

  	
  #version 400
  	
  	flat in vec3 LightIntensity;
  	
  	layout( location = 0 ) out vec4 FragColor;
  	
  	void main() {
  		FragColor = vec4(LightIntensity, 1.0);
  	}	
  	
  

  
  
• Compile and link both shaders within the OpenGL application, and install the shader program prior to rendering.
  

glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);

uniform BlobSettings {
  vec4 InnerColor;
  vec4 OuterColor;
  float RadiusInner;
  float RadiusOuter;
};

#version 400

layout (location = 0) in vec3 VertexPosition;
layout (location = 1) in vec3 VertexTexCoord;

out vec3 TexCoord;

void main()
{
	TexCoord = VertexTexCoord;
	gl_Position = vec4(VertexPosition,1.0);
}

#version 400
in vec3 TexCoord;
layout (location = 0) out vec4 FragColor;

uniform BlobSettings {
  vec4 InnerColor;
  vec4 OuterColor;
  float RadiusInner;
  float RadiusOuter;
};

void main() {
	float dx = TexCoord.x - 0.5;
	float dy = TexCoord.y - 0.5;
	float dist = sqrt(dx * dx + dy * dy);
	FragColor =
	   mix( InnerColor, OuterColor,
			 smoothstep( RadiusInner, RadiusOuter, dist )
	   );
}

• Get the index of the uniform block using glGetUniformBlockIndex.
  

  	
  GLuint blockIndex = glGetUniformBlockIndex(programHandle,
  											  "BlobSettings");	
  	
  

  
  
• Allocate space for the buffer to contain the data for the uniform block. We get the size of the block using glGetActiveUniformBlockiv.
  

  	
  GLint blockSize;
  	
  	glGetActiveUniformBlockiv(programHandle, blockIndex,
  						  GL_UNIFORM_BLOCK_DATA_SIZE, &blockSize);
  	
  	GLubyte * blockBuffer= (GLubyte *) malloc(blockSize);	
  	
  

  
  
• Query for the offset of each variable within the block. To do so, we first find the index of each variable within the block.
  

  	
  // Query for the offsets of each block variable
  	const GLchar *names[] = { "InnerColor", "OuterColor",
  							  "RadiusInner", "RadiusOuter" };
  	
  	GLuint indices[4];
  	glGetUniformIndices(programHandle, 4, names, indices);
  	
  	GLint offset[4];
  	glGetActiveUniformsiv(programHandle, 4, indices,
  						  GL_UNIFORM_OFFSET, offset);	
  	
  

  
  
• Place the data into the buffer at the appropriate offsets.
  

  	
  GLfloat outerColor[] = {0.0f, 0.0f, 0.0f, 0.0f};
  	GLfloat innerColor[] = {1.0f, 1.0f, 0.75f, 1.0f};
  	GLfloat innerRadius = 0.25f, outerRadius = 0.45f;
  	
  	memcpy(blockBuffer + offset[0], innerColor,
  									4 * sizeof(GLfloat));
  	memcpy(blockBuffer + offset[1], outerColor,
  									4 * sizeof(GLfloat));
  	memcpy(blockBuffer + offset[2], &innerRadius,
  									sizeof(GLfloat));
  	memcpy(blockBuffer + offset[3], &outerRadius,
  									sizeof(GLfloat));	
  	
  

  
  
• Create the OpenGL buffer object and copy the data into it.
  

  	
  GLuint uboHandle;
  	glGenBuffers( 1, &uboHandle );
  	glBindBuffer( GL_UNIFORM_BUFFER, uboHandle );
  	glBufferData( GL_UNIFORM_BUFFER, blockSize, blockBuffer,
  				  GL_DYNAMIC_DRAW );	
  	
  

  
  
• Bind the buffer object to the uniform block.
  

  	
  glBindBufferBase( GL_UNIFORM_BUFFER, blockIndex, uboHandle );	
  	
  

  
  

uniform BlobSettings {
  vec4 InnerColor;
  vec4 OuterColor;
  float RadiusInner;
  float RadiusOuter;
} Blob;

FragColor =
   mix( Blob.InnerColor, Blob.OuterColor,
	   smoothstep( Blob.RadiusInner, Blob.RadiusOuter, dist )
   );

layout( std140 ) uniform BlobSettings {
   ...
};

layout( row_major, shared ) uniform BlobSettings {
   ...
};

• View a geometric model in any orientation by transforming it in three-dimensional space
• Control the location in three-dimensional space from which the model is viewed
• Clip undesired portions of the model out of the scene that's to be viewed
• Manipulate the appropriate matrix stacks that control model transformation for viewing, and project the model onto the screen
• Combine multiple transformations to mimic sophisticated systems in motion, such as a solar system or an articulated robot arm
• Reverse or mimic the operations of the geometric processing pipeline

• Transformations, which are represented by matrix multiplication, include modeling, viewing, and projection operations. Such operations include rotation, translation, scaling, reflecting, orthographic projection, and perspective projection. Generally, you use a combination of several transformations to draw a scene.
• Since the scene is rendered on a rectangular window, objects (or parts of objects) that lie outside the window must be clipped. In three-dimensional computer graphics, clipping occurs by throwing out objects on one side of a clipping plane.
• Finally, a correspondence must be established between the transformed coordinates and screen pixels. This is known as a viewport transformation.

• "Overview: The Camera Analogy" gives an overview of the transformation process by describing the analogy of taking a photograph with a camera, presents a simple example program that transforms an object, and briefly describes the basic OpenGL transformation commands.
• "Viewing and Modeling Transformations" explains in detail how to specify and imagine the effect of viewing and modeling transformations. These transformations orient the model and the camera relative to each other to obtain the desired final image.
• "Projection Transformations" describes how to specify the shape and orientation of the viewing volume. The viewing volume determines how a scene is projected onto the screen (with a perspective or orthographic projection) and which objects or parts of objects are clipped out of the scene.
• "Viewport Transformation" explains how to control the conversion of three-dimensional model coordinates to screen coordinates.
• "Troubleshooting Transformations" presents some tips for discovering why you might not be getting the desired effect from your modeling, viewing, projection, and viewport transformations.
• "Manipulating the Matrix Stacks" discusses how to save and restore certain transformations. This is particularly useful when you're drawing complicated objects that are built from simpler ones.
• "Additional Clipping Planes" describes how to specify additional clipping planes beyond those defined by the viewing volume.
• "Examples of Composing Several Transformations" walks you through a couple of more complicated uses for transformations.
• "Reversing or Mimicking Transformations" shows you how to take a transformed point in window coordinates and reverse the transformation to obtain its original object coordinates. The transformation itself (without reversal) can also be emulated.

• Set up your tripod and point the camera at the scene (viewing transformation).
• Arrange the scene to be photographed into the desired composition (modeling transformation).
• Choose a camera lens or adjust the zoom (projection transformation).
• Determine how large you want the final photograph to be—for example, you might want it enlarged (viewport transformation).

m[j] is in the ith column and jth row of the common OpenGL transformation matrix. This is the reverse of the standard C convention in which m[j] is in row i and column j. One way to avoid confusion between the column and row is to declare your matrices as m[16].

Another way to avoid possible confusion is to call the OpenGL routines glLoadTransposeMatrix*() and glMultTransposeMatrix*(), which use row-major (the standard C convention) matrices as arguments.

void glLoadTransposeMatrix{fd}(const TYPE *m);

Sets the 16 values of the current matrix to those specified by m, whose values are stored in row-major order. glLoadTransposeMatrix*(m) has the same effect as glLoadMatrix*(m^T).

void glMultTransposeMatrix{fd}(const TYPE *m);

Multiplies the matrix specified by the 16 values pointed to by m by the current matrix and stores the result as the current matrix. glMultTransposeMatrix*(m) has the same effect as glMultMatrix*(m^T).

You might be able to maximize efficiency by using display lists to store frequently used matrices (and their inverses), rather than recomputing them. (See "Display List Design Philosophy" in Chapter 7.) OpenGL implementations often must compute the inverse of the modelview matrix so that normals and clipping planes can be correctly transformed to eye coordinates.


Viewing and Modeling Transformations
Viewing and modeling transformations are inextricably related in OpenGL and are in fact combined into a single modelview matrix. (See "A Simple Example: Drawing a Cube.") One of the toughest problems newcomers to computer graphics face is understanding the effects of combined three-dimensional transformations. As you've already seen, there are alternative ways to think about transformations—do you want to move the camera in one direction or move the object in the opposite direction? Each way of thinking about transformations has advantages and disadvantages, but in some cases one way more naturally matches the effect of the intended transformation. If you can find a natural approach for your particular application, it's easier to visualize the necessary transformations and then write the corresponding code to specify the matrix manipulations. The first part of this section discusses how to think about transformations; later, specific commands are presented. For now, we use only the matrix-manipulation commands you've already seen. Finally, keep in mind that you must call glMatrixMode() with GL_MODELVIEW as its argument prior to performing modeling or viewing transformations.


Thinking about Transformations
Let's start with a simple case of two transformations: a 45-degree counterclockwise rotation about the origin around the z-axis and a translation down the x-axis. Suppose that the object you're drawing is small compared with the translation (so that you can see the effect of the translation) and that it's originally located at the origin. If you rotate the object first and then translate it, the rotated object appears on the x-axis. If you translate it down the x-axis first, however, and then rotate about the origin, the object is on the line y = x, as shown in Figure 3-4. In general, the order of transformations is critical. If you do transformation A and then transformation B, you almost always get something different than if you do them in the opposite order.

Figure3-4
Rotating First or Translating First

Now let's talk about the order in which you specify a series of transformations. All viewing and modeling transformations are represented as 4 x 4 matrices. Each successive glMultMatrix*() or transformation command multiplies a new 4 x 4 matrix M by the current modelview matrix C to yield CM. Finally, vertices v are multiplied by the current modelview matrix. This process means that the last transformation command called in your program is actually the first one applied to the vertices: CMv. Thus, one way of looking at it is to say that you have to specify the matrices in the reverse order. Like many other things, however, once you've gotten used to thinking about this correctly, backward will seem like forward.

Consider the following code sequence, which draws a single point using three transformations:

glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMultMatrixf(N); /* apply transformation N */ glMultMatrixf(M); /* apply transformation M */ glMultMatrixf(L); /* apply transformation L */ glBegin(GL_POINTS); glVertex3f(v); /* draw transformed vertex v */ glEnd(); With this code, the modelview matrix successively contains I, N, NM, and finally NML, where I represents the identity matrix. The transformed vertex is NMLv. Thus, the vertex transformation is N(M(Lv))—that is, v is multiplied first by L, the resulting Lv is multiplied by M, and the resulting MLv is multiplied by N. Notice that the transformations to vertex v effectively occur in the opposite order than they were specified. (Actually, only a single multiplication of a vertex by the modelview matrix occurs; in this example, the N, M, and L matrices are already multiplied into a single matrix before it's applied to v.)


Grand, Fixed Coordinate System
Thus, if you like to think in terms of a grand, fixed coordinate system—in which matrix multiplications affect the position, orientation, and scaling of your model—you have to think of the multiplications as occurring in the opposite order from how they appear in the code. Using the simple example shown on the left side of Figure 3-4 (a rotation about the origin and a translation along the x-axis), if you want the object to appear on the axis after the operations, the rotation must occur first, followed by the translation. To do this, you'll need to reverse the order of operations, so the code looks something like this (where R is the rotation matrix and T is the translation matrix):

glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMultMatrixf(T); /* translation */ glMultMatrixf®; /* rotation */ draw_the_object();
Moving a Local Coordinate System
Another way to view matrix multiplications is to forget about a grand, fixed coordinate system in which your model is transformed and instead imagine that a local coordinate system is tied to the object you're drawing. All operations occur relative to this changing coordinate system. With this approach, the matrix multiplications now appear in the natural order in the code. (Regardless of which analogy you're using, the code is the same, but how you think about it differs.) To see this in the translation-rotation example, begin by visualizing the object with a coordinate system tied to it. The translation operation moves the object and its coordinate system down the x-axis. Then, the rotation occurs about the (now-translated) origin, so the object rotates in place in its position on the axis.

This approach is what you should use for applications such as articulated robot arms, where there are joints at the shoulder, elbow, and wrist, and on each of the fingers. To figure out where the tips of the fingers go relative to the body, you'd like to start at the shoulder, go down to the wrist, and so on, applying the appropriate rotations and translations at each joint. Thinking about it in reverse would be far more confusing.

This second approach can be problematic, however, in cases where scaling occurs, and especially so when the scaling is nonuniform (scaling different amounts along the different axes). After uniform scaling, translations move a vertex by a multiple of what they did before, as the coordinate system is stretched. Non-uniform scaling mixed with rotations may make the axes of the local coordinate system nonperpendicular.

As mentioned earlier, you normally issue viewing transformation commands in your program before any modeling transformations. In this way, a vertex in a model is first transformed into the desired orientation and then transformed by the viewing operation. Since the matrix multiplications must be specified in reverse order, the viewing commands need to come first. Note, however, that you don't need to specify either viewing or modeling transformations if you're satisfied with the default conditions. If there's no viewing transformation, the "camera" is left in the default position at the origin, pointing toward the negative z-axis; if there's no modeling transformation, the model isn't moved, and it retains its specified position, orientation, and size.

Since the commands for performing modeling transformations can be used to perform viewing transformations, modeling transformations are discussed first, even if viewing transformations are actually issued first. This order for discussion also matches the way many programmers think when planning their code. Often, they write all the code necessary to compose the scene, which involves transformations to position and orient objects correctly relative to each other. Next, they decide where they want the viewpoint to be relative to the scene they've composed, and then they write the viewing transformations accordingly.


Modeling Transformations
The three OpenGL routines for modeling transformations are glTranslate*(), glRotate*(), and glScale*(). As you might suspect, these routines transform an object (or coordinate system, if you're thinking of it in that way) by moving, rotating, stretching, shrinking, or reflecting it. All three commands are equivalent to producing an appropriate translation, rotation, or scaling matrix, and then calling glMultMatrix*() with that matrix as the argument. However, using these three routines might be faster than using glMultMatrix*(). OpenGL automatically computes the matrices for you. (See Appendix F if you're interested in the details.)

In the command summaries that follow, each matrix multiplication is described in terms of what it does to the vertices of a geometric object using the fixed coordinate system approach, and in terms of what it does to the local coordinate system that's attached to an object.


Translate
void glTranslate{fd}(TYPE x, TYPE y, TYPE z);

Multiplies the current matrix by a matrix that moves (translates) an object by the given x-, y-, and z-values (or moves the local coordinate system by the same amounts).

Figure 3-5 shows the effect of glTranslate*().

Figure 3-5
Translating an Object

Note that using (0.0, 0.0, 0.0) as the argument for glTranslate*() is the identity operation—that is, it has no effect on an object or its local coordinate system.


Rotate
void glRotate{fd}(TYPE angle, TYPE x, TYPE y, TYPE z);

Multiplies the current matrix by a matrix that rotates an object (or the local coordinate system) in a counterclockwise direction about the ray from the origin through the point (x, y, z). The angle parameter specifies the angle of rotation in degrees.

The effect of glRotatef(45.0, 0.0, 0.0, 1.0), which is a rotation of 45 degrees about the z-axis, is shown in Figure 3-6.

Figure 3-6
Rotating an Object

Note that an object that lies farther from the axis of rotation is more dramatically rotated (has a larger orbit) than an object drawn near the axis. Also, if the angle argument is zero, the glRotate*() command has no effect.


Scale
void glScale{fd}(TYPE x, TYPE y, TYPE z);

Multiplies the current matrix by a matrix that stretches, shrinks, or reflects an object along the axes. Each x-, y-, and z-coordinate of every point in the object is multiplied by the corresponding argument x, y, or z. With the local coordinate system approach, the local coordinate axes are stretched, shrunk, or reflected by the x-, y-, and z-factors, and the associated object is transformed with them.

Figure 3-7 shows the effect of glScalef(2.0, –0.5, 1.0).

Figure 3-7
Scaling and Reflecting an Object

glScale*() is the only one of the three modeling transformations that changes the apparent size of an object: scaling with values greater than 1.0 stretches an object, and using values less than 1.0 shrinks it. Scaling with a -1.0 value reflects an object across an axis. The identity values for scaling are (1.0, 1.0, 1.0). In general, you should limit your use of glScale*() to those cases where it is necessary. Using glScale*() decreases the performance of lighting calculations, because the normal vectors have to be renormalized after transformation.

[indent] Note - A scale value of zero collapses all object coordinates along that axis to zero. It's usually not a good idea to do this, because such an operation cannot be undone. Mathematically speaking, the matrix cannot be inverted, and inverse matrices are required for certain lighting operations (see Chapter 5). Sometimes collapsing coordinates does make sense; the calculation of shadows on a planar surface is one such application (see "Shadows" in Chapter 14). In general, if a coordinate system is to be collapsed, the projection matrix should be used, rather than the modelview matrix.

[/indent]
A Modeling Transformation Code Example
Example 3-2 is a portion of a program that renders a triangle four times, as shown in Figure 3-8. These are the four transformed triangles:

• A solid wireframe triangle is drawn with no modeling transformation.
• The same triangle is drawn again, but with a dashed line stipple, and translated (to the left—along the negative x-axis).
• A triangle is drawn with a long dashed line stipple, with its height (y-axis) halved and its width (x-axis) increased by 50 percent.
• A rotated triangle, made of dotted lines, is drawn.

Figure 3-8
Modeling Transformation Example


Example 3-2 Using Modeling Transformations: model.c
glLoadIdentity(); glColor3f(1.0, 1.0, 1.0); draw_triangle(); /* solid lines */ glEnable(GL_LINE_STIPPLE); /* dashed lines */ glLineStipple(1, 0xF0F0); glLoadIdentity(); glTranslatef(-20.0, 0.0, 0.0); draw_triangle(); glLineStipple(1, 0xF00F); /*long dashed lines */ glLoadIdentity(); glScalef(1.5, 0.5, 1.0); draw_triangle(); glLineStipple(1, 0x8888); /* dotted lines */ glLoadIdentity(); glRotatef(90.0, 0.0, 0.0, 1.0); draw_triangle(); glDisable(GL_LINE_STIPPLE); Note the use of glLoadIdentity() to isolate the effects of modeling transformations; initializing the matrix values prevents successive transformations from having a cumulative effect. Even though using glLoadIdentity() repeatedly has the desired effect, it may be inefficient, because you may have to respecify viewing or modeling transformations. (See "Manipulating the Matrix Stacks" for a better way to isolate transformations.)

[indent] Note - Sometimes, programmers who want a continuously rotating object attempt to achieve this by repeatedly applying a rotation matrix that has small values. The problem with this technique is that because of round-off errors, the product of thousands of tiny rotations gradually drifts away from the value you really want (it might even become something that isn't a rotation). Instead of using this technique, increment the angle and issue a new rotation command with the new angle at each update step.

[/indent]
Nate Robins' Transformation Tutorial
If you have downloaded Nate Robins' suite of tutorial programs, this is an opportune time to run the transformation tutorial. (For information on how and where to download these programs, see "Nate Robins' OpenGL Tutors.") With this tutorial, you can experiment with the effects of rotation, translation, and scaling.


Viewing Transformations
A viewing transformation changes the position and orientation of the viewpoint. If you recall the camera analogy, the viewing transformation positions the camera tripod, pointing the camera toward the model. Just as you move the camera to some position and rotate it until it points in the desired direction, viewing transformations are generally composed of translations and rotations. Also remember that to achieve a certain scene composition in the final image or photograph, you can either move the camera or move all the objects in the opposite direction. Thus, a modeling transformation that rotates an object counterclockwise is equivalent to a viewing transformation that rotates the camera clockwise, for example. Finally, keep in mind that the viewing transformation commands must be called before any modeling transformations are performed, so that the modeling transformations take effect on the objects first.

You can manufacture a viewing transformation in any of several ways, as described next. You can also choose to use the default location and orientation of the viewpoint, which is at the origin, looking down the negative z-axis.

• Use one or more modeling transformation commands (that is, glTranslate*() and glRotate*()). You can think of the effect of these transformations as moving the camera position or as moving all the objects in the world, relative to a stationary camera.
• Use the Utility Library routine gluLookAt() to define a line of sight. This routine encapsulates a series of rotation and translation commands.
• Create your own utility routine to encapsulate rotations and translations. Some applications might require custom routines that allow you to specify the viewing transformation in a convenient way. For example, you might want to specify the roll, pitch, and heading rotation angles of a plane in flight, or you might want to specify a transformation in terms of polar coordinates for a camera that's orbiting around an object.

Using glTranslate*() and glRotate*()
When you use modeling transformation commands to emulate viewing transformations, you're trying to move the viewpoint in a desired way while keeping the objects in the world stationary. Since the viewpoint is initially located at the origin and since objects are often most easily constructed there as well (see Figure 3-9), you generally have to perform some transformation so that the objects can be viewed. Note that, as shown in the figure, the camera initially points down the negative z-axis. (You're seeing the back of the camera.)

Figure 3-9
Object and Viewpoint at the Origin

In the simplest case, you can move the viewpoint backward, away from the objects; this has the same effect as moving the objects forward, or away from the viewpoint. Remember that, by default, forward is down the negative z-axis; if you rotate the viewpoint, forward has a different meaning. Therefore, to put five units of distance between the viewpoint and the objects by moving the viewpoint, as shown in Figure 3-10, use

glTranslatef(0.0, 0.0, -5.0); Figure 3-10
Separating the Viewpoint and the Object

This routine moves the objects in the scene –5 units along the z-axis. This is also equivalent to moving the camera +5 units along the z-axis.

Now suppose you want to view the objects from the side. Should you issue a rotate command before or after the translate command? If you're thinking in terms of a grand, fixed coordinate system, first imagine both the object and the camera at the origin. You could rotate the object first and then move it away from the camera so that the desired side is visible. You know that with the fixed coordinate system approach, commands have to be issued in the opposite order in which they should take effect, so you know that you need to write the translate command in your code first and follow it with the rotate command.

Now let's use the local coordinate system approach. In this case, think about moving the object and its local coordinate system away from the origin; then, the rotate command is carried out using the now-translated coordinate system. With this approach, commands are issued in the order in which they're applied, so once again the translate command comes first. Thus, the sequence of transformation commands to produce the desired result is

glTranslatef(0.0, 0.0, -5.0); glRotatef(90.0, 0.0, 1.0, 0.0); If you're having trouble keeping track of the effect of successive matrix multiplications, try using both the fixed and local coordinate system approaches and see whether one makes more sense to you. Note that with the fixed coordinate system, rotations always occur about the grand origin, whereas with the local coordinate system, rotations occur about the origin of the local system. You might also try using the gluLookAt() utility routine described next.


Using the gluLookAt() Utility Routine
Often, programmers construct a scene around the origin or some other convenient location and then want to look at it from an arbitrary point to get a good view of it. As its name suggests, the gluLookAt() utility routine is designed for just this purpose. It takes three sets of arguments, which specify the location of the viewpoint, define a reference point toward which the camera is aimed, and indicate which direction is up. Choose the viewpoint to yield the desired view of the scene. The reference point is typically somewhere in the middle of the scene. (If you've built your scene at the origin, the reference point is probably the origin.) It might be a little trickier to specify the correct up-vector. Again, if you've built some real-world scene at or around the origin and if you've been taking the positive y-axis to point upward, then that's your up-vector for gluLookAt(). However, if you're designing a flight simulator, up is the direction perpendicular to the plane's wings, from the plane toward the sky when the plane is right-side-up on the ground.

The gluLookAt() routine is particularly useful when you want to pan across a landscape, for instance. With a viewing volume that's symmetric in both x and y, the (eyex, eyey, eyez) point specified is always in the center of the image on the screen, so you can use a series of commands to move this point slightly, thereby panning across the scene.

void gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz);

Defines a viewing matrix and multiplies it to the right of the current matrix. The desired viewpoint is specified by eyex, eyey, and eyez. The centerx, centery, and centerz arguments specify any point along the desired line of sight, but typically they specify some point in the center of the scene being looked at. The upx, upy, and upz arguments indicate which direction is up (that is, the direction from the bottom to the top of the viewing volume).

In the default position, the camera is at the origin, is looking down the negative z-axis, and has the positive y-axis as straight up. This is the same as calling

gluLookAt(0.0, 0.0, 0.0, 0.0, 0.0, -100.0, 0.0, 1.0, 0.0); The z-value of the reference point is –100.0, but could be any negative z, because the line of sight will remain the same. In this case, you don't actually want to call gluLookAt(), because this is the default (see Figure 3-11) and you are already there. (The lines extending from the camera represent the viewing volume, which indicates its field of view.)

Figure 3-11
Default Camera Position

Figure 3-12 shows the effect of a typical gluLookAt() routine. The camera position (eyex, eyey, eyez) is at (4, 2, 1). In this case, the camera is looking right at the model, so the reference point is at (2, 4, –3). An orientation vector of (2, 2, –1) is chosen to rotate the viewpoint to this 45-degree angle.

Figure 3-12
Using gluLookAt()

Therefore, to achieve this effect, call

gluLookAt(4.0, 2.0, 1.0, 2.0, 4.0, -3.0, 2.0, 2.0, -1.0); Note that gluLookAt() is part of the Utility Library, rather than the basic OpenGL library. This isn't because it's not useful, but because it encapsulates several basic OpenGL commands—specifically, glTranslate*() and glRotate*(). To see this, imagine a camera located at an arbitrary viewpoint and oriented according to a line of sight, both as specified with gluLookAt() and a scene located at the origin. To "undo" what gluLookAt() does, you need to transform the camera so that it sits at the origin and points down the negative z-axis, the default position. A simple translate moves the camera to the origin. You can easily imagine a series of rotations about each of the three axes of a fixed coordinate system that would orient the camera so that it pointed toward negative z-values. Since OpenGL allows rotation about an arbitrary axis, you can accomplish any desired rotation of the camera with a single glRotate*() command.

[indent] Note - You can have only one active viewing transformation. You cannot try to combine the effects of two viewing transformations, any more than a camera can have two tripods. If you want to change the position of the camera, make sure you call glLoadIdentity() to erase the effects of any current viewing transformation.

[/indent]
Nate Robins' Projection Tutorial
If you have Nate Robins' suite of tutorial programs, run the projection tutorial. With this tutorial, you can see the effects of changes to the parameters of gluLookAt().

Advanced

To transform any arbitrary vector so that it's coincident with another arbitrary vector (for instance, the negative z-axis), you need to do a little mathematics. The axis about which you want to rotate is given by the cross product of the two normalized vectors. To find the angle of rotation, normalize the initial two vectors. The cosine of the desired angle between the vectors is equal to the dot product of the normalized vectors. The angle of rotation around the axis given by the cross product is always between 0 and 180 degrees. (See Appendix E for definitions of cross and dot products.)

Note that computing the angle between two normalized vectors by taking the inverse cosine of their dot product is not very accurate, especially for small angles, but it should work well enough to get you started.


Creating a Custom Utility Routine
Advanced

For some specialized applications, you might want to define your own transformation routine. Since this is rarely done and is a fairly advanced topic, it's left mostly as an exercise for the reader. The following exercises suggest two custom viewing transformations that might be useful.

Try This

There are plenty of examples of GLSL shaders available in print or on the web. In this article, rather than showing an a la carte example, we will go through the creation of a shader library. Since the two most likely requirements in and OpenGL program are texturing and lighting the scene, those will be the two things we'll be doing. Specifically we'll be covering Texturing, and as an extension Multi-Texturing, and Per-pixel Lighting for Directional, Point, and Spot Lights.

There a couple assumptions that are made in this article. First, it is assumed that you already know how to properly compile, link and use a shader in OpenGL. Second, it is assumed that you do not need an explanation on the Phong Lighting Model. The references for this article cover those things so look to those if you want a thorough explanation of either of those things.

First thing we're going to do is create the Texturing library. This library is fairly simple, and admittedly overkill, but it provides a basis for going to the more complex Lighting library.

A Texturing Example

The vertex shader used in this example isn't very exciting so lets just get it out of the way.

/**
 * \file Texturing.vert
 */
void main()
{
    gl_TexCoord[0] = gl_MultiTexCoord0;
   
    gl_Position = ftransform();
}

Now its time to write our Texturing library function.

There are six options for how to texture a geometry in OpenGL

• GL_REPLACE
• GL_MODULATE
• GL_DECAL
• GL_BLEND
• GL_ADD
• GL_COMBINE

/**
 * \file Texturing.frag
 */
const int REPLACE  = 0;
const int MODULATE = 1;
const int DECAL    = 2;
const int BLEND    = 3;
const int ADD      = 4;
const int COMBINE  = 5;

void applyTexture2D(in sampler2D texUnit, in int type, in int index, inout vec4 color)
{
    // Read from the texture
    vec4 texture = texture2D(texUnit, gl_TexCoord[index].st);
   
    if (type == REPLACE)
    {
        color = texture;
    }
    else if (type == MODULATE)
    {
        color *= texture;
    }
    else if (type == DECAL)
    {
        vec3 temp = mix(color.rgb, texture.rgb, texture.a);
       
        color = vec4(temp, color.a);
    }
    else if (type == BLEND)
    {
        vec3 temp = mix(color.rgb, gl_TextureEnvColor[index].rgb, texture.rgb);
       
        color = vec4(temp, color.a * texture.a);
    }
    else if (type == ADD)
    {
        color.rgb += texture.rgb;
        color.a   *= texture.a;
       
        color = clamp(color, 0.0, 1.0);
    }
    else
    {
        color = clamp(texture * color, 0.0, 1.0);
    }
}

So now we have a function that will replicate OpenGL's texturing facility. Now we just need to create the other fragment shader that uses this function.

/**
 * SingleTexture.frag
 */

void applyTexture2D(in sampler2D texUnit, in int type, in int index, inout vec4 color);

uniform sampler2D TexUnit0;
uniform int TexturingType;

void main()
{
    vec4 color = gl_Color;
   
    applyTexture2D(TexUnit0, TexturingType, 0, color);
   
    gl_FragColor = color;
}

Other than that the shader is fairly straightforward. There are two uniforms, the sampler2D which just points to the texture unit we wish to use, and the integer TexturingType which denotes what OpenGL texturing to emulate. The main function just takes the color of the vertex and passes that along with TexUnit0, TexturingType and the index of the texture coordinates to the function. The result of which is used as the fragment color.

Its worth noting that OpenGL does not provide a mechanism to query what the environment of the texture is (minus the texture environment color, gl_TextureEnvColor[]). So if you send via glTexEnv that you want to use GL_ADD, there is no way inside the shader to determine that is being requested by the program.

A Multi-Texturing Example

Next up is Multi-Texturing. There is no longer a need to use any OpenGL extensions to do multi-texturing, all of it can be done within a fragment shader. You can blend together as many textures as your video card supports (call glGetIntegerv with GL_MAX_TEXTURE_UNITS to determine that information), but in our case we'll only be doing two. No changes are required to our Texturing library or the vertex shader we we're using, and we'll need to add three lines of code to our fragment shader to get two textures blended together.

/**
 * \file MultiTexture.frag
 */
uniform sampler2D TexUnit0;
uniform int TexturingType0;
uniform sampler2D TexUnit1;
uniform int TexturingType1;

void main()
{
    vec4 color = gl_Color;
   
    applyTexture2D(TexUnit0, TexturingType0, 0, color);
    applyTexture2D(TexUnit1, TexturingType1, 0, color);
   
    gl_FragColor = color;
}

A One-Sided Per-Pixel Lighting Example

This example is fairly complicated so the discussion is broken up into parts. The first part will be the vertex shader. Since we're doing everything in the pixel shader, the vertex shader is fairly simple.

/**
 * \file Lighting.vert
 */
varying vec3 normal;
varying vec3 vertex;

void main()
{
    // Calculate the normal
    normal = normalize(gl_NormalMatrix * gl_Normal);
   
    // Transform the vertex position to eye space
    vertex = vec3(gl_ModelViewMatrix * gl_Vertex);
       
    gl_Position = ftransform();
}

/**
 * \file OneSidedLighting.frag
 */
void calculateLighting(in int numLights, in vec3 N, in vec3 V, in float shininess,
                       inout vec4 ambient, inout vec4 diffuse, inout vec4 specular);

varying vec3 normal;
varying vec3 vertex;

void main()
{
    // Normalize the normal. A varying variable CANNOT
    // be modified by a fragment shader. So a new variable
    // needs to be created.
    vec3 n = normalize(normal);
   
    vec4 ambient  = vec4(0.0);
    vec4 diffuse  = vec4(0.0);
    vec4 specular = vec4(0.0);

    // In this case the built in uniform gl_MaxLights is used
    // to denote the number of lights. A better option may be passing
    // in the number of lights as a uniform or replacing the current
    // value with a smaller value.
    calculateLighting(gl_MaxLights, n, vertex, gl_FrontMaterial.shininess,
                      ambient, diffuse, specular);
   
    vec4 color = gl_FrontLightModelProduct.sceneColor  +
                 (ambient  * gl_FrontMaterial.ambient) +
                 (diffuse  * gl_FrontMaterial.diffuse) +
                 (specular * gl_FrontMaterial.specular);
                
    color = clamp(color, 0.0, 1.0);
   
    gl_FragColor = color;
}

The Phong Lighting Shader

This library is A LOT more complicated than our texturing library. There are a couple of auxillary functions used by this library to simplify the code. The first of which determines whether a light is enabled.

/**
 * \file PhongLighting.frag
 */
const vec4 AMBIENT_BLACK = vec4(0.0, 0.0, 0.0, 1.0);
const vec4 DEFAULT_BLACK = vec4(0.0, 0.0, 0.0, 0.0);

bool isLightEnabled(in int i)
{
    // A separate variable is used to get
    // rid of a linker error.
    bool enabled = true;
   
    // If all the colors of the Light are set
    // to BLACK then we know we don't need to bother
    // doing a lighting calculation on it.
    if ((gl_LightSource[i].ambient  == AMBIENT_BLACK) &&
        (gl_LightSource[i].diffuse  == DEFAULT_BLACK) &&
        (gl_LightSource[i].specular == DEFAULT_BLACK))
        enabled = false;
       
    return(enabled);
}

/**
 * \file PhongLighting.frag
 */
void calculateLighting(in int numLights, in vec3 N, in vec3 V, in float shininess,
                       inout vec4 ambient, inout vec4 diffuse, inout vec4 specular)
{
    // Just loop through each light, and if its enabled add
    // its contributions to the color of the pixel.
    for (int i = 0; i < numLights; i++)
    {
        if (isLightEnabled(i))
        {
            if (gl_LightSource[i].position.w == 0.0)
                directionalLight(i, N, shininess, ambient, diffuse, specular);
            else if (gl_LightSource[i].spotCutoff == 180.0)
                pointLight(i, N, V, shininess, ambient, diffuse, specular);
            else
                 spotLight(i, N, V, shininess, ambient, diffuse, specular);
        }
    }
}

/**
 * \file PhongLighting.frag
 */
float calculateAttenuation(in int i, in float dist)
{
    return(1.0 / (gl_LightSource[i].constantAttenuation +
                  gl_LightSource[i].linearAttenuation * dist +
                  gl_LightSource[i].quadraticAttenuation * dist * dist));
}

void directionalLight(in int i, in vec3 N, in float shininess,
                      inout vec4 ambient, inout vec4 diffuse, inout vec4 specular)
{
    vec3 L = normalize(gl_LightSource[i].position.xyz);
   
    float nDotL = dot(N, L);
   
    if (nDotL > 0.0)
    {   
        vec3 H = gl_LightSource[i].halfVector.xyz;
       
        float pf = pow(max(dot(N,H), 0.0), shininess);

        diffuse  += gl_LightSource[i].diffuse  * nDotL;
        specular += gl_LightSource[i].specular * pf;
    }
   
    ambient  += gl_LightSource[i].ambient;
}

void pointLight(in int i, in vec3 N, in vec3 V, in float shininess,
                inout vec4 ambient, inout vec4 diffuse, inout vec4 specular)
{
    vec3 D = gl_LightSource[i].position.xyz - V;
    vec3 L = normalize(D);

    float dist = length(D);
    float attenuation = calculateAttenuation(i, dist);

    float nDotL = dot(N,L);

    if (nDotL > 0.0)
    {   
        vec3 E = normalize(-V);
        vec3 R = reflect(-L, N);
       
        float pf = pow(max(dot(R,E), 0.0), shininess);

        diffuse  += gl_LightSource[i].diffuse  * attenuation * nDotL;
        specular += gl_LightSource[i].specular * attenuation * pf;
    }
   
    ambient  += gl_LightSource[i].ambient * attenuation;
}

void spotLight(in int i, in vec3 N, in vec3 V, in float shininess,
               inout vec4 ambient, inout vec4 diffuse, inout vec4 specular)
{
    vec3 D = gl_LightSource[i].position.xyz - V;
    vec3 L = normalize(D);

    float dist = length(D);
    float attenuation = calculateAttenuation(i, dist);

    float nDotL = dot(N,L);

    if (nDotL > 0.0)
    {   
        float spotEffect = dot(normalize(gl_LightSource[i].spotDirection), -L);
       
        if (spotEffect > gl_LightSource[i].spotCosCutoff)
        {
            attenuation *=  pow(spotEffect, gl_LightSource[i].spotExponent);

            vec3 E = normalize(-V);
            vec3 R = reflect(-L, N);
       
            float pf = pow(max(dot(R,E), 0.0), shininess);

            diffuse  += gl_LightSource[i].diffuse  * attenuation * nDotL;
            specular += gl_LightSource[i].specular * attenuation * pf;
        }
    }
   
    ambient  += gl_LightSource[i].ambient * attenuation;
}

Now we have a library that handles per-pixel Phong Lighting. So lets take it a step further.

A Two-Sided Per-Pixel Lighting Example

OpenGL by default does two sided lighting. This means that lighting is calculated for the front and back faces of a polygon. This is really useful for something that is lit from the back, an everyday example of this is a lamp shade.

The only thing that needs to be modified to achieve this is to modify our fragment shader's main function.

/**
 * TwoSidedLighting.frag
 */
void main()
{
    // Normalize the normal. A varying variable CANNOT
    // be modified by a fragment shader. So a new variable
    // needs to be created.
    vec3 n = normalize(normal);
   
    vec4 ambient, diffuse, specular, color;

    // Initialize the contributions.
    ambient  = vec4(0.0);
    diffuse  = vec4(0.0);
    specular = vec4(0.0);
   
    // In this case the built in uniform gl_MaxLights is used
    // to denote the number of lights. A better option may be passing
    // in the number of lights as a uniform or replacing the current
    // value with a smaller value.
    calculateLighting(gl_MaxLights, n, vertex, gl_FrontMaterial.shininess,
                      ambient, diffuse, specular);
   
    color  = gl_FrontLightModelProduct.sceneColor  +
             (ambient  * gl_FrontMaterial.ambient) +
             (diffuse  * gl_FrontMaterial.diffuse) +
             (specular * gl_FrontMaterial.specular);

    // Re-initialize the contributions for the back
    // pass over the lights
    ambient  = vec4(0.0);
    diffuse  = vec4(0.0);
    specular = vec4(0.0);
          
    // Now caculate the back contribution. All that needs to be
    // done is to flip the normal.
    calculateLighting(gl_MaxLights, -n, vertex, gl_BackMaterial.shininess,
                      ambient, diffuse, specular);

    color += gl_BackLightModelProduct.sceneColor  +
             (ambient  * gl_BackMaterial.ambient) +
             (diffuse  * gl_BackMaterial.diffuse) +
             (specular * gl_BackMaterial.specular);

    color = clamp(color, 0.0, 1.0);
   
    gl_FragColor = color;
}

Conclusion

Hopefully this article will give you an idea of how to write shader libraries. With the enclosed libraries you could combine Lighting and Texturing into a single pass. You could change the lighting model from Phong to something else, such as Toon Shading. The possibilities with GLSL are enormous.

Just remember if you come up with something really cool to share with the rest of us. Thanks for reading.

References

GLSL Tutorial - Lighthouse3D August 2007
Lighting with GLSL : Phong Model - oZone3D.net August 2007
Per Fragment Lighting - ClockworkCoders August 2007
Rost, Randi J. OpenGL Shading Language 1st ed. Boston : Addison-Wesley, 2004

Useful Links

ShaderGen - Fixed Functionality Shader Generation Tool (used to emulate OpenGL texturing)
ShaderDesigner - A GLSL IDE available in the OpenGL SDK (used for development of the enclosed shaders)

glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, img, 0);

GLuint maxbuffers;
glGetIntergeri(GL_MAX_COLOR_ATTACHMENTS, &maxbuffers);

glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, img, 0);

glBindFrameBuffer(GL_FRAMEBUFFER_EXT, fbo);
glPushAttrib(GL_VIEWPORT_BIT | GL_COLOR_BUFFER_BIT);
glViewport(0,0,width, height);

// Set the render target
glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);

// Render as normal here
// output goes to the FBO and it’s attached buffers

glPopAttrib();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

GLuint maxbuffers;
glGetIntergeri(GL_MAX_DRAW_BUFFERS, &maxbuffers);

GLenum buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT };
glDrawBuffers(2, buffers);

GLenum buffers[] = { GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT0_EXT };
glDrawBuffers(2, buffers);

#version 110



void main()

{

	gl_FragData[0] = vec4(0.0, 1.0, 0.0);

	gl_FragData[1] = vec4(0.0, 0.0, 1.0);

}

GLenum mrt[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT }
glDrawBuffers(2, mrt);

#version 110

void main(void)
{
	gl_FragData[0] = vec4(gl_Color.r, gl_Color.g,gl_Color.b,1.0);
	gl_FragData[1] = vec4(gl_Color.r/2.0, gl_Color.g/2.0,gl_Color.b/2.0,1.0);
}

• Attach a colour Renderbuffer to the FBO
• Attach a texture to the FBO

• Currently you can’t have a stencil attachment. There is an extension in the works to allow for a texture format which would allow depth-stencil textures and thus render to stencil, however as of yet there is a lack of support for it.
• Don’t constantly make the destroy FBOs, instead generate what you need at load/setup time and reuse them during the program as required.
• Avoid modifying the texture you have rendered to via any glTexImage and related calls. Doing so can and most probably will hurt your performance.

#define GL_VERSION_1_1                    1

• Explain in greater detail why you need to take some extra steps to use anything beyond OpenGL 1.1.
• Explain OpenGL's extension mechanism, and how it can be used to access OpenGL 1.2 and 1.3 functionality.
• Give you an overview of the new options available in OpenGL 1.2 and 1.3, as well as a look at some of the most useful extensions.
• Give you some tips for using extensions while ensuring that your game will run well on a wide range of systems.
• Provide a demo showing you how to use the techniques described.

• Headers and libraries. As I mentioned in the introduction, the latest version of the OpenGL headers and libraries available from Microsoft correspond to version 1.1. If you look around on the Internet, you may come across another OpenGL implementation for Windows created by Silicon Graphics. SGI's implementation also corresponds to OpenGL 1.1. Unfortunately, this implementation is no longer supported by SGI. In addition, the Microsoft implementation is based upon it, so you really gain nothing by using it. Where does that leave us?
  
  Well, there is reason to hope that someone will release up to date libraries. Although, to my knowledge, no one has committed to doing so, several parties have discussed it. Microsoft is the obvious candidate, and despite years of promising and not delivering, it appears that they have taken an interest in the recently proposed OpenGL 2.0. Whether or not that interest will lead to action remains to be seen, but given the large number of graphics workstations running Windows NT and Windows 2000, it's not beyond the realm of possibility.
  
  Besides Microsoft, there has apparently been discussion among the members of OpenGL's Architectural Review Board (ARB) to provide their own implementation of the headers and libraries. At present, though, this is still in the discussion stage, so it may be a while before we see anything come of it.
• The runtime. Most versions of Windows (the first release of Windows 95 being the exception) come with a 1.1 runtime. Fortunately, this isn't really as important as the other elements. All that the runtime does is guarantee a baseline level of functionality, and allow you to interface with the ICD.
• The ICD. This is the one area where you're okay. Most hardware vendors (including NVIDIA and ATI) have been keeping up with the latest OpenGL standard. For them to be able to advertise that their drivers are compliant with the OpenGL 1.3 standard, they have to support everything included in the 1.3 specification (though not necessarily in hardware). The cool thing about this is that the ICD contains the code to do everything in newer versions of OpenGL, and we can take advantage of that.

PREFIX_extension_name

Caution: Some extensions share a name, but have a different prefix. These extensions are generally not interchangeable, as they may use entirely different semantics. For example, ARB_texture_env_combine is not the same thing as EXT_texture_env_combine. Rather than making assumptions, be sure to consult the extension specifications when you're unsure.

Some extensions may define more than one name string. This would be the case if the extension provided both core OpenGL functionality and functionality specific to the windows system.

Extensions don't need to define both functions and enumerants (though many do), but they usually include at least one of the two. The few cases where that's not true is when existing functions or enumerants are combined in new ways.

Extensions that are promoted to be a part of the core OpenGL specification may be removed from the extension registry. To obtain information about these, you'll have to refer to the latest OpenGL specification. [4]

• determine whether or not the extension is supported
• obtain the entry point for the any of the extension's functions that you want to use
• define any enumerants you're going to use.

Caution: Before checking for extension availability and obtaining pointers to functions, you MUST have a current rendering context. In addition, the entry points are specific to each rendering context, so if you're using more than one, you'll have to obtain a separate entry point for each.

char* extensionsList = (char*) glGetString(GL_EXTENSIONS);

I'm casting the value returned by glGetString() because the function actually returns an array of unsigned chars. Since most of the string manipulation functions I'll be using require signed chars, I do the cast once now instead of doing it many times later.

strstr("GL_EXT_texture_env", extensionsList);

void (APIENTRY * pglCopyTexSubImage3DEXT) (GLenum, GLint, GLint,
    GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;

Update 4/24/03: For the book, and initially here, I used the function name (i.e. glCopyTexSubImage3DEXT) as the pointer name. A reader pointed out to me that on a number of operating systems (e.g. Linux) this can cause serious problems, so it should be avoided. Thanks, Ian!

PROC wglGetProcAddress( LPCSTR  lpszProcName );

pglCopyTexSubImage3DEXT  =
    (void (APIENTRY *) (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
    wglGetProcAddress("glCopyTexSubImage3DEXT");

PFNGLCOPYTEXSUBIMAGE3DEXTPROC pglCopyTexSubImage3DEXT = NULL;
pglCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC) wglGetProcAddress("glCopyTexSubImage3DEXT");

#define GL_TEXTURE_LOD_BIAS_EXT    0x8501

const char* wglGetExtensionsStringARB(HDC hdc);

Caution: Normally, it's good practice to check for an extension by examining the buffer returned by glGetString() before trying to obtain function entry points. However, it's not strictly necessary to do so. If you try to get the entry point for a non-existant function, wglGetProcAddress() will return NULL, and you can simply test for that. The reason I'm mentioning this is because to use wglGetExtensionsStringARB(), that's exactly what you have to do. It appears that with most ICDs, the name string for this extension, WGL_ARB_extensions_string, doesn't appear in the buffer returned by glGetString(). Instead, it is included in the buffer returned by wglGetExtensionsStringARB()! Go figure.

Some WGL extension string names included in the buffer returned by wglGetExtensionsStringARB() may also appear in the buffer returned by glGetString(). This is due to the fact that those extensions existed before the creation of the ARB_extensions_string extension, and so their name strings appear in both places to avoid breaking existing software.

Sometimes, an extension that has been added to the OpenGL 1.2 or 1.3 core specification will undergo slight changes, causing the semantics and/or behavior to be somewhat different from what is documented in the extension's specification. You should check the latest OpenGL specification to find out about these changes.

• EXT_blend_color allows you to specify a constant color which is used to define blend weighting factors.
• SGI_color_matrix introduces a new matrix stack to the pixel pipeline, causing the RGBA components of each pixel to be multiplied by a 4x4 matrix.
• EXT_blend_subtract gives you two ways to use the difference between two blended surfaces (rather than the sum).
• EXT_blend_minmax lets you keep either the minimum or maximum color components of the source and destination colors.

• ARB_pixel_format augments the standard pixel format functions (i.e. DescribePixelFormat, ChoosePixelFormat, SetPixelFormat, and GetPixelFormat), giving you more control over which pixel format is used. The functions allow you to query individual pixel format attributes, and allow for the addition of new attributes that are not included in the pixel format descriptor structure. Many other WGL extensions are dependent on this extension.
• ARB_pbuffer adds pixel buffers, which are off-screen (non-visible) rendering buffers. On most cards, these buffers are in video memory, and the operation is hardware accelerated. They are often useful for creating dynamic textures, especially when used with the render texture extension.
• ARB_render_texture depends on the pbuffer extension. It is specifically designed to provide buffers that can be rendered to and be used as texture data. These buffers are the perfect solution for dynamic texturing.
• ARB_buffer_region allows you to save portions of the color, depth, or stencil buffers to either system or video memory. This region can then be quickly restored to the OpenGL window.

There are times when a vendor-specific extension can be completely replaced by an EXT or ARB extension. In this case, the latter should always be favored.

Figure 1: Basic lightmapping (click to enlarge)

bool InitializeExtensions()
{
  if (CheckExtension("GL_ARB_multitexture"))
  {
    glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FARBPROC)
        wglGetProcAddress("glMultiTexCoord2fARB");
    glActiveTexture = (PFNGLCLIENTACTIVETEXTUREARBPROC)
        wglGetProcAddress("glActiveTextureARB");
    glClientActiveTexture = (PFNGLACTIVETEXTUREARBPROC)
        wglGetProcAddress("glClientActiveTextureARB");
  }
  else
  {
    MessageBox(g_hwnd, "This program requires multitexturing, which "
      "is not supported by your hardware", "ERROR", MB_OK);
    return false;
  }

  if (CheckExtension("GL_EXT_point_parameters"))
  {
    glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)
        wglGetProcAddress("glPointParameterfvEXT");
  }

  if (CheckExtension("WGL_EXT_swap_control"))
  {
    wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)
        wglGetProcAddress("wglSwapIntervalEXT");
  }

  if (!CheckExtension("GL_EXT_bgra"))
  {
    MessageBox(g_hwnd, "This program requires the BGRA pixel storage"
      "format which is not supported by your hardware", "ERROR", MB_OK);
    return false;
  }

  g_useTextureCompression =
      CheckExtension("GL_ARB_texture_compression");
  g_useEdgeClamp = CheckExtension("GL_EXT_texture_edge_clamp");
  g_useSGISMipmapGeneration =
      CheckExtension("GL_SGIS_generate_mipmap");

  return true;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
  // TODO: Modify the Window class or styles here by modifying
  //  the CREATESTRUCT cs

  cs.cx=400;
  cs.cy=400;

  return CFrameWnd::PreCreateWindow(cs);
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
  // TODO: Modify the Window class or styles here by modifying
  //  the CREATESTRUCT cs

  cs.cx=400;
  cs.cy=400;

  return CFrameWnd::PreCreateWindow(cs);
}
BOOL CMainFrame::OnQueryNewPalette() 
{
  // TODO: Add your message handler code here and/or call default
  CView *pView=GetActiveView();
  pView->Invalidate(FALSE);
  return CFrameWnd::OnQueryNewPalette();
}
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
  // TODO: Modify the Window class or styles here by modifying
  // the CREATESTRUCT cs
  
  cs.cx=400;
  cs.cy=400;

  return CFrameWnd::PreCreateWindow(cs);
}

int CMfc_cubeView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
  if (CView::OnCreate(lpCreateStruct) == -1)
    return -1;
  
  // TODO: Add your specialized creation code here
  PIXELFORMATDESCRIPTOR pfd=
  {
    sizeof(PIXELFORMATDESCRIPTOR),
      1,
      PFD_DRAW_TO_WINDOW|
      PFD_SUPPORT_OPENGL|
      PFD_DOUBLEBUFFER,
      PFD_TYPE_RGBA,
      24,          //24-bit color
      0,0,0,0,0,0,
      0,0,0,0,0,0,0,
      32,          //32 bit depth buffer
      0,0,
      PFD_MAIN_PLANE,    //Main layer type
      0,
      0,0,0
  };
  CClientDC clientDC(this);
  /*
  ChoosePixelFormat
  Requests a pixel-format index for a pixel format that most closely
  matches the format requested.   This function's two arguments are a
  handle to the DC for which to select the pixel format and the
  address of the PIXELFORMATDESCRIPTOR structure that holds the attributes
  of the requested pixel format
  */
  int pixelFormat =ChoosePixelFormat(clientDC.m_hDC,&pfd);
  BOOL success =   SetPixelFormat(clientDC.m_hDC,pixelFormat,&pfd);
  /*
  DescribePixelFormat
  Fills a PIXELFORMATDESCRIPTOR  structure with information about the given
  pixel format.  This function's four arguments are a handle to the DC, the 
  pixel index to examine, and the size and address of PIXELFORMATDESCRIPTOR structure.
  */
  DescribePixelFormat(clientDC.m_hDC,pixelFormat, sizeof(pfd),&pfd);

  if (pfd.dwFlags & PFD_NEED_PALETTE)
      SetupLogicalPalette();

  /*
  wglCreateContext
  Creates a rendering context compatible with the given DC.
  */
  m_hRC=wglCreateContext(clientDC.m_hDC);
  /*
  wglMakeCurrent
  Makes a rendering context current, which binds the rendering
  context to the given DC.  This function's two arguments
  are a handle to a DC and the handle to the rendering context.
  */
  wglMakeCurrent(clientDC.m_hDC,m_hRC);

  //Texture Mapping
  //Once you have your DIB loaded and its color tables created, you can
  // actually start thinking about your texture mapping
  //GL_TEXTURE_2D equates to a two-dimensional texture
  //GL_CLAMP for a single image
  //GL_REPEAT for a repeating pattern
  //GL_TEXTURE_MAG_FILTER determines how a texture is magnified when
  // the destination is larger than the texture.
  //GL_TEXTURE_MIN_FILTER determines how a texture is reduced
  //glTexEnvi set the texturing environment

  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
  
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);

  glEnable(GL_DEPTH);
  glEnable(GL_TEXTURE_2D);

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

  wglMakeCurrent(clientDC.m_hDC,NULL);

  /* CDib is a class used to read Device Independant Bitmaps */
  m_pDib = new CDib("snake.BMP");
  CreateColorTables(m_pDib);
  SetupColorTables();
  /* The timer determines the rendering refresh rate in milliseconds*/
  SetTimer(1,1,0);
  return 0;
}

void CMfc_cubeView::OnDestroy() 
{
  CView::OnDestroy();
  
  // TODO: Add your message handler code here
  KillTimer(1);
  delete m_pDib;
  /*Frees the Rendering Context.  Cleanup of resources*/
  wglDeleteContext(m_hRC);
  if (m_hPalette)
 	DeleteObject(m_hPalette);

}

BOOL CMfc_cubeView::PreCreateWindow(CREATESTRUCT& cs)
{
  // TODO: Modify the Window class or styles here by modifying
  // the CREATESTRUCT cs
  cs.style |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;

  return CView::PreCreateWindow(cs);
}

void CMfc_cubeView::OnDraw(CDC* pDC)
{
  CMfc_cubeDoc* pDoc = GetDocument();
  ASSERT_VALID(pDoc);

  // TODO: add draw code for native data here
  if (m_hPalette)
  {
    SelectPalette(pDC->m_hDC,m_hPalette, FALSE);
    RealizePalette(pDC->m_hDC);
  }
  wglMakeCurrent(pDC->m_hDC,m_hRC);
  DrawWithOpenGL();
  SwapBuffers(pDC->m_hDC);
  wglMakeCurrent(pDC->m_hDC,NULL);
}

void CMfc_cubeView::OnSize(UINT nType, int cx, int cy) 
{
  CView::OnSize(nType, cx, cy);
  
  // TODO: Add your message handler code here
  CClientDC clientDC(this);
  wglMakeCurrent(clientDC.m_hDC,m_hRC);
  glViewport(0,0,cx,cy);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glFrustum(-1.0,1.0,-1.0,1.0,2.0,9.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  GLfloat light0Ambient[]={0.0f,0.0f,0.0f,1.0f};
  GLfloat light0Diffuse[]={1.0f,1.0f,1.0f,1.0f};
  GLfloat light0Position[]={0.0f,0.0f,0.0f,1.0f};

  glLightfv(GL_LIGHT0,GL_AMBIENT,light0Ambient);
  glLightfv(GL_LIGHT0,GL_DIFFUSE, light0Diffuse);
  glLightfv(GL_LIGHT0,GL_POSITION,light0Position);

  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);

  glTranslatef(0.0f,0.0f,-6.0f);
  wglMakeCurrent(NULL,NULL);
}

void CMfc_cubeView::OnTimer(UINT nIDEvent) 
{
  // TODO: Add your message handler code here and/or call default

  if (m_cube_animate==1 )
  {
    m_cube_spin+=2;
  }
  if (m_icosa_animate==1)
  {
    m_icosa_spin+=2;
  }
  Invalidate(FALSE);

  CView::OnTimer(nIDEvent);
}

void CMfc_cubeView::DrawWithOpenGL()
{
  glShadeModel(GL_SMOOTH);
  glEnable(GL_DEPTH_TEST);
  glClearColor(0.0f,0.0f,0.0f,1.0f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  AnimateCube();
}

void CMfc_cubeView::AnimateCube()
{
  GLfloat glfMaterialColor[]={0.2f,0.8f,0.5f,1.0f};
  GLvoid* pTextureBits = (GLvoid*) m_pDib->GetDibBitsPtr();
  GLint width = m_pDib->GetDibWidth();
  GLint height = m_pDib->GetDibHeight();

  glPushMatrix();
  glTexImage2D(GL_TEXTURE_2D,0,3,width,height,0,GL_COLOR_INDEX,
           	GL_UNSIGNED_BYTE,pTextureBits);
  glClear(GL_COLOR_INDEX|GL_DEPTH_BUFFER_BIT);

  glRotatef(m_cube_spin,1.0,1.0,1.0);
  glScalef (0.5,0.5,0.5);   /* modeling transformation */
    
  //glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,glfMaterialColor);

  glBegin(GL_POLYGON);
  //glNormal3f(0.0f,0.0f,1.0f);
  //vertice 1
  glTexCoord2f(0.0f,1.0f);
  glVertex3f(1.0f,1.0f,1.0f);
  //vertice 2
  glTexCoord2f(0.0f,0.0f);
  glVertex3f(-1.0f,1.0f,1.0f);
  //vertice 3
  glTexCoord2f(1.0f,0.0f);
  glVertex3f(-1.0f,-1.0f,1.0f);
  //vertice 4
  glTexCoord2f(1.0f,1.0f);
  glVertex3f(1.0f,-1.0f,1.0f);
  glEnd();
    
  glBegin(GL_POLYGON);
  //glNormal3f(0.0f,0.0f,-1.0f);
  //vertice 1
  glTexCoord2f(0.0f,1.0f);
  glVertex3f(1.0f,1.0f,-1.0f);
  //vertice 2
  glTexCoord2f(0.0f,0.0f);
  glVertex3f(1.0f,-1.0f,-1.0f);
  //vertice 3
  glTexCoord2f(1.0f,0.0f);
  glVertex3f(-1.0f,-1.0f,-1.0f);
  //vertice 4
  glTexCoord2f(0.0f,0.0f);
  glVertex3f(-1.0f,1.0f,-1.0f);
  glEnd();

  glBegin(GL_POLYGON);
  //glNormal3f(-1.0f,0.0f,0.0f);
  //vertice 1
  glTexCoord2f(0.0f,1.0f);
  glVertex3f(-1.0f,1.0f,1.0f);
  //vertice 2
  glTexCoord2f(0.0f,0.0f);
  glVertex3f(-1.0f,1.0f,-1.0f);
  //vertice 3
  glTexCoord2f(1.0f,0.0f);
  glVertex3f(-1.0f,-1.0f,-1.0f);
  //vertice 4
  glTexCoord2f(1.0f,1.0f);
  glVertex3f(-1.0f,-1.0f,1.0f);
  glEnd();

  glBegin(GL_POLYGON);
  //glNormal3f(1.0f,0.0f,0.0f);
  //vertice 1
  glTexCoord2f(0.0f,1.0f);
  glVertex3f(1.0f,1.0f,1.0f);
  //vertice 2
  glTexCoord2f(0.0f,0.0f);
  glVertex3f(1.0f,-1.0f,1.0f);
  //vertice 3
  glTexCoord2f(1.0f,0.0f);
  glVertex3f(1.0f,-1.0f,-1.0f);
  //vertice 4
  glTexCoord2f(1.0f,1.0f);
  glVertex3f(1.0f,1.0f,-1.0f);
  glEnd();

  glBegin(GL_POLYGON);
  //glNormal3f(0.0f,1.0f,0.0f);
  //vertice 1
  glTexCoord2f(0.0f,1.0f);
  glVertex3f(-1.0f,1.0f,-1.0f);
  //vertice 2
  glTexCoord2f(0.0f,0.0f);
  glVertex3f(-1.0f,1.0f,1.0f);
  //vertice 3
  glTexCoord2f(1.0f,0.0f);
  glVertex3f(1.0f,1.0f,1.0f);
  //vertice 4
  glTexCoord2f(1.0f,1.0f);
  glVertex3f(1.0f,1.0f,-1.0f);
  glEnd();

  glBegin(GL_POLYGON);
  //glNormal3f(0.0f,-1.0f,0.0f);
  //vertice 1
  glTexCoord2f(0.0f,1.0f);
  glVertex3f(-1.0f,-1.0f,-1.0f);
  //vertice 2
  glTexCoord2f(0.0f,0.0f);
  glVertex3f(1.0f,-1.0f,-1.0f);
  //vertice 3
  glTexCoord2f(1.0f,0.0f);
  glVertex3f(1.0f,-1.0f,1.0f);
  //vertice 4
  glTexCoord2f(1.0f,1.0f);
  glVertex3f(-1.0f,-1.0f,1.0f);
  glEnd();

  glPopMatrix();
}

void CMfc_cubeView::CreateColorTables(CDib *pDib)
{
  LPRGBQUAD pColorTable = pDib->GetDibRGBTablePtr();
  for(UINT i=0; i<256; ++i)
  {
    m_red[i]=(GLfloat) pColorTable[i].rgbRed/255;
    m_green[i]=(GLfloat) pColorTable[i].rgbGreen/255;
    m_blue[i]=(GLfloat) pColorTable[i].rgbBlue/255;
  }
}

void CMfc_cubeView::SetupColorTables()
{
  CClientDC clientDC(this);
  wglMakeCurrent(clientDC.m_hDC,m_hRC);
  glPixelMapfv(GL_PIXEL_MAP_I_TO_R,256,m_red);
  glPixelMapfv(GL_PIXEL_MAP_I_TO_G,256,m_green);
  glPixelMapfv(GL_PIXEL_MAP_I_TO_B,256,m_blue);
  glPixelTransferi(GL_MAP_COLOR,TRUE);
  wglMakeCurrent(clientDC.m_hDC,m_hRC);
}

void CMfc_cubeView::SetupLogicalPalette()
{
  struct
  {
    WORD Version;
    WORD NumberOfEntries;
    PALETTEENTRY aEntries[256];
  }logicalPalette={0x300,256};

  BYTE reds[]={0,36,72,109,145,182,218,255};
  BYTE greens[]={0,36,72,109,145,182,218,255};
  BYTE blues[]={0,85,170,255};

  for(int colorNum=0; colorNum<256; ++colorNum)
  {
    logicalPalette.aEntries[colorNum].peRed=reds[colorNum&0x07];
    logicalPalette.aEntries[colorNum].peGreen=greens[(colorNum>>0x03)&0x07];
    logicalPalette.aEntries[colorNum].peBlue=blues[(colorNum>>0x06)&0x03];
    logicalPalette.aEntries[colorNum].peFlags=0;
  }
  m_hPalette=CreatePalette ((LOGPALETTE*)&logicalPalette);
}

/* glmVertexNormals: Generates smooth vertex normals for a model.
 * First builds a list of all the triangles each vertex is in.  Then
 * loops through each vertex in the the list averaging all the facet
 * normals of the triangles each vertex is in.  Finally, sets the
 * normal index in the triangle for the vertex to the generated smooth
 * normal.  If the dot product of a facet normal and the facet normal
 * associated with the first triangle in the list of triangles the
 * current vertex is in is greater than the cosine of the angle
 * parameter to the function, that facet normal is not added into the
 * average normal calculation and the corresponding vertex is given
 * the facet normal.  This tends to preserve hard edges.  The angle to
 * use depends on the model, but 90 degrees is usually a good start.
 *
 * model - initialized GLMmodel structure
 * angle - maximum angle (in degrees) to smooth across
 */

Smooth normals for a cube generated with a 91° edge tolerance (smooth across the edges). Eight normals generated (one per vertex).	Smooth normals for a cube generated with an 89° edge tolerance (not smooth across the edges). Thirty-two normals generated.
Figure 1

Flat shaded teapot (one normal per face).	Smooth normals generated (with a 90° edge tolerance). The lines are where the bezier patches overlap. There are duplicate vertices along the lines.
Optimized teapot model (duplicate vertices removed).	Wireframe teapot to illustrate structure.
Figure 2

Flat shaded pawn.	Smooth normals generated (with a 90° edge tolerance). Notice the sharp edges in the model.
	The third pawn image with the good specular highlight has normals that were created with an edge tolerance of 76°. These edge tolerance angles are very model specific.
Smooth shaded pawn.
Figure 3

Flat shaded head.	Smooth normals generated (with a 90° edge tolerance). Notice the sharp edges (especially around the eyes) in the model.
Figure 4

struct 
{
  struct
  {
    float pos[3];
    float col[3];
  }ver[8];

  struct
  {
    unsigned int ver[6];
    float norm[3];
  }quad[6];
}cube;

typedef struct
{
  float pos[4];
  float diffuse[4];
  float specular[4];
  float ambient[4];
}light_t;

light_t light={
      {6,10,15,1},  //position (the final 1 means the light is positional)
      {1,1,1,1},    //diffuse
      {0,0,0,1},    //specular
      {0,0,0,1} 	//ambient
    };

glEnable(GL_LIGHTING);                 	//enables lighting
glEnable(GL_LIGHT0);                   	//enables a light
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,0);  //sets lighting to one-sided

glEnable(GL_COLOR_MATERIAL);

glColorMaterial(GL_FRONT,GL_DIFFUSE);

float black[4]={0,0,0,0};
glMaterialfv(GL_FRONT,GL_AMBIENT,black);
glMaterialfv(GL_FRONT,GL_SPECULAR,black);

void crossProduct(float *c,float a[3], float b[3]);
void normalize(float *vect);
void getFaceNormal(float *norm,float pointa[3],float pointb[3],float pointc[3]);

void 
getFaceNormal(float *norm,float pointa[3],float pointb[3],float pointc[3])
{
  float vect[2][3];
  int a,b;
  float point[3][3];

  for (a=0;a<3;++a)
  {
    point[0][a]=pointa[a];    //copies points into point[][]
    point[1][a]=pointb[a]; 
    point[2][a]=pointc[a];
  }

  for (a=0;a<2;++a)        //calculates vectors from point[0] to point[1]
  {                        //and point[0] to point[2]
    for (b=0;b<3;++b)
    {
      vect[a][b]=point[2-a][b]-point[0][b];      
    }
  }

  crossProduct(norm,vect[0],vect[1]);           	//calculates vector at 90° to to 2 vectors
  normalize(norm);                                  //makes the vector length 1
}

void crossProduct(float *c,float a[3], float b[3])  //finds the cross product of two vectors
{  
  c[0]=a[1]*b[2] - b[1]*a[2];
  c[1]=a[2]*b[0] - b[2]*a[0];
  c[2]=a[0]*b[1] - b[0]*a[1];
}

length=sqrt(        //A^2 + B^2 + C^2 = length^2
  pow(vect[0],2)+  
  pow(vect[1],2)+
  pow(vect[2],2)
  );

for (a=0;a<3;++a)        
{
  vect[a]/=length;
}

for (a=0;a<6;++a)
{
  getFaceNormal(cube.quad[a].norm,  cube.ver[ cube.quad[a].ver[2] ].pos,
            cube.ver[ cube.quad[a].ver[1] ].pos,
            cube.ver[ cube.quad[a].ver[0] ].pos);
}

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLightfv(GL_LIGHT0,GL_POSITION,light.pos);   	//updates the light's position
glLightfv(GL_LIGHT0,GL_DIFFUSE,light.diffuse);    //updates the light's diffuse colour
glLightfv(GL_LIGHT0,GL_SPECULAR,light.specular);  //updates the light's specular colour
glLightfv(GL_LIGHT0,GL_AMBIENT,light.ambient);    //updates the light's ambient colour

glPushMatrix();

for (a=0;a<6;++a)
{
  glNormal3fv(cube.quad[ a ].norm);           	//sets the current normal to this quad's normal
  for (b=0;b<4;++b)
  {
    currentVer=cube.quad[a].ver[b];

This tutorial is Copyright © 2001 Ben Woodhouse

int main(int argc, char **argv)
{
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  glutCreateWindow("My first GLUT program");
  
  glutDisplayFunc(redraw); 
  
  glMatrixMode(GL_PROJECTION); //hello
  gluPerspective(45, //view angle
             	1.0, //aspect ratio
             	10.0, //near clip
             	200.0);//far clip
  glMatrixMode(GL_MODELVIEW);
  
  glutMainLoop();
  
  return 0; 
}

glutCreateWindow("Spinning cube");

glEnable(GL_CULL_FACE);

struct
{
  struct
  {
    float pos[3];
    float col[3];
  }ver[8];

  struct
  {
    unsigned int ver[4];
  } quad[6];
}cube;

initCube();

void initCube(void);

void initCube(void)
{
  //defines the position of each vertex
  float  vertexPosDat[8][3]=
  {
    {-10, 10, 10},  //left,top,front
    {10, 10, 10},   //right,top,front
    {10, 10,-10},   //right,top,back
    {-10, 10,-10},  //left, top,back
    {-10,-10, 10},  //left,bottom,front
    {10, -10, 10},  //right,bottom,front
    {10, -10,-10},  //right,bottom,back
    {-10,-10,-10}   //left,bottom,back
  };

  //defines the colour of each vertex
  float   vertexColDat[8][3]=
  {
    {0.5, 0 ,0},   //dark red
    {1, 1, 0.3},   //yellow
    {1, 0, 0}, 	//red
    {0.5, 1, 0.2}, //dull yellow??
    {1, 1, 0}, 	//yellow
    {0.9, 0.5, 0}, //orange
    {1, 0.9, 0.1}, //yellow
    {1, 0, 0}, 	//red
  };

  //defines the vertexes of each quad in anti-clockwise order
  unsigned int quadVerDat[6][4]=
  {
    {0,1,2,3},  //top
    {0,3,7,4},  //left
    {3,2,6,7},  //back
    {2,1,5,6},  //right
    {0,4,5,1},  //front
    {4,7,6,5},  //bottom
  };

  int a,b;

  //put the vertex data into the cube.ver[] struct
  for (a=0;a<8;++a)
  {
    for (b=0;b<3;++b)
    {
      cube.ver[a].pos[b]=vertexPosDat[a][b];
      cube.ver[a].col[b]=vertexColDat[a][b];
    }
  }

  //put the quad data into the cube.quad[] struct
  for (a=0;a<6;++a)
  {
    for (b=0;b<4;++b)
    {
      cube.quad[a].ver[b]=quadVerDat[a][b];
    }
  }
} //end of cubeInit()

static void redraw(void)
{
  static float rotateBy=0;
  int a,b;
  unsigned int currentVer;
  
  rotateBy+=0.1;
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushMatrix();
  glTranslatef(0,0,-50);

  glRotatef(rotateBy,1,1,0);  //rotate by rotateBy degrees about the vector (1,1,0)

  glBegin(GL_QUADS); 
  for (a=0;a<6;++a)                       	//quads loop
  {
    for (b=0;b<4;++b)                     	//points loop
    {
      currentVer=cube.quad[a].ver[b];            //sets the current vertex to this point's vertex

      glColor3fv(cube.ver[ currentVer ].col);    //changes the colour to the current vertex's colour
      glVertex3fv(cube.ver[ currentVer ].pos);   //draws a vertex at the current vertex's position
    }
  }

  glEnd();
  glPopMatrix();

  glutSwapBuffers();
  glutPostRedisplay();
}

This tutorial is Copyright © 2001 Ben Woodhouse

Mark Kilgard's GLUT page
The GLUT FAQ
The online GLUT 3 specification

#include <windows.h>           	//header file for windows
#include <gl\gl.h>             	//header file for openGL
#include <gl\glu.h>                //header file for the openGL utility library
#include <gl\glut.h>           	//header file for GLUT

static void redraw(void);          //declarations
int main(int argc, char **argv);

• GLUT_RGB specifies we want an RGB colour buffer in our window
• GLUT_DOUBLE specifies we want a double buffer. Double buffering enables us to finish drawing before our image is sent to the screen, preventing flicker.
• GLUT_DEPTH specifies we want a depth buffer. The depth buffer ensures that objects near the camera will always be on top of those further away. The output tends to be a bit messy otherwise. While this isn't necessary when we're only drawing a single triangle, it's good practice, so we'll include it anyway.

int main(int argc, char **argv)
{
  glutInit(&argc,argv);                                   	//initializes the GLUT framework
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);   //sets up the display mode
  glutCreateWindow("My first GLUT program");                  //creates a window
  glutDisplayFunc(redraw);                                    //specifies our redraw function

  glMatrixMode(GL_PROJECTION);   //changes the current matrix to the projection matrix

  //sets up the projection matrix for a perspective transform
  gluPerspective(45, 	//view angle
             	1.0,    //aspect ratio
             	10.0,   //near clip
             	200.0); //far clip

  glMatrixMode(GL_MODELVIEW);   //changes the current matrix to the modelview matrix

  glutMainLoop();           	//the main loop of the GLUT framework

  return 0;
}

static void redraw(void)                           	//all drawing code goes here
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  //clears the colour and depth buffers

  glPushMatrix();     	//saves the current matrix on the top of the matrix stack
  glTranslatef(0,0,-100); //translates the current matrix 0 in x, 0 in y and -100 in z

  glBegin(GL_TRIANGLES);  //tells OpenGL that we're going to start drawing triangles
  glColor3f(1,0,0);   	//sets the current colour to red
  glVertex3f(-30,-30,0);  //specifies the first vertex of our triangle
  
  glColor3f(0,1,0);   	//sets the current colour to green
  glVertex3f(30,-30,0);   //specifies the second vertex of our triangle
  
  glColor3f(0,0,1);   	//sets the current colour to blue
  glVertex3f(-30,30,0);   //specifies the third vertex of our triangle
  glEnd();                //tells OpenGL that we've finished drawing

  glPopMatrix();          //retrieves our saved matrix from the top of the matrix stack
  glutSwapBuffers();      //swaps the front and back buffers
}                     	//The end of our program!

This tutorial is Copyright © 2001 Ben Woodhouse

glDeleteTextures (1, &m_Player->GetProjectiles ().rocket [nDeadRocket].GetTexture ().nID);

// In the header file
class CSingleton 
{
  static class CSingleton *m_Singleton;
  static Csingleton *GetSingleton (void);
};

// In the implementation file
CSingleton *CSingleton::m_Singleton = 0;

CSingleton *CSingleton::GetSingleton (void) 
{
  if (m_Singleton == 0)
	m_Singleton = new CSingleton;
  return m_Singleton;
}

class CTextureManager {
public :
  CTextureManager (void);
  ~CTextureManager (void);
  static CTextureManager &GetSingleton (void);

private :    // This is called automaticaly! Don't do it yourself!
  static void Initialize (void);
public :
  static void Destroy (void);

public :    // Usage / Implumentation
  int LoadTexture (const char *szFilename, int nTextureID = -1);
  int LoadTextureFromMemory (UBYTE *pData, int nWidth, int nHeight, int nBPP, int nTextureID = -1);

  void FreeTexture (int nID);
  void FreeAll (void);

public :    // Debug / Utilitarian
  char *GetErrorMessage (void);
    
  int    GetNumTextures (void);
  int GetAvailableSpace (void);
  int GetTexID (int nIndex);

private :
  static CTextureManager *m_Singleton;

  UBYTE *LoadBitmapFile (const char *filename, int &nWidth, int &nHeight, int &nBPP);
  UBYTE *LoadTargaFile (const char *filename, int &nWidth, int &nHeight, int &nBPP);

  int GetNewTextureID (int nPossibleTextureID);  // get a new one if one isn't provided
  bool CheckSize (int nDimension);

private :
  char szErrorMessage [80];  // they arn't bugs, their features!
  int nNumTextures;
  int nAvailable;        	// available space in the nTexID array
  int *nTexIDs;
};

Fig. 1a - Object Hierarchy	1b - GL model	1c - GL light model

void struct_part_name(void)
{
  glNewList(part_name,GL_COMPILE);
  .../* GL Commands to model */
  glEndList();
}

void struct_left_arm(void)
{
  glNewList(left_arm,GL_COMPILE); 

	// Shoulder
	glTranslatef(1.1,0.25,0.0);
	glScalef(0.5,0.5,0.5);
	glColor3ub(128,128,128);
	glutSolidSphere(0.5,20,20);
  
	// Arm
	glTranslatef(0.0,-1.10,0.0);
	glScalef(0.5,1.5,0.5);
	glColor3ub(255,255,255);
	glutSolidCube(1.0);

  glEndList();
}

...
#include <gl/glut.h>
...

void DrawRobot() { glPushMatrix(); /* all objects are bust's son that is if we move bust all other parts move too */ /*-------------------- DRAW HEAD AND BUST -----------------------*/ glPushMatrix(); /* Draw head */ /* Draw bust */ glPopMatrix();
/*---------------- DRAW RIGHT ARM AND FOREARM --------------*/ glPushMatrix(); glPushMatrix(); /* Draw Right arm */ glPopMatrix(); glPushMatrix(); /* forearm is arm's child */ /* Draw Forearm */ glPopMatrix(); glPopMatrix();
/*-------------- DRAW LEFT ARM AND FOREARM -----------------*/ glPushMatrix(); glPushMatrix(); /* Draw Left arm */ glPopMatrix(); glPushMatrix(); /* forearm is arm's child */ /* Draw Forearm */ glPopMatrix(); glPopMatrix();
/*------------------ DRAW PELVIS AND LEGS ----------------*/ glPushMatrix(); /* another glPushMatrix because if we move pelvis the legs move too... (legs are pelvis' son) */ glPushMatrix(); /* Draw pelvis */ glPopMatrix(); glPushMatrix(); glPushMatrix(); /* Draw Right thigh */ glPopMatrix(); glPushMatrix(); /* leg is thigh's child */ /* Draw Leg */ glPopMatrix(); glPopMatrix(); glPushMatrix(); glPushMatrix(); /* Draw Left thigh */ glPopMatrix(); glPushMatrix(); /* leg is thigh's child */ /* Draw Leg */ glPopMatrix(); glPopMatrix(); glPopMatrix(); glPopMatrix(); }

void DrawRobot(void)
{
  /*-------------BUST AND HEAD--------------*/
  glPushMatrix();
	glRotatef(bust_angle_y,0,1,0);
	glRotatef(bust_angle_x,1,0,0);
	glPushMatrix();
  	glCallList(bust);
  	glCallList(head);
	glPopMatrix();

	/*--------RIGHT ARM AND FOREARM---------*/
	glPushMatrix();
  	glTranslatef(0,0.25,0);
  	glRotatef(right_arm_angle,1,0,0);
  	glTranslatef(0,-0.25,0);
  	glPushMatrix();
    	glCallList(right_arm);
  	glPopMatrix();
 	 
  	glPushMatrix();
    	glTranslatef(1.25,-0.7,0);
    	glRotatef(right_forearm_angle,1,0,0);
    	glTranslatef(-1.25,0.7,0);
    	glCallList(right_forearm);
  	glPopMatrix();
	glPopMatrix();
    
	/*---------LEFT ARM AND FOREARM---------*/
	glPushMatrix();
  	glTranslatef(0,0.25,0);
  	glRotatef(left_arm_angle,1,0,0);
  	glTranslatef(0,-0.25,0);
  	glPushMatrix();
    	glCallList(left_arm);
  	glPopMatrix();

  	glPushMatrix();
    	glTranslatef(1.25,-0.7,0);
    	glRotatef(left_forearm_angle,1,0,0);
    	glTranslatef(-1.25,0.7,0);
    	glCallList(left_forearm);
  	glPopMatrix();
	glPopMatrix();