OpenGL

Na Galipedia, a Wikipedia en galego.
  OpenGl

Desenvolvedor: Silicon Graphics Inc.
Última versión: 2.1 (2 Agosto do 2006)
Sistema operativo: Multiplataforma
Xénero: API
Licenza: Diversas
En galego: Non
Sitio web: www.opengl.org

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

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[editar | editar a fonte]

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 implementaciones (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 implementación como unha implementación de OpenGL.

Existen implementacións eficientes de OpenGL fornecidas por fabricantes para Mac OS, Microsoft Windows, Linux, varias plataformas Unix, e PlayStation 3. Existen tamén varias implementaciones software que permiten que OpenGL estexa 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 implementación 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[3]. Con iso intentábase mellorar a mercadotecnia de OpenGL e eliminar as barreiras entre o desenvolvemento de OpenGL e OpenGL[4]. ARB converteuse dentro de Khronos no OpenGL ARB Working Group[5]. 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[editar | editar a fonte]

OpenGL ten dous propósitos principais:

  • Ocultar a complexidade da interfaz 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 implementaciones 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 implementación de algoritmos novos de renderizado.

OpenGL influíu no desenvolvemento dos cartóns gráficos, promocionando 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.
Proceso na pipeline de gráficos

Unha descrición do proceso na pipeline gráfica podería ser [6]:

  1. Avaliación, procédese das funcións polinomiais que definen certas entradas, como as superficies NURBS, aproximando curvas e a xeometría da superficie.
  2. 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.
  3. 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.
  4. 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.
  5. 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[editar | editar a fonte]

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

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:

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:

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

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[editar | editar a fonte]

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[7], 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, aparte 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[8], 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[9].

En 1995 Microsoft lanzou Direct3D, que se convertería no principal competidor de OpenGL. O 17 de decembro de 1997[10] 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[11]. 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[12].

Versións[editar | editar a fonte]

OpenGL 2.1[editar | editar a fonte]

O 2 de agosto de 2006 publicouse OpenGL 2.1. Sendo completamente compatible coas versións anteriores[13], 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.
Esta funcionalidade corresponde á extensión GL_EXT_texture_sRGB.

OpenGL 3.0[editar | editar a fonte]

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.[14]

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 atrás, toda a antiga API vai estar dispoñible.

Documentación[editar | editar a fonte]

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:

Libro de referencia e tutorial. Considerado libro de cabeceira para programadores de OpenGL.
En esencia, unha copia da páxinas do man de OpenGL.
Inclúe un poster desplegable co diagrama da estrutura dunha implementación ideal de OpenGL.
  • O Libro Verde - The Green Book: Programming OpenGL for the X Window System. ISBN 0-201-48359-9
Libro sobre o interfaz 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 interfaz de OpenGL en plataformas de Microsoft Windows.

Para OpenGL 2.0 e posteriores:

Libro de referencia e tutorial para GLSL.

Extensións[editar | editar a fonte]

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 implementar 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 [1].

Bibliotecas de utilidades[editar | editar a fonte]

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: Interfaz de usuario baseada en GLUT; proporciona elementos de control talles 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)[editar | editar a fonte]

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:

Membros do Grupo Khronos[editar | editar a fonte]

En 2006, algúns dos membros do OpenGL ARB Working Group eran:

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[editar | editar a fonte]

Bibliotecas adicionais para OpenGL[editar | editar a fonte]

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

Outras APIs de gráficos[editar | editar a fonte]

  • Direct3D - Principal competidor de OpenGL
  • Mesa 3D - Implementación 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[editar | editar a fonte]

  1. "SGI - OpenGL Overview". http://www.sgi.com/products/software/opengl/overview.html.
  2. "SGI - Licenza". http://www.sgi.com/products/software/opengl/license.html.
  3. "Boletín de prensa de Khronos anunciando a fusión con ARB". http://www.khronos.org/news/press/Releases/opengl_arb_to_pass_control_of_opengl_specification_to_khronos_group/.
  4. "Análise da fusión de Khronos e ARB". http://www.tgdaily.com/2006/07/18/analysis_khronos_and_open_gl_merge/.
  5. "OpenGL Architecture Review Board Working Group". http://www.opengl.org/about/arb/.
  6. "Especificación do Sistema Gráfico OpenGL Versión 2.1". http://www.opengl.org/registry/doc/glspec21.20061201.pdf.
  7. "Iris GL, propiedade de SGI". 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.
  8. "Creación do OpenGL ARB". http://www.sgi.com/global/é/newsroom/2004/09212004.html.
  9. "Fin de OpenGL++". http://www.opengl.org/about/arb/meeting_notes/notes/Meeting1.2/meeting_note_10-03-98.html.
  10. "Anuncio público de Fahrenheit". http://www.windowsitpro.com/Article/ArticleID/17533/17533.html.
  11. meu_m0CGN/is_n3341/ai_20211297 "Membros do Proxecto Fahrenheit. 1998.". http://www.findarticles.com/p/articles/o meu_m0CGN/is_n3341/ai_20211297.
  12. "Fin do Proxecto Fahrenheit". http://www.theregister.co.uk/1999/11/29/ms_quietly_dumps_windows_opengl/.
  13. "Características de OpenGL 2.1". http://www.opengl.org/documentation/current_version/.
  14. "OpenGL ARB anuncia unha actualización en OpenGL 3.0". http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=229374#Post229374. Consultado o 2007-10-31.

Ligazóns externas[editar | editar a fonte]