Programa básico para el manejo de la iluminación en OpenGL, ya contiene las instrucciones

que se desarrollan en el documento

Programa Ejemplo, para este ejemplo copiar el código y comenzar a desmarcar los
comentarios para así ver los resultados.

#include <windows.h>
#include <GL/glut.h>
#include <stdlib.h>
/*
const GLfloat AltoBrillo[] = { 128.0f };
const GLfloat MedioBrillo[] = { 64.0f };
const GLfloat BajoBrillo[] = { 12.0f };
*/
using namespace std;

float AnguloLento = 0.0;

void Inicializa()
{ glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
glutInitWindowSize(800,600);
glutCreateWindow("Iluminacion");
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,50,0,40,-5,5);
}

void ActivaLaLuzFoco1()
{ // PASO 1. ACTIVAMOS LA ILUMINACION
//glEnable(GL_LIGHTING); // Activamos la iluminacion
//glEnable(GL_LIGHT0); // Encendemos la luz 0
//glEnable(GL_NORMALIZE); // Le indicamos a OpenGL que calcule las normales
vertices

// PASO 2. DEFINIMOS LOS COMPONENTES DE LA LUZ

// Ambiente: La luz que llega rebotada de las paredes, los muebles, etc. no se sabe
// de dónde viene. Es una luz más débil que las otras:
// Difusa: La luz que llega directamente desde la fuente de luz pero rebota en
// todas direcciónes (junto con la ambiente definen el color del objeto):
// Especular: La luz que llega directamente de la fuente de luz y rebota en
// una dirección, según la normal de la superficie (provoca el brillo, por ejemplo,
// del circulito blanco de la bola de billar negra):

//GLfloat ambiente[] = { 0.2, 0.2, 0.2, 1.0 }; // Intensidad de la luz ambiente

//GLfloat difusa[] = { 0.5, 0.5, 0.5, 1.0 };
//GLfloat especular[] = { 0.8, 0.8, 0.8, 1.0 };
//glLightfv(GL_LIGHT0, GL_AMBIENT, ambiente);
//glLightfv(GL_LIGHT0, GL_SPECULAR, especular);
 //glLightfv(GL_LIGHT0, GL_DIFFUSE, difusa);

// PASO 3. ACTIVAMOS LA LUZ (ENCENDEMOS EL FOCO Y DEFINIMOS SU

POSICION
//GLfloat posicion[] = { 50.0, 40.0, 2.0, 1.0 }; // Posicion del foco jugar con pos
//glLightfv(GL_LIGHT0, GL_POSITION, posicion);

// PASO 4. DEFINIMOS LAS PROPIEDADES DE LOS MATERIALES

// Ahora definiremos las propiedades de los materiales
// Aqui se define como el material de nuestro objeto refleja la luz.
// El material con el que esta "hecho" refleja cada componente de la luz que
// le llega. Esto se hace con la función glMaterial:
//GLfloat mat1_ambiente[] = { 1.2, 1.2, 1.2, 1.0 }; // 0.2, 1.2 Props del material
//GLfloat mat1_ambiente[] = { 0.2, 0.2, 0.2, 1.0 };
//GLfloat mat1_difusa[] = { 1.0, 1.0, 1.0, 1.0 };
//GLfloat mat1_especular[] = { 1.1, 1.1, 1.1, 1.0 };
//GLfloat mat1_ambientedifuso[] = { 1.0, 0.0, 0.0, 0.0 };

// PASO 5. DEFINIMOS LAS CARAS A LAS QUE AFECTARA EL MATERIAL

// podemos definir en que caras afectara la definicion de la luz
// parám.1 a que caras del objeto se aplica, GL_FRONT, GL_BACK y
GL_FRONT_AND_BACK
// paráme.2 la caract del material a cambiar GL_AMBIENT, GL_DIFFUSE y
GL_SPECULAR
// para cada componente de la luz en OpenGL. GL_AMBIENT_AND_DIFFUSE para
cambiar valores
// de luz ambiente y difusa a la vez (son las que determinan el color del objeto).

//glMaterialfv(GL_FRONT, GL_AMBIENT, mat1_ambiente);

//glMaterialfv(GL_FRONT, GL_SPECULAR, mat1_especular);
//glMaterialfv(GL_FRONT, GL_DIFFUSE, mat1_difusa);
//glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat1_ambientedifuso);

//glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat1_ambiente);

//glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat1_especular);
//glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat1_difusa);

// PASO 6. DEFINIMOS EL BRILLO O CAMTIDAD DE LUZ QUE REFLEJARA.

// GL_SHININESS es un parámetro que modifica la forma de presentar la luz especular
// representa el brillo del objeto y es un valor único de 0 a 255.
//GLfloat AltoBrillo[] = { 128.0f }; // brillo de los materiales
//GLfloat MedioBrillo[] = { 64.0f };
//GLfloat BajoBrillo[] = { 12.0f };

//glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, AltoBrillo); //Para el brillo

//glMaterialfv(GL_FRONT, GL_SHININESS, BajoBrillo); //Para el brillo
 // PODEMOS DEFINIR SI EL MATERIAL EMITIRA LUZ
// GL_EMISSION representa la luz que emite el propio objeto y que normalmente
// será 0,0,0 para objetos normales.
// Para representar una bombilla pondríamos una esfera en el mismo lugar que una
// luz puntual y daríamos valor a este parámetro.
// Emision de del objeto
//GLfloat mat1_emision[] = { 0.0, 0.0, 0.0 }; // con ceros no emite nada
//GLfloat mat1_emision[] = { 1.0, 1.0, 1.0 };
//GLfloat mat1_emision[] = { 0.2, 0.2, 0.2 };
//glMaterialfv(GL_FRONT, GL_EMISSION, mat1_emision); //Para el brillo

// Este parámetro modifica la forma de hacer el cálculo del brillo de luz especular
// GL_TRUE usara para este cálculo un punto fijo del mundo OpenGL con lo que el
// cálculo será más lento pero mejor el resultado.
// GL_FALSE tomara un punto en el infinito para el cálculo, lo que es lo mismo que
// una dirección. Será menos costoso pero menos vistoso.
//glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE);
//GL_TRUE/GL_FALSE);

// Esto permite dibujear los polígonos por los dos lados correctamente invirtiendo
// las normales en caso de verlos desde el otro lado.
// GL_TRUE para objetos abiertos donde requerimos ver ambas caras, aqui no se usa

// Permite habilitar una luz ambiente general para todo lo que dibujemos, de forma
// que se verá con cierta claridad general.
// GLfloat ambiente_general[ ]={0.2, 0.2, 0.2, 1.0};
// glLightModelfv(GL_LIGHT_MODEL_AMBIENT,ambiente_general);

// DEfinjmos el modelo de sombreado o para calculo de las sombras

// GL_FLAT. Usa el color del primer vértice para cada cara del objeto.
// GL_SMOOTH. interpola el color de cada punto de la cara con el color de los vértices
//glShadeModel(GL_SMOOTH);
//glShadeModel(GL_FLAT);

//glEnable(GL_COLOR_MATERIAL); // Para habilitar el color del material.

}

