Capítulo 2: Introducción a OpenGL

1. Introducción

1.1. Autores

Rodrigo Borrego Bernabé. DNI 52.412.535-C

Carmen Sánchez Gómez. DNI 07.980.715-Z
1.2. Tabla de contenidos

1. Introducción ................................................................................................ 1
1.1. Autores.................................................................................................. 1
1.2. Tabla de contenidos .............................................................................. 2
1.3. Tabla de figuras .................................................................................... 3
2. Antes de comenzar ..................................................................................... 4
3. ¿Qué es OpenGL? ...................................................................................... 5
4. Historia ........................................................................................................ 7
4.1. OpenGL ................................................................................................ 8
5. Características de OpenGL........................................................................10
6. Arquitectura de OpenGL ............................................................................11
6.1. OpenGL como una máquina de estado ...............................................11
6.2. Flujo de renderización de OpenGL ......................................................11
6.2.1. Display lists ...................................................................................12
6.2.2. Evaluadores ..................................................................................12
6.2.3. Operaciones Per-Vertex ................................................................12
6.2.4. Ensamblado de primitivas .............................................................13
6.2.5. Operaciones sobre píxeles ............................................................13
6.2.6. Ensamblado de texturas ................................................................13
6.2.7. Rasterización .................................................................................13
6.2.8. Operaciones sobre fragmentos .....................................................13
6.3. Invarianza en OpenGL .........................................................................14
6.3.1. Repetibilidad ..................................................................................14
6.3.2. Algoritmos multipasada .................................................................14
6.3.3. Reglas de invarianza .....................................................................15
7. Bibliotecas relacionadas con OpenGL .......................................................16
7.1. OpenGL Utility Library (GLU) ...............................................................16
7.2. GLX y WGL ..........................................................................................16
7.3. AUX......................................................................................................16
7.4. OpenGL Utility Toolkit (GLUT) .............................................................16
8. Aplicaciones ...............................................................................................17
8.1. Simulación ...........................................................................................17
8.2. Juegos .................................................................................................19
8.3. Ciencia y análisis .................................................................................21
9. Bibliografía .................................................................................................23
1.3. Tabla de figuras

Ilustración 2.1. Flujo de renderización de OpenGL ...........................................12

2. Antes de comenzar

La informática gráfica es la parte de la informática que se encarga de la

representación de gráficas en el ordenador y se ha convertido en el mundo de
la computación en un recurso habitual para la comunicación entre los
ordenadores y los usuarios.

En la actualidad las implicaciones son múltiples con otros sectores y su

importancia es extrema.

Se encarga del almacenamiento, creación y visualización de imágenes en el

ordenador. Las imágenes reales o con efectos realistas se consiguen
aproximando al máximo la representación gráfica que se genera en la pantalla
a las imágenes que percibe el ser humano con la vista. Para dar realismo a las
imágenes se emplean técnicas de luz, colores, texturas, transparencias,
brillos…

OpenGL fue la primera librería gráfica que abordo el uso eficiente de esos
recursos, así como la estandarización de los procedimientos de la generación
de gráficos. Actualmente es un estándar sobre gráficos por computadora, uno
de los más prestigiosos y utilizados del mundo.
3. ¿Qué es OpenGL?

OpenGL es una especificación estándar que define una API multilenguaje y

multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. Fue
desarrollada por Silicon Graphics Inc. (SGI) en 1992.

Su nombre viene del inglés Open Graphics Library, cuya traducción es

biblioteca de gráficos abierta (o mejor, libre, teniendo en cuenta su política de
licencias).

Existen implementaciones eficientes de OpenGL suministradas por fabricantes

para Mac OS, Microsoft Windows, Linux, varias plataformas Unix, y PlayStation
3. También existen varias implementaciones software que permiten que
OpenGL esté disponible para diversas plataformas sin soporte de fabricante.

La especificación OpenGL era revisada por el OpenGL Architecture Review

