OpenGL (Open Graphics Library) es una especificación estándar que define una API multilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. La interfaz consiste en más de 250 funciones diferentes que pueden usarse para dibujar escenas tridimensionales complejas a partir de primitivas geométricas simples, tales como puntos, líneas y triángulos. Fue desarrollada originalmente por Silicon Graphics Inc. (SGI) en 1992 y se usa ampliamente en CAD, realidad virtual, representación científica, visualización de información y simulación de vuelo. También se usa en desarrollo de videojuegos, donde compite con Direct3D en plataformas Microsoft Windows.
Especificación Fundamentalmente OpenGL es una especificación, es decir, un documento que describe un conjunto de funciones y el comportamiento exacto que deben tener. Partiendo de ella, los fabricantes de hardware crean implementaciones, que son bibliotecas de funciones que se ajustan a los requisitos de la especificación, utilizando aceleración hardware cuando es posible. Dichas implementaciones deben superar unos tests de conformidad para que sus fabricantes puedan calificar su implementación como conforme a OpenGL y para poder usar el logotipo oficial de OpenGL.
Hay implementaciones eficientes de OpenGL para Mac OS, Microsoft Windows, GNU/Linux, varias plataformas Unix y PlayStation 4. Existen también varias implementaciones en software que permiten ejecutar aplicaciones que dependen de OpenGL sin soporte de aceleración hardware. Es destacable la biblioteca de software libre / código abierto Mesa 3D, una API de gráficos sin aceleración hardware y completamente compatible con OpenGL. Sin embargo, para evitar los costes de la licencia requerida 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 21 de septiembre de 2006 se anunció que el control de OpenGL pasaría del ARB al Grupo Khronos. Con ello se intentaba mejorar el marketing de OpenGL y eliminar las barreras entre el desarrollo de OpenGL y OpenGL ES. ARB se convirtió dentro de Khronos en el OpenGL ARB Working Group. El subgrupo de Khronos que gestiona la especificación de OpenGL se denomina OpenGL ARB Working Group. 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.
Mark Segal y Kurt Akeley fueron los autores de la especificación original de OpenGL. Chris Frazier fue el editor de la versión 1.1. Jon Leech ha editado las versiones desde 1.2 hasta la presente 3.0.
Las nuevas versiones de las especificaciones de OpenGL son lanzadas por el Khronos Group, cada una de las cuales extiende la API para soportar varias nuevas características. Los detalles de cada versión se deciden por consenso entre los miembros del Grupo, incluidos los fabricantes de tarjetas gráficas, diseñadores de sistemas operativos y empresas de tecnología en general como Mozilla y Google.
Además de las características requeridas por la API principal, los proveedores de unidades de procesamiento gráfico (GPU) pueden proporcionar funcionalidad adicional en forma de extensiones. Las extensiones pueden introducir nuevas funciones y nuevos constantes, y pueden relajar o eliminar restricciones en las funciones existentes de OpenGL. Los proveedores pueden usar extensiones para exponer APIs personalizadas sin necesidad de soporte de otros proveedores o del Khronos Group en su conjunto, lo cual aumenta considerablemente la flexibilidad de OpenGL. Todas las extensiones se recopilan y se definen en el Registro de OpenGL.
Diseño OpenGL tiene dos propósitos esenciales:
Ocultar la complejidad de la interfaz con las diferentes tarjetas gráficas, presentando al programador una API única y uniforme. Ocultar las diferentes capacidades de las diversas plataformas hardware, requiriendo que todas las implementaciones soporten la funcionalidad completa de OpenGL (utilizando emulación software si fuese necesario).
El funcionamiento básico de OpenGL consiste en 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 Máquina de estados de OpenGL. La mayor parte de los comandos de OpenGL bien emiten primitivas a la pipeline gráfica o bien configuran cómo la pipeline procesa dichas primitivas. Hasta la aparición de la versión 2.0 cada etapa de la pipeline ejecutaba una función prefijada, resultando poco configurable. A partir de la versión 2.0 algunas etapas son programables usando un lenguaje de programación llamado 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 API descriptivas, donde un programador sólo debe describir la escena y puede dejar que la biblioteca controle los detalles para representarla. El diseño de bajo nivel de OpenGL requiere que los programadores conozcan en profundidad la pipeline gráfica, a cambio de darles libertad para implementar algoritmos gráficos novedosos.
OpenGL ha influido en el desarrollo de las tarjetas gráficas, 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. lang=es|thumb|450px|Proceso en la pipeline de gráficos. Una pipeline de transformación e iluminación. Z-buffering. Mapeado de texturas. Alpha blending.
Una descripción somera del proceso en la pipeline gráfica podría ser: 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.
Muchas tarjetas gráficas 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.
Ejemplo Nota: Cuidado, este ejemplo es únicamente válido con OpenGL 2.1 y versiones anteriores. Hace uso intensivo de funciones actualmente anticuadas.
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 API 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.