void Dibuja()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
 glColor3f(0.8, 0.80, 0.0);
glPushMatrix();
GLfloat mate_emision[] = { 1.0, 1.0, 1.0 };
glRotatef(10.0,1.0,1.0,1.0);
glPushMatrix();
glTranslatef(10.0,20.0,0.0);
glScalef(4.0,4.0,4.0);
glRotatef(AnguloLento,1.0,1.0,1.0);
glutSolidIcosahedron();
glPopMatrix();

glColor3f(0.0, 1.0, 1.0);

glPushMatrix();
glTranslatef(25.0,20.0,0.0);
glScalef(3.0,3.0,3.0);
glRotatef(AnguloLento,1.0,1.0,1.0);
glutSolidDodecahedron();
glPopMatrix();

glColor3f(1.0, 0.0, 1.0);

glPushMatrix();
glTranslatef(40.0,17.5,0.0);
glScalef(4.0,4.0,4.0);
glRotatef(AnguloLento,1.0,1.0,1.0);
//glutSolidDodecahedron();
glutSolidOctahedron();
glPopMatrix();
glPopMatrix();

AnguloLento+=0.1;
if (AnguloLento>360) AnguloLento=0.01;
glutPostRedisplay();
glutSwapBuffers();
}

int main(int argc, char **argv)

{ glutInit(&argc, argv);
Inicializa();
ActivaLaLuzFoco1();
glutDisplayFunc(Dibuja);
glutMainLoop();
return 0;
}