Diferencia entre revisiones de «OpenGL»

OpenGL
Información general
Tipo de programa	API
Desarrollador	Silicon Graphics Inc.
Lanzamiento inicial	1 de julio de 1992
Licencia	Diversas
Información técnica
Programado en	C; GLSL;
Versiones
Última versión estable	2.1 ( 2 de agosto de 2006)
Lanzamientos
Enlaces
	Sitio web oficial
	[editar datos en Wikidata]

Explorar historial interactivamente

← Ir a diferencia anterior Ir a siguiente diferencia →

Contenido eliminado Contenido añadido

VisualWikitexto

En renglón

Revisión del 17:14 3 feb 2007

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^[1]. 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^[2]).

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.

Especificación

A grandes rasgos, OpenGL es una especificación, es decir, un documento que describe un conjunto de funciones y su comportamiento exacto. A partir de ella, los fabricantes de hardware crean implementaciones (bibliotecas de funciones creadas para enlazar con las funciones de la especificación OpenGL, utilizando aceleración hardware cuando sea posible). Dichos fabricantes tienen que superar pruebas específicas que les permitan calificar su implementación como una implementación de OpenGL.

Existen implementaciones eficientes de OpenGL suministradas por fabricantes para Mac OS, Microsoft Windows, Linux, varias plataformas Unix, Wii y PlayStation 3. Existen también varias implementaciones software que permiten que OpenGL esté disponible para diversas plataformas sin soporte de fabricante. Es de señalar la biblioteca de software libre / código abierto Mesa 3D, una API de gráficos basada totalmente en software y completamente compatible con OpenGL. Sin embargo, para evitar los costes de la licencia para ser denominada formalmente como una implementación de OpenGL, afirma ser simplemente una API muy similar.

La especificación OpenGL era revisada por el OpenGL Architecture Review Board (ARB), fundado en 1992. El ARB estaba formado por un conjunto de empresas interesadas en la creación de una API consistente y ampliamente disponible. Microsoft, uno de los miembros fundadores, abandonó el proyecto en 2003.

El 31 de julio de 2006 se anunció que el control de OpenGL pasaría del ARB al Grupo Khronos^[3]. Con ello se intentaba mejorar el marketing de OpenGL y eliminar las barreras entre el desarrollo de OpenGL y OpenGL ES^[4]. ARB se convirtió dentro de Khronos en el OpenGL ARB Working Group^[5]. Para una relación de los miembros que componen el OpenGL ARB Working Group, véase el apartado Miembros del Grupo Khronos. El gran número de empresas con variados intereses que han pasado tanto por el antiguo ARB como por el grupo actual han hecho de OpenGL una API de propósito general con un amplio rango de posibilidades.

Diseño

OpenGL tiene dos propósitos principales:

Ocultar la complejidad de la interfaz con las diferentes aceleradoras 3D, presentando al programador una API única y uniforme.
Ocultar las diferentes capacidades de las diversas plataformas hardware, requiriendo que todas las implementaciones soporten el conjunto completo de características de OpenGL (utilizando emulación software si fuese necesario).

La operación básica de OpenGL es aceptar primitivas tales como puntos, líneas y polígonos, y convertirlas en píxeles. Este proceso es realizado por una pipeline gráfica conocida como la Máquina de estados de OpenGL. La mayor parte de los comandos de OpenGL emiten primitivas a la pipeline gráfica o configuran como la pipeline procesa dichas primitivas. Hasta la aparición de la versión 2.0 cada etapa de la pipeline ejecutaba una función establecida, resultando poco configurable. A partir de la versión 2.0 varias etapas son completamente programables usando GLSL.

OpenGL es una API basada en procedimientos de bajo nivel que requiere que el programador dicte los pasos exactos necesarios para renderizar una escena. Esto contrasta con las APIs descriptivas, donde un programador sólo debe describir la escena y puede dejar que la biblioteca controle los detalles para renderizarla. El diseño de bajo nivel de OpenGL requiere que los programadores conozcan en profundidad la pipeline gráfica, a cambio de la libertad ofrecida en la implementación de algoritmos novedosos de renderizado.

OpenGL ha influido en el desarrollo de aceleradores 3D, promocionando un nivel básico de funcionalidad que actualmente es común en el hardware comercial; algunas de esas contribuciones son:

Primitivas básicas de puntos, líneas y polígonos rasterizados.
Una pipeline de transformación e iluminación.
Z-buffering.
Mapeado de texturas.
Alpha blending.