Board (ARB), fundado en 1992. El ARB estaba formado por un nutrido conjunto
de empresas interesadas en la creación de una API consistente y ampliamente
disponible, entre las que destacan, además de Silicon Graphics, grandes
compañías como Compaq, IBM, Intel, Microsoft, HP, Sun Microsystems, Apple,
y fabricantes de tarjetas gráficas como por ejemplo ATI, nVidia o 3D labs.

El comité ARB se encarga de gestionar el estándar OpenGL para que vaya

adoptando nuevas tecnologías, implementadas en un principio como
extensiones; y a medida que se aceptan, integrándose en sucesivas versiones
del estándar. Las extensiones no son más que llamadas a funciones que no
pertenecen al estándar de OpenGL.

Cuando una compañía desarrolla una nueva tecnología se la presenta al ARB.

Si éste lo acepta, se añade como extensión propia de esa compañía para que
se pueda utilizar en OpenGL. Se crean nuevas funciones añadiéndoles en el
nombre la abreviatura de la compañía, por ejemplo ATI para ATI y NV para
nVidia. Seguidamente, si varias compañías aceptan esa tecnología pasa a ser
una extensión con abreviatura _EXT. Si por último el comité ARB acepta como
estándar esta tecnología se cambiará el nombre siguiendo la nomenclatura del
estándar.

En septiembre del 2006 el comité ARB cambió de gestor, y ahora la

especificación de OpenGL la controla el consorcio de industria Khronos,
dedicada a la creación de API's para la creación y visualización de formatos
multimedia en distintos dispositivos y plataformas. Khronos gestiona otros
proyectos relacionados con OpenGL como por ejemplo OpenGL ES
(Embedded System), para dispositivos móviles, portátiles, etc.

OpenGL se utiliza en campos como CAD, realidad virtual, representación

científica y de información, simulación de vuelo o desarrollo de videojuegos, en
el que su principal competidor es Direct3D de Microsoft Windows.

Es independiente del Hardware gráfico y contiene comandos que ayuda a

definir objetos, aplicar transformaciones a esos objetos, cambiar sus
propiedades (color, textura, lux…) entre otros. Al ser una librería gráfica hay
que saber que OpenGL no posee funciones para el control de Audio, Red o
Control de Entrada.
4. Historia

Antes de la aparición a OpenGL, muchos fabricantes tenían diferentes

bibliotecas gráficas, esto hacia que hubiera que tratar con interfaces muy
diferentes y escribir drivers específicos para cada tipo de hardware, resultando
muy costoso. Para solventar esto, se subcontrataban equipos de
programadores para agilizar el desarrollo, los cuales tenían que implementar
manualmente el código necesario para que el programa pudiera trabajar con
cada plataforma, sistema operativo y hardware diferente. Dado que cada
equipo trabajaba por separado en sus interfaces, se producía mucho código
redundante. También producía que la potabilidad de aplicaciones de una
plataforma hardware a otra consumiera demasiado tiempo y entrañara
dificultad.

Al principio de los años 1990 SGI era un grupo de referencia en gráficos 3D

para estaciones de trabajo. Suya era la API IRIS GL, considerada puntera en el
campo y estándar de facto, llegando a eclipsar a PHIGS, basada en estándares
abiertos. IRIS GL se consideraba más fácil de usar y, lo más importante,
soportaba renderizado en modo inmediato. Además, PHIGS, aparte de su
mayor dificultad, fue considerada inferior a IRIS GL respecto a funcionalidad y
capacidad.

La competencia de SGI (Sun Microsystems, Hewlett-Packard e IBM, entre

otros) fue capaz de introducir en el mercado hardware 3D compatible con el
estándar PHIGS mediante extensiones. Esto fue reduciendo la cuota de
mercado de SGI conforme iban entrando diferentes proveedores en el
mercado. Por todo ello, en un intento de fortalecer su influencia en el mercado,
SGI decidió convertir el estándar IRIS GL en un estándar abierto.

SGI observó que la API IRIS GL no podía ser abierta debido a conflictos de
licencias y patentes; también contenía funciones no relevantes para los gráficos
3D como APIs para ventanas, teclado o ratón (en parte, porque fue
desarrollada antes de la aparición del X Window System o de los sistemas
NeWS de Sun). Además, mientras iba madurando el soporte del mercado para
el nuevo estándar, se pretendía mantener los antiguos clientes mediante
bibliotecas añadidas como Iris Inventor o Iris Performer.

