colores y sombras

Universidad & Salamanca
Ingeniería Superior Informática.
TEMA 7
Colores y Sombras
Informática Gráfica
José María Corral Martín
Álvaro F. García Sánchez

Colores y sombras 2
7.1. Introducción................................................................................................. 4
7.2. ¿Qué es el color? ........................................................................................ 4
7.2.1. La luz como Onda................................................................................. 5
7.2.2. La luz como partícula............................................................................ 6
7.2.3. Dualidad onda - partícula...................................................................... 6
7.3. Percepción del color.................................................................................... 6
7.3.1. Características psicológicas del color................................................... 7
7.4. Dispositivos de visualización ....................................................................... 9
7.4.1. TRC ...................................................................................................... 9
7.4.1.1. Análisis de los tiempos involucrados............................................ 10
7.4.1.2. Exploración de línea..................................................................... 10
7.4.1.3. Sincronizaciones horizontales y verticales ................................... 11
7.4.2. LCD..................................................................................................... 12
7.4.2.1. Funcionamiento............................................................................ 14
7.4.2.2 LCD de texto ................................................................................. 14
7.4.2.3. TFT............................................................................................... 14
7.4.3. Pantalla de plasma ............................................................................. 15
7.5. El monitor vs. El ojo................................................................................... 16
7.6. Profundidad del color ................................................................................ 16
7.6.1. Color de 1-bit ...................................................................................... 16
7.6.2. Color de 4-bits .................................................................................... 17
7.6.3. Color de 8-bits .................................................................................... 18
7.6.4. Color de 24-bits .................................................................................. 18
7.7. Modelos de color ....................................................................................... 19
7.7.1. Modelo de color XYZ .......................................................................... 19
7.7.1.1. Espacio de color CIE.................................................................... 19
7.7.1.1.1. Diagrama de cromaticidad CIE.............................................. 20
7.7.1.1.2. Gama de colores ................................................................... 20
7.7.2. El modelo de color RGB ..................................................................... 21
7.7.3. El modelo de color CMY (Cyan, Magenta, Amarillo)........................... 23
7.7.4. El modelo de color YUV...................................................................... 24
7.7.5. El modelo de color YIQ ....................................................................... 24
7.7.6. El modelo de color HSI ....................................................................... 25
7.7.7. El sistema HLS (Hue, Saturation and Luminance).............................. 26
7.7.8. Modelo HSV........................................................................................ 26
7.8. Colores en OpenGL .................................................................................. 28
7.8.1. Utilización de colores con OpenGL..................................................... 28
7.8.2. Modelo de color RGBA ....................................................................... 30
7.8.3. Modelo de color indexado................................................................... 36
7.8.4. Modelo de color RGBA vs. Modelo de color Indexado........................ 48
7.8.5. Ocultaciones ....................................................................................... 49
7.8.5.1. Algoritmo de las caras de detrás.................................................. 49
7.8.5.2 Algoritmo del Z-buffer.................................................................... 50
7.8.5.3. Combinando ambos algoritmos.................................................... 51
7.8.6. El color de los materiales.................................................................... 52
7.9. Sombras.................................................................................................... 58
7.9.1 Efecto falloff (Distance falloff) .............................................................. 60
7.9.2 Sombreado .......................................................................................... 61
7.9.3 Tipos de sombreado ............................................................................ 62
7.9.3.1 Sombreado plano (Flat Shading)................................................... 62

Colores y sombras 3
7.9.3.2 Sombreado de Gouraud................................................................ 63
7.9.3.3 Sombreado de Phong ................................................................... 65
7.9.3.4 Sombreado Blinn–Phong .............................................................. 67
7.9.4 Sombreado en OpenGL....................................................................... 68
7.9.4.1 Sombreado Plano (Flat) ................................................................ 68
7.9.4.2 Sombreado Interpolativo y Gouraud.............................................. 70
7.9.4.3 Stencil Buffer................................................................................. 71
7.9.4.4 Buffer de Profundidad o Z buffer ................................................... 75
7.9.5. Volúmenes de sombras ...................................................................... 76
7.9.5.1 Paso de profundidad (Depth pass)................................................ 78
7.9.5.2 Error de Profundidad (Depth fail)................................................... 78
7.9.7.3 OR exclusivo ................................................................................ 78
7.10 Fusión (Dithering)..................................................................................... 78
7.11. Creación de Paletas de Ventana............................................................. 80
7.11.1 Arbitraje de paletas............................................................................ 80
7.11.2. Creación de una paleta..................................................................... 82
7.11.3 Estructura de la paleta....................................................................... 82
7.11.4 Destrucción de una paleta. ............................................................... 85
7.12 Conclusión................................................................................................ 87
7.13 Otras funciones para luces y sombras ..................................................... 87
glAccum........................................................................................................ 87
glColorMask.................................................................................................. 88
glDrawBuffer................................................................................................. 88
glFog............................................................................................................. 89
glIndexMask.................................................................................................. 90
glIsEnabled................................................................................................... 90
glLogicOp...................................................................................................... 90
glPolygonMode ............................................................................................. 91
7.14 Bibliografia................................................................................................ 92
7.15 Enlaces de interés.................................................................................... 96

Colores y sombras 4
7.1. Introducción
Los despliegues realistas de objetos se obtienen generando
proyecciones en perspectiva con superficies ocultas eliminadas y después
aplicando modelos de sombreado y color a las superficies visibles. Un modelo
de sombreado se utiliza para calcular la intensidad de luz que debe observarse
cuando se visualiza una superficie. Estos cálculos de intensidad se basan en
las propiedades ópticas de las superficies, las posiciones relativas de las
superficies y su orientación con respecto a las fuentes de luz.
En este tema se introducirán los conceptos de color y sombreado,
algunos de los modelos más utilizados actualmente para su representación
para posteriormente mostrar todo lo necesario para la utilización del color y del
sombreado en escenas con OpenGL con multitud de ejemplos sencillos.
7.2. ¿Qué es el color?
El color de un objeto percibido por la vista se debe a las propiedades
inherentes al mismo, de reflejar, seleccionar y absorber determinados rayos de
los que integran la luz blanca. La luz solar es un fenómeno vibratorio de
innumerables variaciones en cuanto a longitud de onda. Al pasar la luz por un
prisma se ve que está compuesta por un sinnúmero de colores; los
fundamentales son: violeta (que corresponde a la vibración más pequeña y
simple), añil, azul, verde, amarilla, naranja y rojo. El color negro resulta de la
ausencia de toda impresión luminosa.
Diccionario Enciclopédico Abreviado Espasa-Calpe.S.A
Según la definición el color de un objeto se debe a la combinación de las
distintas longitudes de onda que el objeto refleja, así por ejemplo un objeto rojo
sería aquel que absorbiese todos los rayos que componen la luz blanca menos
el de menor longitud de onda (el rojo).
El color en las artes es el medio más valioso para que una obra
transmita las mismas sensaciones que el artista experimenta frente a la escena
o motivo original; utilizando el color adecuadamente y con conocimiento de su
naturaleza y efectos será posible expresar la alegría o tristeza, la luminosidad u
oscuridad, tranquilidad o la exaltación, etc.
El color en la informática gráfica se desenvuelve de la misma manera
que en el arte de la pintura, aunque en su actuación va mucho mas allá porque
su fin es especialmente especifico, puede servir para favorecer, destacar,
disimular y aún ocultar, para crear una sensación excitante o tranquila, para
denotar temperatura, tamaño, profundidad o peso y como la música, puede ser
utilizada deliberadamente para despertar un sentimiento.
El color tiene su propia técnica y está sometido a ciertas leyes,
conociéndolas será posible dominar el arte de la armonización, conocer los
medios útiles que sirven para evitar la monotonía en una combinación

Colores y sombras 5
cromática, estimular la facultad del gusto selectivo y afirmar la sensibilidad,
desconociéndolas es posible trastornar y anular las percepciones deseadas.
7.2.1. La luz como Onda
Lo que percibimos como color es una banda de frecuencias del espectro
electromagnético, otras bandas de frecuencias incluidas en el espectro son las
ondas de radio, infrarrojos, etc. Cada
frecuencia contenida en el espectro
visible se corresponde con un color
distinto.
El espectro visible abarca
desde los 4.3*10 14 Hz (rojo) hasta los
7.5 * 10 14 Figura 1 - Estructura de una onda
Hz (violeta). En este
intervalo de frecuencias el ojo humano distingue aproximadamente unos
400.000 colores diferentes (esta gama se extiende desde el rojo pasando por el
anaranjado y amarillo en el extremo de las bajas frecuencias hasta los azules y
violetas de las altas frecuencias).
Figura 2 - Espectro Electromagnético
Lo que se designa como luz blanca es la impresión creada por el
conjunto de radiaciones que son visibles por nuestro ojo; la luz blanca cuando
es descompuesta produce el fenómeno de arco iris, estos son los que
llamamos colores, el conjunto de estos, o franja continua de longitudes de onda
creada por la luz al descomponerse, constituye el espectro.
Describimos los colores en función de su frecuencia o de su longitud de
onda dado que la luz es una onda electromagnética (C = λ*f). La longitud de
onda en el espectro visible varía desde los 720 nanómetros del rojo a los 390
nanómetros del violeta.
Cualquier fuente de luz (sol, foco de luz ...) emite todas las
frecuencias en el intervalo visible para producir la luz blanca.

Colores y sombras 6
Un objeto sobre el que incide luz blanca absorberá algunas frecuencias
y reflejará otras. La combinación de éstas últimas determinará el color del
objeto. Describimos el objeto como violeta si predominan las altas frecuencias
en la luz reflejada, es decir, la luz tiene una frecuencia dominante o longitud
de onda dominante en el extremo violeta del espectro. La frecuencia
dominante se denomina color o matiz de la luz.
7.2.2. La luz como partícula
La luz puede ser descrita como una onda oscilante, pero también puede
ser considerada como un haz de partículas viajando a altas velocidades (3,0 x
10 8 m/s). Los haces de luz están compuestos por partículas denominadas
fotones.
A nivel físico, los llamados colores compuestos, están hechos de
diversas cantidades de de colores “puros” encontrados en el espectro.
Al iluminar cualquier objeto dado con una fuente de luz es golpeado por
“billones y billones” de fotones, o pequeñas partículas de luz, algunos de ellos
serán absorbidos y otros reflejados. La reflexión de la luz sobre un objeto
depende del tipo, distribución y cantidad de átomos que contenga.
Cada uno de esos fotones es también una onda, con su correspondiente
longitud de onda y por tanto un color específico en el espectro.
7.2.3. Dualidad onda - partícula
La frecuencia (υ) de la teoría de las ondas se puede relacionar con la
teoría del fotón (E) de la teoría de la partícula a través de la ecuación de
Planck:
E = h υ
donde h es la constante de planck (factor de proporcionalidad = 6,63 x
10 -34 (Js)).
La frecuencia (υ) de una determinada onda es inversamente
proporcional a su longitud de onda.
7.3. Percepción del color
El color es la impresión producida al incidir en la retina los rayos
luminosos difundidos o reflejados por los cuerpos. El ojo humano es capaz de
captar las variaciones de la longitud de onda del espectro electromagnético
visualizándolo como diferentes colores, desde el violeta hasta el rojo.

Colores y sombras 7
Este fenómeno se debe al aspecto físico de la radiación, el ojo humano
que actúa como sensor y el cerebro que es capaz de percibir, diferenciar e
interpretar las imágenes que
conforman este espectro.
La retina del ojo, a
través de una estructura
formada por unos elementos
denominados bastones
(concentrados en los lados de
la retina) y conos
(concentrados en el centro),
tiene la capacidad para
discernir los colores, la
forma, los detalles y la
posición de los objetos.
Los conos están especializados en la visión del color, así unos ven
solamente el azul y el violeta, otros el verde y el amarillo y otros el rojo y el
naranja. Además, es capaz de adaptarse a las diferentes cantidades de luz y al
brillo de las escenas y discernir e identificar los diferentes colores.
Los bastones al contrario que los conos requieren muy poca luz, lo que
los hace muy adecuados para la visión nocturna, sin embargo, no son capaces
de discernir los colores.
Los fotones penetran en nuestro ojo enfocándose en la retina, ésta actúa
como una película fotográfica. Las células de la retina son excitadas por los
fotones, lo cual provoca un estímulo que es transmitido por las neuronas al
cerebro.
El cerebro interpreta esta información como luz y color. El nivel de
excitación es proporcional al número de fotones que llegan a la retina.
7.3.1. Características psicológicas del color
Figura 3 - Sección de un ojo humano
Necesitamos otras propiedades, además de la frecuencia, para
caracterizar nuestra percepción de la luz.
La cromaticidad hace referencia al conjunto de variables del color que
se utilizan normalmente para describir las diferentes propiedades de una fuente
de luz.
- El matiz es el croma de un color y depende de la longitud de onda
dominante. Es la cualidad que permite clasificar a los colores como
amarillo, rojo, violeta, etc. El matiz se mide de acuerdo con la proximidad
que tiene un color con relación a otro que se halle próximo en el círculo
cromático; por ejemplo: verde amarillento, naranja rojizo, azul violáceo,
etcétera

Colores y sombras 8
Figura 4 – Matiz
- Valor o luminosidad indica las luminancias de un color; es decir, el
grado de claridad u oscuridad que posee como cualidad intrínseca.
Dentro del círculo cromático, el amarillo es el color de mayor luminancia
y el violeta el de menor. Independientemente de los valores propios de
los colores, éstos se pueden alterar mediante la adición de blanco que
lleva el color a claves o valores de luminancia más altos, o de negro que
los disminuye.
- El tono es la resultante de la mezcla de los colores con blanco o
negro y tiene referencia de valor y de matiz. Por ejemplo, el amarillo
mezclado con negro modifica su matiz hacia el verde y se oscurece.
Figura 5 - Tono
- La saturación se refiere al grado de pureza de un color y se mide
con relación al gris. Los colores muy saturados poseen mayor grado de
pureza y se presentan con más intensidad luminosa en relación con su
valor. Los colores con menor saturación se muestran más agrisados,
con mayor cantidad de impurezas y con menor intensidad luminosa.
Figura 6 - Saturación
Se utilizan modelos de color con combinaciones de luz en términos de
frecuencia dominante haciendo uso de 3 colores para obtener una gama amplia
de colores. Esto se suele denominar gama de color del modelo. Los tres
colores utilizados en el modelo se denominan colores primarios.
Ningún conjunto de colores primarios describe todas las frecuencias del
espectro visible. Agregando colores primarios aumentamos el número de
posibles colores pero harían falta un número infinito de colores para poder
representar todos los posibles colores. Para muchos fines con los tres colores

Colores y sombras 9
primarios es suficiente, sino se puede representar un color concreto se pueden
utilizar métodos extendidos.
Cuando se proyectan juntas luces rojas, verdes y azules, obtenemos el
blanco.
Los colores secundarios se obtienen de la mezcla de los colores
primarios.
Figura 7 - Colores Primarios
7.4. Dispositivos de visualización
7.4.1. TRC
Figura 8 - Colores Secundarios
Un monitor para mostrar una imagen utiliza un tubo de rayos catódicos
(TRC) cuyo frente se "ilumina" con un cañón de electrones localizado en la
parte posterior del tubo, el cual dispara un haz de electrones muy concentrado
que al impactar con el material sensible del frente del tubo lo excita iluminando
los puntos que componen la imagen.
La forma en
que el haz "barre" la
pantalla para
desplegar una
imagen se denomina
deflexión. Ésta se
realiza excitando
convenientemente un
juego de bobinas
(def. Horizontal y def.
Vertical) que están
colocadas de forma
muy precisa en el
cuello del TRC. El
campo magnético que
Figura 9 - Tubo de rayos catódicos
generan al ser
excitadas desvía el haz para conseguir que apunten al frente del tubo a la
posición deseada.
Un monitor no forma la imagen, ésta se procesa y forma en la placa de
video del ordenador. Después se almacena en la memoria de video y se envía
esta información (señales de video y sincronización) al monitor. Éste la toma y
la ordena para poder mostrarla, para ello se utilizan dos señales de

Colores y sombras 10
sincronización de eventos consiguiendo que la imagen se muestre de forma
coherente y ordenada. La señales de sincronismo horizontal y vertical se
generan en la placa de video y sus características dependen del modo de video
elegido (resolución).
7.4.1.1. Análisis de los tiempos involucrados
Tiempo activo horizontal
Para desplegar una imagen, el haz apunta a la esquina superiorizquierda
de la pantalla y se mueve horizontalmente hasta el derecho de la
misma. El tiempo que emplea el haz para desplazarse del lado izquierdo al
derecho se denomina "tiempo activo horizontal".
Retardo Horizontal o tiempo de borrado
Es el tiempo utilizado en el regreso del haz a la izquierda de la pantalla
cuando éste ha alcanzado el lado derecho de la misma.
Tiempo Total horizontal
El haz cumple un ciclo horizontal completo cuando, empezando en el
borde izquierdo de la pantalla va hacia el lado derecho, y regresa atrás de
nuevo. Este “tiempo total horizontal” se obtiene sumando los tiempos de
Retardo Horizontal y Activo Horizontal
Velocidad de Refresco Horizontal
Dependiendo de la velocidad con la que el monitor puede trabajar,
pueden ocurrir cada segundo unos 20.000 a 80.000 ciclos horizontales . El
número de ciclos horizontales por segundo es denominado Refresco Horizontal
y normalmente está en KHz.
Tiempo Total Horizontal
Cuando trabajamos con la velocidad horizontal de un monitor
generalmente utilizamos el Refresco Horizontal. Sin embargo, al tratar con los
ciclos horizontales de un monitor específico, normalmente utilizaremos el
tiempo real de cada ciclo horizontal. El ciclo horizontal de un monitor es la
suma de los tiempos real horizontal y tiempo de borrado o retrazo.
7.4.1.2. Exploración de línea
Para desplegar una imagen completa no sólo hay que desplegar el haz
“de izquierda a derecha” de la pantalla, es decir, horizontalmente, sino también
“de arriba abajo”, es decir, verticalmente. Cada recorrido horizontal del haz se
llama exploración de línea "scanline”.

