OpenGL

OpenGL
Información general
Tipo de programa	API
Desarrollador	Silicon Graphics Inc.
Lanzamiento inicial	1 de julio de 1992
Licencia	Diversas
Versiones
Última versión estable	4.0​ ( 11 de marzo de 2010 (14 años, 2 meses y 1 día))
Lanzamientos
IRIS GL y PHIGS	OpenGL	Vulkan
Enlaces
Sitio web oficial

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 3. 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 basada 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.​

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 la Máquina de estados de OpenGL.​ La mayor parte de los comandos de OpenGL o 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 APIs 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.

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:​

1. 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.
2. 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.
3. 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.
4. Operaciones por fragmentos o segmentos, como actualizaciones según valores venideros o ya almacenados de profundidad y de combinaciones de colores, entre otros.
5. 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

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​ 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.​ 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.​

Versiones

OpenGL 1.0

Released January, 1992.
The first OpenGL specification was released by Mark Segal and Kurt Akeley.

OpenGL 1.1

Released January, 1997.
OpenGL 1.1 focused on supporting textures and texture formats on GPU hardware.
Supported GPU Cards: all

Extension	Extension ID	Functions
Vertex Arrays	EXT_vertex_array	glVertexPointer, glColorPointer, glNormalPointer
Polygon Offsets (depth biasing)	EXT_polygon_offset	glPolygonOffset
RGBA logical blending	EXT_blend_logic_op	glBlendFunc
Texture Copy and Sub-copy	EXT_subtexture, EXT_copy_texture	glTexSubImage1D/2D/3D
Texture Formats	EXT_texture	RGB, LUMINANCE, ALPHA, INTENSITY (in glTexImage2D)
Texture Objects	EXT_texture_object	glGenTextures, glBindTextures

OpenGL 1.2

Released March 16, 1998.
OpenGL 1.2 focused on supporting volume textures, packed pixels, normal rescaling, clamped/edge texture sampling and image processing.
Supported GPU Cards: Rage 128, Rage 128 GL, Rage XL/XC, Rage 128 Pro, Rage Fury MAXX, and all later cards.

Extension	Extension ID	Functions
3D Volume Textures	GL_EXT_texture3D	glTexImage3DEXT
BGRA Texture Format	GL_EXT_bgra	BGR_EXT, BGRA_EXT (in glTexImage2D)
Packed Pixels	GL_EXT_packed_pixels
Normal Rescaling	GL_EXT_rescale_normal
Separate Specular Color	GL_EXT_separate_specular_color
Texture Coord Edge Clamping	SGIS_texture_edge_clamp
Texture LOD Control	SGIS_texture_lod
Draw Range Elements	EXT_draw_range_elements	glDrawRangeElements
Image Processing Subset	EXT_color_table, EXT_convolution, SGI_color_matrix, EXT_histogram, EXT_blend_color, EXT_blend_minmax

OpenGL 1.2.1

Released October 14, 1998
OpenGL 1.2.1 was a minor release after OpenGL 1.2 (March 16, 1998) which added multi-texture, or texture units, to the rendering pipeline. This allowed multiple textures to be blended per pixel during rasterization.
Supported Cards: Radeon, Radeon Mobility, Radeon 7500 Mobility, Radeon 8500, Radeon 9000, Radeon 9200, Radeon 9600, Radeon 9800, GeForce 3, GeForce 4Ti, GeForce FX, and all later cards

Extension	Extension ID	Functions
Multi-Texturing	SGIS_multitexture	glActiveTextureARB, glClientActiveTextureARB

OpenGL 1.3

Released August 14, 2001.
OpenGL 1.3 added support for cubemap texture, multi-texturing, multi-sampling, and texture unit combine operations (add, combine, dot3, border clamp).
Supported Cards: Radeon 32/36, Radeon 64/7200, Radeon 7000, Radeo AIW, Radeon 7500, Radeon IGP 320M, Radeon IGP 345M, ES1000, Radeon 8500, Radeon 9000/Pro, Radeon 9100/9200/9250 (Pro & IGP), GeForce 3, GeForce 4Ti, GeForce FX, and all later cards.