El resultado de todo lo anterior fue el lanzamiento del estándar OpenGL, cuyas

principales ventajas fueron:

• Estandarizar el acceso al hardware.

• Trasladar a los fabricantes la responsabilidad del desarrollo de las
interfaces con el hardware.
• Delegar las funciones para ventanas al sistema operativo.

Con la variedad de hardware gráfico existente, lograr que todos hablasen el

mismo lenguaje obtuvo un efecto importante, ofreciendo a los desarrolladores
de software una plataforma de alto nivel sobre la que trabajar.
SGI lideró la creación del OpenGL Architecture Review Board (OpenGL ARB),
grupo de empresas que mantendría y extendería la especificación OpenGL.

OpenGL evolucionó desde IRIS GL, superando su problema de dependencia

del hardware al ofrecer emulación software para aquellas características no
soportadas por el hardware del que se dispusiese. Así, las aplicaciones podían
utilizar gráficos avanzados en sistemas relativamente poco potentes.

Durante un tiempo, se barajó la posibilidad de lanzar un producto denominado

OpenGL++, que se divulgó entre unos pocos grupos interesados, pero nunca
apareció finalmente como producto.

Como competidor principal de OpenGL debemos mencionar a Microsoft

Direct3D, que aunque solo esté disponible para sistemas Windows goza de una
gran aceptación entre los fabricantes.

4.1. OpenGL

La segunda versión es en realidad la séptima revisión desde lanzamiento de la

versión 1.0.

El 2 de agosto de 2006 se publicó OpenGL 2.1. Siendo completamente

compatible con las versiones anteriores, aporta además nuevas características,
entre las que destacan:

• Sombreado programable. Con la nueva versión el núcleo de OpenGL

consta de sus APIs y el OpenGL Shading Language. Entre sus nuevas
funcionalidades OpenGL Shading Language incluye la posibilidad de
crear sombreados asociados al aspecto ("fragmentos") de la geometría
("vértices") de un objeto 3D.
• De una sola vez pueden aplicarse sombreados sobre diferentes
renderizados y generar distintos resultados que se almacenan en
buffers.
• La aplicación de texturas no está condicionada por su tamaño que, a
diferencia de lo que ocurría en el pasado, no tiene por qué ser potencia
de dos. De esta forma ahora se soportan texturas rectangulares y se
reduce el consumo de memoria.
• Se pueden aplicar patrones ("stencil") sobre las dos caras de las
primitivas geométricas, mejorando el rendimiento en el volumen
sombreado y en los algoritmos de renderizado de geometría sólida.
• "Point Sprites", puntos geométricos sobre los que se aplican texturas.
Son especialmente útiles en sistemas con partículas.
Incorpora soporte para las interfaces de programación de aplicación (API) del
Lenguaje de Sombreado OpenGL (OpenGL Shading Language). Con la
incorporación de OpenGL Shading Language en el núcleo de OpenGL, los
desarrolladores pueden estar seguros de que todas las tarjetas gráficas que
soportan OpenGL 2.0 incluirán esta característica independientemente del
sistema operativo.

OpenGL® Shading Language ha sido ampliamente probado durante un año

siguiendo los procesos de estandarización definidos por el ARB. Las
potenciales aplicaciones incluyen imágenes de alta calidad para juegos,
imágenes con mayor realismo para formación y simulación, mejores
herramientas de análisis para visualización médica, así como entornos
simulados de productos manufacturados con mejor diseño. Desde que se
anunció en 2003, OpenGL Shading Language se ha convertido en el lenguaje
de sombreado más utilizado para el desarrollo de aplicaciones de visualización
y gráficos interactivos, con implementaciones en UNIX, Microsoft Windows,
Linux y otros sistemas operativos.
5. Características de OpenGL

OpenGL está enfocado a la creación de contenido visual para su volcado sobre

