PRCTICA 3

Unidad 3
Objetivos:
I) comprender como las condiciones de iluminacin del mundo real se pueden aproximar usando
OpenGL.
II) Renderizar objetos iluminados definiendo las fuentes de luz deseadas y sus modelos de iluminacin.
III) Definir las propiedades del material de los objetos a ser iluminados.
IV) Manipular la matriz de stack para controlar la posicin de las fuentes de iluminacin.
INTRODUCCIN
La iluminacin de objetos sirve para dar una sensacin de realidad sobre los grficos, realzando
y dando la sensacin de profundidad en esquemas 3D. Un objeto en dos dimensiones que se grfica,
con fondo negro y color de objeto blanco, puede ver diferente usando iluminacin tal como se muestra
en la siguiente figura:

Figura iluminada

Figura sin iluminacin

En el PENDICE 1, se le indica un cdigo al cual presenta el modelo de iluminacin

Especular.
El proceso es el siguiente:
a) Definir los vectores normales para cada vrtice de todos los objetos. Estos vectores normales
determinan la orientacin del objeto relativa a las fuentes de luz.
b) Crear, seleccionar y posicionar una o ms fuentes de luz.
c) Crear y seleccionar un modelo de iluminacin, que defina el nivel global de la luz de
ambiente y la ubicacin efectiva del observadord) Definir las propiedades del material para los objetos en la escena.

TIPOS DE ILUMINACIN
AMBIENTE.- Es luz esparcida en todas direcciones, muy similar a la luz del da.
DIFUSA.- Viene en una direccin, cuando choca con una superficie la mayor parte del haz de luz es
reflejado en la misma concentracin.
ESPECULAR.- Es cuando el rayo de luz incide sobre una superficie y al chocar en ella se desvan y
regresan los rayos al medio de donde salieron formando un ngulo igual a la luz incidente sobre el
objeto.

TEORA

Mediante la iluminacin es como se consigue un mayor efecto de

realismo. El modelo de iluminacin de OpenGL es bastante sencillo, los
algoritmos son de la decada de los 70-80, pero a diferencia de aquella
epoca ahora se realizan en tiempo real a una velocidad de 60-100 frames
por segundo, estos avances han sido gracias a la evolucin del hardware.
La calidad de las imagenes de OpenGL no es comparable a una pelcula
de animacin por ordenador donde el clculo de un frame puede llevar
horas al realizarse con algoritmos de trazado de rayos mucho mas
sofisticados.

Modos de Renderizacin
Cuando renderizamos una primitiva disponemos de dos mtodos de
rellenado. Para cambiar entre uno u otro se hace con la funcin void
glShadeModel(GLenum mode), como parmetro le pasamos uno de los siguientes
modos:
: Renderiza la primitiva con un solo color, elegido de uno de los
vrtices
dependiendo
de
la
primitiva.
GL_SMOOTH : Renderiza la primitiva interpolando el color de los vrtices.
GL_FLAT

Esto en cuanto a la manera de renderizar la primitiva, el color de cada uno

de los vrtices hasta ahora lo especificabamos con la funcin glColor. En el
modo de iluminacin activado el color de cada uno de los vrtices es
calculado a partir del material del vrtice y las luces.

Modelo de iluminacin
El modelo de iluminacin como hemos mencionado anteriormente es
bastante bsico y pasamos a describirlo a continuacin describiendo cada
una de sus partes.
El clculo del color se realiza en cada vrtice segn las luces que haya

encendidas y las propiedades del material de dicho vrtice, no tiene en

cuenta posibles oclusiones de terceros objetos que produciran sombras,
reflejos de la luz que permitira tener espejos o refracciones de la luz para
ver a traves de materiales como el agua.

Luces
Para habilitar el modo de iluminacin se realiza con la
funcin glEnable(GL_LIGHTING), cuando renderizamos en este modo la
instruccin glColor no tienen ninguna influencia ya que el color resultante
de cada vrtice es calculado a partir de los materiales del vrtice y las
luces que haya encendidas.
Disponemos de ocho luces que podemos encender o apagar con la
funcin glEnable(GL_LIGHTi) donde i =[0..7]. Cada luz la podemos configurar
estableciendo los siguientes parmetros con la funcin glLight{if}v :
Parametro

