OpenGL

**OpenGL** é unha especificación estándar que define unha API multilinguaxe e multiplataforma para escribir aplicacións que produzan gráficos 2D e 3D. Foi desenvolvida por Silicon Graphics Inc. (**SGI**) en 1992. O seu nome vén do inglés **Open Graphics Library**, cuxa tradución é *biblioteca de gráficos aberta* (ou mellor, *libre*, tendo en conta a súa política de licenzas
).

OpenGL emprégase en campos como CAD, realidade virtual, representación científica e de información, simulación de voo ou desenvolvemento de videoxogos, no que o seu principal competidor é Direct3D de Microsoft Windows.

## Especificación 
A grandes liñas, OpenGL é unha especificación, é dicir, un documento que describe un conxunto de funcións e o seu comportamento exacto. A partir dela, os fabricantes de hardware crean postas en funcionamento (bibliotecas de funcións creadas para enlazar coas funcións da especificación OpenGL, utilizando aceleración hardware cando sexa posible). Devanditos fabricantes teñen que superar probas específicas que lles permitan cualificar a súa posta en funcionamento como OpenGL.

Existen postas en funcionamento eficientes de OpenGL fornecidas por fabricantes para macOS, Microsoft Windows, Linux, varias plataformas Unix, e PlayStation 3. Existen tamén varios software que permiten que OpenGL estea dispoñible para diversas plataformas sen soporte de fabricante. É de sinalar a biblioteca de software libre / código aberto Mesa 3D, unha API de gráficos baseada totalmente en software e completamente compatible con OpenGL. Con todo, para evitar os custos da licenza para ser denominada formalmente como unha posta en funcionamento de OpenGL, afirma ser simplemente unha API moi *similar*.

A especificación OpenGL era revisada polo OpenGL Architecture Review Board (**ARB**), fundado en 1992. O ARB estaba formado por un conxunto de empresas interesadas na creación dunha API consistente e amplamente dispoñible. Microsoft, un dos membros fundadores, abandonou o proxecto en 2003.

O 31 de xullo de 2006 anunciouse que o control de OpenGL pasaría do ARB ao Grupo Khronos. Con iso intentábase mellorar a mercadotecnia de OpenGL e eliminar as barreiras entre o desenvolvemento de OpenGL e OpenGL. ARB converteuse dentro de Khronos no **OpenGL ARB Working Group**. Para unha relación dos membros que compón o OpenGL ARB Working Group, véxase o apartado Membros do Grupo Khronos. O gran número de empresas con variados intereses que pasaron tanto polo antigo ARB como polo grupo actual fixeron de OpenGL unha API de propósito xeral cun amplo rango de posibilidades.

## Deseño 
OpenGL ten dous propósitos principais:
* Ocultar a complexidade da interface coas diferentes tarxetas gráficas, presentando ao programador unha API única e uniforme.
* Ocultar as diferentes capacidades das diversas plataformas hardware, requirindo que todas as postas en funcionamento soporten o conxunto completo de características de OpenGL (empregando emulación software se fose necesario).

A operación básica de OpenGL é aceptar primitivas coma puntos, liñas e polígonos, e convertelas en píxeles. Este proceso é realizado por unha *pipeline* gráfica coñecida como a Máquina de estados de OpenGL. A maior parte dos comandos de OpenGL emiten primitivas á pipeline gráfica ou configuran como a pipeline procesa ditas primitivas. Ata a aparición da versión 2.0 cada etapa da pipeline executaba unha función establecida, resultando pouco configurable. A partir da versión 2.0 varias etapas son completamente programables usando GLSL.

OpenGL é unha API baseada en procedementos de baixo nivel que require que o programador dite os pasos exactos necesarios para renderizar unha escena. Isto contrasta coas APIs descritivas, onde un programador só debe describir a escena e pode deixar que a biblioteca controle os detalles para renderizarla. O deseño de baixo nivel de OpenGL require que os programadores coñezan en profundidade a pipeline gráfica, a cambio da liberdade ofrecida na posta en funcionamento de algoritmos novos de renderizado.