un framebuffer que luego será mostrado en pantalla (y eventualmente a la
lectura de la información almacenada en ese framebuffer). No contempla el
manejo de dispositivos relacionados indirectamente con la interacción gráfica
con el ordenador (como el ratón o el teclado).

OpenGL basa su funcionamiento en una serie de modos configurables y la

ejecución de una serie de primitivas de dibujo que no son más que la
realización de segmentos, polígonos, puntos o rectángulos de píxeles. Los
modos se seleccionan y configuran y las operaciones se realizan mediante el
envío de comandos gracias a la invocación de funciones (llamadas a métodos).

Los comandos OpenGL se organizan en secuencias y su procesamiento se

realiza siempre en el orden en que se reciben, aunque puede producirse un
retraso entre la ejecución de un comando y la representación de sus efectos.
Este comportamiento implica que la ejecución de una primitiva debe ser
completada (se debe realizar por completo el trazado) antes de que cualquier
otra primitiva subsecuente pueda ser invocada y pueda actuar sobre el
contenido del frambuffer. Esto implica también que la obtención de información
(operaciones de lectura) recupera siempre un estado consistente con la
ejecución completa de los comandos OpenGL anteriormente invocados (salvo
que explícitamente se especifique otro comportamiento).

OpenGL proporciona mecanismos para el control directo de las operaciones

fundamentales en el trabajo con gráficos en dos y tres dimensiones, incluyendo
tratamiento de luces, métodos de anti-aliasing, etc. Sin embargo, no
proporciona mecanismos de definición de objetos geométricos complejos, más
bien permite especificar cómo dichos objetos deben ser renderizados a partir
de objetos geométricos simples.

El ámbito de operación de OpenGL llega hasta el framebuffer pero en ningún

caso más allá. Es decir, queda bajo la responsabilidad del sistema sobre el que
se ejecuta la aplicación el control de las ventanas de la aplicación, del volcado
del framebuffer al monitor (y la realización de operaciones como la corrección
del gamma, etc.).
6. Arquitectura de OpenGL

OpenGL implementa una arquitectura cliente servidor, donde un programa (el

cliente) solicita comandos y dichos comandos son interpretados y procesados
por el sistema OpenGL (el servidor). No es necesario que el servidor se sitúe
en el mismo ordenador que el cliente, permitiendo a la especificación OpenGL
ser “transparente a la red”. Un mismo servidor puede mantener una serie de
contextos OpenGL, representando cada uno de ellos el encapsulamiento de un
estado OpenGL . Un cliente selecciona el contexto al que se desea conectar
para solicitar las operaciones (y el comportamiento ante la solicitud de
comandos sin estar conectado a un contexto queda sin definir).

6.1. OpenGL como una máquina de estado

Se ha mencionado ya implícitamente que OpenGL es una máquina de estado.

Existen ciertas variables de estado como el color, por ejemplo, que determinan
el estado de la máquina. Este estado puede ser modificado mediante
comandos y las modificaciones se mantendrán hasta que se vuelvan a alterar
las variables.

Un buen número de variables de estado se refieren a modos que pueden ser

habilitados o deshabilitados con los comandos glEnable() y glDisable(). Se
puede comprobar el estado de un modo con glIsEnabled().
Además de los modos, las variables de estado almacenan valores que pueden
ser recuperados con diferentes comandos según el tipo de dato que se quiera
obtener (glGetBooleanv(), glGetDoublev(), glGetFloatv(), glGetIntegerv(),
glGetPointerv(), etc.). Se puede acceder a ciertas variables de estado
mediante invocaciones específicas, como glGetLight*(), glGetError() o
glGetPolygonStipple(). Es posible almacenar colecciones de variables de
estado en pilas con los métodos glPushAttrib() o glPushClientAttrib() y
recuperarlas después con glPopAttrib() o glPopClientAttrib().

El listado completo de variables de estado disponibles puede ser consultado en

la documentación.

6.2. Flujo de renderización de OpenGL

La mayoría de las implementaciones de OpenGL implementan un orden de