Extension	Extension ID	Functions
Compressed Textures	GL_ARB_texture_compression
Cubemaps	GL_EXT_texture_cube_map	TEXTURE_CUBE_MAP_EXT
Multi-Sampling	GL_ARB_multisample
Texture Add	GL_ARB_texture_env_add
Texture Combine	GL_ARB_texture_env_combine
Texture Dot3	GL_ARB_texture_env_dot3
Texture Border Clamping	GL_ARB_texture_border_clamp
Matrix Transpose	GL_ARB_transpose_matrix

OpenGL 1.4

Released July 24, 2002.
OpenGL 1.4 added hardware shadowing support, fog coordinates, automatic mipmap generation, and additional texture modes.
Supported Cards: Quadro DCC, Quadro4 380 XGL, Quadro4 500XGL, 550XGL, Quadro4 700XGL, 750XGL, 900XGL, 980XGL, and all later cards.

Extension	Extension ID	Functions
Automatic Mipmaps	SGIS_generate_mipmap
Blend Squaring Functions	GL_NV_blend_square
Depth Textures	GL_ARB_depth_texture	DEPTH_COMPONENT16/24/32_ARB
Hardware Shadowing Z-depth	GL_ARB_shadow	COMPARE_R_TO_TEXTURE
Fog Coordinates	GL_EXT_fog_coord
Multiple Draw Arrays	GL_EXT_multi_draw_arrays
Point Parameters	GL_ARB_point_parameter
Secondary Color	GL_EXT_secondary_color
Separate Blend Functions	GL_EXT_blend_func_separate
Stencil Wrapping	GL_EXT_stencil_wrap
Texture Crossbar Environment Mode	GL_ARB_texture_env_crossbar
Texture LOD Bias	GL_EXT_texture_lod_bias
Texture Mirrored Repeat	GL_ARB_texture_mirrored_repeat
Window Raster Position	GL_ARB_window_pos

OpenGL 1.5

Released July 29, 2003.
OpenGL 1.5 added support for vertex buffer objects (VBOs), occlusion queries, and extended shadowing functions.
Supported Cards: Radeon X800, Radeon 9600, Radeon 9700, Radeon 9800, GeForce FX, and all later cards.

Extension	Extension ID	Functions	More Info
VBOs Vertex Buffer Objects	GL_ARB_vertex_buffer_object	glBindBufferARB, glBufferDataARB, glGenBuffersARB	songho
Occlusion Queries	GL_ARB_occlusion_query
Extended Shadow Functions	GL_EXT_shadow_funcs

OpenGL 2.0

Released September 7, 2004.
OpenGL 2.0 added support for a true, GPU-based assembly language called ARB (designed by the Architecture Review Board), which would become the standard for vertex and fragment shaders. Cards released with OpenGL 2.0 were the first to offer user-programmable shaders.
Supported cards: Radeon 9650, Radeon 9500, Radeon 9500/9550/9600/9700/9800 (Pro, SE, XT), Radeon X1050, Radeon Xpress 200 / 1100, Radeon X300, Radeon X550, Radeon X600/Pro, Radeon X700, Radeon X800 (VE, SE, GT, Pro), Radeon X850, Radeon Xpress 1250, Radeon X1200, Radeon X1250, Radeon 2100, Radeon X1300, X1550, X1600, X1650, X1800, X1900, X1950 (Pro, XT, GT), GeForce 6800, Quadro 600, Qaudro FX 500, Quadro FX 700, Quadro FX 1000, FX 2000, FX 3000, Quadro FX 1400, Quadro FX 1500, Quadro FX 3450, Quadro FX 3500, Quadro FX 4500X2, Quadro FX4500 SDI, and all later cards.

