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/