Muchas aceleradoras 3D actuales proporcionan una funcionalidad superior a la básica aquí expuesta, pero las nuevas características generalmente son mejoras de esta pipeline básica más que cambios revolucionarios de ella.

Una descripción somera del proceso en la pipeline gráfica podría ser ^[6]:

Evaluación, si procede, de las funciones polinomiales que definen ciertas entradas, como las superficies NURBS, aproximando curvas y la geometría de la superficie.
Operaciones por vértices, transformándolos, iluminándolos según su material y recortando partes no visibles de la escena para producir un volumen de visión.
Rasterización, o conversión de la información previa en píxeles. Los polígonos son representados con el color adecuado mediante algoritmos de interpolación.
Operaciones por fragmentos o segmentos, como actualizaciones según valores venideros o ya almacenados de profundidad y de combinaciones de colores, entre otros.
Por último, los fragmentos son volcados en el Frame buffer.

Ejemplo

Primero, limpiamos el buffer de color para empezar en un canvas negro:

glClear( GL_COLOR_BUFFER_BIT );

Se establece la matriz modelview, que controla la posición de la cámara respecto a las primitivas que renderizamos. La retrasamos 3 unidades en el eje Z, dejándola apuntando hacia el origen:

glMatrixMode( GL_MODELVIEW );          /* Los comandos para matriz modificarán modelview */
glLoadIdentity();                      /* Inicializar modelview */
glTranslatef( 0, 0, -3 );              /* Desplazar 3 unidades en el eje Z */

La matriz projection controla la perspectiva aplicada a las primitivas; se utiliza de forma similar a la anterior:

glMatrixMode( GL_PROJECTION );         /* Los comandos para matriz modificarán projection */
glLoadIdentity();                      /* Inicializar projection */
glFrustum( -1, 1, -1, 1, 1, 1000 );    /* Aplicar una proyección en perspectiva */

Por último, se dibuja un polígono (un cuadrado verde orientado en el plano XY):

glBegin( GL_POLYGON );                 /* Inicio de polígono */
glColor3f( 0, 1, 0 );                  /* Establecer color actual a verde */
glVertex3f( -1, -1, 0 );               /* Establecer un vértice */
glVertex3f( -1, 1, 0 );                /* Establecer un vértice */
glVertex3f( 1, 1, 0 );                 /* Establecer un vértice */
glVertex3f( 1, -1, 0 );                /* Establecer un vértice */
glEnd();                               /* Fin de polígono */

Historia

En los años 1980 el desarrollo de software que fuese compatible con un amplio rango de hardware gráfico era un verdadero reto para los desarrolladores. Había que tratar con interfaces muy diferentes y escribir drivers específicos para cada tipo de hardware, resultando muy costoso; por ello, se subcontrataban equipos de programadores para agilizar el desarrollo. Dado que cada equipo trabajaba por separado en sus interfaces, se producía mucho código redundante. Además, era un proceso caro, por lo que varios grupos innovadores aceptaron el reto de encontrar un método mejor.

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.

Algunos de los logros que se consiguieron 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.

En 1992, 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 en los años siguientes. 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.

En 1994 SGI barajó la posibilidad de lanzar un producto denominado OpenGL++, el cual incluía elementos como una API de scene-graph (basada presumiblemente en la tecnología de Performer). Dicha especificación fue divulgada entre unos pocos grupos interesados, pero nunca apareció finalmente como producto.

En 1995 Microsoft lanzó Direct3D, que se convertiría en el principal competidor de OpenGL. El 17 de diciembre de 1997^[7] Microsoft y SGI iniciaron el proyecto Fahrenheit, esfuerzo cooperativo con el objetivo de unificar las interfaces de OpenGL y Direct3D (y añadir también una API scene-graph). En 1998 se uniría al proyecto Hewlett-Packard^[8]. Pese a tener un principio prometedor en estandarizar las APIs de gráficos 3D, debido a restricciones financieras en SGI y la falta general de apoyo por parte de la industria, fue finalmente abandonado en 1999^[9].

OpenGL 2.1

El 2 de agosto de 2006 se publicó OpenGL 2.1. Siendo completamente compatible con las versiones anteriores^[10], aporta además nuevas características como:

Revisión 1.20 del OpenGL Shading Language (GLSL).
Comandos que soportan la especificación de matrices no cuadradas.
Objetos Pixel buffer para acelerar el tráfico de imágenes en los buffers en comandos como glTexImage2D y glReadPixels.