OpenGL 2.0 was conceived by 3Dlabs to address concerns that OpenGL was stagnating and lacked a strong direction. 3Dlabs proposed a number of major additions to the standard. Most of these were, at the time, rejected by the ARB or otherwise never came to fruition in the form that 3Dlabs proposed. However, their proposal for a C-style shading language was eventually completed, resulting in the current formulation of GLSL (the OpenGL Shading Language, also slang). Like the assembly-like shading languages that it was replacing, it allowed the programmer to replace the fixed-function vertex and fragment pipe with shaders, though this time written in a C-like high-level language.

The design of GLSL was notable for making relatively few concessions to the limitations of the hardware then available; this hearkened back to the earlier tradition of OpenGL setting an ambitious, forward-looking target for 3D accelerators rather than merely tracking the state of currently available hardware. The final OpenGL 2.0 specification​ includes support for GLSL.

Extension	Extension ID	Functions
Shader Objects	GL_ARB_shader_objects
Vertex Programs	GL_ARB_vertex_program	glBindProgramARB, glGenProgramsARB
Vertex Shaders (VS)	GL_ARB_vertex_shader
Fragment Shaders (FS)	GL_ARB_fragment_shader
Multiple Render Targets	GL_ARB_draw_buffers	glDrawBuffers
Rectangular Texture	GL_ARB_texture_rectangle	GL_TEXTURE_RECTANGLE_ARB
Point Sprites	GL_ARB_point_sprite
Separate Blend Equation	GL_EXT_blend_equation_separate
Separate Stencil	GL_EXT_stencil_two_side

OpenGL 2.1

El 2 de agosto de 2006 se publicó OpenGL 2.1. Siendo completamente compatible con las versiones anteriores,​ 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.

OpenGL 3.0

La versión OpenGL 3.0​ fue publicada el 11 de agosto de 2008. Es compatible hacia atrás con todas las versiones anteriores de OpenGL, aunque introduce un nuevo mecanismo para despreciar (deprecate en inglés) funcionalidad obsoleta y así poder simplificar la API en versiones futuras.

Las principales novedades son:

• OpenGL Shading Language versión 1.30 (GLSL)
• Vertex Array Objects.
• Framebuffer Objects más flexibles.
• Texturas y render buffers en coma flotante de 32-bits.
• Soporte para formato en coma flotante de 16-bits para vértices y píxeles.
• Capacidad de almacenar vértices en un buffer tras haber sido transformados.
• Texture arrays
• Z-buffer en coma flotante de 32-bits.

Sólo el hardware a nivel de DirectX 10 es capaz de ejecutar OpenGL 3.0.

OpenGL 3.1

La versión 3.1 (Longs Peak Reloaded) fue publicada el 24 de marzo de 2009, y presenta una serie de características para hacer la API más conveniente de utilizar, además de las características orientadas al rendimiento:

• Lenguaje de Sombreado OpenGL revisión 1,40 (GLSL)
• Buffer de textura de objetos - un nuevo tipo de textura que tiene una gama de dimensiones texels
• Uniforme de objetos de búfer de datos para una rápida share / actualización
• Texturas normalizadas firmadas (rango ± 1,0)
• Un mínimo de 16 unidades de textura accesible por el Vertex Shader
• Reinicio de primitiva
• Instancias - dibujo de objetos varias veces a través de la reutilización de los vértices de datos
• CopyBuffer API para copia rápida de datos, utilizada en conjunción con OpenCL

Con la liberación de la especificación OpenGL 3.1, una extensión de compatibilidad permite a los desarrolladores acceder a la funcionalidad de OpenGL 1.X/2.X eliminada en OpenGL 3.1 también fue publicada. En particular, el legado de la funcionalidad para amplia línea de apoyo se mantiene.

Legado funcionalidad eliminado incluye:

• Todas las opciones de función fija
• Modo directo
• Índice de modo de color, es decir, formatos de pixel con paletas de colores

OpenGL 3.2

La versión 3.2 fue publicada el 3 de agosto de 2009. Incluye las siguientes características:

• Lenguaje de Sombreado OpenGL revisión 1,50 (GLSL)
• Soporte de Geometría Shader
• BGRA vértice componente de pedidos
• Fragmento Shader coordinar el control de convención
• Perfecta mapa cubo filtrado
• Fragmento de profundidad de sujeción
• Multisampled texturas y textura de las muestras para lugares específicos de la muestra
• Objetos de sincronización y cerca

OpenGL 3.3

Publicada el 11 de marzo 2010

OpenGL 3.3, simultáneamente lanzado con OpenGL 4.0 y complementada por un conjunto de nuevas extensiones ARB, porta tanta funcionalidad como es posible desde la especificación OpenGL 4.0 para su uso en la generación anterior de hardware GPU. Incluye GLSL 3.30.

OpenGL 4.0

Publicada el 11 de marzo 2010 Tarjetas compatibles: Radeon HD serie 5000, nVidia GTX serie 400;

Características:​

• OpenGL Shading Language versión 4.00 (GLSL)
• Dos fases de sombreado que permiten a la GPU descargar la teselación geométrica de la CPU.
• Per-shaders fragmento de la muestra y de sombreado programable posiciones fragmento de entrada para mayor calidad de representación y anti-aliasing de flexibilidad.
• Subrutinas Shader para una flexibilidad de programación aumentada significativamente.
• Separación del estado de textura y de los datos de textura mediante la adición de un nuevo tipo de objeto llamado sampler objetos.
• Dibujo de los datos generados por el API de OpenGL o externos, tales como OpenCL, sin intervención de la CPU.
• Operaciones de 64-bit de coma flotante de doble precisión de sombreado y entradas / salidas para prestar mayor precisión y calidad.
• Mejoras de rendimiento, tales como shaders de geometría en instancias, instancias matrices y una consulta de nuevo temporizador.

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.​

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.
• C#: Tao​ es un framework para .NET que incluye OpenGL entre otras bibliotecas multimedia.
• D: véase​ y.​
• Delphi: Dot.​
• Fortran: f90gl​ soporta OpenGL 1.2, GLU 1.2, GLUT 3.7.
• Gambas: gb.opengl​
• Java: JOGL​ y LWJGL​ entre otros; véase.​
• Lisp: véase.​
• Perl: véase.​
• Pike: tiene un interfaz nativo a OpenGL.​ Además, soporta GLU y GLUT.
• Python: PyOpenGL​ soporta GL, GLU y GLUT.
• Visual Basic: véase.​
• XBase++: véase.​

• Haskell: HOpenGL,​ soporta GL, GLU y GLUT.

Miembros del Grupo Khronos

En 2008, algunos de los miembros del Grupo Khronos son:

• AMD
• Apple
• Blizzard
• Intel Graphics Controllers
• nVIDIA

Para una lista completa y actualizada de los miembros del proyecto, véanse las listas de miembros,​ 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
• WebGL - Especificación estándar para desplegar gráficos en 3D en navegadores web
• OpenWF - Interface de abstracción de bajo nivel de hardware para sistemas de ventana compuesto
• OpenSL ES - API multiplataforma para audio 2D y 3D acelerada por hardware
• OpenML - Ambiente de programación multiplataforma, para capturar, transportar, procesar, desplegar, y sincronizar medios digitales
• OpenKODE - APIs nativos para los juegos en dispositivos de mano y las aplicaciones de medios

Bibliotecas adicionales para OpenGL

• GLU - Funciones adicionales (NURBS, esferas, discos, etc)
• GLUT - API para facilitar desarrollo con OpenGL y gestionar ventanas y eventos
• GLUI - Biblioteca de interfaz basada en GLUT
• GLX - Interfaz de OpenGL con el sistema X Window System

Otras interfaces de gráficos

• 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

Enlaces externos

• Sitio web oficial de OpenGL
• Sitio web de SGI sobre OpenGL
• OpenGL en el Open Directory Project
• Grupo Khronos
• NeHe Tutorials, tutoriales para el aprendizaje de OpenGL
• Proyecto Fahrenheit en Microsoft
• Black ByteTutoriales en Español de OpenGL