Valor por defecto

GL_AMBIENT

(0.0, 0.0, 0.0, 1.0)

GL_DIFFUSE

GL_SPECULAR

(1.0, 1.0,
(0.0, 0.0,
GL_LIGHT7
(1.0, 1.0,
(0.0, 0.0,
GL_LIGHT7

1.0, 1.0) GL_LIGTH0

0.0, 1.0) GL_LIGTH11.0, 1.0) GL_LIGTH0
0.0, 1.0) GL_LIGTH1-

GL_POSITION

(0.0, 0.0, 0.0, 1.0)

GL_SPOT_DIRECTION

(0.0, 0.0, -1.0)

GL_SPOT_EXPONENT

0.0

GL_SPOT_CUTOFF

180.0

GL_CONSTANT_ATTENUATI
1.0
ON
GL_LINEAR_ATTENUATION 0.0
GL_QUADRATIC_ATTENUAT
0.0
ION

Significado
intensidad ambiente de la
luz
intensidad difusa de la luz
intensidad especular de la
luz
(x, y, z, w) posicin de la luz
(x, y, z) direccin de la luz
exponente del foco
angulo de abertura del foco
factor de atenuacin
constante
factor de atenuacin lineal
factor de atenuacin
cuadratico

Componentes de la luz
La luz tiene tres componentes: ambiente, difusa y especular:
Ambiente : Es la luz que se emite en todas direcciones y rebota en todas
direcciones.
Difusa : Luz emitida desde el punto de luz que rebota en todas las
direcciones.
Especular : Luz emtidia en una direccin que rebota segn la normal del
polgono, provoca el brillo puntual del objeto, p.e. el brillo blanco de la
bola de bola de billar negra.

Ademas de las componentes de luz es necesario saber que tipo de fuente

de luz se trata, en OpenGL disponemos de dos tipos:
Direccional : Todos los rayos son paralelos e inciden en la direccin, el
valor w de GL_POSITION es cero, la direccin se especifica mediante (x, y, z)
de GL_POSITION.
Un
ejemplo
de
luz
direccional
es
el
sol.
Posicional : La luz esta colocada en el punto (x, y, z) el valor w
de GL_POSITION es distinto de cero.
Si se trata de una luz posicional, un foco, podemos alterar una serie de
parmetros:
: La direccin en que apunta.
GL_SPOT_EXPONENT : Concentracin de la luz en en centro del foco.
GL_SPOT_CUTOFF : Apertura del foco en grados, el ngulo se multiplica por
dos, 180 signfica que la luz sale en todas direcciones.
GL_SPOT_DIRECTION

Tambien podemos provcar atenuacin en el foco, la formula del factor de

atenuacin es la siguiente:
Adems de las ocho luces tenemos una luz ambiente global que podemos
modificar mediante la instruccin:
: Nos permite cambiar la luz
ambiente global y otros parmetros de configuracin del modelo de
iluminacin.
glLightModel{if}v(GLenum param, TYPE* param)

Parametro

Valor por defecto Significado

GL_LIGHT_MODEL_AMBIEN (0.2, 0.2, 0.2,

T
1.0)
GL_LIGHT_MODEL_LOCAL_
0.0
VIEWER

o FALSE

GL_LIGHT_MOEL_TWO_SID
0.0
E

o FALSE

GL_LIGHT_MODEL_CONTRO
GL_SINGLE_COLOR
L_COLOR

intensidad ambiente de la luz global

como se calculan los ngulos para la
reflexin de la luz especular
permite elegir entre iluminacin a una o dos
caras
la componente especular se calcula
separado de la ambiente y difusa