Esta funcionalidad corresponde a la extensión ARB_pixel_buffer_object.

Texturas sRGB.

Esta funcionalidad corresponde a la extensión GL_EXT_texture_sRGB.

Documentación

La popularidad de OpenGL se debe en parte a su detallada documentación oficial. El OpenGL ARB ha publicado una serie de manuales actualizados conforme la API iba evolucionando. Son fácilmente reconocibles (y conocidos) por el color de sus tapas:

El Libro Rojo - The Red Book: The OpenGL Programmer's guide. ISBN 0-321-33573-2

Libro de referencia y tutorial. Considerado libro de cabecera para programadores de OpenGL.

El Libro Azul - The Blue Book: The OpenGL Reference manual. ISBN 0-321-17383-X

En esencia, una copia de la páginas del man de OpenGL.

Incluye un poster desplegable con el diagrama de la estructura de una implementación ideal de OpenGL.

El Libro Verde - The Green Book: Programming OpenGL for the X Window System. ISBN 0-201-48359-9

Libro sobre el interfaz X11 y GLUT.

El Libro Alpha (de tapa blanca) - The Alpha Book: OpenGL Programming for Windows 95 and Windows NT. ISBN 0-201-40709-4

Libro sobre el interfaz de OpenGL en plataformas de Microsoft Windows.

Para OpenGL 2.0 y posteriores:

El Libro Naranja - The Orange Book: The OpenGL Shading Language. ISBN 0-321-33489-2

Libro de referencia y tutorial para GLSL.

Extensiones

El estándar OpenGL permite a los fabricantes añadir nuevas funcionalidades adicionales mediante extensiones conforme aparecen nuevas tecnologías. Dichas extensiones pueden introducir nuevas funciones y constantes, y suavizar o incluso eliminar restricciones en funciones ya existentes. Cada fabricante dispone de una abreviatura que le identifica en el nombre de sus nuevas funciones o constantes. Por ejemplo, la abreviatura de NVIDIA (NV) aparece en la definición de su función glCombinerParameterfvNV() y su constante GL_NORMAL_MAP_NV.

Es posible que varios fabricantes se pongan de acuerdo en implementar la misma funcionalidad extendida. En ese caso, se usa la abreviatura EXT. Incluso puede ocurrir que el ARB adopte la extensión, convirtiéndose así en estándar y utilizando la abreviatura ARB en sus nombres. La primera extensión ARB fue GL_ARB_multitexture, presentada en la versión 1.2.1. Siguiendo el camino marcado por la extensión, el multitexturing no es ya una extensión opcional, sino que entró a formar parte del núcleo de OpenGL desde la versión 1.3.

Antes de usar una extensión, los programas deben comprobar su disponibilidad y, después, acceder a las nuevas funcionalidades ofrecidas. Este proceso es dependiente de la plataforma, pero bibliotecas como GLEW y GLEE lo simplifican.

Las especificaciones para la mayor parte de las extensiones pueden encontrarse en el registro oficial de extensiones [1].

Bibliotecas de utilidades

Se han programado varias bibliotecas externas que añaden características no disponibles en el propio OpenGL. Algunas de ellas son:

GLU: Ofrece funciones de dibujo de alto nivel basadas en primitivas de OpenGL. Las funciones de GLU se reconocen fácilmente pues todas empiezan con el prefijo glu.

GLUT: API multiplataforma que facilita una rudimentaria funcionalidad para el manejo de ventanas e interacción por medio de teclado y ratón.

GLUI: Interfaz de usuario basada en GLUT; proporciona elementos de control tales como botones, cajas de selección y spinners. Es independiente del sistema operativo, sustentándose en GLUT para manejar los elementos dependientes del sistema.

Referencias para lenguajes de programación (bindings)

Para enfatizar las características multilenguaje y multiplataforma de OpenGL, se han desarrollado varios bindings en muchos lenguajes. Algunos de los lenguajes para los que están disponibles dichos bindings son:

Ada: Ada OpenGL 1.1 soporta GL, GLU y GLUT [2].
C#: Tao es un framework para .NET que incluye OpenGL entre otras bibliotecas multimedia [3].
D: véase [4] y [5].
Delphi: Dot [6].
Fortran: f90gl soporta OpenGL 1.2, GLU 1.2, GLUT 3.7 [7].
Java: JOGL [8] y LWJGL [9] entre otros; véase [10].
Lisp: véase [11].
Perl: véase [12].
Pike: tiene un interfaz nativo a OpenGL. Además, soporta GLU y GLUT. [13].
Python: PyOpenGL soporta GL, GLU y GLUT [14].
Visual Basic: véase [15].