OpenGL influíu no desenvolvemento dos cartóns gráficos, promovendo un nivel básico de funcionalidade que actualmente é común no hardware comercial; algunhas desas contribucións son:
* Primitivas básicas de puntos, liñas e polígonos rasterizados.
miniatura|dereita|430px|Proceso na pipeline de gráficos
* Unha pipeline de transformación e iluminación.
* Z-buffering.
* Mapeado de texturas.
* Alpha blending.

Unha descrición do proceso na pipeline gráfica podería ser :
# Avaliación, procédese das funcións polinomiais que definen certas entradas, como as superficies NURBS, aproximando curvas e a xeometría da superficie.
# Operacións por vértices, transformándoos, iluminándoos segundo o seu material e recortando partes non visibles da escena para producir un volume de visión.
# Rasterización, ou conversión da información previa en píxeles. Os polígonos son representados coa cor adecuada mediante algoritmos de interpolación.
# Operacións por fragmentos ou segmentos, como actualizacións segundo valores vindeiros ou xa almacenados de profundidade e de combinacións de cores, entre outros.
# Para rematar, os fragmentos son volcados no Frame buffer.

Moitas tarxetas gráficas actuais proporcionan unha funcionalidade superior á básica aquí exposta, pero as novas características xeralmente son melloras desta pipeline básica máis que cambios revolucionarios dela.

## Exemplo 
Primeiro, limpamos o buffer de cor para empezar nun *canvas* negro:

```c
glClear( GL_COR_BUFFER_BIT );
```

Establécese a matriz *modelview*, que controla a posición da cámara respecto das primitivas que renderizamos. Atrasámola 3 unidades no eixo *Z*, deixándoa apuntando cara á orixe:

```c
glMatrixMode( GL_MODELVIEW ); /* Os comandos para matriz modificarán *modelview* */
glLoadIdentity(); /* Inicializar *modelview* */
glTranslatef( 0, 0, -3 ); /* Desprazar 3 unidades no eixo Z */
```

A matriz *projection* controla a perspectiva aplicada ás primitivas; utilízase de forma similar á anterior:

```c
glMatrixMode( GL_PROJECTION ); /* Os comandos para matriz modificarán *projection* */
glLoadIdentity(); /* Inicializar *projection* */
glFrustum( -1, 1, -1, 1, 1, 1000 ); /* Aplicar unha proxección en perspectiva */
```

Para rematar, debúxase un polígono (un cadrado verde orientado no plano *XY*):