operaciones idéntico, una serie de etapas de procesamiento denominado el
flujo de renderización de OpenGL (OpenGL rendering pipeline). El flujo está
representado en la Ilustración 2.1, y aunque es necesario resaltar que no es
una definición estricta ni obligatoria, proporciona indicaciones bastante fiables
sobre el orden de las operaciones en OpenGL.
 Ilustración 2.1. Flujo de renderización de OpenGL

Lo primero que se debe reseñar es que el flujo de datos de la información

geométrica (vértices, líneas y polígonos) es distinto en una parte del proceso
del flujo de la información de píxeles (píxeles, mapas de bits e imágenes). La
segunda parte del proceso, sin embargo, es común para ambos tipos de datos
hasta finalizar toda la información en los buffers de salida (framebuffers).

6.2.1. Display lists

Según el modo seleccionado, una serie de datos a mostrar pueden ser

mostrados inmediatamente cuando son creados o bien almacenarlos para
mostrarlos con posterioridad. Cuando su salida es retardada, se almacenan en
las display list hasta que son requeridos.

6.2.2. Evaluadores

Las primitivas geométricas están definidas en última instancia como un

conjunto de vértices. Las curvas paramétricas y las superficies están definidas
por puntos de control y funciones polinómicas denominadas funciones base.
Los evaluadores proporcionan los mecanismos para obtener los vértices
utilizados para representar las superficies a partir de los puntos de control. El
método proporciona los vértices, las coordenadas de las texturas, los colores y
los valores de coordenadas espaciales.

6.2.3. Operaciones Per-Vertex

Antes de poder procesar la información geométrica los vértices deben ser

convertidos en primitivas. Ciertos datos geométricos (por ejemplo las
coordenadas espaciales) son transformados por matrices 4x4 de números
reales para convertir una posición en el modelo tridimensional en una posición
en la pantalla. Esta operación puede ser aún más complicada si están
activadas algunas capacidades avanzadas. Es en esta fase donde se procesa
la aplicación de las texturas, calculando las zonas a mostrar y su posición. Las
modificaciones debidas a la iluminación también son procesadas en esta fase,
que debe tener en cuenta los vértices procesados, las superficies, la posición
de los focos de luz y las propiedades de los materiales para producir la
información sobre el color a mostrar.

6.2.4. Ensamblado de primitivas

En esta fase deben calcularse los puntos que por su posición quedan fuera de
la imagen visible, esto es, aquella información geométrica que no debe ser
renderizada. También deben calcularse las intersecciones entre primitivas (que
pueden añadir nuevos vértices con la intersección de líneas o polígonos). Es
también en esta fase cuando se realiza el procesamiento de la perspectiva.

6.2.5. Operaciones sobre píxeles

Como ya se ha reseñado, la información de píxeles es procesada de manera

diferente. La primera operación a realizar sobre una matriz de píxeles en
memoria es la conversión entre una amplia variedad de formatos a las
correspondientes componentes activas. A continuación los datos son
escalados, trasladados y procesados por un mapa de píxeles para enviar el
resultado a la etapa de rasterización o almacenados en la memoria de texturas.
El proceso puede ser inverso, esto es, es posible la extracción de los datos de
los framebuffers para su conservación en la memoria del sistema.

6.2.6. Ensamblado de texturas

Las aplicaciones OpenGL pueden aplicar imágenes de texturas sobre los

objetos geométricos para proporcionarles una apariencia más realista. Si se
utilizan varias imágenes simultáneamente es aconsejable cargarlas sobre
objetos de texturas de modo que se puedan intercambiar entre ellos. Algunas
implementaciones destinan recursos específicos para acelerar el proceso y
mejorar el rendimiento de la aplicación de texturas y existen memorias de alto
rendimiento para texturas.

6.2.7. Rasterización

La rasterización es la conversión de los datos, tanto geométricos como de

píxeles, en fragmentos. Cada cuadro en un fragmento se corresponde con un
pixel en el framebuffer. Para esta conversión es necesario tener en cuenta los
vértices, las líneas, las intersecciones, los tamaños de puntos, el grosor de las
líneas, el modelo de sombras, la ocultación de ciertos objetos, etc. Además,
cada cuadro de un fragmento debe llevar asociada una información de color.