Colores y sombras 11
Tiempo activo vertical
Es el tiempo total que necesita el monitor para desplegar todas las líneas
horizontales. Dependiendo de la resolución vertical de un monitor, una imagen
en la pantalla puede componerse de 320 a 1600 líneas horizontales.
Retrazo o borrado vertical o tiempo de retardo
Es el tiempo que necesita el haz para una vez que ha alcanzado la
esquina inferior derecha de la pantalla retornar rápidamente a la parte superior
izquierda de la misma.
Tiempo Total Vertical
Es el tiempo que utiliza el haz para "barrer" desde la parte superior hasta
la inferior de la pantalla y volver a la esquina superior-izquierda.
Tiempo Total Vertical = Tiempo activo Vertical + Tiempo de Retrazo
Vertical
Hz.
Velocidad de Refresco Vertical o refresco vertical de un monitor
Es el número de ciclos verticales completados por segundo medido en
Raster: Es el ciclo completo de formación de un cuadro de imagen
7.4.1.3. Sincronizaciones horizontales y verticales
Señal de sincronización vertical
Utilizando esta señal el monitor controla el regreso del haz desde la
esquina inferior-derecha a la esquina superior-izquierda
Señal de sincronización Horizontal
Con esta señal el monitor controla el regreso del haz desde el lado
derecho al izquierdo
Pulso de Sincronización horizontal y posición de la imagen
Durante el tiempo de retardo horizontal el monitor recibe el pulso de
sincronización horizontal. El tiempo entre el extremo del tiempo activo
horizontal y la salida del pulso de la sincronización horizontal se denomina el
Porche Delantero Horizontal.
El tiempo durante el cual el pulso de sincronización horizontal
permanece activo, se denomina Ancho de Sincronización Horizontal.
Después de recibir el pulso de la sincronización horizontal, el monitor
devuelve el haz al lado izquierdo de la pantalla. El periodo de tiempo entre el
extremo del pulso de la Sincronización Horizontal y el comienzo del próximo
tiempo activo horizontal es denominado Porche Trasero Horizontal.

Colores y sombras 12
Modificando la posición del pulso de la sincronización horizontal respecto
al tiempo de retrazo horizontal se ajusta la posición de la imagen en la pantalla
a la derecha o izquierda.
Figura 10 - Pulso de sincronización horizontal
Pulso de Sincronización vertical y posición de imagen
Durante el tiempo de retrazo vertical el monitor recibe el pulso de la
sincronización vertical. El tiempo entre el extremo del tiempo activo vertical y la
salida del pulso de la sincronización vertical se llama el Porche Delantero
Vertical.
El tiempo durante el cual el pulso de la sincronización vertical
permanece activo se denomina la Anchura de la Sincronización Vertical.
Después de recibir el pulso de la sincronización vertical, el monitor devuelve el
haz al tope de la pantalla.
El periodo de tiempo entre el extremo del pulso de la Sincronización
Vertical y la salida del próximo tiempo activo vertical es el Porche Trasero
Vertical.
Modificando la posición del pulso de la sincronización vertical respecto al
tiempo de retardo vertical se ajusta la situación de la imagen en la pantalla
arriba o abajo.
7.4.2. LCD
LCD (Liquid Crystal Display) son las siglas en inglés de Pantalla de
Cristal Líquido, dispositivo inventado por Jack Janning, quien fue empleado de
NCR.
Se trata de un sistema eléctrico de presentación de datos formado por 2
capas conductoras transparentes y en medio un material especial cristalino
(cristal líquido) que tienen la capacidad de orientar la luz a su paso.

Colores y sombras 13
Cuando la
corriente circula
entre los
electrodos
transparentes con
la forma a
representar (por
ejemplo, un
segmento de un
número) el
material cristalino
se reorienta
alterando su
transparencia.
Figura 11 - LCD
El material base de un LCD lo constituye el cristal líquido, el cual exhibe
un comportamiento similar al de los líquidos y unas propiedades físicas
anisotrópicas similares a las de los sólidos cristalinos. Las moléculas de cristal
líquido poseen una forma alargada y son más o menos paralelas entre sí en la
fase cristalina. Según la disposición molecular y su ordenamiento, se clasifican
en tres tipos: nemáticos, esméticos y colestéricos. La mayoría de cristales
responden con facilidad a los campos eléctricos, exhibiendo distintas
propiedades ópticas en presencia o ausencia del campo. El tipo más común de
visualizador LCD es, con mucho, el denominado nemático de torsión, término
que indica que sus moléculas en su estado desactivado presentan una
disposición en espiral. La polarización o no de la luz que circula por el interior
de la estructura, mediante la aplicación o no de un campo eléctrico exterior,
permite la activación de una serie de segmentos transparentes, los cuales
rodean al cristal líquido. Según sus características ópticas, pueden también
clasificarse como: reflectivos, transmisivos y transreflectivos.
Las pantallas LCD se encuentran en multitud de dispositivos industriales
y de consumo: máquinas expendedoras, electrodomésticos, equipos de
telecomunicaciones, computadoras, etc. Todos estos dispositivos utilizan
pantallas fabricadas por terceros de una manera más o menos estandarizada.
Cada LCD se compone de una pequeña placa integrada que consta de:
• La propia pantalla LCD.
• Un microchip controlador.
• Una pequeña memoria que contiene una tabla de caracteres.
• Un interfaz de contactos eléctricos, para conexión externa.
• Opcionalmente, una luz trasera para iluminar la pantalla.
El controlador simplifica el uso del LCD proporcionando una serie de
funciones básicas que se invocan mediante el interfaz eléctrico, destacando:
• La escritura de caracteres en la pantalla.
• El posicionado de un cursor parpadeante, si se desea.
• El desplazamiento horizontal de los caracteres de la pantalla
(scrolling).

Colores y sombras 14
La memoria implementa un mapa de bits para cada carácter de un juego
de caracteres, es decir, cada octeto de esta memoria describe los puntitos o
píxel que deben iluminarse para representar un carácter en la pantalla.
Generalmente, se pueden definir caracteres a medida modificando el contenido
de esta memoria. Así, es posible mostrar símbolos que no están originalmente
contemplados en el juego de caracteres.
El interfaz de contactos eléctricos suele ser de tipo paralelo, donde
varias señales eléctricas simultáneas indican la función que debe ejecutar el
controlador junto con sus parámetros. Por tanto, se requiere cierta
sincronización entre estas señales eléctricas.
La luz trasera facilita la lectura de la pantalla LCD en cualquier condición
de iluminación ambiental.
Existen dos tipos de pantallas LCD en el mercado: pantallas de texto y
pantallas gráficas.
7.4.2.1. Funcionamiento
El funcionamiento de estas pantallas se fundamenta en sustancias que
comparten las propiedades de sólidos y líquidos a la vez. Cuando un rayo de
luz atraviesa una partícula de estas sustancias tiene necesariamente que
seguir el espacio vacío que hay entre sus moléculas como lo haría atravesar un
cristal sólido pero a cada una de estas partículas se le puede aplicar una
corriente eléctrica que cambie su polarización dejando pasar a la luz o no.
Una pantalla LCD esta formada por 2 filtros polarizados colocados
perpendicularmente de manera que al aplicar una corriente eléctrica al segundo
de ellos dejaremos pasar o no la luz que ha atravesado el primero de ellos.
Para conseguir el color es necesario aplicar tres filtros más para cada uno de
los colores básicos rojo, verde y azul y para la reproducción de varias
tonalidades de color se deben aplicar diferentes niveles de brillo intermedios
entre luz y no luz lo, cual consigue con variaciones en el voltaje que se aplicaba
los filtros.
7.4.2.2 LCD de texto
Los LCD de texto son los más baratos y simples de utilizar. Solamente
permiten visualizar mensajes cortos de texto. Existen algunos modelos
estandarizados en la industria, en función de su tamaño medido en número de
líneas y columnas de texto. Existen modelos de una, dos y cuatro filas
únicamente. El número de columnas típico es de ocho, dieciséis, veinte y
cuarenta caracteres.
7.4.2.3. TFT
TFT o Thin Film Transistor (Transistor de Película Fina) es un tipo
especial de transistor de efecto campo construido depositando finas películas
sobre contactos metálicos, capa activa semiconductora y capa dieléctrica.

Colores y sombras 15
La aplicación más conocida de los TFT son las pantallas de visualización
planas de LCD, en las cuales cada píxel se controla mediante uno a cuatro
transistores. La tecnología de TFT proporciona la mejor resolución de todas las
técnicas flat-panel, pero es también la más costosa. Las pantallas de TFT a
veces se llaman LCDs de matriz activa.
Opera de forma individual con cada píxel, es decir, es direccionamiento
directo o de matriz activa. esto se consigue mediante una delgada capa de
transistores que controlan de forma individual cada píxel obteniendo mejores
tiempos de respuesta al no ser necesario el barrido completo de la pantalla ya
que el tiempo de de excitación de un píxel es menor que el tiempo de barrido
de la pantalla consiguiendo imágenes más nítidas y sin parpadeos.
7.4.3. Pantalla de plasma
Una pantalla de plasma es una pantalla plana en la cual la luz se crea
por la excitación de sustancias
fosforecentes mediante una
descarga de plasma entre dos
pantallas planas de vidrio. La
descarga de gas no contiene
mercurio (como en la luz de fondo
de las pantallas de LCD); una
mezcla de gases nobles (neón y
xenón) es utilizada en su lugar. Esta
mezcla de gas es inerte y totalmente
inofensiva.
La pantalla de plasma fue
inventada en la Universidad de Illinois
en Urbana-Champaign por Donald L.
Bitzer y H. Gene Slottow en 1964 para
Figura 12 – Funcionamiento de una
pantalla de plasma
el sistema informático PLATO. Los paneles originales eran monocromáticos.
Desde 1975, Larry Weber, de la Universidad de Illinois en Urbana-
Champaign, intentó crear una pantalla de plasma de color, consiguiéndolo
finalmente en 1995.
El mayor brillo y ángulo de visión de las pantallas de plasma actuales ha
provocado que estas pantallas sean cada vez más populares.
El plasma consiste en una sustancia eléctrica neutra con una lata de
ionización compuesta por iones, electrones y partículas neutras. Básicamente
el plasma es un mar de electrones e iones que conduce de manera excelente
la electricidad. Si se aplica suficiente calor los electrones se separan de sus
núcleos.

Colores y sombras 16
Una pantalla de plasma se compone de una matriz de celdas conocidas
como píxeles, que se componen a su vez de tres sub-píxeles, que
corresponden a los colores rojo, verde y azul.
El gas en estado de plasma reacciona con el fósforo de cada sub-píxel
para producir luz coloreada (roja, verde o azul). Estos fósforos son los mismos
que se utilizan en los tubos de rayos catódicos de los televisores y monitores
convencionales. Cada sub-píxel está controlado individualmente por un
procesador y se pueden producir más de 16 millones de colores diferentes.
Imágenes perfectas en un display de profundidad mínima.
7.5. El monitor vs. El ojo
El ojo no es como una cámara de televisión, la cámara produce una
imagen como la superposición de una serie de puntos brillantes y oscuros
obtenidos cuando los electrones acelerados por el cañón del televisor a lo largo
del tubo que se halla en el interior impactan contra una pantalla de material
fluorescente: este material absorbe la energía del choque, se excita y
posteriormente se des-excita emitiendo luz... ¡el puntito brillante que vemos!
Para una televisión en color, esos puntos brillantes corresponden cada
uno a un color primario, emitido en función de la energía que ha cedido el
electrón acelerado en el choque. Además existe una conexión uno-a-uno entre
cada punto del objeto y su imagen final, la cual se mantiene a través del
proceso por el que la cámara lo produce. Por lo tanto se puede interrumpir el
proceso en cualquiera de sus fases y se puede establecer que esa señal
electrónica proviene de ese punto en particular del objeto.
En el cerebro, ¡las cosas son muy distintas! Una parte de la corteza
visual que es la que procesa la señal, puede conectarse a muchas partes
diferentes de la retina de modo que el proceso de ver se hace muy complejo.
Se cree que ciertas partes de la corteza son muy buenas en el reconocimiento
de líneas horizontales y otras lo son en el reconocimiento de las verticales,
otras reconocen mejor el contorno de los objetos, etc... Esta compleja
arquitectura es la que hace que el cerebro sea mucho mejor en procesar la
información visual que incluso el más moderno de los ordenadores, el cual,
como una cámara de televisión, trabaja la información sobre la base de uno-auno
(1:1).
7.6. Profundidad del color
La calidad de la imagen se puede mejorar incrementando la resolución
de la pantalla, el número de píxeles del dibujo o también incrementando el
número de colores disponibles.
7.6.1. Color de 1-bit
No existe un nombre que se utilice habitualmente para denominar este
simple modo de color. La denominación de “blanco y negro” ha sido utilizada

Colores y sombras 17
incorrectamente para referirnos a la “escala de grises” cuando en realidad sólo
se pueden representar 2 colores.
Este modo de video permite 2 colores ya que se utiliza 1 bit dedicado a
la información de color por cada píxel (2 1 ).
Cuando hablamos de color de 1 bit nos
referimos a blanco o negro; algunas veces los 2 colores
no son blanco y negro, hubo terminales que utilizaron 2
tipos de verdes: claro y oscuro. El siguiente dibujo es
un ejemplo de una imagen de 1 bit de profundidad, sólo
utiliza el blanco y el negro.
El color de 1-bit se utilizó en dispositivos
de texto, hubo excepciones, los Macintosh (que
no tenían este modo de texto) y los originales IBM
MGA (Monochome Graphics Adapter, que tenía
un modo grafico adicional al modo de texto).
7.6.2. Color de 4-bits
Fue utilizado por los dispositivos IBM EGA (Enhanced Graphics
Adapter), también por el Commodore 64 y 128 y otros muchos.
BLACK DARK GREY BLUE LIGHT BLUE
GREEN LIGHT GREEN CYAN LIGHT CYAN
RED LIGHT RED PURPLE LIGHT PURPLE
YELLOW LIGHT YELLOW LIGHT GREY
Figura 13 - Imagen con
1 bit de profundidad
WHITE
Este modo de video permite 16 colores ya que se utilizan 4 bits
dedicados a la información de color por cada píxel (2 4 )
El Commodore Amiga e IBM VGA (Vídeo Graphics Adapter) permitían
indexación. Sólo se podía disponer de 16 colores de manera simultánea, pero
los 16 colores se pueden elegir de una amplia paleta y cada paleta puede
redefinir sus colores. Así un programa puede utilizar una escala de 16 grises,
los 16 colores originales de EGA, o elegir cualquier combinación de colores de
la amplia paleta de colores disponible. La única restricción es la utilización de
16 colores de forma simultánea.

Colores y sombras 18
7.6.3. Color de 8-bits
Este modo de video permite 256 colores
en pantalla ya que se utilizan 8 bits dedicados a
la información de color por cada píxel (2 8 ). Con
estos bits se hace referencia al índice de la
paleta de color. La paleta nos permite
seleccionar entre 16 millones de colores. Cada
color de la paleta se selecciona especificando 8
bits para cada intensidad de rojo, verde y azul
(la intensidad de cada componente puede tener
una valor entre 0 y 255)
Este modo de color combinado con la fusión
permite obtener resultados aceptables para
ciertas aplicaciones. También se pueden utilizar
los 8 bits para imágenes de un tono continuo en
blanco y negro con 256 matices de color, vemos
un ejemplo de imagen de tono continuo.
7.6.4. Color de 24-bits
Este modo de video permite 16.777.216 colores en pantalla ya que se
utilizan 24 bits dedicados a la información de color por cada píxel (2 24 ). Este
modo de color mantiene 8 bits de color para componente de color rojo, verde y
azul. Disponemos de los más de 16 millones de colores en cada píxel de la
pantalla.
Figura 15 - Imagen con 24 bits de profundidad
Figura 14 - Imagen byn
con 256 matices de color
El inconveniente de la utilización de este modo es la utilización de
memoria que se necesita para pantallas de alta resolución (2MB para
1024x768). También es más lento mover grandes cantidades de memoria para
realizar una animación o simplemente dibujar en pantalla. Aunque las tarjetas
aceleradoras están optimizadas para este tipo de operaciones.