Materiales
En el modelo de renderizacin sin iluminacin definiamos el color de cada
vrtice, ahora tenemos que definir los materiales. Se definen cuatro
componentes de material para cada vrtice.
Ambiente : Es la componente del material que refleja la luz
independientemente de la direccin que venga.
Difusa : Es la componente del material que refleja segn la direccin de

procedencia de la luz.
Especular : Componente que refleja la luz especular, provoca el efecto
brillo.
Emisiva : Componente de color que se aade independientemente de la
luz recibida.
Para establecer las componentes del material lo hacemos con la
funcin glMaterial
Parametro

Valor por defecto

GL_AMBIENT

(0.2, 0.2, 0.2, 1.0)

GL_DIFFUSE

(0.8, 0.8, 0.8, 1.0)

GL_SPECULAR

(0.0, 0.0, 0.0, 1.0)

GL_SHININESS

0.0

GL_EMISSION

(0.0, 0.0, 0.0, 1.0)

Significado
componente ambiente
componente difusa
componente espcular
exponente de brillo
componete emisiva

Tenemos la posibilidad de dotar de funcionalidad a la

funcin glColor habilitandola con la instruccin glEnable(GL_COLOR_MATERIAL).
Con la opcion color-material activado la funcin glColor cambia el material
que indicamos en la funcin glColorMaterial :
: Especifica que materiales (mode)
cambia y de que caras (face) al usar la funcin glColor . Face toma valores
entreGL_FRONT, GL_BACK, GL_FRONT_AND_BACK (por defecto), mode
entre GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_AMBIENT_AND_DIFFUSE (por defecto).
glColorMaterial (GLenum face, GLenum mode)

Normales
Una de las caractersticas que se puede establecer de un vrtice es el
color (o el material si estamos en modo iluminacion), pero podemos
establecer otras caractersticas como la coordenada de la textura o la
normal que sirve para realizar los calculos de la iluminacin resultante. No
importa el orden en que se definan las caractersticas pero siempre se
har antes de definir el vrtice.
glColor3f(1.0, 0.3, 0.4); // Color del vrtice
glNormal3f(1.0, 0.0, 0.0); // Normal del vrtice
glTexCoord2f(0.0, 1.0); // Coordenada de la textura
glVertex3f(1.0, 3.2, 3.6); // Vrtice

El vector normal se utiliza para calcular la incidencia de la luz sobre el

vrtice, si el vector normal no es unitario el vrtice estar sobreiluminado
(mayor que 1) o infrailuminado (menor que 1).
Es muy importante que para cada vrtice se defina la normal, ya que
OpenGL no asigna la normal a partir de la orientacin de la primitiva. De lo
contrario utilizar como normal la ultima normal establecida.

Modelo Matemtico de iluminacin

En la siguiente formulacin las operaciones se calculan
independientemente para cada componente R, G, B.
La componente A de un vrtice es igual a la componente A de la
componente difusa del material.
El color de un vrtice producido por la iluminacin se calcula de la
siguiente forma:
color
vertice =

(A) componente emisin del material en el vrtice +

(B) luz ambiente global escalada
(C) sumatorio de las aportaciones ambiente, difusa y especular de todas
las luces, debidamente atenuadas

Despues del clculo cada componente RGBA es limitada al rango [0, 1].
(A) Emisin del material
Es el valor de la componte emision del material asignada al vrtice
(B) Luz ambiente global escalada
Se calcula multiplicando la luz ambiente global por la componente
ambiente del material.
ambient light model * ambient material
(C) Contribuciones desde las fuentes de luz
La contribucin es la suma de las contribuciones de cada fuente de luz
contribucin de una luz = factor de atenuacin * efecto foco * (termino
ambiente + termino difuso + termino especular)
Factor de atenuacin
Si la luz es direccional el factor es 1 sino se calcula tal y como se ha
explicado en el apartado Luces.
Efecto foco
Si la luz es direccional el efecto foco es 1 sino se calcula tal y como
sigue:
1 si no es un foco propiamente dicho (GL_SPOT_CUTOFF es 180.0)
0 si la luz es un foco pero el vrtice cae fuera del cono
iluminado
max(vd,0)GL_SPOT_EXPONENT donde:

v = (vx, vy, vz) es el vector unitario que apunta desde el

foco GL_POSITION al vrtice.
d = (dx, dy, dz) es la direccin del foco(GL_SPOT_DIRECTION).
El producto de vd vara segn el coseno del ngulo que forman.
Trmino Ambiente
Se calcula multiplicando la luz ambiente por la componente ambiente del
material.
ambient light * ambient material
Trmino Difuso
Se calcula multiplicando la luz ambiente por la componente ambiente del
material.
max(Ln, 0)GL_SPOT_EXPONENT*diffuse light *
diffuse material donde
n = (nx, ny, nz) es el vector normal del vrtice.
L = (Lx, Ly, Lz) es el vector unitario que apunta desde el vrtice al
foco GL_POSITION.
Trmino Especular
El trmino especular tambien depende de si la luz cae o no directamente
sobre el vrtic. Si Ln es menor o igual que cero no hay componente
especular, sino la luz cae en la cara frontal y se calcula como sigue:
max(sn, 0)GL_SHININESS*specularlight * specularmaterial donde
n = (nx, ny, nz) es el vector normal del vrtice.
s = (sx, sy, sz) es el vector unitario resultante de la suma de dos
vectores:
el vector que va del vrtice a la posicin de la luz
el vector que va del vrtice al punto de vista,

si GL_LIGHT_MODEL_LOCAL_VIEWER es cierto, sino se utiliza el vector

(0, 0, 1)

Posicionamiento de las luces

OpenGL trata la posicin y direccin de la luz como si del vertice de una
primitiva se tratase (coordenada y normal). A la posicin y orientacin de
la luz se le aplica la matriz de modelizacin como si fuese una primitiva.
Para ser mas exacto cuando especificamos la posicin o direccin con la
funcin glLight*() la posicin o direccin is transformada por la matriz de
modelizacin y posteriormente almacenada. Podemos controlar la luz
modificando la matriz de modelizacin para aplicarle trasnlaciones,
rotaciones, escalados...
La luz conviene con posicionarla antes de renderizar la escena, de lo
contrario no sabemos que posicin esta especificada y cual ser el
resultado, y como hemos mencionado anteriormente, una vez renderizada
una primitiva los cambios realizados sobre el estado de OpenGL no varan
el resultado de esta.
Ahora veremos ejemplos de iluminacin donde la luz permanece fija, la luz
se mueve con el punto de vista.
Luz Fija
En este caso la luz permanece en un punto fijo de la escena, es decir la
colocamos en coordenadas mundo. Al quererla colocar en coordenadas
mundo su posicin la deberemos especificar (en coordenadas mundo)
una vez hayamos realizado el cambio de sistema de coordenadas, por
ejemplo con una sentenciagluLookAt().
GLfloat lightPos[4] = {1.0, 4.0, 7.5, 1.0}; // Luz direccional
void Display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(posx, posy, posz, eyex, eyey, eyez, upx, upy, upz);
glPushMatrix();
// Aqui podriamos aplicar alguna transformacin para mover la luz
glLightfv(GL_LIGHT0, GL_LIGHT_POSITION, lightPos);
// Aqui dibujamos la luz
glPushAttrib(GL_LIGHTING_BIT); // Guardamos el estado de las luces
glDisable(GL_LIGHTING); // Deshabilitamos las luces
glutSolidSphere(1.0, 25, 25); // Dibujamos la luz para que sepamos donde
esta
glPopAttrib(GL_LIGHTING_BIT); // Restauramos el estado de las luces

glPopMatrix();
// Dibujamos la escena
glTranslatef(0.0, 0.0, -5.0);
glutTeaPot(1.0);
glutSwapBuffers();
}

Si dibujamos la escena antes de situar la luz estaremos cometiendo un