6.2.8. Operaciones sobre fragmentos

Una vez que todas las operaciones anteriores han sido realizadas y como
último paso antes del volcado de los fragmentos en el framebuffer es necesario
realizar una serie de operaciones que pueden alterar (o incluso descartar) los
distintos fragmentos. Todas estas operaciones pueden estar habilitadas o no
según el estado de la máquina OpenGL.

La primera operación es la aplicación de texturas, donde para cada fragmento

se genera y se aplica un texel (texture element) a partir de la memoria de
texturas. A continuación se efectúan los cálculos relativos a la niebla, el test de
las tijeras, el test de transparencias, la eliminación de superficies ocultas,
operaciones lógicas, fusión de fragmentos, etc.

6.3. Invarianza en OpenGL

Debido a que OpenGL no es una especificación exacta a nivel de píxel no está

garantizada la coincidencia entre dos imágenes producidas por diferentes
implementaciones OpenGL. Sin embargo, lo que sí está especificado es la
coincidencia exacta, en ciertos casos, de imágenes producidas por la misma
implementación. La invarianza está expresada en la especificación OpenGL por
el cumplimiento de varias reglas.

6.3.1. Repetibilidad

La repetición de la misma serie de comandos partiendo de un mismo estado

inicial debe producir el mismo estado final y los mismos resultados en los
framebuffers.

El propósito de la repetibilidad es evitar comportamientos extraños cuando se

redibuje una escena con doble buffer. Estos comportamientos, si no se verifica
la repetibilidad pueden ser molestos para el observador. Además, esta regla es
útil para la realización de pruebas con las implementaciones.

Sin embargo, así descrita la repetibilidad es una condición demasiado débil,

puesto que atendiendo solo a esta regla la variación de un único y minúsculo
polígono podría dar lugar a una representación con todos los píxeles diferentes.
Es por ello que son necesarias reglas adicionales de invarianza para garantizar
la utilidad de una implementación.

6.3.2. Algoritmos multipasada

Los algoritmos multipasada se caracterizan por renderizar una escena múltiples

veces, cada una de ellas partiendo de un vector de modo OpenGL ligeramente
diferente, para, eventualmente, producir una salida en el framebuffer. Un
ejemplo de estos algoritmos sería el borrado de una primitiva del framebuffer
pintándola de nuevo, bien con un color diferente (el color de fondo) o utilizando
la operación lógica XOR. Estos algoritmos, en una implementación consistente
deben producir en cada renderizado resultados que difieran entre sí de manera
coherente con los cambios realizados sobre el vector de modo.

6.3.3. Reglas de invarianza

Para un contexto OpenGL concreto:

Regla 1. Para un vector de estado de la máquina OpenGL y el framebuffer
y para cualquier comando OpenGL el estado de la máquina OpenGL y el
framebuffer resultante debe ser idéntico en cada ejecución.

Regla 2. Los cambios en una serie de valores de estado no deben generar

efectos colaterales (no deben interferir con otros valores de estado). La
lista de valores de estado completa puede consultarse en la
especificación OpenGL, catalogados en valores de estado que deben
cumplir esta regla y los que se sugiere que la cumplan.

Corolario 1. La generación de fragmentos debe ser invariable con

respecto a las variables de estado más significativas.

Corolario 2. Las coordenadas de ventana (en las tres dimensiones) de

los fragmentos generados también deben ser invariantes en sus
características básicas.

Regla 3. La aritmética de cada operación aplicada sobre un fragmento

debe ser invariante excepto en lo relativo a parámetros que directamente
controlen dicha operación.

Corolario 1. Las imágenes renderizadas en diferentes buffers de color

pero compartiendo el mismo framebuffer (bien simultáneamente o
por separado utilizando la misma secuencia de comandos) deben
ser idénticas píxel a píxel.

Regla 4. El mismo sombreado debe producir el mismo resultado al ser

efectuado repetidas veces sobre la misma entrada.
7. Bibliotecas relacionadas con OpenGL

