Edición de «OpenGL»

{{distinguir|OpenCL}}
{{Ficha de software
|nombre                      = OpenGL ES 3
|logo = 
|captura                     = 
|pie                         = 
|autor                       = [[Silicon Graphics]]
|desarrollador               = [[Khronos Group]]
|lanzamiento                 = {{fecha|01|1992}}
|última_versión              = 4.6<ref>{{Cita web |url=https://www.opengl.org/documentation/current_version/ |título=Copia archivada |fechaacceso=19 de abril de 2015 |fechaarchivo=1 de julio de 2017 |urlarchivo=https://web.archive.org/web/20170701194824/https://www.opengl.org/documentation/current_version/ |deadurl=yes }}</ref>
|fecha_última_versión        = {{fecha de lanzamiento|31|07|2017}}
|lenguaje_programación       = [[C (lenguaje de programación)|C]]
|sistema_operativo           = [[Multiplataforma]]
|plataforma                  = 
|tamaño                      = 
|género                      = [[Application Programming Interface|API]]
|licencia                    = Diversas
|idiomas                     = 
|español                     = Sí
|sitio_web                   = [http://www.opengl.org/ www.opengl.org]
}}

'''OpenGL''' ('''Open G'''raphics '''L'''ibrary) es una especificación estándar que define una [[Interfaz de programación de aplicaciones|API]] multilenguaje y [[multiplataforma]] para escribir aplicaciones que produzcan gráficos [[Computación gráfica 2D|2D]] y [[Gráficos 3D por computadora|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|Silicon Graphics Inc.]] ('''SGI''') en 1992<ref>{{Cita web | url=http://www.sgi.com/products/software/opengl/overview.html | título=SGI - OpenGL Overview}}</ref> y se usa ampliamente en [[Diseño asistido por computador|CAD]], [[realidad virtual]], representación científica, visualización de información y [[simulador de vuelo|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 [[Junta de revisión de la arquitectura OpenGL|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]].<ref>{{Cita web
 |url          = http://www.khronos.org/news/press/Releases/opengl_arb_to_pass_control_of_opengl_specification_to_khronos_group/
 |título      = Boletín de prensa de Khronos anunciando la fusión con ARB
 |urlarchivo   = https://web.archive.org/web/20080503182855/http://www.khronos.org/news/press/releases/opengl_arb_to_pass_control_of_opengl_specification_to_khronos_group/
 |fechaarchivo = 3 de mayo de 2008
}}</ref> Con ello se intentaba mejorar el marketing de OpenGL y eliminar las barreras entre el desarrollo de OpenGL y [[OpenGL ES]].<ref>{{Cita web
 |url          = http://www.tgdaily.com/2006/07/18/analysis_khronos_and_open_gl_merge/
 |título      = Análisis de la fusión de Khronos y ARB
 |fechaacceso  = 14 de enero de 2007
 |urlarchivo   = https://web.archive.org/web/20080520113726/http://www.tgdaily.com/2006/07/18/analysis_khronos_and_open_gl_merge/
 |fechaarchivo = 20 de mayo de 2008
}}</ref> ARB se convirtió dentro de Khronos en el '''OpenGL ARB Working Group'''.<ref>{{Cita web
|url=http://www.opengl.org/about/arb/
|título=OpenGL Architecture Review Board Working Group
|fechaacceso=14 de enero de 2007
|fechaarchivo=24 de noviembre de 2011
|urlarchivo=https://web.archive.org/web/20111124074301/http://www.opengl.org/about/arb/
|deadurl=yes
}}</ref> El subgrupo de Khronos que gestiona la especificación de OpenGL se denomina '''OpenGL ARB Working Group'''.<ref>{{Cita web | url=http://www.opengl.org/about/arb/ | título=OpenGL Architecture Review Board Working Group | fechaacceso=14 de enero de 2007 | fechaarchivo=24 de noviembre de 2011 | urlarchivo=https://web.archive.org/web/20111124074301/http://www.opengl.org/about/arb/ | deadurl=yes }}</ref> Para una relación de los miembros que componen el OpenGL ARB Working Group, véase el apartado [[#Miembros del Grupo Khronos|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.<ref>{{Cita web |url=http://www.opengl.org/registry/doc/glspec30.20080811.pdf |título=Especificación de OpenGL, versión 3.0}}</ref>

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.<ref>{{Cita web |url=https://www.khronos.org/members/|título= Khronos Membership Overview and FAQ}}</ref>

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.<ref>{{Cita web |url=https://registry.khronos.org/OpenGL/index_gl.php|título= Khronos Registry}}</ref>

== Diseño ==
OpenGL tiene dos propósitos esenciales:

* Ocultar la complejidad de la interfaz con las diferentes [[Tarjeta gráfica|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''.<ref>{{Cita web |url=http://www.opengl.org/documentation/specs/version1.1/state.pdf |título=Copia archivada |fechaacceso=14 de enero de 2007 |fechaarchivo=16 de mayo de 2008 |urlarchivo=https://web.archive.org/web/20080516235400/http://opengl.org/documentation/specs/version1.1/state.pdf |deadurl=yes }}</ref> 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 [[Renderización|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 [[Rasterización|rasterizados]].
[[Archivo: Pipeline OpenGL.svg|lang=es|thumb|450px|Proceso en la pipeline de gráficos.]]
* Una pipeline de [[Transform and Lighting|transformación e iluminación]].
* [[Z-Buffer|Z-buffering]].
* [[Mapeado de texturas]].
* [[Alpha blending]].

Una descripción somera del proceso en la pipeline gráfica podría ser:<ref>{{Cita web
|url=http://www.opengl.org/registry/doc/glspec21.20061201.pdf
|título=Especificación del Sistema Gráfico OpenGL Versión 2.1
}}</ref>
# 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 [[Framebuffer|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:

<syntaxhighlight lang="c">
glClear( GL_COLOR_BUFFER_BIT );
</syntaxhighlight>

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:

<syntaxhighlight lang="c">
glMatrixMode( GL_MODELVIEW ); /* Los comandos para matriz modificarán ''modelview'' */
glLoadIdentity(); /* Inicializar ''modelview'' */
glTranslatef( 0, 0, -3 ); /* Desplazar 3 unidades en el eje Z */
</syntaxhighlight>
La matriz ''projection'' controla la perspectiva aplicada a las primitivas; se utiliza de forma similar a la anterior:

<syntaxhighlight lang="c">
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 */
</syntaxhighlight>

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

<syntaxhighlight lang="c">
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 */
</syntaxhighlight>

== 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 [[Silicon Graphics|SGI]] era un grupo de referencia en gráficos 3D para estaciones de trabajo. Suya era la API [[IRIS GL]],<ref>{{Cita web
 |url          = http://www.neoteo.com/tabid/54/ID/2173/Title/DirectX_y_OpenGL__las_dos_API_mas_importantes_del_mercado_grafico/Default.aspx?2173=Title&DirectX_y_OpenGL__las_dos_API_mas_importantes_del_mercado_grafico=Default.aspx
 |título      = Iris GL, propiedad de SGI
 |fechaacceso  = 16 de febrero de 2007
 |urlarchivo   = https://web.archive.org/web/20070929092543/http://www.neoteo.com/tabid/54/ID/2173/Title/DirectX_y_OpenGL__las_dos_API_mas_importantes_del_mercado_grafico/Default.aspx?2173=Title&DirectX_y_OpenGL__las_dos_API_mas_importantes_del_mercado_grafico=Default.aspx
 |fechaarchivo = 29 de septiembre de 2007
}}</ref> 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,<ref>{{Cita web
|url=http://www.sgi.com/global/es/newsroom/2004/09212004.html
|título=Creación del OpenGL ARB
}}</ref> 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.<ref>{{Cita web
|url=http://www.opengl.org/about/arb/meeting_notes/notes/Meeting1.2/meeting_note_10-03-98.html
|título=Fin de OpenGL++
|fechaacceso=16 de febrero de 2007
|fechaarchivo=16 de mayo de 2008
|urlarchivo=https://web.archive.org/web/20080516083305/http://www.opengl.org/about/arb/meeting_notes/notes/Meeting1.2/meeting_note_10-03-98.html
|deadurl=yes
}}</ref>

En 1995 [[Microsoft]] lanzó [[Direct3D]], que se convertiría en el principal competidor de OpenGL. El 17 de diciembre de 1997<ref>{{Cita web
 |url          = http://www.windowsitpro.com/Article/ArticleID/17533/17533.html
 |título      = Anuncio público de Fahrenheit
 |urlarchivo   = https://web.archive.org/web/20070927212603/http://www.windowsitpro.com/Article/ArticleID/17533/17533.html
 |fechaarchivo = 27 de septiembre de 2007
}}</ref> Microsoft y SGI iniciaron el proyecto [[Fahrenheit (API gráfica)|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.<ref>{{Cita web
 |url     = http://www.findarticles.com/p/articles/mi_m0CGN/is_n3341/ai_20211297
 |título     = Miembros del Proyecto Fahrenheit. 1998.
 |fechaacceso     = 15 de enero de 2007
 |urlarchivo     = https://web.archive.org/web/20080115191836/http://findarticles.com/p/articles/mi_m0CGN/is_n3341/ai_20211297
 |fechaarchivo     = 15 de enero de 2008
 }}</ref> Pese a tener un principio prometedor en estandarizar las API 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.<ref>{{Cita web
|url=http://www.theregister.co.uk/1999/11/29/ms_quietly_dumps_windows_opengl/
|título=Fin del Proyecto Fahrenheit
}}</ref>

En la [[Game Developers Conference|GDC]] de 2015, [[Khronos Group]] anunció la API sucesora de OpenGL, llamada '''[[Vulkan]]'''.<ref name="More on Vulkan"/><ref name="khronos-vulkan-overview-pdf">{{cite web|url=https://www.khronos.org/assets/uploads/developers/library/overview/2015_vulkan_v1_Overview.pdf |format=PDF |title=Vulkan : Graphics and compute Belong Together |date=March 2015 |publisher=Khronos.org |accessdate=5 de marzo de 2015}}</ref><ref name="khronos-vulkan">{{cite web|url=https://www.khronos.org/vulkan |title=Vulkan - Graphics and compute belong together |publisher=Khronos.org |date= |accessdate=5 de marzo de 2015}}</ref> Inicialmente, fue presentada por Khronos como "la iniciativa '''OpenGL''' de próxima generación", pero luego el nombre fue descartado, quedando Vulkan como definitivo.<ref>{{cite web |url=http://www.develop-online.net/news/glnext-revealed-as-vulkan-graphics-api/0203867 |last=Batchelor |first=James |date={{date|2015-03-03}} |title=glNext revealed as Vulkan graphics API |work=develop-online.net}}</ref> Vulkan está basado en [[Mantle (API)|Mantle]], otra API de la empresa [[Advanced Micro Devices|AMD]], cuyo código fue cedido a Khronos con la intención de generar un estándar abierto similar a OpenGL, pero de bajo nivel.<ref name="More on Vulkan">{{cite web|title=More on Vulkan and SPIR - V: The future of high-performance graphics|url=https://www.khronos.org/assets/uploads/developers/library/2015-gdc/Khronos-Vulkan-GDC_Mar15.pdf|publisher=Khronos Group|accessdate=27 de junio de 2015|page=10|quote=Thanks AMD!}}</ref><ref>{{cite web |url=http://www.pcworld.com/article/2894036/mantle-is-a-vulkan-amds-dead-graphics-api-rises-from-the-ashes-as-opengls-successor.html |last=Mah Ung |first=Gordon |date={{date|2015-03-06}} |title=Mantle is a Vulkan: AMD's dead graphics API rises from the ashes in OpenGL's successor |publisher=PCWorld }}</ref><ref>{{cite web |url=http://community.amd.com/community/amd-blogs/amd-gaming/blog/2015/03/03/one-of-mantles-futures-vulkan |title=AMD Gaming: One of Mantle's Futures: Vulkan &#124; AMD Blogs |publisher=Community.amd.com |date= |accessdate=5 de marzo de 2015 |urlarchivo=https://web.archive.org/web/20150306190250/http://community.amd.com/community/amd-blogs/amd-gaming/blog/2015/03/03/one-of-mantles-futures-vulkan |fechaarchivo=6 de marzo de 2015 }}</ref><ref name=not-dead-yet>{{cite web|url=http://www.extremetech.com/extreme/200286-not-dead-yet-amds-mantle-powers-new-vulkan-api-vr-efforts |title=Not dead yet: AMD’s Mantle powers new Vulkan API, VR efforts |publisher=ExtremeTech |last=Hruska |first=Joel |date={{date|2015-03-04}} |accessdate=5 de marzo de 2015}}</ref><ref>{{cite web|url=http://wccftech.com/mantle-lives-vulkan-wip/ |title=AMD's Mantle Lives On In Vulkan - Lays The Foundation For The Next OpenGL |publisher=Wccftech.com |date=20 de junio de 2014 |accessdate=5 de marzo de 2015}}</ref><ref>{{cite web|last=Kirsch |first=Nathan |url=http://www.legitreviews.com/amd-mantle-dead-known-vulcan-api-uses-mantle-technology-opengl_159339 |title=Is AMD Mantle Dead As We Have Known It? Vulcan API Uses Mantle Technology for OpenGL |publisher=Legit Reviews |date= |accessdate=5 de marzo de 2015}}</ref>

== Versiones ==
{{Mal traducido}}
=== OpenGL 1.0 ===
Publicada en enero de 1992.<br />
La primera especificación de OpenGL fue publicada por Mark Segal y Kurt Akeley.

==== OpenGL 1.1 ====
Publicada en enero de 1997.<br />
OpenGL 1.1 se enfocó en el soporte de texturas y formatos de textura sobre hardware de GPU.
<br />Tarjetas gráficas soportadas: todas
{| class="wikitable"
|-
! Extensión
! Id de extensión
! Funciones
|-
| 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 "color", LUMINANCIA, ALPHA "transparencia", INTENCIDAD. (en glTexImage2D)
|-
| Texture Objects
| EXT_texture_object
| glGenTextures, glBindTextures
|}

==== OpenGL 1.2 ====
Publicada el 16 de marzo de 1998.<br />
OpenGL 1.2 se enfocó en el soporte de texturas de volumen, píxeles empaquetados, reescalado normal, muestreo de texturas clamped/edge y procesamiento de imágenes.
<br />Tarjetas gráficas soportadas: Rage 128, Rage 128 GL, Rage XL/XC, Rage 128 Pro, Rage Fury MAXX, y todas las tarjetas posteriores.

{| class="wikitable"
|-
! Extensión
! Id de extensión
! Funciones
|-
| 3D Volume Textures
| GL_EXT_texture3D
| glTexImage3DEXT
|-
| BGRA Texture Format
| GL_EXT_bgra
| BGR_EXT, BGRA_EXT (en 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 ====
Publicada el 14 de octubre de 1998<br />
OpenGL 1.2.1 fue un lanzamiento menor publicado después de OpenGL 1.2 (16 de marzo de 1998) el cual añadió multi-textura, o unidades de textura, al canal de renderizado. Esto permitió texturas múltiples que son combinadas por píxel durante la rasterización. 
<br />Tarjetas gráficas soportadas: Radeon, Radeon Mobility, Radeon 7500 Mobility, Radeon 8500, Radeon 9000, Radeon 9200, Radeon 9600, Radeon 9800, [[GeForce]] 3, GeForce 4Ti, GeForce FX, y todas las tarjetas posteriores

{| class="wikitable"
|-
! Extensión
! Id de extensión
! Funciones
|-
| Multi-Texturing
| SGIS_multitexture
| glActiveTextureARB, glClientActiveTextureARB
|}

==== OpenGL 1.3 ====
Publicada el 14 de agosto de 2001.<br />
OpenGL 1.3 añadió soporte para textura cubemap, múltiples texturas, multi-muestreo y operaciones de combinación de unidades de textura (añadir, combinar, dot3, border clamp).
<br />Tarjetas gráficas soportadas: 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, y todas las tarjetas posteriores.

{| class="wikitable"
|-
! Extensión
! Id de extensión
! Funciones
|-
| 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 ====
Publicada el 24 de julio de 2002.<br />
OpenGL 1.4 añadió soporte de sombreado por hardware, coordenadas niebla, generación automática de mipmaps, y modos de textura adicionales.
<br />Tarjetas gráficas soportadas: Quadro DCC, Quadro4 380 XGL, Quadro4 500XGL, 550XGL, Quadro4 700XGL, 750XGL, 900XGL, 980XGL, y todas las tarjetas posteriores.

{| class="wikitable"
|-
! Extensión
! Id de extensión
! Funciones
|-
| 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 ====
Publicada el 29 de julio de 2003.<br />
OpenGL 1.5 añadió soporte para objetos de búfer de vértice (VBOs), consultas de oclusión, y amplió las funciones de sombreado.
<br />Tarjetas gráficas soportadas: Radeon X800, Radeon 9600, Radeon 9700, Radeon 9800, GeForce FX, y todas las tarjetas posteriores.

{| class="wikitable"
|-
! Extensión
! Id de extensión
! Funciones
! Más Información
|-
| VBOs Vertex Buffer Objects
| GL_ARB_vertex_buffer_object
| glBindBufferARB, glBufferDataARB, glGenBuffersARB
| [http://www.songho.ca/opengl/gl_vbo.html songho]
|-
| Occlusion Queries
| GL_ARB_occlusion_query
| 
|
|-
| Extended Shadow Functions
| GL_EXT_shadow_funcs
| 
|
|}

=== OpenGL 2.0 ===
Publicada el 7 de septiembre de 2004.<br />
OpenGL 2.0 añadió soporte para un [[lenguaje ensamblador]] basado en GPU verdadero, llamado ARB (diseñado por el Architecture Review Board), que se convertiría en el estándar para vertex y fragment shaders. Las tarjetas publicadas con OpenGL 2.0 fueron las primeras en ofrecer shaders programables por el usuario.
<br />Tarjetas soportadas: 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, Quadro 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, y todas las tarjetas posteriores.

OpenGL 2.0 fue concebido por [[3Dlabs]] para abordar las preocupaciones de que OpenGL estaba estancado y carecía de una dirección fuerte. 3Dlabs propuso una serie de importantes adiciones a la norma. La mayoría de estas fueron, en ese momento, rechazadas por el ARB o de otra manera nunca llegaron a realizarse en la forma que 3Dlabs propuso. Sin embargo, su propuesta de un lenguaje de sombreado de estilo [[C (lenguaje de programación)|C]] se completó con el tiempo, resultando en la formulación actual del [[GLSL]] (Open'''GL''' '''S'''hading '''L'''anguage, también '''sl'''ang).Al igual que los lenguajes de sombreado estilo-ensamblador que trataba de sustituir, permite al programador sustituir los fixed-function vertex y el fragment pipe con shaders, aunque esta vez escritos en un lenguaje tipo C de alto nivel.

El diseño de GLSL se destacó por hacer relativamente pocas concesiones a las limitaciones del hardware entonces disponible, lo que recordaba a la tradición anterior de OpenGL estableciendo un objetivo ambicioso, con visión de futuro para los aceleradores 3D en lugar de simplemente seguir el estado de hardware disponible actualmente. La última especificación OpenGL 2.0<ref>{{Cita web |url=http://www.opengl.org/documentation/specs/version2.0/glspec20.pdf |título=Copia archivada |fechaacceso=28 de marzo de 2010 |fechaarchivo=2 de abril de 2007 |urlarchivo=https://web.archive.org/web/20070402033551/http://www.opengl.org/documentation/specs/version2.0/glspec20.pdf |deadurl=yes }}</ref> incluye soporte para GLSL.

{| class="wikitable"
|-
! Extensión
! ID de extensión
! Funciones
|-
| 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,<ref>{{Cita web
|url=http://www.opengl.org/documentation/current_version/
|título=Características de OpenGL 2.1
|fechaacceso=16 de enero de 2007
|fechaarchivo=22 de mayo de 2008
|urlarchivo=https://web.archive.org/web/20080522212939/http://www.opengl.org/documentation/current_version/
|deadurl=yes
}}</ref> 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 [[Buffer de datos|buffers]] en comandos como ''glTexImage2D'' y ''glReadPixels''.
:Esta funcionalidad corresponde a la extensión ''ARB_pixel_buffer_object''.
* Texturas [[Espacio de color sRGB|sRGB]].
:Esta funcionalidad corresponde a la extensión ''GL_EXT_texture_sRGB''.

=== OpenGL 3.0 ===

La versión OpenGL 3.0<ref>http://www.opengl.org/registry/doc/glspec30.20080811.pdf</ref> fue publicada el 11 de agosto de 2008.

'''Tarjetas compatibles:''' [https://en.wikipedia.org/wiki/GeForce_8_series GeForce 8 Series] [https://en.wikipedia.org/wiki/Radeon_HD_2000_series ATI HD Radeon 2000 Series].
(Es decir, sólo el '''hardware''' compatible con Direct3D 10.0 es capaz de ejecutar OpenGL 3.0.)

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

==== 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]])
* ''Texture Buffer Objects'' - un tipo de nueva textura que contiene una matriz unidimensional de [[texels]]
* ''Uniform Buffer Objects'' para compartir o actualizar datos de forma rápida
* Texturas normalizadas firmadas (rango ± 1,0)
* Un mínimo de 16 unidades de textura accesibles por el ''Vertex Shader''
* Reinicio de primitiva
* Instancias - dibujo de objetos en múltiples ocasiones a través de la reutilización de los ''vertex data''
* ''CopyBuffer API'' para copia rápida de datos, utilizada en conjunto con [[OpenCL]]

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

Funcionalidad heredada eliminada incluye:

* Todas las opciones de función fija
* Modo directo
* ''Color index mode'', por ejemplo, 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:

* OpenGL Shading Language versión 1.50 (GLSL)
* Soporte de Geometría ai
*
* 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 de 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 de 2010<br />
Tarjetas compatibles: [[Radeon HD serie 5000]], [[nVidia GTX serie 400]];

Características:<ref>{{cita web | url=http://www.khronos.org/news/press/releases/khronos-unleashes-cutting-edge-cross-platform-graphics-acceleration-opengl4 | título=Khronos Unleashes Cutting-Edge, Cross-Platform Graphics Acceleration with OpenGL 4.0 | obra=Khronos Press Releases | autor=Khronos webmaster | fecha=11 de marzo de 2010 | fechaacceso=11 de marzo de 2010 | urlarchivo=https://www.webcitation.org/61CxcWixl?url=http://www.khronos.org/news/press/releases/khronos-unleashes-cutting-edge-cross-platform-graphics-acceleration-opengl4 | fechaarchivo=25 de agosto de 2011 }}</ref>

* OpenGL Shading Language versión 4.00 ([[GLSL]])
* Dos fases de sombreado que permiten a la GPU descargar el teselado geométrico 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 API 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.

==== OpenGL 4.1 ====
Anunciado el 26 de julio de 2010<ref>{{cita web|url=http://www.extremetech.com/article2/0,2845,2366981,00.asp|título=OpenGL 4.1 Specification Released}}</ref> <br />
Tarjetas soportadas: [[GeForce 400 Series|Nvidia GeForce 400 series]], [[GeForce 500 Series|Nvidia GeForce 500 series]], [[Radeon HD 5000 series|ATI Radeon HD 5000 series]], [[Northern Islands (GPU family)|AMD Radeon HD 6000 Series]]

Esta nueva versión añade estas características adicionales a la especificación, muchas de las cuales ayudan a ponerla en consonancia con las de Direct3D 11:
* Lenguaje de sombreado OpenGL (GLSL) 4.1
* Compatibilidad completa con [[OpenGL ES|OpenGL para sistemas integrados]] (OpenGL ES) 2.0
* Reducción de tiempos de recompilación
* La capacidad de vincular los programas de forma individual a las cinco etapas programables (Vertex, Control de mosaico, Evaluación del Teselado, la Geometría, y Fragmento)
* Mejoras a la coma flotante general de 64 bits compatible con agregado en OpenGL 4.0

==== OpenGL 4.2 ====
Publicado el 8 de agosto de 2011<ref>{{cita web|url=http://www.khronos.org/news/press/khronos-enriches-cross-platform-3d-graphics-with-release-of-opengl-4.2-spec|título=Khronos Enriches Cross-Platform 3D Graphics with Release of OpenGL 4.2 Specification}}</ref> <br />
Tarjetas soportadas: [[GeForce 400 Series|Nvidia GeForce 400 series]], [[GeForce 500 Series|Nvidia GeForce 500 series]], [[Radeon HD 5000 series|ATI Radeon HD 5000 series]], [[Northern Islands (GPU family)|AMD Radeon HD 6000 Series]], [[Radeon HD 7000 series|ATI Radeon HD 7000 series]]

* Soporte para shaders con contadores atómicos y ''load/store/atomic read-modify-write operations'' en un único nivel de una textura.
* Capacidad de capturar geometría de la GPU en mosaico y dibujar varias instancias de una "transform feedback " para que los objetos complejos sean fácilmente replicados o cambiados de posición.
* OpenGL puede modificar ahora un subconjunto arbitrario de una textura comprimida sin necesidad de volver a descargar toda la textura a la GPU llevando esto a un mayor rendimiento.
* Soporte para empaquetar varios valores de 8 bits y 16 bits en un único valor de 32 bits, llevando a un procesamiento más eficiente del shader y presión reducida en la memoria y el ancho de banda.

==== OpenGL 4.3 ====
Publicado el 6 de agosto de 2012<ref>{{cita web|url=http://www.khronos.org/news/press/khronos-releases-opengl-4.3-specification-with-major-enhancements|título=Khronos Releases OpenGL 4.3 Specification with Major Enhancements}}</ref>
Tarjetas Soportadas: [[GeForce 400 Series|Nvidia GeForce 400 series]], [[GeForce 500 Series|Nvidia GeForce 500 series]], [[GeForce 600 Series|Nvidia GeForce 600 series]], [[Radeon HD 8000 series|ATI Radeon HD 8000 series]]

* Incluye la versión más actualizada de GLSL en su versión 4.30 (OpenGL Shading Language).
* Cálculo de shaders que aprovechan el paralelismo de la GPU para todo lo relacionado con geometría o gráficos.
* Almacenamiento en búfer de objetos Shader.
* Consultas de parámetros de texturas para hallar los límites que las plataformas pueden tener para procesar las mismas.
* Alta calidad de comprensión en texturas ETC2/EAC como característica estándar.
* Compatibilidad total con las API de OpenGL ES 3.0.
* Capacidades de depuración que permiten recibir mensajes de depuración mientras se desarrolla la aplicación.
* Vistas de texturas para análisis de las mismas en diferentes formas sin replicación de datos.
* Incrementa la seguridad de la memoria.
* Una extensión multi-aplicación que añade robustez al sistema, e impide que las aplicaciones que provoquen un fallo y tengan que resetearse afecten a otras que estén en ejecución.

==== OpenGL 4.4 ====
Publicado el 22 de julio de 2013<ref>{{cita web|url=https://www.khronos.org/news/press/khronos-releases-opengl-4.4-specification|título=Khronos Releases OpenGL 4.4 Specification}}</ref>

* Control de colocación de tampones
* Consultas asincrónicas eficientes
* Diseño de variables de sombreado
* Encuadernación eficiente de múltiples objetos
* Portabilidad optimizada de aplicaciones Direct3D
* Extensión de textura sin encuadernación
* Extensión de textura escasa
==== OpenGL 4.5 ====
Publicado el 11 de agosto de 2014<ref>{{cite web|url=https://www.khronos.org/news/press/khronos-group-announces-key-advances-in-opengl-ecosystem|title=Khronos Group Announces Key Advances in OpenGL Ecosystem - Khronos Group Press Release|publisher=|accessdate=17 de abril de 2015}}</ref><ref>{{cite web|url=http://www.opengl.org/registry/|title=OpenGL® Registry|author=Khronos Group|publisher=|accessdate=17 de abril de 2015}}</ref>

Tarjetas Soportadas: [[GeForce 400 series|Nvidia GeForce 400 series]] y nuevas, también [[Tegra K1]] y Tegra X1.<ref>{{cite web|url=http://www.ustream.tv/recorded/51255959|title=SG4121: OpenGL Update for NVIDIA GPUs|work=Ustream|accessdate=17 de abril de 2015|urlarchivo=https://web.archive.org/web/20150517205154/http://www.ustream.tv/recorded/51255959|fechaarchivo=17 de mayo de 2015}}</ref><ref>{{cite web|url=http://www.slideshare.net/Mark_Kilgard/opengl-45-update-for-nvidia-gpus|title=OpenGL 4.5 Update for NVIDIA GPUs|author=Mark Kilgard|publisher=|accessdate=17 de abril de 2015}}</ref>

* Direct State Access (DSA)- Acceso de estado directo<ref>{{cite web|url=http://arstechnica.com/information-technology/2014/08/opengl-4-5-released-with-one-of-direct3ds-best-features/|title=OpenGL 4.5 released—with one of Direct3D’s best features|work=Ars Technica|accessdate=17 de abril de 2015}}</ref>
* Flush Control - Mejorado el sistema de multiproceso.
* Robustness - Mejoras en el WebGL.
* OpenGL ES 3.1 API y compatibilidad de shaders.

==== OpenGL 4.6 ====
Publicado el 17 de julio del 2017<ref>{{Cita web|url=https://registry.khronos.org/OpenGL/index_gl.php|título=Khronos OpenGL® Registry - The Khronos Group Inc|fechaacceso=2022-12-16|sitioweb=registry.khronos.org}}</ref><ref>{{Cita web|url=https://www.khronos.org/news/press/khronos-releases-opengl-4.6-with-spir-v-support|título=Khronos Releases OpenGL 4.6 with SPIR-V Support|fechaacceso=2022-12-16|fecha=2017-07-31|sitioweb=The Khronos Group|idioma=en}}</ref>

* Procesamiento de geometría del lado de la GPU más eficiente
* Ejecución de sombreado más eficiente (AZDO)
* Más información a través de estadísticas, consulta de desbordamiento y contadores
* Mayor rendimiento sin contextos de manejo de errores
* Sujeción de la función de desplazamiento de polígono, resuelve un problema de representación de sombras
* Sombreadores SPIR-V
* Filtrado anisotrópico mejorado

Soporte de hardware: AMD Radeon HD 7000 Series y posteriores (sombreadores FP64 implementados por emulación en algunas GPU TeraScale), Intel Haswell y posteriores, Nvidia GeForce 400 series y posteriores<ref>{{Cita web|url=https://www.phoronix.com/news/NVIDIA-OpenGL-4.6-Driver|título=NVIDIA Releases 381.26.11 Linux Driver With OpenGL 4.6 Support|fechaacceso=2022-12-16|sitioweb=www.phoronix.com|idioma=en}}</ref>

== 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 Referencia manual. ISBN 0-321-17383-X
:En esencia, una copia de la páginas del [[Man (Unix)|man]] de OpenGL.
:Incluye un póster 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 la 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 la 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.<ref>{{cita web
|url=http://oss.sgi.com/projects/ogl-sample/registry
|título=Registry (redirect) <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
|urlarchivo=https://web.archive.org/web/20070115045310/http://oss.sgi.com/projects/ogl-sample/registry/
|fechaarchivo=15 de enero de 2007
}}</ref>

== Vulkan ==
Vulkan, anteriormente denominada "Iniciativa OpenGL de próxima generación" (glNext),<ref>{{Cita web|url=https://www.pcworld.com/article/432182/meet-vulkan-the-powerful-platform-agnostic-gaming-tech-taking-aim-at-directx-12.html|título=Meet Vulkan, the powerful, platform-agnostic gaming tech taking aim at DirectX 12|fechaacceso=2022-12-16|apellido=Reporter|nombre=Games|sitioweb=PCWorld|idioma=en}}</ref><ref>{{Cita web|url=https://arstechnica.com/gadgets/2015/03/khronos-unveils-vulkan-opengl-built-for-modern-systems/|título=Khronos unveils Vulkan: OpenGL built for modern systems|fechaacceso=2022-12-16|apellido=Staff|nombre=Ars|fecha=2015-03-03|sitioweb=Ars Technica|idioma=en-us}}</ref> es un esfuerzo de rediseño básico para unificar OpenGL y OpenGL ES en una API común que no será compatible con las versiones anteriores de OpenGL.

La versión inicial de Vulkan API se lanzó el 16 de febrero de 2016.

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

* [[Lenguaje de programación Ada|Ada]]: '''Ada OpenGL 1.1'''<ref>{{cita web
 |url          = http://www.cs.chalmers.se/~bond/OPENGL/ADA
 |título      = Index of /~bond/OPENGL/ADA <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
 |fechaacceso  = 2009
 |autor        = 
 |enlaceautor  = 
 |idioma       = 
 |urlarchivo   = https://web.archive.org/web/20041013020717/http://www.cs.chalmers.se/~bond/OPENGL/ADA
 |fechaarchivo = 13 de octubre de 2004
}}</ref> soporta GL, GLU y GLUT.
* [[C Sharp|C#]]: '''Tao'''<ref>{{cita web
|url=http://www.taoframework.com
|título=News &#124; The Tao Framework <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
|urlarchivo=https://web.archive.org/web/20080607090153/http://www.taoframework.com/
|fechaarchivo=7 de junio de 2008
}}</ref> es un framework para [[.NET de Microsoft|.NET]] que incluye OpenGL entre otras bibliotecas multimedia.
* [[Lenguaje de programación D|D]]: véase<ref>{{cita web
|url=http://dsource.org/projects/bindings
|título=bindings - dsource.org <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref> y.<ref>{{cita web
|url=http://dsource.org/projects/derelict
|título=derelict - dsource.org <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref>
* [[Embarcadero Delphi]]: '''Dot'''.<ref>{{cita web|url=http://www.delphi3d.net/dot|título=Nikita is no more! Elena is here! :) <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->|fechaacceso=2009|autor=|enlaceautor=|idioma=|urlarchivo=https://web.archive.org/web/20120419110420/http://www.delphi3d.net/dot/|fechaarchivo=19 de abril de 2012}}</ref>
* [[Fortran]]: '''f90gl'''<ref>{{cita web
|url=http://math.nist.gov/f90gl
|título=f90gl: Fortran interface for OpenGL and GLUT <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref> soporta OpenGL 1.2, GLU 1.2, GLUT 3.7.
* [[Gambas]]: gb.opengl<ref>{{cita web|url=http://new.gambasdoc.org/help/comp/gb.opengl?es|título=Documentación de Gambas - gb.opengl <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->|fechaacceso=2009|autor=|enlaceautor=|idioma=|urlarchivo=https://web.archive.org/web/20120312011058/http://new.gambasdoc.org/help/comp/gb.opengl?es|fechaarchivo=12 de marzo de 2012}}</ref>
* [[Genie (lenguaje de programación)|Genie]]
* [[Lazarus (entorno de desarrollo)|Lazarus]]-[[Free Pascal]]: LCL/GLUT<ref>{{cita web|url=http://wiki.lazarus.freepascal.org/OpenGL_Tutorial|título=Lazarus- OpenGL Tutorial|fechaacceso=2011|autor=|enlaceautor=|idioma=|urlarchivo=https://web.archive.org/web/20171011041846/http://wiki.lazarus.freepascal.org/OpenGL_Tutorial|fechaarchivo=11 de octubre de 2017}}</ref>
* [[Lenguaje de programación Java|Java]]: [[JOGL]]<ref>{{cita web
 |url          = https://jogl.dev.java.net
 |título      = jogl: <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
 |fechaacceso  = 2009
 |autor        = 
 |enlaceautor  = 
 |idioma       = 
 |urlarchivo   = https://web.archive.org/web/20090821034819/https://jogl.dev.java.net/
 |fechaarchivo = 21 de agosto de 2009
}}</ref> y [[LWJGL]]<ref>{{cita web
|url=http://lwjgl.org
|título=lwjgl.org - Home of the Lightweight Java Game Library <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref> entre otros; véase.<ref name="4d7de4e5">{{cita web
|url=http://www.opengl.org/resources/java
|título=Programming Language Bindings <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref>
* [[Lisp]]: véase.<ref>{{cita web
|url=http://www.agentsheets.com/lisp/OpenGL.html
|título=Welcome to OpenGL for MCL <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
|fechaarchivo=26 de enero de 2008
|urlarchivo=https://web.archive.org/web/20080126091818/http://www.agentsheets.com/lisp/OpenGL.html
|deadurl=yes
}}</ref>
* [[Perl]]: véase.<ref name="4d7de4e5" />
* [[Pike (lenguaje de programación)|Pike]]: tiene una interfaz nativa a OpenGL.<ref>{{cita web|url=http://pike.ida.liu.se/about/pike/modules.xml|título=pike.ida.liu.se: Modules <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->|fechaacceso=2009|autor=|enlaceautor=|idioma=|urlarchivo=https://web.archive.org/web/20121002205154/http://pike.ida.liu.se/about/pike/modules.xml|fechaarchivo=2 de octubre de 2012}}</ref> Además, soporta GLU y GLUT.
* [[Python]]: '''PyOpenGL'''<ref>{{cita web
|url=http://pyopengl.sourceforge.net
|título=PyOpenGL - The Python OpenGL Binding <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref> soporta GL, GLU y GLUT.
* [[Visual Basic]]: véase.<ref name="4d7de4e5" />
* [[XBase++]]: véase.<ref>{{cita web
 |url          = http://www.alaska-software.com/products/academiccontent.shtm
 |título      = Contenido del Paquete Académico
 |fechaacceso  = 2009
 |autor        = 
 |enlaceautor  = 
 |idioma       = 
 |urlarchivo   = https://web.archive.org/web/20160304081808/http://www.alaska-software.com/products/academiccontent.shtm
 |fechaarchivo = 4 de marzo de 2016
}}</ref>

* [[Haskell]]: '''HOpenGL''',<ref>https://web.archive.org/web/20071012184537/http://haskell.org/HOpenGL/index.html</ref> soporta GL, GLU y GLUT.
* [[Vala (lenguaje de programación)|Vala]]

== Miembros del Grupo Khronos ==

En 2008, algunos de los miembros del Grupo Khronos son:
* [[AMD]]
* [[Apple Inc.|Apple]]
* [[Blizzard Entertainment|Blizzard]]
* [[Intel|Intel Graphics Controllers]]
* [[nVIDIA]]

Para una lista completa y actualizada de los miembros del proyecto, véanse las listas de miembros,<ref>{{cita web
|url=http://www.khronos.org/members/promoters
|título=Khronos Promoting Members <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref> contribuyentes<ref>{{cita web
|url=http://www.khronos.org/members/contributors
|título=Khronos Contributing Members <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref> y académicos<ref>{{cita web
|url=http://www.khronos.org/members/academic
|título=Khronos Academic Members <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref> del Grupo Khronos.<ref>{{cita web
|url=http://www.khronos.org
|título=The Khronos Group: Open Standards, Royalty Free, Dynamic Media Technologies <!--Generado por Muro Bot. Puedes ayudar a rellenar esta plantilla-->
|fechaacceso=2009
|autor=
|enlaceautor=
|idioma=
}}</ref>

== Véase también ==
* [[GLSL]] - [[Lenguaje de alto nivel]] de [[shader]]s para OpenGL
* [[JOGL]] (Java OpenGL) - Biblioteca para usar OpenGL en [[Lenguaje de programación Java|Java]]
* [[OpenGL ES]] - Biblioteca para [[sistema embebido|sistemas integrados]]
* [[WebGL]] - Especificación estándar para desplegar [[gráficos en 3D]] en [[navegador web|navegadores web]]
* [[OpenWF]] - Interfaz 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]] - API nativos para los juegos en dispositivos de mano y las aplicaciones de medios
* [[Comparación entre Direct3D y OpenGL]]

=== 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 ===
* [[Vulkan]] - Sucesor 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

=== Aplicaciones OpenGL ===
* [[Anexo:Aplicaciones que usan OpenGL|Aplicaciones que usan OpenGL]]

== Referencias ==
{{listaref|2}}

== Enlaces externos ==
* [http://realtech-vr.com/home/glview/ Sitio web oficial de realtech-vr Visor de Extensiones OpenGL y Visor de Extensiones DirectX]
* [http://www.opengl.org/ Sitio web oficial de OpenGL] {{Wayback|url=http://www.opengl.org/ |date=20110226000710 }}
* [http://www.sgi.com/products/software/opengl/ Sitio web de SGI sobre OpenGL]
* [http://dmoz.org/Computers/Programming/Graphics/Libraries/OpenGL/ OpenGL] en el [[Open Directory Project]]
* [http://www.khronos.org/ Grupo Khronos]
* [https://web.archive.org/web/20071126072642/http://nehe.gamedev.net/ NeHe Tutorials, tutoriales para el aprendizaje de OpenGL]
* [https://web.archive.org/web/20090122235422/http://www.microsoft.com/presspass/press/1997/dec97/fahrpr.mspx Proyecto Fahrenheit en Microsoft]
* [https://web.archive.org/web/20070212011603/http://black-byte.com/tutoriales/ Black Byte] Tutoriales en Español de OpenGL
* [http://programmers.stackexchange.com/questions/60544/why-do-game-developers-prefer-windows/88055#88055 Why do game developers prefer Windows?] post sobre OpenGL vs DirectX
* [https://www.songho.ca/opengl/ OpenGL] Guía educativa desde conceptos básicos hasta avanzados

{{Control de autoridades}}
[[Categoría:OpenGL| ]]
[[Categoría:Software de gráficos]]
[[Categoría:Acrónimos de informática]]
[[Categoría:Estándares gráficos]]