Capítulo 2: Introducción a OpenGL

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/