```c
glBegin( GL_POLYGON ); /* Inicio de polígono */
glColor3f( 0, 1, 0 ); /* Establecer cor 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 
Nos anos 1980 o desenvolvemento de software que fose compatible cun amplo rango de hardware gráfico era un verdadeiro reto para os desenvolvedores. Había que tratar con interfaces moi diferentes e escribir drivers específicos para cada tipo de hardware, resultando moi custoso; por iso, subcontratábanse equipos de programadores para axilizar o desenvolvemento. Dado que cada equipo traballaba por separado nos seus interfaces, producíase moito código redundante. Ademais, era un proceso caro, polo que varios grupos innovadores aceptaron o reto de atopar un método mellor.

Ao principio dos anos 1990 SGI era un grupo de referencia en gráficos 3D para estacións de traballo. Súa era a API IRIS GL, considerada punteira no campo e estándar de facto, chegando a eclipsar a PHIGS, baseada en estándares abertos. IRIS GL considerábase máis fácil de usar e, o máis importante, soportaba renderizado en *modo inmediato*. Ademais, PHIGS, á parte da súa maior dificultade, foi considerada inferior a IRIS GL respecto de funcionalidade e capacidade.

A competencia de SGI (Sun Microsystems, Hewlett-Packard e IBM, entre outros) foi capaz de introducir no mercado hardware 3D compatible co estándar PHIGS mediante extensións. Isto foi reducindo a cota de mercado de SGI conforme ían entrando diferentes provedores no mercado. Por todo iso, nun intento de fortalecer a súa influencia no mercado, SGI decidiu converter o estándar IRIS GL nun estándar aberto.

SGI observou que a API IRIS GL non podía ser aberta debido a conflitos de licenzas e patentes; tamén contiña funcións non relevantes para os gráficos 3D como APIs para fiestras, teclado ou rato (en parte, porque foi desenvolvida antes da aparición do X Window System ou dos sistemas NEWS de Sun). Ademais, mentres ía madurando o soporte do mercado para o novo estándar, pretendíase manter os antigos clientes mediante bibliotecas engadidas como Iris Inventor ou Iris Performer.

O resultado de todo o anterior foi o lanzamento do estándar OpenGL.

Algúns dos logros que se conseguiron foron:
* Estandarizar o acceso ao hardware.
* Trasladar aos fabricantes a responsabilidade do desenvolvemento das interfaces co hardware.
* Delegar as funcións para fiestras ao sistema operativo.
Coa variedade de hardware gráfico existente, lograr que todos *falasen* o mesmo linguaxe obtivo un efecto importante, ofrecendo aos desenvolvedores de software unha plataforma de alto nivel sobre a que traballar.

En 1992, SGI liderou a creación do OpenGL Architecture Review Board (**OpenGL ARB**), grupo de empresas que mantería e estendería a especificación OpenGL nos anos seguintes. OpenGL evolucionou desde IRIS GL, superando o seu problema de dependencia do hardware ao ofrecer emulación software para aquelas características non soportadas polo hardware do que se dispuxese. Así, as aplicacións podían utilizar gráficos avanzados en sistemas relativamente pouco potentes.

En 1994 SGI barallou a posibilidade de lanzar un produto denominado OpenGL++, o cal incluía elementos como unha API de *scene-graph* (baseada presumiblemente na tecnoloxía de Performer). Dita especificación foi divulgada entre uns poucos grupos interesados, pero nunca apareceu finalmente como produto.

En 1995 Microsoft lanzou Direct3D, que se convertería no principal competidor de OpenGL. O 17 de decembro de 1997 Microsoft e SGI iniciaron o proxecto Fahrenheit, esforzo cooperativo co obxectivo de unificar as interfaces de OpenGL e Direct3D (e engadir tamén unha API *scene-graph*). En 1998 uniríase ao proxecto Hewlett-Packard. A pesar de ter un principio prometedor en estandarizar as APIs de gráficos 3D, debido a restricións financeiras en SGI e a falta xeral de apoio por parte da industria, foi finalmente abandonado en 1999.

## Versións 
### OpenGL 2.1 
O 2 de agosto de 2006 publicouse OpenGL 2.1. Sendo completamente compatible coas versións anteriores, achega ademais novas características como:

* Revisión 1.20 do *OpenGL Shading Language* (GLSL).
* Comandos que soportan a especificación de matrices non cadradas.
* Obxectos *Pixel buffer* para acelerar o tráfico de imaxes nos buffers en comandos como *glTexImage2D* e *glReadPixels*.
:Esta funcionalidade corresponde á extensión *ARB_pixel_buffer_object*.
* Texturas sRGB.
:Esta funcionalidade corresponde á extensión *GL_EXT_texture_sRGB*.

### OpenGL 3.0 
A nova revisión da API OpenGL vai ser OpenGL 3.0, anteriormente coñecida como Longs Peak. Estaba planeado inicialmente a ser finalizado en setembro de 2007, pero o grupo Khronos anunciou o 30 de outubro que por diversos problemas a revisión ía ser atrasada.

Como resultado, as especificacións non van estar dispoñibles ata finais de 2007 ou principios de 2008.

OpenGL 3.0 representa a primeira maior revision da API na historia de OpenGL. Consiste nunha refacturacion no xeito na que OpenGL funciona. Para soportar compatibilidade cara a atrás, toda a antiga API vai estar dispoñible.

## Documentación 
A popularidade de OpenGL débese en parte á súa detallada documentación oficial. O **OpenGL ARB** publicou unha serie de manuais actualizados conforme a API ía evolucionando. Son facilmente recoñecibles (e coñecidos) pola cor das súas tapas:

* **O Libro Vermello** - The Red Book: The OpenGL Programmer's guide. ISBN 0-321-33573-2
:Libro de referencia e tutorial. Considerado libro *de cabeceira* para programadores de OpenGL.

* **O Libro Azul** - The Blue Book: The OpenGL Reference manual. ISBN 0-321-17383-X
:En esencia, unha copia da páxinas do man de OpenGL.
:Inclúe un póster despregable co diagrama da estrutura dunha posta en funcionamento *ideal* de OpenGL.

* **O Libro Verde** - The Green Book: Programming OpenGL for the X Window System. ISBN 0-201-48359-9
:Libro sobre o interface *X11* e GLUT.

* '*O Libro *Alpha*** (de tapa branca) - The Alpha Book: OpenGL Programming for Windows 95 and Windows NT. ISBN 0-201-40709-4
:Libro sobre o interface de OpenGL en plataformas de Microsoft Windows.

Para OpenGL 2.0 e posteriores:

* **O Libro Laranxa*' - The Orange Book: The OpenGL Shading Language. ISBN 0-321-33489-2
:Libro de referencia e tutorial para GLSL.

## Extensións 
O estándar OpenGL permite aos fabricantes engadir novas funcionalidades adicionais mediante *extensións* conforme aparecen novas tecnoloxías. Devanditas extensións poden introducir novas funcións e constantes, e suavizar ou ata eliminar restricións en funcións xa existentes. Cada fabricante dispón dunha abreviatura que lle identifica no nome das súas novas funcións ou constantes. Por exemplo, a abreviatura de NVIDIA (*NV*) aparece na definición da súa función *glCombinerParameterfvNV()* e o seu constante *GL_NORMAL_MAP_NV*.

É posible que varios fabricantes póñanse de acordo en poñer en funcionamento a mesma funcionalidade estendida. Nese caso, úsase a abreviatura *EXT*. Ata pode ocorrer que o **ARB** adopte a extensión, converténdose así en estándar e utilizando a abreviatura *ARB* nos seus nomes. A primeira extensión *ARB* foi *GL_ARB_multitexture*, presentada na versión 1.2.1. Seguindo o camiño marcado pola extensión, o *multitexturing* non é xa unha extensión opcional, senón que entrou a formar parte do núcleo de OpenGL desde a versión 1.3.

Antes de usar unha extensión, os programas deben comprobar a súa dispoñibilidade e, despois, acceder ás novas funcionalidades ofrecidas. Este proceso é dependente da plataforma, pero bibliotecas como GLEW e GLEE simplifícano.

As especificacións para a maior parte das extensións poden atoparse no rexistro oficial de extensións https://web.archive.org/web/20080205042328/http://oss.sgi.com/projects/ogl-sample/registry/.

## Bibliotecas de utilidades 
Programáronse varias bibliotecas externas que engaden características non dispoñibles no propio OpenGL. Algunhas delas son:

* GLU: Ofrece funcións de debuxo de alto nivel baseadas en primitivas de OpenGL. As funcións de GLU recoñécense facilmente pois todas empezan co prefixo *glu*.
* GLUT: API multiplataforma que facilita unha rudimentaria funcionalidade para o manexo de fiestras e interacción por medio de teclado e rato.
* GLUI: Interface de usuario baseada en GLUT; proporciona elementos de control tales como botóns, caixas de selección e *spinners*. É independente do sistema operativo, sustentándose en GLUT para manexar os elementos dependentes do sistema.

## Referencias para linguaxes de programación (*bindings*) 
Para salientar as características multilenguaje e multiplataforma de OpenGL, desenvolvéronse varios *bindings* en moitas linguaxes. Algúns das linguaxes para os que están dispoñibles devanditos *bindings* son:

* Ada: **Ada OpenGL 1.1** soporta GL, GLU e GLUT http://web.arquive.org/web/20041013020717/http://www.cs.chalmers.se/bond/OPENGL/ADA/.
* C#: **Tao** é un framework para .NET que inclúe OpenGL entre outras bibliotecas multimedia https://web.archive.org/web/20080607090153/http://www.taoframework.com/.
* D: véxase http://dsource.org/projects/bindings e http://dsource.org/projects/derelict.
* Delphi: **Dot** https://web.archive.org/web/20080308074632/http://www.delphi3d.net/dot/.
* Fortran: **f90gl** soporta OpenGL 1.2, GLU 1.2, GLUT 3.7 http://math.nist.gov/f90gl/.
* Gambas: https://web.archive.org/web/20120304091223/http://new.gambasdoc.org/help/comp/gb.opengl?%C3%A9
* Java: JOGL https://web.archive.org/web/20090821034819/https://jogl.dev.java.net/ e LWJGL http://lwjgl.org/ entre outros; véxase https://web.archive.org/web/20080124024908/http://www.opengl.org/resources/java/.
* Lisp: véxase http://www.agentsheets.com/lisp/OpenGL.html .
* Perl: véxase https://web.archive.org/web/20080124024908/http://www.opengl.org/resources/java/.
* Pike: ten unha interface nativo a OpenGL. Ademais, soporta GLU e GLUT. https://web.archive.org/web/20121002205154/http://pike.ida.liu.se/about/pike/modules.xml.
* Python: **PyOpenGL** soporta GL, GLU e GLUT http://pyopengl.sourceforge.net/.
* Visual Basic: véxase https://web.archive.org/web/20080124024908/http://www.opengl.org/resources/java/.
* Haskell: **HOpenGL**, soporta GL, GLU e GLUT. Véxase https://web.archive.org/web/20071012184537/http://haskell.org/HOpenGL/index.html.

## Membros do Grupo Khronos 
En 2006, algúns dos membros do OpenGL ARB Working Group eran:
* AMD
* Creative Labs
* Intel Graphics Controllers
* nVIDIA
* Iranthala Software ARG
* Sony Computer Entertainment Inc.
* Sun Microsystems
* Texas Instruments

Para unha lista completa e actualizada dos membros do proxecto, véxanse as listas de membros promotores, contribuíntes e académicos do Grupo Khronos.

## Véxase tamén 
* GLSL - Linguaxe de alto nivel de shaders para OpenGL
* JOGL (Java OpenGL) - Biblioteca para usar OpenGL en Java
* OpenGL E - Biblioteca para sistemas integrados

### Bibliotecas adicionais para OpenGL 
* GLU - Funcións adicionais (NURBS, esferas, discos etc)
* GLUT - API para facilitar desenvolvemento con OpenGL e xestionar fiestras e eventos
* GLUI - Biblioteca de interface baseada en GLUT

### Outras APIs de gráficos 
* Direct3D - Principal competidor de OpenGL
* Mesa 3D - Posta en funcionamento de código aberto de OpenGL
* LWJGL (Lightweight Java Game Library) - Acceso a OpenGL, OpenAL e varios dispositivos de entrada
* VirtualGL - Comandos 3D entre servidor dedicado e cliente

## Notas 
## Véxase tamén 
### Ligazóns externas 
* Páxina oficial de OpenGL
* Páxina de SGI sobre OpenGL
* OpenGL no Open Directory Project
* Grupo Khronos
* NeHe Tutorials, tutoriales para a aprendizaxe de OpenGL
* Proxecto Fahrenheit en Microsoft
* Black Byte Titoriais en español de OpenGL