error ya que todava no hemos actualizado la posicin de esta y estaremos
utilizando la posicin de la luz del anterior frame.
Luz ligada al punto de vista
Ahora deseamos colocar la luz en relacin al sistema de coordenadas de
la cmara, es decir el origen de coordenadas (0, 0, 0). En este caso es ms
sencillo, debemos especificar la posicin antes de aplicar cualquier
transformacin de cambio de coordenadas.
GLfloat lightPos[4] = {1.0, 4.0, 7.5, 1.0}; // Luz direccional
void Display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glPushMatrix();
// Aqui podriamos aplicar alguna transformacin para mover la luz
glLightfv(GL_LIGHT0, GL_LIGHT_POSITION, lightPos);
// Aqui dibujamos la luz
glPushAttrib(GL_LIGHTING_BIT); // Guardamos el estado de las luces
glDisable(GL_LIGHTING); // Deshabilitamos las luces
glutSolidSphere(1.0, 25, 25); // Dibujamos la luz para que sepamos donde
esta
glPopAttrib(GL_LIGHTING_BIT); // Restauramos el estado de las luces
glPopMatrix();
gluLookAt(posx, posy, posz, eyex, eyey, eyez, upx, upy, upz);
// Dibujamos la escena
glTranslatef(0.0, 0.0, -5.0);
glutTeaPot(1.0);
glutSwapBuffers();
}

El posicionamiento de la luz depende de la matriz de modelizacin que

haya cargada, siempre tenemos que tener en cuenta en que sistema de
coordenada la deseamos posicionar y que transformaciones le aplicamos.
Para la direccin de la luz debemos usar el mismo criterio, tambin se le
transforma mediante la matriz de modelizacin como si de la normal de un
vrtice se tratase.
Valores predeterminados de parmetros

Nombre del Parmetro

Valor Default

Significado

GL_AMBIENT

(0.0, 0.0, 0.0,

1.0)

ambient RGBA intensity of

light

GL_DIFFUSE

(1.0, 1.0, 1.0,

1.0)

diffuse RGBA intensity of

light

GL_SPECULAR

(1.0, 1.0, 1.0,

1.0)

specular RGBA intensity of

light

GL_POSITION

(0.0, 0.0, 1.0,

0.0)

(x, y, z, w) position of light

GL_SPOT_DIRECTION

(0.0, 0.0, -1.0)

(x, y, z) direction of spotlight

GL_SPOT_EXPONENT

0.0

spotlight exponent

GL_SPOT_CUTOFF

180.0

spotlight cutoff angle

GL_CONSTANT_ATTENUATI
ON

1.0

constant attenuation factor

GL_LINEAR_ATTENUATION

0.0

linear attenuation factor

GL_QUADRATIC_ATTENUA
TION

0.0

quadratic attenuation factor

PRCTICA
1) Cambie el color de la luz por una luz de color azul
2) Cambie la iluminacin para que sea por el lado izquierdo en vez del derecho,
es decir que la parte ms oscura este del lado derecho.
3) Genere un barrido de luz que sea de derecha a izquierda y cuando llegue al otro
extremo cambie la direccin de izquerda a derecha y as en ciclo. Esto dar la impresin

de que una persona est alumbrando la esfera con una lmpara y la gira de un sentido a
otro.
ENTREGA: Viernes 26 de Febrero, 2016.

APNDICE 1
#include "stdafx.h"
#include <windows.h>

// Header File For Windows

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
void init(void)
{
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutSolidSphere(1.0, 20, 16);
glFlush();
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei)w, (GLsizei)h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-1.5, 1.5, -1.5*(GLfloat)h / (GLfloat)w,
1.5*(GLfloat)h / (GLfloat)w, -10.0, 10.0);
else
glOrtho(-1.5*(GLfloat)w / (GLfloat)h,
1.5*(GLfloat)w / (GLfloat)h, -1.5, 1.5, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutInitWindowPosition(100, 100);
glutCreateWindow(argv[0]);
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

REFERENCIA:
sitio web:
http://dmi.uib.es/~josemaria/OpenGL/Iluminacion.html