Miembros del Grupo Khronos

En 2006, algunos de los miembros del OpenGL ARB Working Group eran:

Para una lista completa y actualizada de los miembros del proyecto, véanse las listas de miembros promotores, contribuyentes y académicos del Grupo Khronos.

Véase también

GLSL - Lenguaje de alto nivel de shaders para OpenGL
JOGL (Java OpenGL) - Biblioteca para usar OpenGL en Java
OpenGL ES - Biblioteca para sistemas integrados

Bibliotecas adicionales para OpenGL

GLU - Funciones adicionales
GLUT - API para facilitar desarrollo con OpenGL
GLUI - Biblioteca de interfaz basada en GLUT

Otras APIs de gráficos

Direct3D - Principal competidor de OpenGL
Mesa 3D - Implementación de código abierto de OpenGL
LWJGL (Lightweight Java Game Library) - Acceso a OpenGL, OpenAL y varios dispositivos de entrada
VirtualGL - Comandos 3D entre servidor dedicado y cliente

Referencias

Enlaces externos

[1] «SGI - OpenGL Overview».

[2] «SGI - Licencia».

[3] «Boletín de prensa de Khronos anunciando la fusión con ARB».

[4] «Análisis de la fusión de Khronos y ARB».

[5] «OpenGL Architecture Review Board Working Group».

[6] «Especificación del Sistema Gráfico OpenGL Versión 2.1».

[7] «Anuncio público de Fahrenheit».

[8] «Miembros del Proyecto Fahrenheit. 1998.».

[9] «Fin del Proyecto Fahrenheit».

[10] «Características de OpenGL 2.1».

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

@@ Línea 52: / Línea 52: @@
 *Ocultar las diferentes capacidades de las diversas plataformas hardware, requiriendo que todas las implementaciones soporten el conjunto completo de características de OpenGL (utilizando emulación software si fuese necesario).
-La operación básica de OpenGL es aceptar primitivas tales como puntos, líneas y polígonos, y convertirlas en píxeles. Este proceso es realizado por una ''pipeline'' gráfica conocida como la [http://www.opengl.org/documentation/specs/version1.1/state.pdf Máquina de estados de OpenGL]. La mayor parte de los comandos de OpenGL emiten primitivas a la pipeline gráfica o configuran como la pipeline procesa dichas primitivas. Antes de la aparición de la versión 2.0, cada etapa de la pipeline ejecutaba una función establecida, resultando poco configurable. A partir de la versión 2.0, varias etapas son completamente programables usando [[GLSL]].
+La operación básica de OpenGL es aceptar primitivas tales como puntos, líneas y polígonos, y convertirlas en píxeles. Este proceso es realizado por una ''pipeline'' gráfica conocida como la [http://www.opengl.org/documentation/specs/version1.1/state.pdf Máquina de estados de OpenGL]. La mayor parte de los comandos de OpenGL emiten primitivas a la pipeline gráfica o configuran como la pipeline procesa dichas primitivas. Hasta la aparición de la versión 2.0 cada etapa de la pipeline ejecutaba una función establecida, resultando poco configurable. A partir de la versión 2.0 varias etapas son completamente programables usando [[GLSL]].
 OpenGL es una API basada en procedimientos de bajo nivel que requiere que el programador dicte los pasos exactos necesarios para renderizar una escena. Esto contrasta con las APIs descriptivas, donde un programador sólo debe describir la escena y puede dejar que la biblioteca controle los detalles para renderizarla. El diseño de bajo nivel de OpenGL requiere que los programadores conozcan en profundidad la pipeline gráfica, a cambio de la libertad ofrecida en la implementación de algoritmos novedosos de renderizado.
@@ Línea 63: / Línea 63: @@
 *[[Alpha blending]].
-Muchas aceleradoras 3D actuales proporcionan una funcionalidad superior a la básica aquí expuesta, pero las nuevas características generalmente son mejoras de esta pipeline básica más que cambios revolucionarios de esta.
+Muchas aceleradoras 3D actuales proporcionan una funcionalidad superior a la básica aquí expuesta, pero las nuevas características generalmente son mejoras de esta pipeline básica más que cambios revolucionarios de ella.
+[[Imagen: Pipeline OpenGL (es).png|thumb|right|430px|Proceso en la pipeline de gráficos]]
 Una descripción somera del proceso en la pipeline gráfica podría ser <ref>{{