Colores y sombras 19
7.7. Modelos de color
El propósito de un modelo de color es facilitar la especificación de
colores en algún formato estándar. Un modelo de color es una especificación
de un modelo de coordenadas 3-D y un subespacio dentro de ese sistema
donde cada color se representa por un punto único.
La mayoría de los modelos de color que se utilizan están orientados
hacia el hardware como monitores o impresoras o aplicaciones de
manipulación de color. El modelo orientado al hardware más común es el RGB
(red-green-blue), el modelo CMY (cyan-magenta-yellow) para impresoras en
color y el YIQ que es el estándar para la difusión de TV ( Y = luminancia, I y Q
son dos componentes cromáticas). Para la manipulación del color se suelen
utilizar los modelos HSI (matiz, saturación e intensidad) y HSV (matiz,
saturación y valor).
Los modelos más utilizados en el procesamiento de imágenes son RGB,
YIQ y HSI.
7.7.1. Modelo de color XYZ
En los años 30, la Commission Internationale de l'Eclairage (CIE) definió
un espacio de color estándar, una manera de definir colores en términos
matemáticos, para facilitar la comunicación de la información de color. Este
espacio de color está basado en la investigación sobre la naturaleza de la
percepción del color.
7.7.1.1. Espacio de color CIE
En el intento de lograr una representación que utilice solamente
coeficientes de mezcla positivos, el CIE ("d'Eclairage de Internationale de la
Comisión") definió tres nuevas fuentes de luz hipotéticas, x, y, y z, resultando
curvas positivas:
Figura 16 - representación de las fuentes de luz x, y, z
Dado un espectro y un deseamos encontrar los valores correspondientes
de X, de Y, y de Z, lo podemos lograr integrando el producto de la energía

Colores y sombras 20
espectral con cada una de las tres curvas sobre todas las longitudes de onda.
Los pesos de X, Y y Z se toman del espacio tridimensional del CIE XYZ, según
lo mostrado arriba.
Esto es logrado proyectando el espacio de color 3D sobre el plano
X+Y+Z=1, resultando un diagrama de la cromaticidad del CIE.
Se define la proyección como:
Resultando el diagrama de cromaticidad CIE
7.7.1.1.1. Diagrama de cromaticidad CIE
El diagrama de cromaticidad CIE es un
modelo de dos dimensiones de visión del color.
El arco alrededor de la parte superior de la
herradura incluye los colores espectrales puros
desde el violeta azulado hasta el rojo.
Mezclando dos colores espectrales puros
en diferentes proporciones es posible crear
todos los colores que se encuentran en la línea
recta dibujada entre ellos en el diagrama. Es
posible crear el mismo tono de gris mezclando el
verde azulado y el rojo o mezclando el verde
amarillento y el violeta azulado. Esto es
posible debido a un fenómeno peculiar
de la visión del color llamado
metamerismo. Los colores púrpura, que
no existen en el espectro de la luz pura, se encuentran en la parte inferior del
diagrama. Los púrpuras son mezclas de rojo y azul, los extremos opuestos del
espectro.
El diagrama de cromaticidad CIE refleja el tono y la saturación, pero es
necesario un modelo tridimensional para añadir el componente del brillo.
Muchas aplicaciones informáticas incluyen cuadros de diálogo en los que es
posible seleccionar colores manipulando el tono, la saturación y el brillo. Por
ejemplo, Adobe Photoshop utiliza un cuadro Selector de Color que puede
configurarse según las preferencias personales.
7.7.1.1.2. Gama de colores
Figura 17 - Diagrama de cromaticidad
CIE
El diagrama de cromaticidad se puede utilizar para comparar las
"gamas" de varios dispositivos de salida posibles (es decir, los monitores e
impresoras). Note que una impresora de color no puede reproducir todos los
colores visibles en un monitor de color.

Colores y sombras 21
7.7.2. El modelo de color RGB
Figura 18 - Comparación de gamas de colores
El modelo aditivo de color utilizado para los gráficos de computadora es
representado por el cubo del color del RGB, donde R, G, y B representan los
colores producidos por los fósforos rojos, verdes y azules, cubo del color de
respectivamente. El cubo se proyecta dentro del espacio de color del CIE XYZ
Nuestros ojos perciben el color a través de la simulación de tres
pigmentos visuales en los conos de la retina. Estos pigmentos tienen una
sensibilidad pico en las longitudes de onda 630 nm (rojo), 530 nm (verde), y
430 nm (azul). Comparando las intensidades en una fuente de luz, se percibe
el color de la luz. Esta teoría es la base para desplegar la salida de color en un
monitor de video mediante el uso de los tres colores primarios, conocido como
modelo de color RGB.
Cada color aparece en sus componentes primarias espectrales rojo,
verde y azul. El modelo está basado en un sistema de coordenadas cartesiano.
El subespacio de interés es el cubo que se muestra en la figura 19.
Todos los colores han sido normalizados de
forma que el cubo es unitario, es decir, se supone
que todos los valores de rojo, verde y azul están
en el rango [0, 1].
Este esquema de color es un modelo
aditivo: las intensidades de los colores primarios
se suman para producir otros colores. Cada punto
de color contenido en los límites del cubo puede
representarse como la tríada (R,G,B), donde los
valores de R,G,B se asignan en el intervalo de 0 a
1. Por ejemplo, el vértice magenta se obtiene
sumando el rojo y el azul para producir la tríada Figura 19 - Cubo RGB
(1,0,1) y el blanco en (1,1,1) es la suma de los
vértices rojo, verde y azul. Las sombras de gris se representan a lo largo de la
diagonal principal del cubo del origen (negro) al vértice blanco. Cada punto
situado en esta diagonal tiene una contribución igual de cada color primario, de
manera que una sombra de gris en medio del negro y el blanco se representan
como (0.5, 0.5, 0.5).

Colores y sombras 22
Las imágenes en el modelo de color RGB están formadas por tres
planos de imágenes independientes, cada una de los colores primarios.
Cuando se introducen en un monitor RGB, las tres imágenes se combinan en la
pantalla de fósforo para producir una imagen de color compuesta. Por tanto, se
utiliza el modelo RGB para el procesamiento de imágenes si las imágenes se
expresan en términos de los tres planos de colores. La mayoría de las cámaras
en color que se usan para adquirir imágenes digitales utilizan el formato RGB.
Uno de los mejores ejemplos de la utilidad del modelo RGB es el
procesamiento de imágenes aéreas y de satélites multiespectrales. Estas
imágenes se obtienen para diferentes rangos espectrales. Por ejemplo, las
imágenes LANDSAT se obtienen como mínimo en cuatro ventanas espectrales
distintas de la misma escena. Dos ventanas estarán alojadas en el espectro
visible y se corresponden aproximadamente con verde y rojo; las otras dos se
encontrarán en el infrarrojo. Así pues cada plano de la imagen tiene sentido
físico y la combinación de color utilizando el modelo RGB para procesamiento y
visualización tiene sentido cuando se ve en una pantalla en color.
A continuación se muestra una imagen en color de verduras y frutas
junto con sus tres bandas de color rojo, verde y azul. El mayor nivel de gris en
cada banda corresponde con el color predominante en cada objeto (fruta o
verdura).
Figura 20 - (a) Imagen original en color. (b) Plano de rojo. (c) Plano verde. (d)
Plano azul
Sin embargo este modelo de color no siempre es el mejor para el
procesamiento de imágenes, por ejemplo para realizar una imagen en color con
sombra de una cara humana. Este problema puede resolverse mediante la
igualación del histograma. Al tener tres bandas y puesto que el histograma
trabaja sólo con las intensidades, cuando igualemos el histograma en cada

Colores y sombras 23
banda, en cada una de ellas tendremos mejora, sin embargo, el resultado
global, (cuando se combinen las tres bandas), será impredecible.
A pesar de todo este modelo es la elección más corriente para gráficos
por ordenador ya que los CRT usan fósforo rojo, verde y azul para crear el
color deseado. Sin embargo, este modelo no describe de forma eficiente las
tres componentes de color (R,G,B). El igual ancho de banda da lugar a la
misma profundidad del píxel y resolución del dispositivo para cada
componente. Sin embargo, la sensibilidad de la componente de color del ojo
humano es menor que la de la luminancia.
Por estas razones, muchos métodos de codificación de imágenes y
sistemas de transmisión utilizan la luminancia y dos diferencias de colores.
Estos son los formatos YUV, YIQ, Y CbCr.
7.7.3. El modelo de color CMY (Cyan, Magenta, Amarillo)
Un modelo de color definido con los colores primarios cyan, magenta y
amarillo (CMY) es útil para describir la salida de color de los dispositivos de
copia hardware. A diferencia de los monitores de video, que producen un
modelo de color combinando luz de los fósforos de la pantalla, los dispositivos
hardware como las impresoras producen una imagen de color cubriendo un
papel con pigmentos de color. Se obtienen los colores por luz reflejada, lo cual
es un proceso sustractivo.
Por ejemplo, el cyan (azul-verde) puede formase combinando luz verde
con luz azul, por tanto cuando se refleja luz blanca sobre un objeto que es
verde-azul la luz reflejada no debe tener componente roja, es decir, la luz roja
es absorbida, o sustraída por el objeto. De forma análoga para obtener el
magenta se resta la componente verde de la luz incidente y el amarillo sustrae
la componente azul.
En el modelo CMY, el
punto (1,1,1) representa el
negro, ya que todas las
componentes de la luz incidente
se sustraen. El origen representa
la luz blanca. Cantidades iguales
de cada uno de los colores
primarios producen grises a lo
largo de la diagonal principal del
cubo.
Rojo
Magenta
Azul
Negro
Blanco
Amarillo Verde
Figura 21 - Cubo de Color
Cyan (Verde-Azul)
Como ya sabemos el cyan, magenta y amarillo son los colores
secundarios. Para convertir los colores primarios en secundarios hemos de
realizar la siguiente transformación:

Colores y sombras 24
⎛ C ⎞ ⎛1⎞
⎛ R ⎞
⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎜ M ⎟ = ⎜1⎟
⋅⎜
G⎟
⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎝ Y ⎠ ⎝1⎠
⎝ B ⎠
La figura 20 (a,b,c) muestra las representaciones en las
correspondientes bandas de la imagen en la figura 20 (a). Para obtener estas
imágenes se ha normalizado cada canal a uno independientemente,
dividiéndolo por 255, a continuación se le ha restado a uno dicha cantidad y por
último se ha multiplicado el resultado por 255.
7.7.4. El modelo de color YUV
Este es el formato de color que se utiliza por los estándares de TV
NTSC, PAL y SECAM. La Y representa la componente de blanco y negro y la
información de color U y V se añade para mostrar una imagen en color. La
transformación es:
⎛ Y ⎞ ⎛ 0.
299
⎜ ⎟ ⎜
⎜U
⎟ = ⎜−
0.
147
⎜ ⎟ ⎜
⎝V
⎠ ⎝ 0.
615
0.
587
− 0.
289
− 0.
515
0.
114 ⎞ ⎛ R ⎞
⎟ ⎜ ⎟
0.
436 ⎟ − ⎜G
⎟
− 0.
100⎟
⎜ ⎟
⎠ ⎝ B ⎠
Observemos que U = 0.492 (B - Y). y que V = 0.877 (R – Y ).
Normalmente U y V son submuestreados por un factor de dos a cuatro en la
dimensión espacial, ya que el ojo humano es mucho menos sensible a estos
factores. Esto es muy útil, por ejemplo, para reducir el número de bits utilizado
en técnicas de compresión de imágenes.
7.7.5. El modelo de color YIQ
Este modelo se utiliza en las emisiones de TV en color. Básicamente,
YIQ es una recodificación de RGB para aumentar la eficiencia en la trasmisión
y para mantener la compatibilidad con los estándares de TV monocromo. De
hecho, la componente Y del sistema YIQ proporciona toda la información de
video que se requiere para una televisión monocromo. La conversión de RGB a
YIQ viene dada por:
⎛Y
⎞ ⎛0.
299
⎜ ⎟ ⎜
⎜ I ⎟ = ⎜0.
596
⎜ ⎟ ⎜
⎝Q
⎠ ⎝0.
212
0.
587
− 0.
275
− 0.
523
0.
114 ⎞ ⎛ R ⎞
⎟ ⎜ ⎟
− 0.
321⎟
• ⎜G
⎟
0.
311 ⎟ ⎜ ⎟
⎠ ⎝ B ⎠
Este sistema fue diseñado teniendo en cuenta las características del
sistema visual humano, obteniendo mayor sensibilidad a los cambios en
luminancia que a los cambios de matiz o saturación. Así pues, este estándar
usa más bits (o ancho de banda) para representar Y y menos para I y Q.
Es uno de los modelos que más se utilizan. Una de sus mayores
ventajas es que las informaciones de luminancia (Y) y color (I y Q) están
separadas, esto nos permite procesar la luminancia sin afectar al color.

Colores y sombras 25
La figura 22 (d,e,f) muestra las representaciones en las correspondientes
bandas de la imagen en la figura 22 (a).
Figura 22 - (a) Plano C del modelo CMY (b) Plano M del modelo CMY (c) Plano
Y del modelo CMY (d) Plano Y del modelo YIQ (e) Plano I del modelo YIQ (f)
Plano Q del modelo YIQ.
Observemos que la figura 22(d) es una imagen en niveles de gris de la
imagen original. Puesto que las bandas YUV tienen rangos distintos todas han
sido llevadas al [0,255] para la visualización. Tengamos en cuenta que tanto la
banda U como V pueden tener valores negativos.
7.7.6. El modelo de color HSI
El matiz es un atributo que describe la pureza de un color. La saturación
es una medida del grado en el que un color puro se diluye con la luz blanca. La
utilidad del modelo de color HSI se debe principalmente a estas dos
características:
- La componente de intensidad se separa de la información de color
- Las otras dos componentes están muy relacionadas con la forma en
la que el ser humano percibe el color.
Gracias a estas propiedades este modelo es muy apropiado para el
desarrollo de algoritmos de procesamiento de imágenes basados en
propiedades del sistema de visión humano.

Colores y sombras 26
7.7.7. El sistema HLS (Hue, Saturation and Luminance)
Este modelo utiliza los tres componentes básicos del color: matiz (Hue),
saturación (Saturation) y brillo (Luminance). Una representación gráfica
incluyendo estas tres propiedades genera el
denominado "espacio y color".
En el perímetro del disco están situados
los colores azul, magenta, rojo, amarillo, verde
y cyan, separados 60º uno de otro:
Cada punto del perímetro describe un
color que es mezcla de los dos adyacentes.
Un punto que no esté en el perímetro
contendrá una mezcla de todos. Por lo tanto,
estos puntos describen colores pastel que
contienen una cierta cantidad de blanco. La
distancia al centro (radio) indicará la
saturación del color. El brillo (intensidad del
color) depende de la altura en el doble cono, y
es un valor entre 0 y 1.
El punto medio del disco central
describe un blanco de intensidad media.
Supongamos que, por ejemplo, comenzamos
en el perímetro del cono en el ángulo cero
(color azul) y nos movemos en línea recta
hacia arriba: estamos añadiendo más blanco,
Figura 23 - Modelo HLS
por lo que pasaremos por un azul claro, un azul pastel casi blanco hasta llegar
finalmente a un blanco brillante. Esto sucede con todos los colores.
La conclusión es que todos los colores convergen al blanco a medida
que avanzamos hacia el vértice superior y hacia el negro a medida que
bajamos.
7.7.8. Modelo HSV
Fue creado a partir de un concepto intuitivo de la manera de trabajar de
un artista y su modo de mezclar colores para obtener el correcto sombreado y
la obtención de los tonos intermedios. La selección y obtención de colores en el
modelo HSV es mucho más intuitiva que en los modelos RGB y CMY. Se basa
principalmente en el control de los valores de matiz, saturación y valor (HSV).
− Hue (Matiz): Se representa en un ángulo en torno a un eje vertical
(0º...360º). Los vértices del hexágono se separaran a intervalos de 60º. El rojo
está en 0º, el amarillo en 60º, el verde en 120º y el azul-verde opuesto al rojo
en H = 180º. Los colores complementarios distan 180º.

Colores y sombras 27
− Saturation (Saturación): Varia
de 0 a 1. Representa la pureza de un
matiz. La pureza máxima se representa
en S = 1. En S = 0 se tiene la escala de
gris.
− Value (Valor): Varia de 0 en la
cúspide del cono hexagonal a 1 en la
parte superior. En la cúspide se
encuentra el negro, en la parte superior
los colores de máxima intensidad.
Los conceptos de color
Figura 24 - Modelo HSV
asociados con los términos sombras,
tintes y tonos se representan en un plano seccional-transversal del cono
hexagonal HSV. Si se agrega negro a un matiz puro se disminuye V hacia el
lado del cono hexagonal. Por lo tanto, varias sombras se representan con
valores S=1 y 0

Colores y sombras 28
7.8. Colores en OpenGL
7.8.1. Utilización de colores con OpenGL
OpenGL especifica un color utilizando las intensidades separadas de
componentes rojo, verde y azul. Por lo tanto un color se especifica con 3
valores positivos, y puesto que el máximo disponible en el PC para el
almacenamiento de esta información son 24 bits (8 bits para cada componente)
podemos modelar los colores disponibles mediante un cubo de 255 unidades
en cada cara. A este volumen lo denominamos el espacio de color RGB.
Este “cubo de color” contiene todos los colores que podremos utilizar en
nuestras aplicaciones, tanto en la superficie como en el interior del mismo.
El modelo de color RGBA es el que utilizamos cuando definimos un color
con la función glColor*; utilizamos el modelo de color indexado cuando
seleccionamos un color de dibujo indicando un índice en una matriz de colores
disponible llamada paleta. Dentro de esta paleta, especificamos el color exacto
que queremos seleccionando las intensidades de las componentes roja, verde
y azul.
Los elementos geométricos se dibujan con los atributos activos en cada
momento. En cualquier momento se pude modificar el valor de
los atributos, sustituyendo el nuevo valor al anterior. Los atributos
podrán apilarse y desapilarse.
La figura siguiente muestra el dibujo simple de dos
triángulos de diferentes colores. Estos se definen con la
instrucción glColor3f(red,green,blue) tal como se muestra en el
código C (ver código completo en el anexo, ejemplo 1).
void triangulo1(void)
{
}
glBegin(GL_TRIANGLES);
glColor3f(1.0,0.0,0.0);
glVertex2f(0.0,0.4);
glVertex2f(-0.4,0.0);
glVertex2f(0.4,0.0);
glEnd();
void triangulo2(void)
{
}
glBegin(GL_TRIANGLES);
glColor3f(0.0,0.0,1.0);
glColor3f(0.0,1.0,0.0);
glVertex2f(0.0,-0.4);
glVertex2f(-0.4,0.2);
glVertex2f(0.4,0.2);
glEnd();
Figura 25 - Triángulos

Colores y sombras 29
Listado 1 - Ejemplo de definición de colores
A pesar de que existe una instrucción que establece el color del segundo
triángulo a azul, ésta no tendrá efecto ya que quedará anulado por la siguiente
instrucción que lo pone a verde.
La sintaxis de la función glColor es la siguiente:
• Propósito: Selecciona el color actual en el modo de color RGBA.
• Fichero de inclusión:
• Sintaxis: void glColor. Donde número de argumentos
puede ser 3 ó 4 (si hay componente alfa), y tipo de argumentos puede ser b(byte),
d(double), f(float), etc.. Por ejemplo: void glColor4b( GLbyte rojo, GLbyte verde,
GLbyte azul, GLbyte alfa); o void glColor3fv(const GLfloat *v);
• Descripción: Selecciona el color activo especificando por separado las
componentes roja, verde y azul. Algunas aceptan también la componente alfa (si no
se especifica vale por defecto 1.0). Las funciones con sufijo v toman un puntero a
una matriz que especifica las componentes.
• Parámetros:
rojo
Especifica la componente roja del color.
verde
Especifica la componente verde del color.
azul
Especifica la componente azul del color.
alfa
Especifica la componente alfa del color. (Ver siguiente apartado)
*v
Al dibujar polígonos se puede controlar que se dibujen sus aristas o solo
el interior. Es normal dibujar las aristas al realizar esquemas, mientras que
estas se suelen suprimir cuando se desea general imágenes realistas. El
control de visibilidad de las aristas se realiza con la función glEdgeflag(b)
donde el argumento b será 0 o 1 dependiendo de que se active o no el dibujo
de las aristas.
Pero no sólo podemos conseguir colores solidos, también gradientes. Eso
lo podemos llevar a la con un triángulo, por ejemplo; bastará con que le
asignemos un color distinto a cada vértice para que OpenGL rendere la imagen
con el gradiente de color resultante entre ellos (fijémonos que estamos con lo
que se denomina, color suave). La construcción del triángulo quedará así:

Colores y sombras 30
glBegin GL_TRIANGLES
glColor3f( 1.0,0.0,0.0 ) //color rojo
glVertex3f( 0.0,1.0,0.0 )
glColor3f( 0.0,1.0,0.0 ) //color verde
glVertex3f( -1.0,-1.0,0.0 )
glColor3f( 0.0,0.0,1.0 ) //color azul
glVertex3f( 1.0,-1.0,0.0 )
glEnd
Listado 2 - Ejemplo de definición de un gradiente
El resultado de la coloración de la escena es la siguiente:
7.8.2. Modelo de color RGBA
Figura 26 - Gradiente
En el modelo RGBA utilizamos la función glColor*( ) para seleccionar el
color actual que establece los colores rojo, verde, azul y la componente alfa (si
se utiliza transparencia). Todos los objetos dibujados después de la aplicación
de esta función tendrán el último color especificado en la misma.
Canal alpha
El canal alpha no es más que una imagen de 8 bits en escala de grises.
OpenGL interpreta esta información como sigue:
• Un valor alpha de 0 (color negro) indica transparencia total, es
decir, que la zona del polígono afectada por este valor no se verá.
• Un valor de 128 (color gris "puro") indica semitransparencia.
• Un valor de 255 (color blanco) indica opacidad total
El funcionamiento es el siguiente:
El modelo RGBA de color dota a cada punto de una cuarta componente
llamada canal alfa. Este sirve para decidir que debe hacerse con ese punto si
contribuye junto con otros a colorear un píxel. Hasta ahora el citado píxel se

Colores y sombras 31
pintaría del color del polígono más cercano pero si activamos el canal alfa
obtendremos “mezclas de colores” para el píxel. Cada polígono contribuirá en
un cierto tanto por ciento a colorear el píxel de forma que podemos obtener
interesantes efectos como emular un cristal tintado o un papel de celofán rojo,
por ejemplo:
Figura 27 - Funcionamiento
canal alpha
En esta imagen se observa que
mezclando dos colores generamos un
tercero o lo que es lo mismo, que si tengo
un objeto de color rojo y le pongo delante
un papel translúcido de color azul, la
intersección de ambos se verá de color
lila.
Eso ocurre porque el polígono que
está más cerca tiene un cierto grado de
transparencia por lo cuál nos deja ver lo
que tiene detrás. A esto se le llama
“Blending”. Siempre se habla de una
fuente (source) y un destino (destination). El destino es el valor de color que
un píxel ya tiene asignado en el frame buffer. La fuente es el color que
viene, el color que se mezclará con el que ya tiene.
Se combinan los colores de la fuente y del destino según el valor de
alfa que tiene cada uno de ellos. Se define una función de mezclado, o de
“blending” que, según sea, aplicará de una forma o de otra el canal alfa de
cada color.
Para hacer esto con OpenGL se deberá activar el mezclado de
colores y desactivarlo con las funciones glEnable(GL_BLEND) y
glDisable(GL_BLEND).
Para indicar como debe hacerse la mezcla se usará la función
glBlendFunc(Glenum factorfuente, Glenum factordestino). Dos
ejemplos:
1. glBlendFunc(GL_ONE,GL_ZERO). En este caso estamos
dando una importancia de 1 (máxima) al canal alfa de la fuente y
de 0 (nula) al canal alfa del destino. Eso equivale a decir que el
color final se compone de un 100% del de la fuente y de un 0%
del color destino por lo cual el píxel acaba siendo del color de la
fuente.
2. glBlendFunc(GL_SRC_ALPHA, GL_ONE). En este caso le
decimos que multiplique a la fuente por su valor de alfa y sume el
resultado al color destino. En este caso y asumiendo un valor de
alfa igual a 0.75 para la fuente, podríamos decir que el color
resultante=(color de la fuente*0.75)+Color del destino.
Sintaxis de la funcion:
glBlendFunc(Glenumfactor_o,Glenumfactor_d):

Colores y sombras 32
• Propósito: Define el color de las funciones de mezcla.
• Fichero de inclusión:
• Sintaxis: void glBlendFunc( GLenum factor_o, GLenum factor_d);
• Descripción: Selecciona los factores de origen y destino para la mezcla de colores.
Primero debemos llamar a glEnable(GL_BLEND) para activar la mezcla de colores.
• Parámetros:
factor_o
GLenum: la función de mezcla de color en origen.
factor_d
GLenum: la función de mezcla de color en destino.
• Retornos: Ninguno

Colores y sombras 33
Para las funciones glColor que aceptan valores enteros el rango de
valores que se acepta varía entre 0.0 y 1.0. el máximo y el mínimo valor que
puede ser almacenado en el framebuffer.
Cuando se especifican las componentes de color utilizando enteros sin
signo, estas componentes son mapeadas linealmente a valores de coma
flotante, de manera que representen valores comprendidos entre el 1.0
(intensidad total) y 0.0 (intensidad nula). Las componentes especificadas
utilizando valores enteros con signo son mapeadas linealmente a valores de
coma flotante, de manera que el valor más positivos representa al 1.0 y el
más negativo al 0.0
Sufijo Tipo de Dato Valor mínimo mínimo Valor de
Mapeo
Valor
Máximo
B 1-byte-integer -128 -1.0 127 1.0
S 2-byte-integer -32768 -1.0 32767 1.0
I 4-byte-integer -
Ub Unsigned 1- byte-
integer
Us Unsigned 2- byte-
integer
Ui Unsigned 4- byte-
integer
2.147.483.648
-1.0 2.147.483.647 1.0
0 0.0 255 1.0
0 0.0 65535 1.0
0 0.0 4.294.967.295 1.0
Valor Máximo de
Mapeo
• Propósito: Selecciona los valores de color y alfa para borrar los buffers de color.
• Fichero de inclusión:
• Sintaxis: void glClearColor(GLclampf rojo, GLclampf verde, GLclampf azul,
GLclampf alfa);
• Descripción: Selecciona los valores de relleno para borrar los buffers rojo, verde,
azul y alfa, que varían entre [0.0f,1.0f].
• Parámetros:
rojo
GLclampf: la componente roja del valor de relleno.
verde
GLclampf: la componente verde del valor de relleno.
azul
GLclampf: la componente azul del valor de relleno.
alfa
GLclampf: la componente alfa del valor de relleno.
• Retornos: Ninguno.
Una de las primeras acciones que hay que realizar en nuestras
aplicaciones es limpiar el área de dibujo en la que vamos a trabajar.

Colores y sombras 34
Limpiaremos la ventana cada vez que dibujemos una nueva imagen. Utilizando
el modelo tetradimensional RGBA podemos crear efectos en la ventana de
dibujo que interactúa con otras ventanas que se encuentren debajo de ella,
manipulando la opacidad de la ventana al limpiarla.
La función glClearColor(GLclampf rojo, GLclampf verde, GLclampf azul,
GLclampf alfa) selecciona los valores de relleno para
borrar los buffers rojo, verde, azul y alfa, que varían entre
[0.0f,1.0f]. Su sintaxis es la siguiente:
La figura muestra un ejemplo de modelo de color
RGBA en el que se muestra la transparencia de un
cristal de color rojo que deja ver parte de la esfera verde
situada por detrás de él. El código correspondiente a la
misma es el siguiente:
Figura 28 – modelo
de color RGBA

Colores y sombras 35
#include
#include
#include
#include
int idventana;
void cristal(void)
{
glShadeModel(GL_FLAT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glPushMatrix();
glTranslatef(-10,-10,-100.0);
glBegin(GL_QUADS);//Dibuja el cristal
glColor4f(1.0,0.0,0.0,0.10);
glVertex3f(0,0,0);
glVertex3f(0,10,0);
glVertex3f(10,10,0);
glVertex3f(10,0,0);
glEnd();
}
glPopMatrix();
glDisable(GL_BLEND);
void bola(void)
{
glPushMatrix();
glTranslatef(0,0,-150);
glColor4f(0.0,0.8,0.0,1.0);//Dibuja la bola amarilla
glutSolidSphere(6,20,10);
glPopMatrix();
}
void display(void)
{
GLfloat pos[4]={2.0,12.0,3.0,0.0};
glClearColor(1,1,1,1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
bola();
cristal();
glutSwapBuffers();
glFlush();
}
void myReshape(GLsizei w, GLsizei h)
{
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);

Colores y sombras 36
}
glLoadIdentity();
if (h==0)
gluPerspective(20,(GLdouble)w,1.0,500.0);
else
gluPerspective(20,(GLdouble)w/(GLdouble)h,1.0,500.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glFlush();
void Idle(void)
{
angulo+=0.5;
if (angulo>360) angulo=0;
glutPostRedisplay();
}
int main(int argc, char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowPosition(0,0);
glutInitWindowSize(300,300);
idventana=glutCreateWindow("Transparencia");
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glutIdleFunc(Idle);
glutMainLoop();
}
return 0;
Listado 3 - Ejemplo de definición de transparencia
7.8.3. Modelo de color indexado
Muchos sistemas tienen frame buffer limitado en profundidad. Podemos
tener una resolución espacial para el frame buffer de 1280x1024, pero cada
píxel tendría solo 8 bits de profundidad. Podemos dividir estos 8 bits en grupos
más pequeños de bits para asignar rojo, verde y azul. En algunas aplicaciones
esta técnica puede ser adecuada, pero no es muy flexible en la asignación de
colores ya que divide los bytes en distintos grupos de bits que pueden afectar
al resultado.

Colores y sombras 37
Podemos seleccionar los colores interpretando nuestra limitación de
profundidad (en los píxeles) como índices mejor que como valores de color.
Estos índices corresponden a filas o entradas en una tabla. Suponiendo que
nuestro frame buffer tiene k bits por píxel. Cada valor de píxel o índice es un
entero entre 0 y 2 k -1. Si podemos mostrar colores con una precisión de m bits
podremos elegir entre 2 m rojos, 2 m verdes y 2 m azules. Produciremos
cualquiera de los 2 3m colores aunque el frame buffer solo pueda especificar 2 k
colores. Utilizamos una tabla de búsqueda de colores de tamaño 2 k * 3 m, el
programa del usuario considerará 2 k filas de la tabla con los colores deseados
utilizando m bits para cada rojo, verde y azul.
Una vez que el usuario ha construido la tabla puede especificar un color
por su índice que apunta a la posición adecuada en la tabla de búsqueda de
color. Para k=m=8, una configuración muy común, se pueden elegir 256
colores de entre 16 millones de colores. Las 256 entradas en la tabla
constituyen la paleta de color del usuario.
Entrada Rojo Verde Azul
0 0 0 0
1 2 m -1 0 0
. 0 2 m -1 0
. . . .
. . . .
2 k -1 . . .
m bits m bits m bits
Si estamos utilizando el modelo de color indexado, el color actual es
seleccionado llamando a la función:
void glIndex{sifd ub} (TYPE c );
void glIndex{sifd ub}v (const TYPE *c );
Sintaxis de la función glIndex:

Colores y sombras 38
• Propósito: Selecciona el índice de color actual para usar con las
operaciones de color.
• Fichero de inclusión:
• Sintaxis:
• void glIndexd( GLdouble c);
• void glIndexf( GLfloat c);
• void glIndexi( GLint c);
• void glIndexs( GLshort c);
• void glIndexdv( const GLdouble *c);
• void glIndexfv( const GLfloat*c);
• void glIndexiv( const GLint *c);
void glIndexsv( const GLshort *c);
• Descripción: Esta función cambia el índice de color actual al
especificado por c.
• Parámetros:
c
El índice del nuevo color para uso en las siguientes operaciones.
*c
Un puntero al índice del nuevo color para uso en las siguientes
operaciones.
• Retornos: Ninguno.
En el modelo RGBA vimos la especificación de glClearColor(), para el
modelo de color indexado existe su análogo que es glClearIndex().
Formato de la instrucción glClearIndex:
• Propósito: Especifica un índice de color para el buffer de
color.
• Fichero de inclusión:
• Sintaxis: void glClearIndex(GLfloat indice);
• Descripción: Selecciona el valor de color que usaremos
para borrar el buffer de color con
glClear(GL_COLOR_BUFFER_BIT).
• Parámetros:
índice
GLfloat: el índice de color para el buffer de color.
• Retornos: Ninguno.
Para especificar el modo indexado de color debemos seleccionar el
miembro iPixelType de la estructura PIXELFORMATDESCRIPTOR como se
muestra a continuación:

Colores y sombras 39
PIXELFORMATDESCRIPTOR pfd; //declaración estructura
pfd.iPixelType = PFD_TYPE_COLORINDEX; //Selección modo
indexado de color
Si por el contrario trabajamos con el modo RGBA de color
seleccionaremos el miembro iPixelType de la estructura
PIXELFORMATDESCRIPTOR de esta manera:
pfd.iPixelType = PFD_TYPE_RGBA; //Selección
modo RGBA de color
Pegar código paleta.c
/////////////////////////////////////////////////////
// Principal o punto de entrada para todos los
programas Windows
/////////////////////////////////////////////////////
int APIENTRY WinMain(HINSTANCE hCurrentInst, HINSTANCE
hPreviousInst,
{
LPSTR lpszCmdLine, int nCmdShow)
HGLRC hRC; // Contexto para OpenGL
HWND hWnd; // Almacenamiento
para la gestion de Ventana
MSG msg; // Estructura de
mensajes de Windows
buffer
color
DWORD buffer = PFD_DOUBLEBUFFER; // tipo de
BYTE color = PFD_TYPE_RGBA; // tipo de
// Si en la llamada a la aplicación se ha
incluido el parámetro -sb
if (strstr(lpszCmdLine, "-sb")) { // Modo RGB
}
buffer = 0;

Colores y sombras 40
// Si en la llamada a la aplicación se ha
incluido el parámetro -ci
color Indexado
if (strstr(lpszCmdLine, "-ci")) {
}
color = PFD_TYPE_COLORINDEX; // Modo de
// Si en la llamada a la aplicación se ha
incluido el parámetro -h
el tipo
if (strstr(lpszCmdLine, "-h")) {
}
//Mostramos ayuda
MessageBox(NULL, "paleta [-ci] [-sb]\n"
" -sb single buffered\n"
" -ci color index\n",
"Usage help", MB_ICONINFORMATION);
exit(0); //saliendo!!
// Crea la ventana principal de la aplicación con
// y buffer de color seleccionado
hWnd = CreateOpenGLWindow("paleta", 0, 0, 256,
256, color, buffer);
if (hWnd == NULL)
salimos del programa!!
// Si no se puede crear correctamente
exit(1);
// Almacena el contexto de dispositivo
hDC = GetDC(hWnd);
// Crea el contexto de generación y lo activa
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
// Visualiza la ventana
ShowWindow(hWnd, SW_SHOW);

Colores y sombras 41
hasta que
UpdateWindow(hWnd);
while (1) //bucle infinito!!
{
PM_NOREMOVE)) {
programa
}
rota, colorea, ...)
}
// Procesa los mensajes de la aplicación
// la aplicación se cierra
while(PeekMessage(&msg, hWnd, 0, 0,
if(GetMessage(&msg, hWnd, 0, 0))
{
}
else
{
}
TranslateMessage(&msg);
DispatchMessage(&msg);
goto quit; //solicitada salida del
// Le hace de todo al triangulo (lo dibuja,
triangulo();
//Solicitan salir del programa
quit:
activado
// Deselecciona el contexto de generación
wglMakeCurrent(NULL, NULL);
ReleaseDC(hDC, hWnd);
wglDeleteContext(hRC);
//destruye la ventana window!
DestroyWindow(hWnd);

Colores y sombras 42
}
// Borra la paleta si fue creada
if (hPalette)
DeleteObject(hPalette);
return 0;
/////////////////////////////////////////////////////
// Creacion de la ventana para la aplicación
/////////////////////////////////////////////////////
HWND CreateOpenGLWindow(char* title, int x, int y, int
width, int height,
{
BYTE type, DWORD flags)
int n, pf;
HWND hWnd; //
Almacenamiento para la gestion de Ventana
clase de Windows
WNDCLASS wc; // Estructura de
LOGPALETTE* lpPal; // Puntero a
memoria para la paleta logica
PIXELFORMATDESCRIPTOR pfd; // Descriptor
del formato de pixel
almacenamiento
vez
static HINSTANCE hInstance = 0; // Instancia de
// Tan solo registro la clase de la ventana una
// uso hInstance como un flag
if (!hInstance) {
hInstance = GetModuleHandle(NULL);
// Registra el estilo de la Ventana
wc.style = CS_OWNDC;

Colores y sombras 43
ventana OpenGL
wc.lpfnWndProc = (WNDPROC)WindowProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
// No se necesita para la brocha de fondo de la
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = "OpenGL";
// Registra la clase de la ventana
if (!RegisterClass(&wc)) {
Window.", "Error", MB_OK);
}
}
MessageBox(NULL, "RegisterClass() failed: "
return NULL;
"No puedo registrar la class
// Crea la ventana principal de la aplicación
hWnd = CreateWindow("OpenGL", title,
WS_OVERLAPPEDWINDOW |
hInstance, NULL);
mostramos error!
WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
x, y, width, height, NULL, NULL,
// Si no se puede crear la ventana principal
if (hWnd == NULL) {
MessageBox(NULL, "CreateWindow() failed: No
puedo crear la ventana.","Error", MB_OK);
return NULL;

Colores y sombras 44
}
hDC = GetDC(hWnd);
// No hay garantías de que el contenido de la
pila que comienza en
la estructura
esta estructura
// pfd este a 0, nos aseguramos de ello
memset(&pfd, 0, sizeof(pfd));
pfd.nSize = sizeof(pfd); // Tamaño de
pfd.nVersion = 1; // Version de
// Dibuja
en la ventana (No en el mapa de bits), // Soporta llamada
OpenGL en la ventana, flags
pfd.dwFlags = PFD_DRAW_TO_WINDOW |
PFD_SUPPORT_OPENGL | flags;
pfd.iPixelType = type; // Tipo de pixel
pfd.cColorBits = 32; // Tamaño del
Buffer de Profundidad
lo descrito por pfd
// Escoge el formato de pixel que mejor encaje en
pf = ChoosePixelFormat(hDC, &pfd);
if (pf == 0) {
MessageBox(NULL, "ChoosePixelFormat() failed: "
ajuste!.", "Error", MB_OK);
}
return 0;
"No encuentro un formato de píxel que se
// Selecciona el formato de píxel para el
contexto de dispositivo
if (SetPixelFormat(hDC, pf, &pfd) == FALSE)
{

Colores y sombras 45
"
"Error", MB_OK);
}
return 0;
MessageBox(NULL, "SetPixelFormat() failed:
"No encuentro el formato especificado.",
//Toma el formato de píxel y recupera la
descripcion del formato de píxel
DescribePixelFormat(hDC, pf,
sizeof(PIXELFORMATDESCRIPTOR), &pfd);
necesita una paleta
/* Si el tipo de píxel seleccionado es Index ó se
entradas especificadas*/
entonces realiza selecciona una paleta con las
if (pfd.dwFlags & PFD_NEED_PALETTE ||
pfd.iPixelType == PFD_TYPE_COLORINDEX) {
n = 1 256) n = 256;
lpPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +
sizeof(PALETTEENTRY) * n);
memset(lpPal, 0, sizeof(LOGPALETTE) +
sizeof(PALETTEENTRY) * n);
>palPalEntry[0]);
lpPal->palVersion = 0x300;
lpPal->palNumEntries = n;
GetSystemPaletteEntries(hDC, 0, n, &lpPal-
/* Si el tipo de píxel seleccionado es RGBA,
entonces realiza selección

Colores y sombras 46
se selecciona Indexado
individual 1 a 1 */
de las mascaras para RGB, si por el contrario
hay que elegir los elementos de forma
if (pfd.iPixelType == PFD_TYPE_RGBA) {
int redMask = (1 pfd.cRedShift) & redMask) *
lpPal->palPalEntry[i].peGreen =
(((i >> pfd.cGreenShift) & greenMask) *
lpPal->palPalEntry[i].peBlue =
(((i >> pfd.cBlueShift) & blueMask) *
lpPal->palPalEntry[i].peFlags = 0;
/* Rellena las entradas con los colores
lpPal->palPalEntry[0].peRed = 0;
lpPal->palPalEntry[0].peGreen = 0;
lpPal->palPalEntry[0].peBlue = 0;
lpPal->palPalEntry[0].peFlags =

Colores y sombras 47
PC_NOCOLLAPSE;
PC_NOCOLLAPSE;
PC_NOCOLLAPSE;
}
lpPal->palPalEntry[1].peRed = 255;
lpPal->palPalEntry[1].peGreen = 0;
lpPal->palPalEntry[1].peBlue = 0;
lpPal->palPalEntry[1].peFlags =
lpPal->palPalEntry[2].peRed = 0;
lpPal->palPalEntry[2].peGreen = 255;
lpPal->palPalEntry[2].peBlue = 0;
lpPal->palPalEntry[2].peFlags =
lpPal->palPalEntry[3].peRed = 0;
lpPal->palPalEntry[3].peGreen = 0;
lpPal->palPalEntry[3].peBlue = 255;
lpPal->palPalEntry[3].peFlags =
//Crea la paleta
hPalette = CreatePalette(lpPal);
if (hPalette) {
//Avanza, selecciona y realiza la paleta
para este contexto de dispositivo
}
}
}
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
//libera la memoria de la estructura lpPal
free(lpPal);
ReleaseDC(hDC, hWnd);
return hWnd;
Listado 4 - Color indexado vs. Color RGBA

Colores y sombras 48
Figura 29 - Paleta modelo de color RGB
7.8.4. Modelo de color RGBA vs. Modelo de color Indexado
Figura 30 - Paleta modelo de color Index
No podemos usar el modo de color indexado y el modo de color RGBA
juntos. Esto significa que si usamos el modo indexado en un dispositivo de
color real, no tendremos acceso a todos los colores disponibles. Bajo algunas
implementaciones, la paleta de color indexado puede tener hasta 4096
entradas; sin embargo, la implementación de Microsoft sólo soporta 256
entradas.
Además de limitar la selección de colores, el modo indexado de color no
soporta otros efectos especiales de OpenGL, incluidos muchos efectos de
iluminación y sombreado, niebla, anti-escalonado y mezcla alfa. Generalmente
es mejor usar el modo RGBA. La ventaja más significativa de usar el indexado
es un mayor control de la paleta en dispositivos de pantalla de 8 bits.
Nuestra decisión en la utilización de modelo de color RGBA o Indexado
puede basarse en el hardware disponible y en las necesidades de nuestra
aplicación. Para la mayoría de sistemas muchos colores pueden ser
representados simultáneamente tanto con el modelo de color RGBA como con
el modelo de color Indexado. Sin embargo, en muchos efectos como el
sombreado, la iluminación, mapeado de texturas y niebla, el modelo RGBA
proporciona una mayor flexibilidad que el modelo de color indexado.
Podemos optar por utilizar el modelo de color indexado en tres casos:
1. Si estamos migrando una aplicación que hace un uso importante del
modelo de color indexado es más sencillo no cambiarlo al modelo RGBA.

Colores y sombras 49
2. Si disponemos de un pequeño numero de planos de color el modelo
RGBA puede producir sombreados de color de baja calidad. Por ejemplo,
si sólo disponemos de 8 planos de color con el modelo RGBA sólo
dispondremos de 3 bits para el rojo, 3 bits para el verde y 2 para el azul,
es decir, 8 (2 3 ) sombras de rojo y verde, y sólo 4 de azul.
En esta situación si tenemos limitados los requerimientos de sombreado
podemos utilizar una tabla de búsqueda de color para obtener mas
colores de sombra. Por ejemplo, si requerimos sólo sombras azules se
puede utilizar el modelo de color indexado y almacenar 256 (2 8 ) sombras
de color azul, esto es mucho mejor que las 4 sombras que nos ofrecía el
modelo de color RGBA.
3. El modelo de color indexado puede ser utilizado para hacer varios
trucos, como mapas de color, animaciones y dibujo por capas.
En general, utilizaremos el modelo de color RGBA siempre que sea
posible ya que permite mapeado de texturas y trabaja mejor con sombreado,
iluminación, niebla, antialiasing y combinación de colores (blending).
7.8.5. Ocultaciones
OpenGL permite utilizar dos métodos de ocultación: el algoritmo de las
caras de detrás (Back Face Removal), y el algoritmo del Z-buffer.
7.8.5.1. Algoritmo de las caras de detrás
Consiste en ocultar las caras que no se dibujarían porque formarían
parte de la parte trasera del objeto. Para decirle a OpenGL que queremos
activar este método de ocultación, tenemos que escribir:
glEnable(GL_CULL_FACE)

Colores y sombras 50
Figura 32 - Ocultando caras de detrás
Figura 31 - Sin ocultaciones
Importante. OpenGL ignora totalmente la normal que le podamos pasar
con la función glNormalf, así que esta normal sólo se utiliza a efectos de
iluminación. A efectos de ocultación de caras, OpenGL decide si oculta o no
una cara a partir del orden de definición de los vértices que la forman.
Así, si la proyección sobre del camino que forman los vértices del
primero al último es en el sentido de las agujas del reloj, entonces se dice que
el orden es clockwise. Si es en sentido inverso, se dice que es
counterclockwise. Por defecto, OpenGL sólo renderiza aquellos polígonos
cuyos vértices estan en orden counterclockwise cuando son proyectados
sobre la ventana. Pero los objetos definidos por la GLUT no tienen porqué estar
definidos clockwise (como es el caso de la tetera). Por tanto, antes de
renderizarlos usando este algoritmo de ocultación, debemos llamar a
glFrontFace(GL_CW) o a glFrontFace(GL_CCW).
7.8.5.2 Algoritmo del Z-buffer
El algoritmo del Z-buffer es del tipo espacio-imagen. Cada vez que se va
a renderizar un pixel, comprueba que no se haya dibujado antes en esa
posición un pixel que esté más cerca respecto a la cámara. Este algoritmo
funciona bien para cualquier tipo de objetos: cóncavos, convexos, abiertos y
cerrados. Para activarlo, hay que hacer una llamada a:
glEnable(GL_DEPTH_TEST)

Colores y sombras 51
Esta llamada le dice a OpenGL que active el test de profundidad.
Además, cada vez que se redibuje la escena, a parte de borrar el buffer de
color, hay que borrar el buffer de profundidad. Esto se hace con la llamada:
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT).
Por último, pero no menos importante, al inicializar OpenGL se le tiene
que decir que cree el buffer de profundidad. Esto se hace al definir el modo de
visualización (ver capítulo GLUT).
Figura 33 - Sin Z-Buffer Figura 34 - Con Z-Buffer
7.8.5.3. Combinando ambos algoritmos
El algoritmo de la eliminación de las caras de detrás es suficiente para
renderizar para objetos convexos y cerrados, como este octahedro, pero para
objetos cóncavos y cerrados no basta. Por ejemplo, un objeto con una cara
parcialmente oculta, como el de la figura, no tiene porqué renderizarse bien:
Figura 35 - Sin ocultaciones Figura 36 - Eliminando caras de detrás
Ahora bien, si sabemos que todos nuestros objetos están cerrados, es
decir, no se ve el interior, podemos combinarlo con el Z-buffer, ya que
descartaremos ya para empezar las caras que no vamos a ver, ganando así en
velocidad de renderización.

Colores y sombras 52
Figura 37 - Z-Buffer Figura 38 - Caras de detrás + Z-Buffer
Ahora bien, la combinación de estos dos algoritmos no siempre es
adecuada. En el caso de la tetera, por ejemplo, puesto que la tapa no está
perfectamente ajustada a la tetera, y por tanto, queda un hueco (es decir, se ve
el interior) ¡Si utilizamos el algoritmo de las caras de detrás veremos a través!
Por tanto, en este caso lo mejor es utilizar sólo el algoritmo del Z-buffer.
Figura 39 - Caras de detrás + Z-Buffer Figura 40 - Sólo Z-Buffer
7.8.6. El color de los materiales
La forma en que la luz incide sobre las superficies de los objetos
depende de las propiedades del material de los mismos. En OpenGL la forma
de definir estas propiedades es la función glMaterial cuya sintaxis es void
glMaterial{if}[v](GLenum face, GLenum pname, TYPEparam);
El primer argumento determina la cara del objeto donde se aplica el
material, puede tomar los valores GL_FRONT, GL_BACK, o
GL_FRONT_AND_BACK.
El siguiente argumento indica la propiedad del material que va a fijarse
(sus posibles valores se muestran en la tabla). Finalmente, el argumento param
permite asignar los valores a la propiedad pname.

Colores y sombras 53
Nombre del parámetro Valor por
defecto
GL_AMBIENT (0.2, 0.2, 0.2,
1.0)
GL_DIFFUSE (0.8, 0.8, 0.8,
1.0)
Significado
ambient color of material
diffuse color of material
GL_AMBIENT_AND_DIFFUSE ambient and diffuse color of
GL_SPECULAR (0.0, 0.0, 0.0,
1.0)
material
specular color of material
GL_SHININESS 0.0 specular exponent
GL_EMISSION (0.0, 0.0, 0.0,
1.0)
emissive color of material
GL_COLOR_INDEXES (0,1,1) ambient, diffuse, and specular
Reflexión ambiente y difusa
color indices
La reflexión difusa determina el color de un objeto y la reflexión ambiente
la forma en que el objeto redistribuye la luz ambiente que recibe. Los objetos
del mundo real suelen tener el mismo color de reflexión ambiente y difusa.
Reflexión especular
La componente especular define el color de los brillos del objeto cuya
forma se controla con el parámetro GL_SHININESS de modo que cuando
mayor sea este parámetro el brillo aparecerá más concentrado.
Emisión
OpenGL permite asignar a los objetos un color de emisión para que
parezca que dichos objetos emiten luz de un color, lo que permite simular
lámparas y objetos luminosos. Se pueden conseguir mejores efectos simulando
fuentes de luz en la misma posición que los objetos para los que se define un
color de emisión.
Cambio de las propiedades del material
Para minimizar el coste asociado a la realización de cambios en las
propiedades del material se usa la función glColorMaterial cuya sintaxis es la
siguiente:

Colores y sombras 54
Propósito: Permite que los colores del material sigan el color definido
por glColor.
• Fichero de inclusión:
• Sintaxis: void glColorMaterial(GLenum cara, GLenum modo);
• Descripción: Esta función permite seleccionar las propiedades de un
material sin tener que llamar directamente a glMaterial. Usando esta
función, podemos definir ciertas propiedades del material siguiendo
el color especificado actualmente por glColor. Para habilitar el
seguimiento, llamaremos a glEnable(GL_COLOR_MATERIAL).
• Parámetros:
func
• Retornos: Ninguno.
Cara podrá tomar los valores GL_FRONT_AND_BACK, GL_FRONT o
GL_BACK y modo GL_AMBIENT_AND_DIFFUSE, GL_DIFFUSE,
GL_SPECULAR o GL_EMISIÓN.
Una vez que se realiza la llamada a la función, se puede cambiar el color
de la propiedad que indica el parámetro modo para la cara definida en cara
usando glColor.
Después de llamar a la función glColorMaterial es necesario realizar
una llamada a glEnable con el argumento GL_COLOR_MATERIAL.
glColorMaterial(GL_FRONT, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glColor3f(0.2, 0.5, 0.8);
......../* dibujamos algo aquí */
glColor3f(0.9, 0.0, 0.2);
......... /*y otros */
glDisable(GL_COLOR_MATERIAL);
Veamos un ejemplo de todo esto:
#include
Listado 5 - Definiciones para materiales

Colores y sombras 55
#include
#include
GLfloat mat_diffuse [] = {0.5, 0.5,
0.5, 1.0};
GLfloat mat_specular [] = {0.5, 0.5,
0.5, 1.0};
GLfloat mat_shininess [] = {50};
void init (void)
{
GLfloat light_position[] = {1.0, 1.0,
1.0, 0.0};
glLightfv(GL_LIGHT0, GL_POSITION,
light_position);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable (GL_LIGHTING);
glEnable (GL_LIGHT0);
glDepthFunc(GL_LEQUAL);
glEnable (GL_DEPTH_TEST);
}
void display (void)
{
int i,j;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
for (i=-1; i

Colores y sombras 56
glTranslatef((float)i*3.0,(float)j*3.0,0.0);
}
}
}
glutSwapBuffers();
glutSolidSphere(1.0,16,16);
glPopMatrix();
void reshape(int w, int h)
{
glViewport ( 0, 0, w, h );
glMatrixMode ( GL_PROJECTION );
glLoadIdentity ( );
if ( h==0 )
else
1.0, 20.0 );
gluPerspective ( 60, ( float ) w, 1.0, 20.0 );
gluPerspective ( 60, ( float ) w / ( float ) h,
glMatrixMode ( GL_MODELVIEW );
glLoadIdentity ( );
gluLookAt(0.0,0.0,10.0,0.0,0.0,0.0,0.0,1.0,0.0);
}
/* Ciclo principal
* Abre una ventana con tamaño inicial definido, barra de
titulo,
* modo RGB, y control de eventos */
int main (int argc, char** argv)
{
glutInit (&argc, argv);

Colores y sombras 57
glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE |
GLUT_DEPTH);
glutInitWindowSize (250,250);
glutInitWindowPosition (100,100);
glutCreateWindow ("Ejemplo de luz");
init ();
/* llamada a inicializacion*/
glutReshapeFunc (reshape); /* llamada
para eventos de reshape de ventana*/
glutDisplayFunc (display); /* llamada
para dibujar...*/
glutMainLoop (); /* Crea la
ventana y dibuja...*/
}
Listado 6 - Ejemplo uso de propiedades de materiales

Colores y sombras
7.9. Sombras
Una sombra es una región de oscuridad donde la luz es obstaculizada.
Una sombra ocupa todo el espacio de detrás de un objeto opaco con una
fuente de luz frente a él. La sección eficaz de una sombra es una silueta
bidimensional o una proyección invertida del objeto que bloquea la luz.
Cuanto menor es el ángulo entre la dirección de la luz y un objeto
alargado que la obstaculice, más corta será su sombra. Por otro lado, cuanto
menor sea el ángulo entre la dirección de la luz y la superficie en la que
aparece la sombra, más larga será ésta. Si el objeto está cerca de la fuente
luminosa, la sombra será mayor que si el objeto se encuentra lejos. Si la
superficie está curvada, habrá más distorsiones.
Cuando la fuente de luz no es puntual, la sombra se divide en umbra y
penumbra. Cuanto más ancha es la fuente de luz, más difuminada o borrosa
será la sombra.
Si hay múltiples fuentes luminosas, habrá múltiples sombras, con las
partes solapadas más oscuras, o con una combinación de colores. Cuando una
persona o un objeto está en contacto con la superficie, como una persona
sentada en el suelo o un poste clavado, las sombras convergen al punto de
contacto.
Si sólo existe una fuente de luz, las sombras arrojadas por aquella serán
siempre grises, sea cual sea el color de la fuente. En cambio, si existen dos
fuentes de luz de distintos colores, supongamos rojo y azul, las sombras
proyectadas por cada una de ellas serán del color de la otra fuente de luz, y
sólo la intersección de ambas sombras será gris. Es decir, la sombra de la luz
roja será azul, pues está iluminada por la fuente azul, y viceversa. En el caso
de que existan más fuentes de luz, cada sombra será del color resultante de la
adición de las fuentes que aún iluminan esa zona, permaneciendo en gris las
zonas donde intersecten las sombras de todas las fuentes luminosas.
El proceso de sombreado o shading (en el contexto de los gráficos
realizada por ordenador) implica la simulación de computadora (o más
exactamente; el cálculo) como las caras de un polígono se comportarán
cuando es iluminado por una fuente de la luz virtual. El cálculo exacto varía
según no sólo que datos están disponibles sobre la cara sombreada, sino
también la técnica de sombreado.
Generalmente este afecta propiedades de la especularidad y valores de
intensidad, reflexión y transparencia.
Este proceso se realiza durante el renderizado.
El sombreado altera el color de las caras de un modelo 3D basándose
en el ángulo de la superficie con la fuente de luz. Las siguientes imágenes
muestran las diferencias:
58

Colores y sombras
Figura 42 Imagen renderizada de una caja.
Esta imagen no tiene sombreado de las caras, pero usa líneas en los
bordes para separar las caras.
Figura 43 Imagen sin líneas en los bordes
Aquí se observa como el sombreado altera el color de las 3 caras
basándose en el ángulo de las fuentes de luz.
Figura 44 Imagen son sombreado en las caras
59

Colores y sombras
7.9.1 Efecto falloff (Distance falloff)
Teóricamente, dos superficies que son paralelas son iluminadas con la
misma intensidad por una fuente de luz distante, como por ejemplo el sol.
Incluso si una superficie está más distante, el ojo ve más en el mismo espacio,
por eso la iluminación parece la misma.
Nótese que en la primera imagen el color de las caras frontales de las
dos cajas son exactamente iguales. Parece que hay una pequeña diferencia en
el punto de encuentro de las caras, pero esto es una ilusión óptica causada por
el borde vertical debajo de donde se encuentran las caras.
En la segunda imagen se puede observar que las superficies de las
caras son brillantes en la caja delantera y más oscuras en la situada en la parte
de atrás. También la superficie sobre la que están pasa de claro a oscuro
según se aleja.
Este efecto falloff produce imágenes que parezcan más realistas.
Figura 45 Cajas renderizadas con OpenGL
Figura 46 Cajas renderizadas con ARRIS CAD, efecto falloff
Un modelo de intensidad puede aplicarse al sombreado de superficies de
varias formas dependiendo del tipo de superficie y de los requisitos de la
aplicación. Los objetos con varias superficies suelen sombrearse de forma
realista con una sola intensidad por cada superficie. Para una superficie curva
60

Colores y sombras
podríamos aplicar el modelo de intensidad a cada punto de la superficie;
aunque esto produce un efecto muy realista es un proceso muy lento.
Para acelerar el proceso se podría representar una superficie curva
como un conjunto de polígonos y aplicar el modelo de sombreado a cada
plano. Cada una de estas superficies poligonales podría sombrarse después
con intensidad constante o bien podríamos variar el sombrado con valores de
intensidad interpolados.
Los algoritmos de superficies visibles determinan qué superficies ve el
ojo dependiendo de su posición. Los algoritmos de sombras determinan que
objetos se ven desde la fuente de luz. Por tanto, estos dos tipos de algoritmos
son esencialmente iguales. Las superficies visibles desde la fuente de luz están
iluminadas, las no visibles están en sombra.
Cuando hay múltiples fuentes de luz una superficie debe clasificarse
respecto a cada fuente de luz. Consideraremos en este tema algoritmos de
sombra para fuentes de luz puntuales. La visibilidad a partir de una fuente
puntual de luz es como la visibilidad en el ojo: “todo o nada”.
Cuando un punto en la superficie no puede verse desde una fuente
puntual de luz, el cálculo de iluminación debe ajustarse para tenerlo en cuenta.
Las áreas en la sombra de todas las fuentes puntuales de luz todavía
están iluminadas por la luz ambiente.
Aunque la utilización de sombras requiere el cálculo de la visibilidad de la
fuente de luz, pueden generarse sombras falsas sin hacer pruebas de
visibilidad.
7.9.2 Sombreado
La intensidad de luz que se observa en cada superficie de un objeto
depende del tipo de fuentes de luz que la ilumine y de las características de la
superficie del objeto. Algunos objetos tienen superficies brillantes y otros
opacas o mate. Además, algunos objetos se construyen con materiales opacos,
mientras que otros son mas o menos trasparentes. Un modelo de sombreado
para producir intensidades realistas sobre las superficies de un objeto debe
considerar estas propiedades.
Los patrones de sombra generados por un método de superficie oculta
son validos en cualquier posición de visión seleccionada siempre que las
posiciones de la fuente de luz no se alteren. Las superficies que son visibles
desde la posición de visión se sombrean según el modelo de intensidad, con
patrones de superficie y sombras anexados. Las superficies visibles que no son
iluminadas por una fuente de punto se les aplica únicamente intensidad de luz
ambiental. Las superficies visibles que son iluminadas por una fuente de puntos
61

Colores y sombras
se sombrean combinando el modelo de intensidad y la lista de patrones. Las
áreas de sombra proyectada se sombrean únicamente con la intensidad de la
luz ambiental.
Asumiendo que se puede computar vectores normales, dado un conjunto
de fuentes de luz y un observador, los modelos de luz e iluminación
desarrollados pueden aplicarse a cada punto de una superficie.
Lamentablemente, aunque se tenga ecuaciones sencillas para determinarlos
vectores normales, la cantidad de computaciones requeridas puede ser muy
grande. Se han visto muchas de las ventajas de usar modelos poligonales para
los objetos. Una ventaja adicional, para polígonos planos, es que se puede
reducir bastante el trabajo requerido para el sombreado. La mayoría de los
sistemas gráficos, incluyendo OpenGL, explota las posibles eficiencias para
polígonos planos, descomponiendo superficies curvas en muchos polígonos
planos pequeños, cada uno teniendo un vector normal bien definido.
7.9.3 Tipos de sombreado
7.9.3.1 Sombreado plano (Flat Shading)
Es una técnica usada en gráficos 3D en la que se sombrea cada
polígono de un objeto basándose en el ángulo que existe entre la superficie
normal del polígono y la dirección de la fuente de luz, sus respectivos colores y
la intensidad de la luz. Es el tipo de sombreado utilizado para el renderizado de
alta velocidad donde técnicas de sombreado más avanzadas tienen un coste
computacional excesivo.
La desventaja del sombreado de intensidad constante es que da a los
modelos con un número bajo de polígonos un aspecto poco natural, formado
por múltiples caras. A veces esta apariencia puede ser ventajosa, como al
modelar objetos poligonales. Los diseñadores a veces usan esta técnica para
observar las diferentes caras del objeto que están creando.
Bajo ciertas restricciones se puede obtener un sombreado realista en un
objeto con superficies planas utilizando intensidades con superficies
constantes. Si el objeto está únicamente expuesto a luz ambiental y no se
aplican texturas, sombras de superficie, etc., el sombreado de intensidad
constante genera representaciones exactas de la superficie del objeto. Para
objetos cuya superficie se ilumina con un foco de luz puntual el modelo produce
una superficie de intensidad constante siempre que el punto de referencia
visual y el foco estén suficientemente alejados de la superficie del objeto. Si por
el contrario el foco está alejado de la superficie no hay variación en la dirección
hacia la fuente. La dirección hacia un punto de visión distinto no cambiara
sobre una superficie, por lo tanto V.R = cte.
Si se representa mediante un conjunto de superficies planas una
superficie curva y los planos que subdividen esta superficie se hacen lo
suficientemente pequeños. Se pueden sombrear con intensidades de superficie
constante.
62

Colores y sombras
Cuando la orientación entre planos adyacentes cambia en forma
abrupta, la diferencia en intensidades de superficie puede producir un efecto
áspero e irreal. Se pueden aliar las discontinuidades de intensidad en estos
casos variando la intensidad sobre cada superficie de acuerdo con algún
esquema de interpolación.
Existen otro tipo de técnicas de sombreado más avanzadas como el
sombreado de Gouraud y el sombreado de Phong.
Figura 47 Comparación de las técnicas de sombreado
7.9.3.2 Sombreado de Gouraud
Creada en 1971 y llamada así en honor a Henri Gouraud, este método
es usado para simular el efecto de difusión de de la luz y los colores a través
de la superficie del objeto, esta técnica consigue alcanzar el sombreado de
superficies con pocos polígonos sin el alto coste computacional de calcular la
iluminación de cada píxel.
El sombreado de Gouraud aplica el patrón de iluminación a cada
vértice del polígono y entonces promedia los valores de color en toda la
superficie del objeto para así alcanzar un efecto de sombreado suave
que parece más realista sobre superficies curvas.
Este método de sombreado se emplea para disimular los polígonos
cuando éstos se emplean para aproximar una superficie curva, como una
esfera o un toroide, por ejemplo.
El método es el siguiente: primero calculamos las normales a la
superficie en los vértices de los polígonos. Esta normal en cada punto podemos
calcularla de dos maneras: 1ª-basándonos las características de la superficie
que vamos a aproximar, por ejemplo si se trata de una esfera, sabemos que la
normal va a ir en dirección opuesta al centro de la esfera. 2ª- Si no conocemos
la superficie que estamos aproximando, podemos sumar todas las normales de
los polígonos de los que forme parte ese vértice y normalizar el resultado.
63

Colores y sombras
Una vez hecho esto, calculamos por los procedimientos de iluminación
vistos anteriormente el color que correspondería a cada vértice. Después,
cuando vamos a dibujar el polígono, vamos interpolando linealmente a través
de cada arista entre los dos colores de los extremos de dicha arista, y por
último al ir trazando las líneas horizontales (o scanlines) que forman el
polígono, interpolamos de nuevo linealmente entre los dos valores que
correspondan a los puntos de las dos aristas entre las que estemos trazando la
línea horizontal. El resultado final de todo esto es un polígono con un suave
gradiente de intensidades sobre su superficie.
Se puede ver gráficamente esto con el ejemplo de
la figura 48, en la que conocemos los valores de la
intensidad en los puntos 1 2 y 3. Al ir dibujando el
triángulo, calculamos los valores del primer y el ultimo
píxel del triangulo en cada línea interpolando, a lo largo
de las aristas, los valores de los vértices. Esto nos da el
valor inicial y el final de cada línea horizontal, y para
rellenarla solo tenemos que interpolar linealmente de
nuevo los estos valores a lo largo de la línea.
Un vector normal a una superficie es un vector
que apunta en una dirección perpendicular a dicha
superficie. Si partimos de un triángulo, con tres vértices
P1, P2 y P3, el procedimiento para calcular la normal es
muy sencillo; se escoge un punto como origen, digamos
P2, y se calculan los vectores v1=P1-P2, y v2=P3-P2;
calculamos el producto vectorial entre V1 y V2, y nos sale
el vector normal.
Además, puesto que el vector normal prácticamente
solo se va a usar para calcular su ángulo con otros
vectores, es muy útil hacer que su módulo sea uno,
dividiendo cada una de las componentes (x,y,z) entre el
módulo del vector.
En la figura se ve un triángulo con su vector normal. Una cosa que hay
que tener en cuenta al calcular un vector normal a un triangulo, es que el
producto vectorial no cumple la propiedad
conmutativa, o sea que hay que tener cuidado
porque según en que orden se multipliquen v1 y v2
el vector normal puede apuntar en una dirección o
en la opuesta.
La aplicación de las normales a la hora de
acelerar el dibujado de polígonos es la siguiente:
como normalmente los triángulos se usan para
representar aproximaciones a superficies, como por
ejemplo esferas, se puede considerar que tales
64
Figura 48 - Scanlines
Figura 49 - Normal
Figura 50 - Normales

Colores y sombras
superficies tienen una cara interior que no se ve (el interior de la esfera, p ej) y
una exterior que si se ve. Entonces, podemos calcular las normales a los
triángulos asegurándonos de que apunten al exterior de la superficie, y
después eliminar los polígonos cuya normal no apunte en dirección a la
pantalla, porque se entiende que estamos viendo su parte trasera y por tanto
no se dibuja. En la figura vemos un ejemplo en 2D de este método. En este
caso, hay una serie de segmentos que aproximan una circunferencia.
Descartamos por medio de las normales las caras 4, 5, 6 y 7 y dibujamos las
caras 1 2 y 3. A estas tres caras que vamos a dibujar hay que aplicarles otro
algoritmo para verificar superficies ocultas, como el del pintor o el buffer z, ya
que el método de las normales no garantiza que las caras que apuntan hacia la
cámara no vayan a estar parcial o totalmente tapadas por otro objeto.
Algunas veces los objetos sombreados con Gouraud muestran las zonas
de unión de polígonos conocido como el efecto de la banda de Mach. Este
fenómeno es una consecuencia de como se conectan los conos al nervio óptico
en el ojo, y no hay nada que se pueda hacer al respecto, fuera de buscar
técnicas de sombreado mas suaves que no produzcan grandes diferencias en
sombreado en los bordes de los polígonos.
7.9.3.3 Sombreado de Phong
Figura 51 Sombreado Gouraud banda de Mach
Es el método usado en los gráficos 3D para la interpolación de
superficies en el pasterizado de polígonos, para obtener mejor resolución
especular que en las generadas en el modelo de reflexión de Pong.
Este método fue desarrollado por Bui Tuong Phong en 1973 en la
universidad de Utah. El modelo de reflexión de Phong es un modelo de
iluminación local que puede producir un cierto grado de realismo en los objetos
3D mediante la combionación de e elementos: difusión, reflexión especular y
luz ambiente para cada punto de la superficie considerada.
65

Colores y sombras
La interpolación de Phong , como método de renderizado, se peude
considerar como una mejora del sombreado de Gouraud que proporciona una
mejor aproximación a la aplicación punto-por-punto de un modelo de reflexión
superficial, asumiendo una suavidad variante de la superficie como vector
normal.
Para ello se determina el vector normal promedio en cada vértice del
polígono. Se interpola linealmente los vértices normales sobre la superficie del
polígono. Se aplica un modelo de iluminación sobre los puntos de la superficie
utilizando las normales interpoladas.
Phong propuso que, en lugar de interpolar intensidades de los vértices,
según se hace en el sombreado Gouraud, se interpole normales a lo largo del
polígono. Para un polígono que comparte lados y vértices con otros polígonos,
Figura 52 - Esquema
se pueden computar normales en los vértices interpolando sobre las normales
de los polígonos que comparten el vértice. Luego, se puede usar interpolación
bilineal, para interpolar las normales sobre el polígono
Figura 53 - Esquema
Se puede usar las normales interpoladas en los vértices A y B para
interpolar a lo largo de lado entre ellas:
n( ) = (1- )nA + nB
Se puede hacer una interpolación similar en todos los lados. LA normal
en cualquier punto interior se puede obtener de los puntos en los lados
mediante
n( , ) = (1- )nC + nD
66

Colores y sombras
Una vez obtenidas las normales en cada punto, se puede hacer cálculos
de sombreado independientes. Normalmente, este proceso se combinará con
la rasterización del polígono, para que la línea entre C y D proyecte a una línea
de rastreo en el frame buffer.
7.9.3.4 Sombreado Blinn–Phong
Es una variante del modelo de reflexión de Phong que intercambia la
precisión visual por eficiencia computacional.
En sombrado de Phong solo se recalcula el ángulo R*V entre el
observador (V) y el rayo de luz de la fuente (L) reflejado (R) en una superficie.
Si en vez de eso se calcula el vector intermedio entre el observador y los
vectores de las fuentes de luz:
Podemos reemplazar R*V con N*H, este producto de puntos representa
el coseno de un ángulo que es la mitad del ángulo representado por el producto
de puntos de Phong si V,L y R se encuentran en el mismo plano. Esto produce
modelos empíricos más certeros para determinar la distribución de las
funciones de reflexión bidireccional que el modelo de Phong. Blinn-Phong es el
modelo de sombreado por defecto que utiliza OpenGL y se lleva a todos los
vértices según pasan por la tubería de gráficos, mientras que los valores de los
pixeles entre los vértices son interpolados por el sombreado de Gouraud
(menos costoso).
Figura 54 Sombreado de Phong y Blinn-Phong
67

Colores y sombras
7.9.4 Sombreado en OpenGL
Se especifica la técnica de sombreado deseada con la función
glShadeModel.
Void glShadeModel(Glenum mode);
El parámetro mod puede tener 2 valores GL_SMOOTH (por defecto) o
GL_FLAT.
7.9.4.1 Sombreado Plano (Flat)
Los tres vectores, l, n y v, pueden variar según se va entre puntos sobre
una superficie.
*Para un polígono plano, n es constante.
*Si se asume un observador distante (la bandera
GL_DISTANT_VIEWER en OpenGL), v es constante sobre el polígono.
*Si la fuente de luz es distante, l es constante.
Distante se puede interpretar como una fuente o un observador en el
infinito; en particular, si los polígonos son pequeños, las distancias relativas
para el infinito no tienen que ser muy grandes. Los ajustes necesarios, como
cambiar la ubicación de la fuente u observador a la dirección de la fuente u
observador, de forma correspondiente, puede hacerse a las ecuaciones de
sombreado y a su implementación.
Si los tres vectores son constantes, entonces el cálculo de sombreado
se lleva a cabo una sola vez para cada polígono, y se asignará la misma
sombra a cada punto en el polígono. Esta técnica se conoce como sombreado
plano o constante. En OpenGL, se especifica sombreado plano mediante
glShadeModel(GL_FLAT);
Si se usa sombreado plano, OpenGL usará las normales asociadas con
el primer vértice de un polígono
Sencillo para el cálculo de sombreado. Para primitivas como un strip de
triángulo, OpenGL usa la normal del tercer vértice para el primer triángulo, la
normal del cuarto vértice para el segundo, etc. Reglas similares se aplican para
otras primitivas, como strips cuadriláteros.
Sombreado plano mostrará diferencias de sombreado entre los
polígonos. Si las fuentes de luz y el observador están cerca del polígono, los
vectores v y l serán diferentes para cada polígono. Sin embargo, si los
polígonos se diseñaron para modelar una superficie suave, sombreado plano
no será el mas apropiado, ya que se verán aunque sea diferencias de
sombreado pequeñas entre polígonos adyacentes.
68

Colores y sombras
Figura 55 Variación se sombreado
El sistema visual humano tiene una sensibilidad remarcada para
pequeñas diferencias de intensidad de color, causada por la propiedad de
inhibición lateral. Si se ve una secuencia incremental de intensidades, se
percibe los incrementos de brillantez reforzados en un lado del intervalo de
intensidad y decremento de brillantez reforzado del otro lado
Ejemplo de código en Open GL
Figura 56 Percepción de intensidad
glShadeModel(GL_FLAT);
glBegin(GL_TRIANGLES);
glColor3f(1.0f, 0.0f, 0.0f); // activamos el color rojo
glVertex3f(-1.0f, 0.0f, 0.0f);
glColor3f(0.0f, 1.0f, 0.0f); // activamos el color verde
glVertex3f(1.0f, 0.0f, 0.0f);
glColor3f(1.0f, 0.0f, 0.0f); // activamos el color azul
glVertex3f(0.0f, 1.0f, 0.0f);
glEnd();
Figura 57 Sombreado G_FLAT
69

Colores y sombras
El triángulo se rellena con el color azul, puesto que el modelo de
sombreado es GL_FLAT y el color activo en la definición del último vértice es el
azul.
7.9.4.2 Sombreado Interpolativo y Gouraud
Si se asigna el modelo de sombreado para que sea suave, mediante
glShadeModel(GL_SMOOTH);
OpenGL interpolará colores para las primitivas, como las líneas. Si se permite
sombreado y luz suaves, y se asigna a cada vértice la normal del polígono
siendo sombreado, se calcularía la luz en cada vértice, determinando el color
del vértice, usando las propiedades materiales y los vectores v y l se computan
para cada vértice. Si la fuente de luz es distante, y el observador es distante o
no hay reflexiones especulares, entonces el sombreado interpolativo
sombreara un polígono con un color constante.
Desde la perspectiva de OpenGL, el sombreado Gouraud es
deceptivamente sencillo. Se necesita solamente asignar correctamente las
normales de vértices. La literatura a menudo no distingue entre el sombreado
interpolativo y el Gouraud. Sin embargo, existe un problema, encontrar las
normales para promediar. Si el programa es lineal, especificar una lista de
vértices (y otras propiedades), no se tiene la información necesaria de cuales
polígonos comparten un vértice. Lo que se requiere es una estructura de datos
para representar un "mesh". Atravesar esta estructura de datos puede generar
los vértices con las normales promediadas. Tal estructura de datos debe
contener, de manera mínima, polígonos, vértices, normales, y propiedades de
los materiales. Una posible estructura se muestra en al siguiente figura,
teniendo como elemento clave los polígonos que se juntan en cada vértice
Figura 58 Estructura de datos para facilitar sombreado
70

Colores y sombras
Ejemplo de código OpenGL
glShadeModel(GL_SMOOTH);
glBegin(GL_TRIANGLES);
glColor3f(1.0f, 0.0f, 0.0f); // activamos el color rojo
glVertex3f(-1.0f, 0.0f, 0.0f);
glColor3f(0.0f, 1.0f, 0.0f); // verde
glVertex3f(1.0f, 0.0f, 0.0f);
glColor3f(1.0f, 0.0f, 0.0f); // azul
glVertex3f(0.0f, 0.0f, 1.0f);
glEnd();
7.9.4.3 Stencil Buffer
Figura 59 Sombreado GL_SMOOTH
Sirve para mejorar la calidad de las sombras y los reflejos.
Es un test extra por píxel y un conjunto de operaciones muy parecidas al
Z-Buffer.
Añade planos de bits adicionales para cada píxel además de los bits de
color y profundidad.
Es una manera de marcar píxeles en una renderización para controlar su
actualización en renderizaciones siguientes.
El valor stencil de un píxel es un entero sin signo (unsigned int).
Para activar y desactivar el test de stencil se utilizará la función
glEnable(GL_STENCIL_TEST) y glDisable(GL_STENCIL_TEST).
Para borrar el stencil buffer se usará la función glClearStencil cuya
sintaxis es la siguiente:
71

Colores y sombras
• Propósito: Especifica un valor de estarcido para el buffer de estarcido.
• Fichero de inclusión:
• Sintaxis: void glClearStencil(GLint valor);
• Descripción: Esta función selecciona el valor de color que usaremos
para borrar el buffer de estarcido con
glClear(GL_STENCIL_BUFFER_BIT).
• Parámetros:
valor
GLint: el valor de limpieza del buffer de estarcido.
• Retornos: Ninguno.
El stencil test compara el valor del píxel del stencil buffer con un valor de
referencia. Permite las comparaciones: never, always, less than, less than or
equal, greater than, greater than or equal, equal, not equal.
Es más potente que el buffer de profundidad. Antes de comparar realiza
una operación AND tanto del valor de referencia como del valor del buffer, con
un valor que sirve como máscara.
GlStencilFunc(GL_EQUAL, 0x1,0xff).
El primer parámetro será la función de comparación, el segundo el valor
de referencia y el tercero la máscara.
Si el píxel no pasa el test de profundidad es rechazado, en cambio, si lo
pasa, se reemplaza el valor del Z-Buffer. El stencil test es más complicado:
- No pasa el stencil test
- Pasa stencil test y no el test de profundidad
- Pasa stencil test y test de profundidad
Para cada caso tenemos 6 operaciones distintas: GL_KEEP,
GL_REPLACE, GL_INVERT, GL_INCREMENT, GL_DECREMENT, GL_ZERO.
Antes de escribir se aplica un máscara:
GlStencilOp(GL_KEEP //Stencil fail
GL_DECR //Pasa el stencil y falla la profundidad
GL_INCR //Pasa el stencil y pasa la profundidad)
GlStencilMask(0xff);
72

Colores y sombras
State Initial Value State Update State Query Token
Description
Command
Stencilling GL_FALSE glEnable GL_STENCIL_TEST
enable
glDisable
Stencil
function
GL_ALWAYS glStencilFunc GL_STENCIL_FUNC
Stencil
compare
mask
All 1’s glStencilFunc GL_STENCIL_VALUE_MASK
Stencil
reference
value
0 glStencilFunc GL_STENCIL_REF
Stencil fail GL_KEEP
operation
glStencilOp GL_STENCIL_FAIL
Stencil GL_KEEP glStencilOp GL_STENCIL_PASS_DEPTH_PASS
depth fail
operation
Stencil
depth pass
operation
GL_KEEP glStencilOp GL_STENCIL_PASS_DEPTH_PASS
Stencil
write mask
All 1’s glStencilMask GL_STENCIL_WRITEMASK
Stencil
buffer clear
value
0 glClearStencil GL_STENCIL_CLEAR_VALUE
Tiene una serie de limitaciones:
- El objeto reflejado sale por fuera de la superficie reflectante
- Desde detrás del espejo se ve el objeto reflejado.
- No permite reflejos infinitos. Está limitado a n reflejos.
A continuación se muestra el algoritmo para el empleo del stencil para
simular sombras:
1.- Cargar la matriz de modelización.
GlMatrixMode(GL_MODELVIEW);
GlLoadIdentity();
GlLookAt(eye[0], eye[1], eye[2], center[0], center[1], center[2], up[0],
up[1], up[2]);
2.- Dada la luz y la ecuación del plano donde se proyecta, asumiendo que el
objeto esta entre la luz y el plano, habilitar la luz y renderizar el objeto y el
plano
Glfloat lightPosition[4]={LX,LY,LZ,1.0);
Glfloat groundPlaneEquation[4]={A,B,C,D};
73

Colores y sombras
GlLightfv{GL_LIGHT0, GL_POSITION,lightPosition);
GlEnable(GL_LIGHT0);
GlEnable(GL_LIGHTING);
DibujarObjeto();
DibujarPlano();
3.- Meter en la pila la matriz de modelización
glPushMatrix();
4.- Construir la matriz de proyección, multiplicar la matriz de modelización
por la matriz de proyección de la sombra.
Glfloat Matriz[4][4];
ShadowMatrix(&matriz[0][0], LightPosition, groundPlaneEquation);
glHultMatrix(&Matriz[0][0]);
5.- Asignar un valor distinto de 0 al stencil buffer
glEnable(GL_STENCIL_BUFFER);
glStencilFunc(GL_ALWAYS, valor, ~0);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
DibujarPlanoASombrear();
GlDisable(GL_STENCIL_TEST);
6.- Deshabilitar la iluminación
glDisable(GL_LIGHTING);
glEnable(GL_BLEND);
glBlendFunc(GL_DST_COLOR,GL_ZERO);
glColor3f(0.5,0.5,0.5);
glDisable(GL_DEPTH_TEST);
Solo debemos actualizar los pixeles marcados con valor
GlEnable(GL_STENCIL_TEST);
GlStencilFunc(GL_EQUAL, valor, ~0);
GlStencilOp(GL_KEEP, GL_KEEP,GL_ZERO);
DibujarObjeto();
7.- Restaurar los valores
74

Colores y sombras
glDisable(GL_BLEND);
glDisable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glPopMatrix();
7.9.4.4 Buffer de Profundidad o Z buffer
Este buffer se utiliza para el manejo de las coordenadas de profundidad
de la imagen 3D. Esta es una solución al problema de visibilidad, para detectar
que objetos de una imagen renderizada son visibles y cuales no. Cuando un
objeto es renderizado por una tarjeta gráfica 3D, la profundidad de cada píxel
es almacenada en un buffer (z-buffer). Este está normalmente formado por un
array bidimensional con un elemento para cada píxel de la pantalla. Si otro
objeto de la escena tiene q renderizarse en el mismo píxel, la tarjeta gráfica
compara las dos profundidades y elige la que está más cercana al observador.
Entonces la profundidad elegida es almacenada en el z-buffer, reemplazando a
la anterior. Al final este buffer permite a la tarjeta gráfica reproducir fielmente la
percepción de profundidad, un objeto cercano tapa a los de más lejos. La
granularidad del z-buffer tiene una gran influencia en la calidad de la imagen:
un buffer de 16 bits puede finalizar en conflicto cuando dos objetos están muy
cercanos. Uno de 24 o 32 se comporta mucho mejor y uno de 8 casi nunca se
usa porque tiene muy poca precisión.
Figura 60 Buffer de profundidad
75

Colores y sombras
7.9.5. Volúmenes de sombras
Para construir un volumen de sombras básicamente se proyecta un rayo
de luz a través de cada vértice en la proyección de la sombra del objeto hacia
algún punto (normalmente el infinito). El conjunto de estas proyecciones
generan un volumen que engloba todos los puntos que pudieran posiblemente
verse ensombrecidos por un objeto. Cualquier objeto dentro de este volumen
debería ser ensombrecido. El volumen es presentado de tal modo que causa
píxeles ensombrecidos tener valores estarcidos. que difieren de aquellos
píxeles no sombreados.
Para un modelo poligonal, el volumen esta formado normalmente por la
clasificación de cada cara en el modelo ya sea encarándose hacia la fuente de
luz o en su contra. El conjunto de todos los bordes que conectan la cara “hacia”
con la cara “contra” forman la silueta con respecto a la fuente de luz. Los
bordes que forman la silueta son excluidos de la luz para construir las caras del
volumen de sombra. Este volumen debe extenderse sobre el rango total de la
escena visible; a veces las dimensiones del volumen de sombra se extienden
hasta el infinito. Para formar un volumen cerrado, el frente y la trasera de esta
extrusión deben ser cubiertas. Estas cubiertas se llaman “caps”. Dependiendo
del método usado para el volumen de sombra, el frente puede cubrir al objeto
mismo y la parte trasera puede ser omitida.
Los pasos para formar un volumen de sombras son:
• Encontrar todos los bordes de siluetas.
• Extender todos los bordes en dirección al foco de luz
• Añadir la capa frontal y trasera a cada superficie para formar un
volumen cerrado.
Figura 61 Volumen de sombras
76

Colores y sombras
Determinar y visualizar el volumen ensombrecido es la parte más
compleja de la técnica. Aunque se esté utilizando un método muy simple para
la creación de volúmenes de sombras de geometría simple en este trabajo no
sería eficiente para el caso de miles de polígonos. También puede ocurrir que
el método cause algunos lugares donde los bordes de las sombras de los
volúmenes se encuentren. ( Debido a que hay un único volumen sombreado
para cada polígono). Esto puede solucionarse visualizando un único volumen
que rodee el modelo entero en lugar de presentar los distintos volúmenes de
cada polígono separados.
Efectos a tener en cuenta son:
• Umbría y penumbra para producir una transición gradual
• La forma, tamaño y distancia de las fuentes de luz
• La iluminación global
Figura 62 Efecto de la fuente en la sombra
Figura 63 Volumen sombras en un triángulo
Existen 3 técnicas que usan el stencil buffer para renderizar las sombras
con volúmenes de sombras lo suficientemente rápido como para utilizarlas en
aplicaciones de tiempo real, paso de profundidad, fallo en profundidad y OR
exclusivo, pero todos ellos utilizan el mismo proceso:
-renderizar la escena como si estuviera completamente en sombra.
- para cada punto de luz:
-usar la información de profundidad de la escena para construir una
mascara en el stencil buffer que tiene huecos solo donde la superficie visible
no es una sombra
-Renderizar la escena de nuevo como si estuviera completamente
iluminada, usando el stencil buffer para la máscara de las áreas sombreadas.
77

Colores y sombras
La diferencia entre estos métodos ocurre en el segundo paso de la
generación de la máscara. Unos requieren un paso, otros dos y requieren
diferente nivel de precisión para el stencil buffer.
7.9.5.1 Paso de profundidad (Depth pass)
Heidemann propuso que si el frente de las superficies y la trasera de las
sombras eran renderizadas en pasos separados, el número de caras frontales
y traseras de un objeto puede ser contado usando el stencil buffer. Si la
superficie de un objeto esta en sombra, habrá más superficies sombreadas
frontalmente entre ella y el ojo que con las superficies traseras sombreadas. Si
su número es igual, sin embargo, la superficie del objeto no es una sombra.
7.9.5.2 Error de Profundidad (Depth fail)
Sobre el 200 algunas personas descubrieron que el método de
Heidmann puede trabajar desde cualquier punto de la cámara reinvirtiendo la
profundidad. En vez de contar las caras frontales sombreadas de la superficie
del objeto, las superficies traseras se pueden contar así fácilmente con el
mismo resultado. Esto soluciona el problema de tener el observador en
sombra, pero introduce la condición de que el extremo posterior del volumen de
sombras debe ser encapsulado o las sombras terminarán perdiéndose donde
los puntos del volumen van al infinito.
7.9.7.3 OR exclusivo
Las dos técnicas anteriores pueden aproximarse mediante la variación
OR exclusivo, que no trata propiamente con la intersección de los volúmenes
de sombras, pero ahorra un paso de renderización y solo requiere un bit de
stencil buffer.
7.10 Fusión (Dithering)
Es una técnica usada para crear la ilusión de profundidad de color en
imágenes con una paleta de colores limitada. En una imagen con fusión los
colores no disponibles en la paleta original son aproximados por una difusión
de los píxel coloreados dentro de la paleta disponible. El ojo humano percibe la
difusión como una mezcla de colores.
Figura 64 Ejemplo fusión
78

Colores y sombras
Esta imagen está formada solo por rojo y azul, pero según se van
haciendo mas pequeños los pixeles el ojo humano empieza a percibir un nuevo
color mezcla de la aproximación de los dos presentes, con lo cual se puede
percibir un color morado no presente en la paleta de colores inicial, pero la
imagen sigue estando compuesta solo por rojo y azul.
Figura 65 Imagen sin fusión Figura 66 Imagen con fusión
Se puede obtener una buena calidad de imagen con aproximadamente 8
bits de R,G,B sin utilizar fusión. Sólo porque nuestra maquina tenga 24 planos
de color no significa que la fusión no sea deseable. Por ejemplo, si estamos
ejecutando en modo doble buffer, los planos de color pueden ser divididos en 2
conjuntos de 12, así tendremos sólo 4 bits para cada componente RGB. Sin
fusión 4 bits por componente ofrecen resultados poco satisfactorios.
Figura 67 Incremento de difusión
79

Colores y sombras
Nota: La fusión al contrario que otras características está habilitada por
defecto.
Se puede deshabilitar con glDisable(GL_DITHER).
Y habilitar con glEnable( GL_DITHER ).
7.11. Creación de Paletas de Ventana
Podemos crear una paleta utilizando la función CreatePalette() e
identificando la paleta mediante un indicador del tipo HPALETTE:
HPALETTE CreatePalette(
CONST LOGPALETTE *lplgpl // puntero a la paleta
lógica de color
);
Esta paleta utiliza una estructura lógica de paleta (LOGPALETE) que
contiene 256 entradas, especificando los 8 bits para las componentes R,G,B.
7.11.1 Arbitraje de paletas
En la publicidad del sistema Windows se afirma que su sistema
operativo es multitarea, por lo tanto se debe permitir la ejecución simultanea de
varias aplicaciones. Pero el hardware solo permite 256 colores en la paleta del
sistema que deben ser compartidos por todas las aplicaciones en ejecución. Si
alguna de las aplicaciones modifica la paleta del sistema puede que se altere la
presentación de imágenes de otras aplicaciones produciendo efectos no
deseados. Windows proporciona un conjunto de mensajes para arbitrar el uso
de paletas entre varias aplicaciones. Por lo tanto si una aplicación modifica la
paleta del sistema se notificará este cambio al resto de las aplicaciones en
ejecución.
Cuando una aplicación se convierte en la aplicación activa Windows
envía el mensaje WM_QUERYNEWPALETTE a la ventana principal de la
aplicación, preguntándole si desea copiar las entradas de su paleta privada en
las entradas del sistema. En caso afirmativo la aplicación selecciona la paleta
en el contexto de dispositivo para la ventana actualizada y llama después a
RealizePalette().
Otro mensaje que puede enviar Windows para el arbitraje de las paletas
es WM_PALETTECHANGED que indica a la ventana que puede seleccionar la
paleta, incluso si no es la ventana activa.
En el siguiente ejemplo mostramos la realización de este procedimiento:
// Procedimiento de la ventana, gestiona todos los
mensaje de este programa
LRESULT CALLBACK WndProc (HWND hWnd,UINT
message,WPARAM wParam,LPARAM lParam)
... // Windows le dice a la aplicación que puede
modificar la paleta del sistema.
80

Colores y sombras
// Es decir, este mensaje solicita una nueva paleta a
la aplicación
case WM_QUERYNEWPALETTE:
// Si la paleta fue creada
if(hPalette)
{
int nRet;
// Selecciona la paleta en el contexto
de dispositivo actual
SelectPalette(hDC, hPalette, FALSE);
//Correspondencia de entradas entre la
paleta actualmente
// seleccionada y la paleta del
sistema. El valor devuelto es
// el número de entradas de la paleta
modificada.
nRet = RealizePalette(hDC);
// Al redibujar se fuerza el
replanteado de la paleta
// en la ventana actual
InvalidateRect(hWnd,NULL,FALSE);
return nRet;
}
break;
// Esta ventana puede seleccionar la paleta,
incluso si no
// es la ventana activa.
case WM_PALETTECHANGED:
// No hacer nada si la paleta no existe, o
si esta
// es la ventana que cambio la paleta
if((hPalette != NULL) && ((HWND)wParam !=
hWnd))
{
// Selecciona la paleta en el contexto
de dispositivo
SelectPalette(hDC,hPalette,FALSE);
// Entrada en la paleta del sistema
RealizePalette(hDC);
// Reasigna los colores actuales a la
nueva paleta realizada
UpdateColors(hDC);
return 0;
}
break;}
81

Colores y sombras
7.11.2. Creación de una paleta.
Determinamos si nuestra aplicación necesita una paleta llamando a la
función DescribePixelFormat() después de haber definido el formato de píxel.
Se ha de comprobar el valor del miembro dwFlags de la estructura
PÍXELFORMATDESCRIPTOR devuelto por DescribePixelFormat(),
comprobaremos el valor del bit PFD_NEED_PALETTE, si estuviese activo
tendríamos que crear una paleta para uso de la aplicación.
7.11.3 Estructura de la paleta.
Para crear una paleta reservaremos memoria para la estructura
LOGPALETTE.
typedef struct tagLOGPALETTE { // lgpl
WORD palVersion;
WORD palNumEntries;
PALETTEENTRY palPalEntry[1];
} LOGPALETTE;
La estructura se ha de completar con información sobre nuestra paleta y
llamar a la función CreatePalette() pasándosela como argumento.
Cada entrada en la paleta es una estructura PALETTEENTRY definida
de la forma:
typedef struct tagPALETTEENTRY { // pe
BYTE peRed;
BYTE peGreen;
BYTE peBlue;
BYTE peFlags;
} PALETTEENTRY;
- peRed, peGreen y peBlue representan las intensidades relativas para las
componentes de 8 bits RGB. Así cada una de las 256 entradas de la paleta
contendrá una definición de color de 24 bits.
- PeFlags se utiliza para especificar opciones avanzadas de la paleta.
Normalmente su valor será NULL.
En el siguiente ejemplo mostramos la creación, arbitraje y estructura de
una paleta:
// Selecciona el formato de píxel para un contexto de
dispositivo
void SetDCPixelFormat(HDC hDC)
{
int nPixelFormat;
static PIXELFORMATDESCRIPTOR pfd = {
82

Colores y sombras
sizeof(PIXELFORMATDESCRIPTOR), // Tamaño de la
estructura
1,
// Version of this structure
PFD_DRAW_TO_WINDOW | // Dibuja en la ventana (No
en el mapa de bits)
PFD_SUPPORT_OPENGL | // Soporta llamada
OpenGL en la ventana
PFD_DOUBLEBUFFER, // Modo de doble Buffer
PFD_TYPE_RGBA, // Modo de color RGBA
24, // Pide
24 bits de color
0,0,0,0,0,0, // No se usa
para seleccionar el modo
0,0, // No se
usa para seleccionar el modo
0,0,0,0,0, // No se
usa para seleccionar el modo
32, // Tamaño
del Buffer de Profundidad
0, // No se
usa para seleccionar el modo
0, // No se
usa para seleccionar el modo
PFD_MAIN_PLANE, // Dibuja en el plano
principal
0, // No se
usa para seleccionar el modo
0,0,0 }; // No se usa
para seleccionar el modo
// Escoge el formato de píxel que mejor encaje en los
descrito por pfd
nPixelFormat = ChoosePixelFormat(hDC, &pfd);
// Selecciona el formato de píxel para el contexto de
dispositivo
SetPixelFormat(hDC, nPixelFormat, &pfd);
}
// Si es necesario, crea una paleta 3-3-2 para el contexto
de dispositivo listado
HPALETTE GetOpenGLPalette(HDC hDC)
{
HPALETTE hRetPal = NULL; // Indicador a la paleta que
va a crear
PIXELFORMATDESCRIPTOR pfd; // Descriptor del
formato de píxel
LOGPALETTE *pPal; // Puntero a memoria
para la paleta lógica
83

Colores y sombras
int nPixelFormat; // índice del formato de
píxel
int nColors; // Numero de entradas en
la paleta
int i; // Variable de
cuenta
BYTE RedRange,GreenRange,BlueRange;
// Rango para cada
entrada de color (7,7,y 3)
//Toma el formato de píxel y recupera la descripción
del formato de píxel
nPixelFormat = GetPixelFormat(hDC);
DescribePixelFormat(hDC, nPixelFormat,
sizeof(PIXELFORMATDESCRIPTOR), &pfd);
//¿Necesita una paleta este formato de píxel? Si no,
no crea una paleta
// y devuelve NULL
if(!(pfd.dwFlags & PFD_NEED_PALETTE))
return NULL;
//Numero de entradas en la paleta. 8 bits abarcan 256
entradas
nColors = 1 palVersion = 0x300; // Windows 3.0
pPal->palNumEntries = nColors; // Dimensiones de la
tabla
//Crea una mascara de 1's. esto crea un numero
representado por tener
//activo los bits x de menor orden, donde x =
pfd.cRedBits,
//pfd.cGgreenBits y pfd.cBlueBits.
RedRange = (1

Colores y sombras
pPal->palPalEntry[i].peRed = (i >> pfd.cRedShift)
& RedRange;
pPal->palPalEntry[i].peRed = (unsigned char)(
(double) pPal->palPalEntry[i].peRed * 255.0
/ RedRange);
pPal->palPalEntry[i].peGreen = (i >>
pfd.cGreenShift) & GreenRange;
pPal->palPalEntry[i].peGreen = (unsigned char)(
(double)pPal->palPalEntry[i].peGreen * 255.0
/ GreenRange);
pPal->palPalEntry[i].peBlue = (i >>
pfd.cBlueShift) & BlueRange;
pPal->palPalEntry[i].peBlue = (unsigned char)(
(double)pPal->palPalEntry[i].peBlue * 255.0
/ BlueRange);
NULL;
pPal->palPalEntry[i].peFlags = (unsigned char)
}
// Crea la paleta
hRetPal = CreatePalette(pPal);
// Avanza, selecciona y realiza la paleta para este
contexto de dispositivo
SelectPalette(hDC,hRetPal,FALSE);
RealizePalette(hDC);
// Libera la memoria usada para la estructura lógica
de paleta
free(pPal);
// Devuelve el indicador a la nueva paleta
return hRetPal;
}
7.11.4 Destrucción de una paleta.
Debemos crear y realizar la paleta antes de crear o activar el contexto de
dispositivo.
En el siguiente ejemplo mostramos las operaciones necesarias para
crear y destruir una ventana teniendo en cuenta la posible existencia de una
paleta
// Procedimiento de la ventana, gestiona todos los mensaje
de este programa
85

Colores y sombras
LRESULT CALLBACK WndProc( HWND hWnd,UINT message,
WPARAM wParam, LPARAM lParam)
{
static HGLRC hRC; // Contexto de
generación permanente
static HDC hDC; // GDI privado del
contexto de dispositivo
activa
switch (message)
{
// Creacion de ventana para OpenGL
case WM_CREATE:
// Almacena el contexto de dispositivo
hDC = GetDC(hWnd);
// Selecciona el formato de píxel
SetDCPixelFormat(hDC);
// Crea la paleta
hPalette = GetOpenGLPalette(hDC);
// Crea el contexto de generación y lo
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
// Llamada a la función de iniciación de la
aplicación
Init();
break;
// Se destruye la aplicación, hay que
limpiar todo!
case WM_DESTROY:
// Desactiva el contexto de generación
actual y lo borra
wglMakeCurrent(hDC,NULL);
wglDeleteContext(hRC);
después de que
ReleaseDC(hWnd,hDC);
// Borra la paleta si fue creada
if(hPalette != NULL)
DeleteObject(hPalette);
// Le dice a la aplicación que termine
// se cierre la ventana
PostQuitMessage(0); break;
86

7.12 Conclusión
En este tema hemos aprendido qué es el color y el sombreado, cual es
la naturaleza de la luz, como la percibe el ojo humano y algunos de los
modelos que se utilizan para su representación.
Hemos visto la necesidad de introducir el sombreado o degradado de
color para obtener un resultado más realista en nuestras escenas.
Se han introducido todas las funciones necesarias para establecer el
color de un objeto, el color con el que se limpia la pantalla, el modelo con el
que se va a realizar el sombreado, la utilización de paletas y su gestión en
OpenGL. Se han proporcionado ejemplos de aplicaciones que hacen uso de
todas para facilitar su comprensión y posterior utilización.
7.13 Otras funciones para luces y sombras
glAccum
• Propósito: Opera en el buffer de acumulación para establecer los valores de
píxel.
• Fichero de inclusión:
• Sintaxis: void glAccum(GLenum func, GLfloat valor);
• Descripción: Esta función opera en el buffer de acumulación. A excepción de
GL_RETURN, los valores de color se escalan según el parámetro valor y
se añaden o suman al buffer de acumulación. En el caso de
GL_RETURN, los valores de color del buffer de acumulación se escalan
según el parámetro valor y se almacenan en el buffer de color actual.
• Parámetros:
func
GLenum: la función de acumulación aplicada. Las funciones válidas son las
siguientes:
GL_ACCUM: Añade valores de color escalados al buffer
de acumulación.
GL_LOAD: Abre valores de color escalados en el buffer
de acumulación, sustituyendo a los que hubiera antes.
GL_ADD: Añade un color constante a los valores del buffer
de acumulación.
GL_MULT: Multiplica los valores de color en el buffer

Colores y sombras
de acumulación por un valor constante.
GL_RETURN: Copia el buffer de acumulación en el buffer
de color principal.
• Retornos: Ninguno.
glColorMask
• Propósito: Activa o desactiva la modificación de las componentes de color en
los buffers de color.
• Fichero de inclusión:
• Sintaxis: void glColorMask(GLboolean bRojo, GLboolean bVerde, GLboolean
bBlue, GLboolean bAlfa);
• Descripción: Esta función permite cambios individuales en las componentes
de color en el buffer de color para activarlas o desactivarlas.
• Parámetros:
bRojo
Glboolean: especifica cuándo se puede modificar la componente roja.
bVerde
Glboolean: especifica cuándo se puede modificar la componente verde.
bAzul
Glboolean: especifica cuándo se puede modificar la componente azul.
bAlfa
Glboolean: especifica cuándo se puede modificar la componente alfa.
• Retornos: Ninguno.
glDrawBuffer
• Propósito: Selecciona un buffer de color para dibujar.
• Fichero de inclusión:
• Sintaxis: void glDrawBuffer(GLenum modo);
• Descripción: Esta función selecciona un buffer de color para las operaciones
de dibujo siguientes. Normalmente la usaremos para seleccionar el buffer
frontal u oculto en un contexto de dibujo con doble buffer.
• Parámetros:
modo
Glenum: una constante que selecciona el buffer de color en el que vamos a
trabajar. Puede ser un valor de la siguiente tabla.
88

Colores y sombras
• Retornos: Ninguno.
Valor de modo Descripción
GL_NONE No se dibuja en ningún buffer de color.
GL_FRONT Dibujamos sólo en el buffer de color frontal (visible).
GL_BACK Dibujamos sólo en el buffer de color trasero (oculto).
GL_FRONT_AND_BACK Dibujamos en ambos buffers de color.
glFog
• Propósito: Especifica los parámetros de niebla.
• Fichero de inclusión:
• Sintaxis:
• void glFogf( GLenum pnombre, GLfloat params);
• void glFogfv( GLenum pnombre, GLfloat *params);
• void glFogi( GLenum pnombre, GLint params);
void glFogiv( GLenum pnombre, GLint *params);
• Descripción: Define los parámetros de niebla. Para dibujar usando niebla,
debemos hacer una llamada a glEnable(GL_FOG).
• Parámetros:
pnombre
Glenum: el parámetro definido. Los nombres válidos son los siguientes:
GL_FOG_COLOR: Color de la niebla.
GL_FOG_DENSITY: Densidad de la niebla.
GL_FOG_END: Distancia más alejada a la que se aplica niebla.
GL_FOG_INDEX: El índice de color usado para niebla si se está
en modo indexado.
GL_FOG_MODE: El tipo de niebla.
GL_FOG_START: La distancia más cercana a la que se aplica la
niebla.
• Retornos: Ninguno.
89

Colores y sombras
glIndexMask
• Propósito: Evita la modificación de bits individuales del buffer de color.
• Fichero de inclusión:
• Sintaxis: void glIndexMask( GLuint mascara);
• Descripción: Esta función permite enmascarar bits individuales en el buffer
de color indexado. Cuando se activa el bit de máscara, los bits son
modificables; cuando son cero, están protegidos. Esta función sólo se aplica
al modo de color indexado.
• Parámetros:
mascara
GLuint: especifica la máscara binaria que activa o desactiva la escritura en los
bits individuales del buffer de color indexado.
• Retornos: Ninguno.
glIsEnabled
• Propósito: Verifica si una función de OpenGL está activada.
• Fichero de inclusión:
• Sintaxis: Glboolean glIsEnabled(GLenum caract);
• Descripción: Devuelve GL_TRUE si la función especificada ha sido activada,
GL_FALSE en otro caso.
• Parámetros:
caract
GLenum: la función a verificar (ver glEnable).
• Retornos: GLboolean: GL_TRUE si la función está activada, GL_FALSE si
no.
glLogicOp
• Propósito: Selecciona la operación lógica para el modo de color indexado.
• Fichero de inclusión:
• Sintaxis: void glLogicOp( GLenum opcode);
• Descripción: La operación lógica de píxel define la combinación de valores
de píxel. Cuando se especifica un nuevo valor de índice de color para una
90

Colores y sombras
localización de píxel, se combina lógicamente con el valor del índice de color
actual de ese píxel.
• Parámetros:
opcode
GLenum: especifica el modo lógico de píxel que hay que usar. Son válidos:
GL_CLEAR, GL_SET, GL_COPY, GL_COPY_INVERTED, GL_NOOP,
GL_INVERT, GL_AND, GL_NAND, GL_OR, GL_NOR, GL_XOR, GL_ EQUIV,
GL_AND_REVERSE, GL_AND_INVERTED, GL_OR_REVERSE y
GL_OR_INVERTED.
• Retornos: Ninguno.
glPolygonMode
• Propósito: Selecciona el modo en que se generan los polígonos.
• Fichero de inclusión:
• Sintaxis: void glPolygonMode(Glenum cara, GLenum modo);
• Descripción: Esta función nos permite cambiar la forma en que se generan
los polígonos. Por defecto, los polígonos se rellenan o sombrean con el color
o las propiedades de material actuales. Sin embargo, podemos especificar
que se dibujen sólo los perfiles o los vértices.
• Parámetros:
cara
GLenum: especifica a qué cara de los polígonos afecta el cambio de modo:
GL_FRONT, GL_BACK, GL_FRONT_AND_BACK.
modo
GLenum: especifica el nuevo modo de dibujo. El valor por defecto es GL_FILL,
que produce polígonos sólidos. GL_LINE produce perfiles de polígonos y
GL_POINT sólo traza los puntos de los vértices. La bandera de borde activada
por glEdgeFlag afecta a las líneas y puntos dibujados con GL_LINE y
GL_POINT.
• Retornos: Ninguno.
91

Colores y sombras
7.14 Bibliografia
"Gráficas por Computador"
Autor: Hearn, Baker
Ed: Prentice Hall
"Computer Graphics: Systems&Concepts"
Autor: Salmon, Slater
Ed: Addison
"Introduction to the GKS"
Autor: Hopgood, Duce
Ed: Academic Press, 86
“Introduction to Computer Graphics”
Autor: Foley, Van Dam
Ed: Addison-Wesley
“Visual Cues”
Autor: Keller
Ed: IEEE, 1993
"Three Dimensional Computer Graphics"
Autor: Watt
Ed: Addison
"Mathematical Elements for Computer Graphics"
Autor: Rogers, Adams
Ed: McGraw
"Curves and Surfaces in Computer Aided Geometric Design"
Autor: Yamaguchi
Ed: Springer
“Interactive Computer Graphics: A Top-Down Approach with OpenGL”
Autor: Angel
Ed: Addison Wesley, 1997
“Computer Graphics 2/e”
Autor: Hearn
Ed: Prentice Hall
“3D Computer Graphics, 2/e”
Autor: Watt
Ed: Addison Wesley
92

Colores y sombras
“Introduction to Computer Graphics”
Autor: Foley
Ed: Addison Wesley
“OpenGL Programming Guide & Reference Manual”
Autor: Varios
Ed: Addison Wesley
“Inventor Mentor & Toolmaker”
Autor: Varios
Ed: Addison Wesley
“SIGGRAPH '98 Conference Proceedings”
Autor: Varios
Ed: Addison Wesley
Opengl Architecture Review Board, “OpenGL Reference Manual, The Official
Reference Document to OpenGL, Version 1.2 “
Autor: Dave Shreiner
“OpenGL SuperBible, Second Edition (SuperBible)”
Autor: Richard S. Wright Jr., Richard S., Jr. Wright
“OpenGL Programming for the X Window System”
Autor: Mark J. Kilgard
“Computer Graphics : Principles and Practice, Second Edition in C by”
Autor: James D. Foley
OpenGL Architecture Review Board, “OpenGL(r) 1.2 Programming Guide
Autor: Mason Woo, Jackie Neider, Tom Davis, Dave Shreiner
OpenGL Architecture Review Board, “OpenGL(r) 1.2 Programming Guide
Autor: Mason Woo, Jackie Neider, Tom Davis, Dave Shreiner
"COMPUTER GRAPHICS: An object-oriented approach to the art and science"
Autor: Cornel Pokorny
Ed: Franklin, Beedle & Associates Incorporated
93

Colores y sombras
"COMPUTER GRAPHICS: C version" (2nd. ed. o posterior)
Autores: Donald Hearn and M. Pauline Baker
Ed: Prentice Hall
"COMPUTER GRAPHICS: Principles and practice (C version)"
Autores: J. Foley, A. van Dam, S.K. Feiner and J.F. Hughes
Ed: Addison-Wesley Publishing Company
"COMPUTER GRAPHICS"
Autor: F.S. Hill Jr.
Ed: Macmillan Publishing Co.
"Interactive Computer Graphics: a top-down approach with OpenGL"
Autor: E. Angel
Ed: Addison-Wesley Publishing Company, 1997
"Mathematical Elements for Computer Graphics"
Autores: D.F.Rogers and J.A.Adams
Ed: McGraw Hill, 1.976.
"Principles of Interactive Computer Graphics"
Autores: W. Newman and R. Sproull
Ed: McGraw Hill, 1979.
"Raster Graphics Handbook, Conrac Division, 2nd edition"
Ed: Van Nostrand Reinhold Co., 1.984.
"The Mathematical Structure of Raster Graphics"
Autores: Eugene L. Fiume
Ed: Academic Press, Inc., 1986.
"Windows NT OpenGL: Getting Started."
Autores: Crain, Dennis
Ed: MSDN Library, Technical Articles
OpenGL Programming Guide: The Official Guide to Learning OpenGL, Release 1
Autores: Neider, Jackie, Tom Davis, and Mason Woo
Ed: Addison-Wesley
“Principles of Digital Image Synthesis”
Autores: Glassner
Ed: Morgan Kaufmann Publisher, 1995.
94

Colores y sombras
Computer Graphics: Principles and Practice (2nd. Ed. in C)
Autores: Foley, van Dam, Feiner, Hughes
Ed: Addison-Wesley Publishing Company, 1993.
Radiosity and Realistic Image Synthesis
Autores: Cohen, Wallace
Ed: Academic Press, 1993.
Computer Graphics Proceedings. Annual Conference Series.
Autores: Varios
Ed: ACM SIGGRAPH (ACM Special Interest Group on Computer Graphics).
Rendering Techniques (Proceedings del EG Workshop on Rendering)
Autores: Varios
Ed: Springer Verlag, años 1994 hasta 1999
OpenGL Architecture Review Board. OpenGL Reference Manual: The Official
Reference Document for OpenGL, Release 1. Reading, MA
Autores: Varios
Ed: Addison-Wesley, 1992
"Advanced 3-D Graphics for Windows NT 3.5: Introducing the OpenGL Interface, Part
I." Microsoft Systems Journal 9 (October 1994)
Autores: Prosise, Jeff
Ed: MSDN Library Archive Edition, Books and Periodicals)
"Advanced 3-D Graphics for Windows NT 3.5: The OpenGL Interface, Part II."
Microsoft Systems Journal 9 (November 1994)
Autores: Prosise, Jeff
Ed: MSDN Library Archive Edition, Books and Periodicals)
"OpenGL I: Quick Start."
Autores: Rogerson, Dale
Ed: (MSDN Library, Technical Articles)
95

Colores y sombras
"OpenGL II: Windows Palettes in RGBA Mode."
Autores: Rogerson, Dale
Ed: (MSDN Library, Technical Articles)
"OpenGL III: Building an OpenGL C++ Class."
Autores: Rogerson, Dale
Ed: (MSDN Library, Technical Articles)
Using DIBs with Palettes.
Autores: Gery, Ron
Ed: (MSDN Library, Technical Articles)
7.15 Enlaces de interés
http://cannes.itam.mx/Alfredo/Espaniol/Cursos/Grafica/Sombreado.pdf
http://en.wikipedia.org/
http://www.opengl.org/
http://www.dsic.upv.es/users/sig/personales/ramon/esp/GrafInternet.html
http://www.ii.uam.es/~pedro/graficos/teoria/index.html
http://m3d.uib.es/grafica2/Ejemplos.html
http://serdis.dis.ulpgc.es/~atrujill/iga/Practicas2000.htm
http://sgio2.cem.itesm.mx/rudomin/graf99/curso.htm
http://victoryrocio.datablocks.net/i/opengl/
http://www.codexmx.com/macedonia/opengl2.htm
http://www.ldc.usb.ve/~jhony/graficasII/p1/informe1.html
http://www.salleurl.edu/CITeM/grafics/recursos/arxius/cap3.pdf
http://www2.ing.puc.cl/~iic1222/glex
http://giig.ugr.es/~cadii/Doc/Articulo
http://trant.sgi.com/opengl/examples/redbook/redbook.html
96

Colores y sombras
http://www.eecs.tulane.edu/www/graphics/doc/OpenGL-Man-Pages/index.html
http://giig.ugr.es/~curena/doce/docto/
http://odra.dcs.fi.uva.es/area2/opengl/colorysombra.html
http://odra.dcs.fi.uva.es/area2/opengl/refgl.html
http://giig.ugr.es/~curena/doce/vr/transparencias/
97