OpenGL contiene un conjunto de poderosos pero primitivos comandos que

efectúan operaciones a muy bajo nivel. Además, acciones como la apertura de
una ventana en el sistema grafico u otras similares no entran en el ámbito de
OpenGL. Por ello es muy habitual contar con el apoyo de algunas bibliotecas
de funciones ajenas a OpenGL pero muy relacionadas con ella. Las más
populares se describen a continuación:

7.1. OpenGL Utility Library (GLU)

Contiene bastantes rutinas que usan OpenGL a bajo nivel para realizar tareas
como transformaciones de matrices para tener una orientación especifica,
subdivisión de polígonos, etc. Son funciones con un nivel de abstracción por
encima de OpenGL para facilitar la labor de programación de aplicaciones.
Esta biblioteca suele estar incluida en las implementaciones OpenGL y sus
métodos son fácilmente reconocibles porque comienzan por el prefijo glu.

7.2. GLX y WGL

GLX da soporte para maquinas que utilicen X Windows System y permite

realizar todos los procesos gráficos relacionados con las ventanas de
aplicación. WGL es el equivalente para sistemas Microsoft.

7.3. AUX

La biblioteca de funciones AUX fue desarrollada en la etapa inicial de desarrollo

de OpenGL por SGI para server de apoyo a la creación de pequeños
programas de demostración. Actualmente está declarada obsoleta y ya no está
ni soportada ni actualizada. El desarrollo de aplicaciones utilizando esta
biblioteca está desaconsejado, debiéndose utilizar GLUT en su lugar. AUX se
describirá en profundidad en el capítulo 4.

7.4. OpenGL Utility Toolkit (GLUT)

Es un sistema de ventanas, escrito por Mark Kilgard, independiente del sistema

usado. GLUT ofrece una interfaz común para múltiples plataformas para el
manejo de ventanas, buffers, renderización de texto, entrada por teclado y
menús, permitiendo a los desarrolladores utilizar un interface común para el
sistema de ventanas independiente de la plataforma. Además, debido a su
sencillez, tiene una suave curva de aprendizaje. GLUT es actualmente
soportado por varios lenguajes, en especial ANSI C y FORTRAN.
8. Aplicaciones

Existen múltiples aplicaciones para las que OpenGL ha servido como base,
desarrolladas en diferentes plataformas (Windows, Unix/Linux, Mac Os, Java y
Sistemas embebidos) y con diferente finalidad (simulación, juegos,
salvapantallas, científicos, mapas, navegación, procesadores…).

A continuación se mencionan algunas de las diferentes aplicaciones

desarrollados con OpenGL, indicar que donde mayor variedad se encuentran
es en la plataforma Windows y sobre todo en juegos.

8.1. Simulación

Aerofly
Simulación de control aéreo
Windows

Cloth-Sim
Simulador en tiempo real de ropa
Windows
Biodesigner
Simulación y modelación molecular
Windows

Dex
Desarrollo, análisis y visualización
de múltiples cuerpos
Linux

X-Vison
Visualización y animación de datos
en 3D
Linux
8.2. Juegos

Chess Commander
Juego de ajedrez.
Windows

Jedi Academy
Entrenamiento de un jedi.
Windows

PinBall
Juego de Pinball.
Windows
Follbilliard
Simulación física del juego del billar
Linux

KhunPhan
Pullze
Linux
8.3. Ciencia y análisis

Great Stella
Estudio de poliedros
Windows

MVE – Medical Volume Explorer

Visualización en 3D de datos
médicos.
Windows

Visit
Visualización y parametrización de
múltiples datos
Linux
Medit
Visualización científica
Linux
9. Bibliografía

OpenGL Programming Guide

OpenGL Programming Guide, Second Edition. Addison Wesley.

Mark Segal, Kurt Akeley. The OpenGL Graphics System: A Specification,

2004.

Wright, Richard S.; Lipchak, Benjamin. OpenGL, 1ª Ed. Anaya Multimedia.

http://www.opengl.org/

http://www.sgi.com/