OpenGL: differenze tra le versioni

Contenuto cancellato Contenuto aggiunto
CruccoBot (discussione | contributi)
m robot Aggiungo: pt, sv
m Binding: Modificate informazioni riguardo C++ e C#
 
(255 versioni intermedie di oltre 100 utenti non mostrate)
Riga 1:
{{Software
'''OpenGL''' (da '''Open''' '''G'''raphics '''L'''ibrary, ossia libreria aperta di grafica) è una specifica che definisce una API per più linguaggi e per più piattaforme per scrivere applicazioni che producono [[computer grafica]] 2D e 3D. L'interfaccia consiste in circa 250 diverse chiamate di funzione che si possono usare per disegnare complesse scene tridimensionali a partira da semplici primitive. È usato per sviluppare nell'industria dei videogiochi (nella quale compete con Direct3D su Microsoft Windows), per applicazioni di CAD, realtà virtuale, e CAE. È lo standard di fatto per la computer grafica 3D in ambiente Unix.
|Nome = OpenGL
|Screenshot =
|Didascalia =
|Sviluppatore = [[Silicon Graphics]]<br />poi [[Khronos Group]] dal [[2000]]
|PrimaVersione = 1.0
|DataPrimaVersione = gennaio 1992
|UltimaVersione = 4.6
|DataUltimaVersione = 31 luglio 2017
|UltimaVersioneBeta =
|DataUltimaVersioneBeta =
|SistemaOperativo = multipiattaforma
|Linguaggio =
|Genere = Libreria software
|Genere2 = computer grafica
|Licenza = Licenza multipla
|SoftwareLibero = sì
|SitoWeb =
|Lingua =
}}
'''OpenGL''' ('''Open''' '''G'''raphics '''L'''ibrary) è una specifica che definisce una [[Application programming interface|API]] per più linguaggi e per più piattaforme per scrivere applicazioni che producono [[computer grafica]] 3D. L'interfaccia consiste in circa 250 diverse chiamate di funzione che si possono usare per disegnare complesse scene tridimensionali a partire da semplici primitive. Sviluppato nel 1992 dalla [[Silicon Graphics Inc.]], è ampiamente usato nell'industria dei videogiochi (nella quale compete con [[DirectX]] su [[Microsoft Windows]]), per applicazioni di [[Computer-aided design|CAD]], [[realtà virtuale]], e [[Computer-aided engineering|CAE]]. È lo standard [[de facto]] per la computer grafica 3D in ambiente [[Unix]].
 
== Specifica ==
Esistono implementazioni efficienti di OpenGL (che sfruttano in modo più o meno completo le [[GPU]]) per [[Microsoft Windows]], molte piattaforme [[Unix]], la [[Playstation 3]], e il [[Mac OS]].
A livello più basso OpenGL è una specifica, ovvero si tratta semplicemente di un documento che descrive un insieme di funzioni ed il comportamento preciso che queste devono avere. Da questa specifica, i produttori di hardware creano implementazioni, ovvero librerie di funzioni create rispettando quanto riportato sulla specifica OpenGL, facendo uso dell'accelerazione hardware dove possibile. I produttori devono comunque superare dei test specifici per poter fregiare i loro prodotti della qualifica di implementazioni OpenGL.
Queste implementazioni vengono normalmente fornite dai costruttori di dispositivi video e si affidano pesantemente sull'hardware fornito dal costruttore.
La libreria ''open source'' ''Mesa'' è un'API grafica basata solamente su librerie software che è compatibile con OpenGL. Tuttavia, a causa della licenza, può solo sostenere di di essere un'API "molto simile".
 
Esistono implementazioni efficienti di OpenGL (che sfruttano in modo più o meno completo le [[Graphics Processing Unit|GPU]]) per [[Microsoft Windows]], [[Linux]], molte piattaforme [[Unix]], [[PlayStation 3]] e [[macOS]]. Queste implementazioni vengono normalmente fornite dai costruttori di dispositivi video e si affidano pesantemente sull'hardware fornito. Esistono realizzazioni software che portano OpenGL su piattaforme che non hanno il supporto dei costruttori hardware. La più nota è la libreria ''open source'' ''[[Mesa 3D|Mesa]]'', un'API grafica basata solamente su librerie software che è compatibile con OpenGL. Tuttavia, a causa della licenza, può solo sostenere di essere un'API "molto simile".
La specifica di OpenGL è supervisionata dall'OpenGL Architecture Review Board (ARB), che si è formato nel [[1992]].
 
L'ARB consiste in un insieme di aziende interessate a creare un'API coerente e ampiamente disponibile.
La specifica di OpenGL è stata inizialmente supervisionata dall'OpenGL Architecture Review Board (ARB), formatosi nel [[1992]].
Secondo il sito Web ufficiale di OpenGL, i membri votanti dell'ARB nel novembre del [[2004]] erano: [[3Dlabs]], [[Apple Computer]], ATI Technologies, Dell, Evans & Sutherland, [[Hewlett-Packard]], [[IBM]], [[Intel]], Matrox, NVIDIA, [[Silicon Graphics|SGI]] e [[Sun Microsystems]]. ([[Microsoft]], uno dei membri fondatori, se n'è andato nel marzo del 2003.)
L'ARB era composto da un gruppo di aziende interessate a creare un'API coerente e ampiamente disponibile.
I membri fondatori dell'ARB comprendevano aziende del calibro di [[3Dlabs]], [[Apple]], [[ATI Technologies]], [[Dell]], [[IBM]], [[Intel]], [[NVIDIA Corporation|NVIDIA]], [[Silicon Graphics|SGI]], [[Sun Microsystems]] e [[Microsoft]], che però ha abbandonato il gruppo nel marzo del 2003. Il coinvolgimento di così tante aziende con interessi molto diversificati, ha portato OpenGL a diventare nel tempo una API ad uso generico, con un ampio ventaglio di capacità.
 
Il controllo di OpenGL è passato, ad inizio 2007, al consorzio Khronos Group, nel tentativo di migliorarne il marketing e di rimuovere le barriere tra lo sviluppo di OpenGL e [[OpenGL ES]]<ref>[https://www.khronos.org/news/press/Releases/opengl_arb_to_pass_control_of_opengl_specification_to_khronos_group/ OpenGL ARB cede il controllo sulla specifica di OpenGL a Khronos Group] {{webarchive|url=https://web.archive.org/web/20080503182855/http://www.khronos.org/news/press/releases/opengl_arb_to_pass_control_of_opengl_specification_to_khronos_group/ |data=3 maggio 2008 }}</ref>
 
== Struttura ==
[[File:Pipeline OpenGL.svg|miniatura|upright=2.3|A Graphics Pipeline Process]]
OpenGL assolve a due compiti fondamentali:
* nascondere la complessità di interfacciamento con acceleratori 3D differenti, offrendo al programmatore una [[Application programming interface|API]] unica ed uniforme;
* nascondere le capacità offerte dai diversi acceleratori 3D, richiedendo che tutte le implementazioni supportino completamente l'insieme di funzioni OpenGL, ricorrendo ad un'emulazione software se necessario.
 
Il compito di OpenGL è quello di ricevere primitive come punti, linee e poligoni, e di convertirli in pixel (''rasterizing'' o [[rasterizzazione]]). Ciò è realizzato attraverso una [[pipeline grafica]] nota come ''OpenGL state machine''<ref>{{Cita web |url=https://www.opengl.org/documentation/specs/version1.1/state.pdf |titolo=OpenGL state machine |accesso=3 maggio 2019 |dataarchivio=22 giugno 2018 |urlarchivio=https://web.archive.org/web/20180622232710/https://www.opengl.org/documentation/specs/version1.1/state.pdf |urlmorto=sì }}</ref>. La maggior parte dei comandi OpenGL forniscono primitive alla pipeline grafica o istruiscono la pipeline su come elaborarle. Prima dell'introduzione di OpenGL 2.0, ogni stadio della pipeline realizzava una funzione fissa ed era configurabile solo entro certi limiti, ma dalla versione 2.0 molti stadi sono totalmente programmabili attraverso il linguaggio [[GLSL]].
 
OpenGL è una API procedurale che opera a basso livello, che richiede al programmatore i passi precisi per disegnare una scena. Questo approccio si pone in contrasto con le API descrittive ad alto livello le quali, operando su [[Albero (grafo)|struttura dati ad albero]] (''scene graph''), richiedono al programmatore solo una descrizione generica della scena, occupandosi dei dettagli più complessi del [[rendering]]. La natura di OpenGL obbliga quindi i programmatori ad avere una buona conoscenza della pipeline grafica stessa, ma al contempo lascia una certa libertà per implementare complessi algoritmi di ''rendering''.
 
Storicamente, OpenGL ha esercitato una notevole influenza sullo sviluppo degli acceleratori 3D, promuovendo un livello base di funzionalità che è oggi comune nelle schede video destinate al grande pubblico:
* punti, linee e poligoni disegnati come primitive base;
* una pipeline per il [[transform and lighting]];
* [[Z-buffering]]
* [[Texture mapping]]
* [[Alpha blending]]
 
Una delle caratteristiche più apprezzate in ambito professionale è la retrocompatibilità tra le diverse versioni di OpenGL: programmi scritti per la versione 1.0 della libreria devono funzionare senza modifiche su implementazioni che seguono la versione 2.1.
 
== Versioni ==
=== Revisioni 1 ===
OpenGL 1 è un'evoluzione di (ed ha uno stile molto simile a) ''IRIS GL'', l'interfaccia 3D di SGI. Una delle restrizioni di IRIS GL era che forniva accesso solamente alle caratteristiche supportate dall'hardware soggiacente. Se l'hardware grafico non supportava una caratteristica, allora l'applicazione non poteva usarla. OpenGL ha superato questo problema fornendo supporto via software per le caratteristiche non supportate dall'hardware, permettendo alle applicazioni di usare della grafica avanzata su sistemi di potenza relativamente bassa. Il progetto Fahrenheit fu uno sforzo congiunto fra Microsoft, SGI, e Hewlett-Packard con l'obiettivo di unificare le interfacce OpenGL e Direct3D. Inizialmente ha mostrato qualche promessa di portare ordine nel mondo delle API di computer grafica 3D interattiva, ma a causa dei vincoli finanziari in SGI e alla generale carenza di supporto nell'industria, è stato poi abbandonato.
 
==== OpenGL 1.0 ====
 
Pubblicato nel [[1992]].
 
La prima specifica di OpenGL fu pubblicata da Mark Segal e Kurt Akeley.
 
==== OpenGL 1.1 ====
 
Pubblicato nel gennaio [[1997]].
 
OpenGL 1.1 si prefigge di supportare funzioni texture e formati texture su GPU hardware.
 
* Schede: ''tutte''
 
==== OpenGL 1.2 ====
 
Pubblicato il 16 marzo [[1998]].
 
OpenGL 1.2 si prefigge di supportare funzioni di ''volume textures'', ''packed pixels'', ''normal rescaling'', ''clamped/edge texture sampling'' e ''image processing''.
 
* Schede: Rage 128, Rage 128 GL, Rage XL/XC, Rage 128 Pro, Rage Fury MAXX e successive.
===== OpenGL 1.2.1 =====
 
Pubblicato il 14 ottobre [[1998]].
 
OpenGL 1.2.1 è una pubblicazione intermedia che aggiunge funzioni di multi-texture, o anche texture units, al rendering pipeline. Ciò permette di mescolare textures multiple sulla base di pixel, durante la rasterizzazione.
* Schede: Radeon, Radeon Mobility, Radeon 7500 Mobility, Radeon 8500, Radeon 9000, Radeon 9200, Radeon 9600, Radeon 9800, GeForce 3, GeForce 4Ti, GeForce FX e successive.
 
==== OpenGL 1.3 ====
 
Pubblicato il 14 agosto [[2001]].
 
OpenGL 1.3 aggiunge il supporto per funzioni di cubemap texture, multi-texturing, multi-sampling, e funzioni di texture unit combine operations (come: add, combine, dot3 e border clamp).
 
* Schede: 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 e successive.
 
==== OpenGL 1.4 ====
 
Pubblicato il 24 luglio [[2002]].
 
OpenGL 1.4 introduce il supporto hardware per funzioni di shadowing, fog coordinates, automatic mipmap generation, e funzioni addizionali di texture.
 
* Schede: Quadro DCC, Quadro4 380 XGL, Quadro4 500XGL, 550XGL, Quadro4 700XGL, 750XGL, 900XGL, 980XGL e successive.
 
==== OpenGL 1.5 ====
 
Pubblicato il 29 luglio [[2003]].
 
OpenGL 1.5 aggiunge supporto per: vertex buffer objects (VBOs), occlusion queries, e extended shadowing.
 
* Schede: Radeon X800, Radeon 9600, Radeon 9700, Radeon 9800, GeForce FX, e successive.
 
=== Revisioni 2 ===
 
Le schede pubblicate con OpenGL 2.0 sono le prime ad offrire shaders programmabili.
 
OpenGL 2 è stato concepito da [[3Dlabs]] per soddisfare le preoccupazioni che OpenGL fosse stagnante e mancasse di una forte direzione.
3Dlabs ha proposto alcune grosse aggiunte allo standard, la più significativa delle quali fu [[GLSL]] (da ''Open'''GL''' '''S'''hading '''L'''anguage'', cioè il linguaggio di shading di OpenGL). Questo consentirebbe ai programmatori di sostituire il codice prefissato di OpenGL per le pipeline di elaborazione dei vertici e dei frammenti con gli shader scritti in un linguaggio simile al [[Linguaggio C|C]]. GLSL era notevole per il fatto di non adeguarsi all'hardware allora disponibile; questo era un ritorno alla tradizione di OpenGL di porsi degli obiettivi ambiziosi e proiettati al futuro per nuovi acceleratori 3D, invece di limitarsi a inseguire lo stato dell'hardware attualmente disponibile.
La specifica finale di OpenGL 2.0<ref>{{Cita web |url=https://www.opengl.org/documentation/specs/version2.0/glspec20.pdf |titolo=Copia archiviata |accesso=3 maggio 2019 |dataarchivio=11 novembre 2019 |urlarchivio=https://web.archive.org/web/20191111182032/https://www.opengl.org/documentation/specs/version2.0/glspec20.pdf |urlmorto=sì }}</ref> comprendeva il supporto a GLSL, ma ometteva molte delle altre caratteristiche originalmente proposte - queste sono state differite a versioni future di OpenGL, sebbene alcune siano già disponibili come estensioni.
 
==== OpenGL 2.0 ====
 
Pubblicato il 7 settembre [[2004]].
 
OpenGL 2.0 aggiunge il supporto per un vero linguaggio assembly, basato sulle [[Graphics Processing Unit|GPU]], chiamato ARB (perché ideato dal [[Architecture Review Board]]), che si prefigge di divenire lo standard per tutte le funzioni di ''vertex and fragment shaders''.
* Schede: 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 e successive.
 
==== OpenGL 2.1 ====
 
Pubblicato il 2 luglio [[2006]].
 
OpenGL 2.1 introduce un supporto per i ''pixel buffer objects'' (PBOs), sRGB textures (gamma-corrected textures), e per matrici ''non-quadre'', oltre alla revisione 1.20 dello ''Shading Language GLSL''<ref>{{Cita web |url=https://www.opengl.org/documentation/current_version/ |titolo=What's New in the Latest Version of OpenGL<!-- Titolo generato automaticamente --> |accesso=3 maggio 2019 |dataarchivio=1 luglio 2017 |urlarchivio=https://web.archive.org/web/20170701194824/https://www.opengl.org/documentation/current_version/ |urlmorto=sì }}</ref>.
* Schede: Radeon GD 2350, GeForce FX (dotate di driver 175.19), GeForce 6000 series, GeForce 7000 series, GeForce Go 7000 series, Quadro FX 4000, Quadro FX 350, Quadro FX 550, Quadro FX 560, Quadro FX 1400, Quadro FX 1500, Quadro FX 5500 e successive.
 
=== Revisioni 3 ===
 
OpenGL 3.0 aggiunge un meccanismo di semplificazione per le API delle future revisioni.
==== OpenGL 3.0 ====
 
Pubblicato l'11 luglio [[2008]].
 
OpenGL 3.0 introduce il supporto per funzioni di geometry shader, frame buffer objects, hardware instancing, vertex array objects (VAOs), e sRGB framebuffers (gamma 2.2)<ref>https://www.opengl.org/registry/doc/glspec30.20080811.pdf</ref>.
* Schede: Radeon HD series; GeForce 8000, 9000, GTX 100, GTX 200, e GTX 300 series.
==== OpenGL 3.1 ====
 
Pubblicato il 28 maggio [[2009]].
 
OpenGL 3.1 aggiunge una serie di features per rendere le API più convenienti all'uso, oltre ad uno spettro di features orientate alla performance<ref>{{Cita web |url=https://www.khronos.org/news/press/releases/khronos-releases-streamlined-opengl-3.1-specification/ |titolo=Khronos Group Prioritizes China's Participation in Creation of Key International Technology Standard - Khronos Group Press Release<!-- Titolo generato automaticamente --> |accesso=3 maggio 2019 |urlarchivio=https://web.archive.org/web/20160327122818/https://www.khronos.org/news/press/releases/khronos-releases-streamlined-opengl-3.1-specification |dataarchivio=27 marzo 2016 |urlmorto=sì }}</ref>; introduce anche una revisione 1.40 del linguaggio ''OpenGL Shading Language''.
 
Con la pubblicazione di OpenGL 3.1 è stata introdotta un'estensione di compatibilità che permette agli sviluppatori di accedere alle funzionalità deprecate di OpenGL 1.X/2.X e rimosse in OpenGL 3.1.
 
Le funzionalità deprecate e rimosse in core profile includono:
* tutte le funzioni della fixed pipeline
* la immediate mode
* il color index mode
* tutte le funzionalità di imaging
 
==== OpenGL 3.2 ====
 
Pubblicato il 3 agosto [[2009]] ed aggiornato il 7 dicembre [[2009]].
 
* Schede: Radeon HD series; GeForce 8000, 9000, GTX 100, GTX 200, e GTX 300 series.
 
==== OpenGL 3.3 ====
Pubblicato l'11 marzo [[2010]].
 
Questa versione ha lo scopo di permettere alle GPU delle generazioni precedenti di usufruire di parte delle funzionalità di OpenGL 4.0. Pensato anche nell'ottica dello sviluppo di [[OpenGL ES]] (API dedicata ai dispositivi mobili come quelli basati su [[Android]], [[webOS]] e [[iPhone OS]]).<ref name="puntoinformatico12-03-2010">{{cita web|url=http://punto-informatico.it/2831258/PI/News/opengl-40-sfida-directx-11.aspx|titolo=OpenGL 4 sfida DirectX 11 su Punto informatico.it|accesso=13 marzo 2010}}</ref>
 
Introduce la revisione 3.30 del linguaggio OpenGL Shading Language.
 
=== Revisioni 4 ===
==== OpenGL 4.0 ====
 
Pubblicato l'11 marzo [[2010]].
 
Questa versione include il supporto per la tessellation ([[tassellatura]]), e la [[virgola mobile]] a [[64 bit]] con [[precisione doppia]] (per migliorare la qualità) per gli [[shader]]. Migliora inoltre il supporto per lo standard [[OpenCL]], dedicato al [[GPGPU]], cioè la possibilità di sfruttare la GPU per un maggior tipo di utilizzi.<ref name="puntoinformatico12-03-2010"/>
 
==== OpenGL 4.1 ====
Pubblicato il 26 luglio [[2010]].
 
Questa versione migliora l'interoperabilità con OpenCL e introduce la compatibilità con OpenGL ES 2.0.
 
==== OpenGL 4.2 ====
Pubblicato l'8 agosto [[2011]].<ref>[https://www.khronos.org/news/press/khronos-enriches-cross-platform-3d-graphics-with-release-of-opengl-4.2-spec Khronos Enriches Cross-Platform 3D Graphics with Release of OpenGL 4.2 Specification]</ref>
 
==== OpenGL 4.3 ====
Pubblicato il 6 agosto [[2012]].<ref>[https://www.khronos.org/news/press/khronos-releases-opengl-4.3-specification-with-major-enhancements Khronos Releases OpenGL 4.3 Specification with Major Enhancements]</ref>
 
Questa versione introduce, tra le altre cose, la versione 4.30 del linguaggio di shading GLSL, il nuovo metodo di compressione delle texture ETC2/EAC, le texture views e la piena compatibilità con [[OpenGL ES#OpenGL ES 3.0|OpenGL ES 3.0]].
 
* Schede: NVIDIA GeForce 400 series, NVIDIA GeForce 500 series, NVIDIA GeForce 600 series
 
==== OpenGL 4.4 ====
Pubblicato il 22 luglio [[2013]].
 
==== OpenGL 4.5 ====
 
Pubblicato l'11 agosto [[2014]], viene introdotto il Flush Control che permette maggiori performance in applicazioni multithread, il DSA (Direct State Access) permette il controllo indipendente dei vari oggetti, inoltre viene ottimizzato il motore di rendering WebGL<ref>[http://www.lffl.org/2014/08/opengl-4-5.html OpenGL 4.5 arrivano le migliorie per le applicazioni multithread]</ref>.
 
==== OpenGL 4.6 ====
 
Pubblicato il 31 Luglio 2017, oltre a molte estensioni e ottimizzazioni, introduce il supporto a [[Spir-v|SPIR-V]].
 
== Estensioni ==
Lo standard OpenGL permette ai produttori individuali di fornire funzionalità aggiuntive tramite le ''estensioni'' man mano che vengono create nuove tecnologie. Un'estensione viene poi distribuita in due parti: come file di intestazione che contiene i prototipi di funzione dell'estensione, e come ''driver'' del produttore.
Ogni produttore ha un'abbreviazione alfabetica che viene usata nel denominare le loro nuove funzioni e costanti.
Per esempio, l'abbreviazione di NVIDIA (''NV'') viene usata nel definire la loro funzione propriatariaproprietaria <code>glCombinerParameterfvNV()</code> e la loro costante <code>GL_NORMAL_MAP_NV</code>.
Può succedere che più di un produttoreproduttori si accordiaccordino per implementare la stessa funzionalità estesa.
 
In tal caso, si usa l'abbreviazione ''EXT''.
Riga 20 ⟶ 209:
La prima estensione ARB è stata la <code>GL_ARB_multitexture</code>.
Avendo seguito il percorso di promozione per le estensioni ufficiali, la multitexture non è più un'estensione ARB implementata opzionalmente, ma è stata integrata nell'API base di OpenGL a partire dalla versione 1.4.
Le specifiche per quasi tutte le estensioni si trovano nel repository ufficiale delle estensioni<ref>{{Cita web |url=http://oss.sgi.com/projects/ogl-sample/registry/ [|titolo=Registry (redirect)<!-- Titolo generato automaticamente --> |accesso=11 agosto 2005 |urlarchivio=https://web.archive.org/web/20080205042328/http://oss.sgi.com/projects/ogl-sample/registry/] |dataarchivio=5 febbraio 2008 |urlmorto=sì }}</ref>.
 
Varie librerie sono state costruite sopra OpenGL per fornire funzionalità non disponibili in OpenGL stesso:
 
* [[OpenGL Utility Library|GLU]]
* [[OpenGL Utility Toolkit|GLUT]]
* [[OpenGL User Interface Library|GLUI]]
 
In particolare, la libreria OpenGL Performer, sviluppata da SGI e disponibile per [[IRIX]], [[Linux]], e varie versioni di [[Microsoft Windows]], si appoggia a OpenGL per abilitare la creazione di applicazioni di simulazione visuale in [[sistema real-time]].
 
==Binding Bindings ==
Al fine di imporre le sue caratteristiche multi-linguaggio e multi-piattaforma, vari [[binding]] e [[porting|port]] sono stati sviluppati per OpenGL in molti linguaggi. Tra i più notevoli, la libreria [[Java 3D]] può appoggiarsi su OpenGL per sfruttare l'accelerazione hardware. Molto recentemente, Sun ha pubblicato le versioni beta del sistema JOGL, che fornisce binding ai comandi OpenGL in C, diversamente da Java 3D che non fornisce tale supporto a basso livello. La pagina OpenGL ufficiale elenca vari bindings per i linguaggi [[Java (linguaggio di programmazione)|Java]], [[Fortran|Fortran 90]], [[Perl]], [[Pike programming language|Pike]], [[Python]], [[Ada (linguaggio)|Ada]], e [[Visual Basic]].
 
Funziona nativamente con [[C++]] e possiede [[Wrapper|wrappers]] per [[C sharp|C#]].
Al fine di imporre le sue caratteristiche multi-linguaggio e multi-piattaforma, vari [[bindings]] e [[porting|port]] sono stati sviluppati per OpenGL in molti linguaggi. Tra i più notevoli, la libreria [[Java 3D]] può appoggiarsi su OpenGL per sfruttare l'accelerazione hardware. Molto recentemente, Sun ha rilasciato le versioni beta del sistema JOGL, che fornisce binding ai comandi OpenGL in [[C (linguaggio)|C]], diversamente da Java 3D che non fornisce tale supporto a basso livello. la pagina OpenGL ufficiale [http://www.opengl.org/] elenca vari bindings per i linguaggi [[Java (linguaggio)|Java]], [[Fortran|Fortran 90]], [[Perl]], [[Pike programming language|Pike]], [[Python]], [[Ada]], e [[Visual Basic]]. I binding sono disponibili anche per [[C plus plus|C++]] e [[C sharp|C#]], vedere [http://www.exocortex.org/3dengine/].
 
== Funzionalità ad alto livello ==
[[File:Perl OpenGL fob2.jpg|alt=Esempio di OpenGL|miniatura|Esempio di OpenGL]]
 
OpenGL è satostato progettato per essere di solo output: fornisce solamente funzioni di [[rendering]]. L'API di base non contempla la gestione di finestre, l'audio, la stampa, la tastiera, il mouse, né altri dispositivi di input. Per quanto questo puòpossa sembrare restrittivo, permette al codice di rendering di essere completamente indipendente dal [[sistema operativo]] su cui funziona, permettendo lo sviluppo di codice indipendente dalla piattaforma.
Tuttavia, per consentire un'interazione con il sistema ospitante, è necessario integrare il software con il sistema a finestre nativo.
Ciò viene effettuato tramite le seguenti API aggiuntive:
 
* [[GLX]] - X11 (comprensivo di trasparenza di rete)
* [[WGL]] - [[Microsoft Windows]]
 
In aggiunta le librerie [[OpenGL Utility Toolkit|GLUT]] e [[Simple DirectMedia Layer|SDL]] forniscono funzionalità per una gestione elementare delle finestre con OpenGL, in maneramaniera portabile.
[[Mac OS XmacOS]] ha tre API per ottenere il supporto di OpenGL: [[AGL (API)|AGL]] per [[Carbon (API)|Carbon]], [[NSOpenGL]] per [[Cocoa (software)|Cocoa]] e [[CGLCore OpenGL]] (CGL) per l'accesso diretto.
 
== Esempio di codice sorgente ==
Di seguito un semplice programma in [[Linguaggio C|C]] che disegna un triangolo utilizzando le primitive OpenGL. Si noti che questo programma fa uso di funzionalità deprecate a partire da OpenGL 3.0.
 
<syntaxhighlight lang="c">
/*************************************************************
* Per compilare con gcc su Linux: *
* gcc file.c -lglut *
* oppure: *
* gcc file.c -L/usr/X11R6/lib -lglut -lXmu -lGL -lGLU -lXi *
*************************************************************/
 
#include <GL/gl.h> // File header per la libreria OpenGL
#include <GL/glut.h> // File header per la libreria GLUT
#include <stdlib.h> // File header per usare 'exit()'
 
/* Funzione invocata quando la finestra viene ridimensionata (anche quando viene creata) */
void
resize (int width, int height)
{
glViewport (0, 0, width, height); // Usiamo tutta finestra
glMatrixMode (GL_PROJECTION); // Seleziona di usare la matrice 'PROJECTION'
glLoadIdentity (); // Resetta la matrice 'PROJECTION'
glMatrixMode (GL_MODELVIEW); // Seleziona di usare la matrice 'MODELVIEW'
glLoadIdentity (); // Resetta la matrice 'MODELVIEW'
}
 
/* Funzione di disegno */
void
draw ()
{
glClearColor (0.0f, 0.0f, 0.0f, 0.0f); // Sfondo nero
glClear (GL_COLOR_BUFFER_BIT); // Cancella la scena
 
glBegin (GL_TRIANGLES); // Disegna un triangolo
glColor3f (1.0f, 0.0f, 0.0f); // Impostiamo il colore rosso
glVertex3f ( 0.0f, 0.5f, 0.0f); // Angolo in alto
glColor3f (0.0f, 1.0f, 0.0f); // Imposta il colore verde
glVertex3f (-0.5f, -0.5f, 0.0f); // Angolo basso sinistro
glColor3f (0.0f, 0.0f, 1.0f); // Imposta il colore blu
glVertex3f (0.5f, -0.5f, 0.0f); // Angolo basso destro
glEnd (); // Fine triangolo
glutSwapBuffers (); // Disegna!
}
 
/* Funzione invocata ogni volta che viene premuto un tasto */
==Storia==
void
OpenGL è un'evoluzione di (ed ha uno stile molto simile a) ''IRIS GL'', l'interfaccia 3D di SGI. Una delle restrizioni di IRIS GL era che forniva accesso solamente alle caratteristiche supportate dall'hardware soggiacente. Se l'hardware grafico non supportava una caratteristica, allora l'applicazione non poteva usarla. OpenGL ha superato questo problema fornendo supporto via software per le caratteristiche non supportate dall'hardware, permettendo alle applicazioni di usare della grafica avanzata su sistemi di potenza relativamente bassa. Il progetto Fahrenheit fu uno sforzo congiunto fra Microsoft, SGI, e Hewlett-Packard con l'obiettivo di unificare le interfacce OpenGL e Direct3D. Inizialmente ha mostrato qualche promessa di portare ordine nel mondo delle API di computer grafica 3D interattiva, ma a causa dei vincoli finanziari in SGI e alla generale carenza si supporto nell'industria, è stato poi abbandonato.
keyPressed (unsigned char key, int x, int y)
{
if (key == 'q') // Se il tasto premuto e` q,
exit (0); // esce
}
 
/* Main */
==Il futuro in Microsoft Windows==
int
Il [[6 agosto]] [2005], le intenzioni di Microsoft riguardo al supporto di OpenGL in [[Windows Vista]] sono state rivelate in un [http://www.opengl.org/discussion_boards/cgi_directory/ultimatebb.cgi?ubb=get_topic;f=12;t=000001 annuncio di notizie su Opengl.org]:
main (int argc, char **argv)
{
glutInit (&argc, argv); // Inizializza la libreria GLUT
glutInitDisplayMode (GLUT_RGB|GLUT_DOUBLE); // Seleziona il modo di visualizzazione: usa RGB e double buffer
glutInitWindowSize (640, 480); // Imposta la dimensione della finestra a 640x480
glutInitWindowPosition (0, 0); // Imposta la posizione dell'angolo alto sinistro della finestra
glutCreateWindow ("Esempio uso OpenGL"); // Crea la finestra
glutDisplayFunc (draw); // Imposta la funzione di disegno
glutReshapeFunc (resize); // Imposta la funzione di ridimensionamento
glutKeyboardFunc (keyPressed); // Imposta la funzione per gli eventi della tastiera
glutMainLoop (); // Inizio
return (1);
}
</syntaxhighlight>
 
== Il futuro in Microsoft Windows ==
<blockquote>I piani attuali di Microsoft per OpenGL su Windows Vista sono di appoggiare OpenGL sopra Direct3D al fine di usare OpenGL su un desktop composito per ottenere l'esperienza Aeroglass. Se si esegue un ICD OpenGL - il desktop compositor si spegnerà - degradando significativamente l'esperienza dell'utente.</blockquote>
Il 6 agosto [[2005]], quelle che in principio erano le intenzioni di Microsoft riguardo al supporto di OpenGL in [[Windows Vista]] vennero rivelate in annuncio di notizie su Opengl.org<ref>[https://www.opengl.org/discussion_boards/cgi_directory/ultimatebb.cgi?ubb=get_topic;f=12;t=000001]</ref>.
 
{{citazione|I piani attuali di Microsoft per OpenGL su Windows Vista sono di appoggiare OpenGL sopra Direct3D al fine di usare OpenGL su un desktop composito per ottenere l'esperienza Aeroglass. Se si esegue un ICD OpenGL - il desktop compositor si spegnerà - degradando significativamente l'esperienza dell'utente.
<blockquote>In pratica, per OpenGL sotto Aeroglass, ciò significa:</blockquote>
 
In pratica, per OpenGL sotto Aeroglass, ciò significa:
<blockquote>Le prestazioni di OpenGL verranno significativamente ridotte - forse fino al 50%.</blockquote>
 
Le prestazioni di OpenGL verranno significativamente ridotte - forse fino al 50%.
<blockquote>OpenGL su Windows verrà portata ad una versione base di OpenGL 1.4.</blockquote>
 
OpenGL su Windows verrà portata ad una versione base di OpenGL 1.4.
<blockquote>Nessuna estensione sarà possibile per esporre future innovazioni hardware.</blockquote>
<blockquote>Sarebbe tecnicamente immediato fornire un ICD OpenGL (''installable client driver'', cioè un driver specifico per OpenGL) all'interno dell'intera esperienza Aeroglass senza compromettere la stabilità o la sicurezza del sistema operativo. Appoggiare OpenGL su Direct3D è una decisione più strategica che tecnica.</blockquote>
 
Nessuna estensione sarà possibile per esporre future innovazioni hardware.
Pertanto, il futuro di OpenGL come libreria principale per i video giochi adesso appare precario. Microsoft ha preso la decisione di non rilasciare le informazioni necessarie per permettere a terze parti (come [[NVidia]], [[ATI]] o gli altri grandi costruttori di schede) di sviluppare i driver di sostituzione, non lasciando modo di evitare il calo di velocità del 50%. Un impiegato di 3Dlabs afferma nello stesso thread di Opengl.org:
Sarebbe tecnicamente immediato fornire un ICD OpenGL (''installable client driver'', cioè un driver specifico per OpenGL) all'interno dell'intera esperienza Aeroglass senza compromettere la stabilità o la sicurezza del sistema operativo. Appoggiare OpenGL su Direct3D è una decisione più strategica che tecnica.}}
 
Allora, il futuro di OpenGL come libreria principale per i videogiochi sembrava precario. Microsoft aveva preso la decisione di non pubblicare le informazioni necessarie per permettere a terze parti (come [[NVIDIA Corporation|NVIDIA]], [[ATI Technologies|ATI]] o gli altri grandi costruttori di schede) di sviluppare i driver di sostituzione, non lasciando modo di evitare il calo di velocità del 50%.
<blockquote>Questa informazione è giunta dal BOF OpenGL tenuto al Siggraph 2005 a Los Angeles la sera di mercoledì scorso. È stato confermato al BOF da NVIDIA, ATI e da noi (3Dlabs).</blockquote>
 
Forse proprio a seguito delle pressioni che giungevano dal mondo dell'industria del software e dagli stessi produttori hardware, Microsoft ha in seguito rivisto questa politica e sono oggi disponibili ICD in grado di funzionare senza problemi in unione al sottosistema Aeroglass, senza calo di prestazioni. Si veda a tal proposito la presentazione relativa ad OpenGL su Windows Vista pubblicata da NVIDIA al SIGGRAPH 2006<ref>[https://www.khronos.org/developers/library/siggraph2006/OpenGL_BOF/NVIDIA_-_OpenGL_on_Vista.ppt Khronos Developer Presentations Library<!-- Titolo generato automaticamente -->]</ref>.
<blockquote>Non appena viene caricato un ICD, il desktop composito si spegne su Windows Vista. Se volete l'esperienza Aeroglass del desktop composito, avrete bisogno di far passare la vostra applicazione attraverso l'implementazione OpenGL di Microsoft, che è appoggiata sopra DirectX. Come evidenziato prima, questa stratificazione può avere un impatto sulle prestazioni.
La loro implementazione supporta solo la versione 1.4 di OpenGL, senza supporto per le estensioni.</blockquote>
 
Così come per il predecessore [[Windows XP]], anche il CD di installazione di [[Windows Vista]] non include alcun ICD (Installable Client Driver), che dovrà essere installato a cura dell'utente. In mancanza di un ICD, Vista fornisce comunque funzionalità OpenGL 1.4 senza estensioni, attraverso uno strato di emulazione basato su Direct3D.
<blockquote>Noi crediamo sia possibile fornire un ICD con pieno supporto per il desktop composito mantenendo l'aderenza ai requisiti di robustezza e sicurezza di Windows Vista.
Ma ci serve l'aiuto di Microsoft per farlo.</blockquote>
 
Il futuro di OpenGL in ambito videoludico è quindi ora nelle mani dei produttori di videogiochi, i quali non sembrano comunque molto propensi all'utilizzo di questa API, come dimostrerebbe anche una decisione di uno dei suoi più illustri sostenitori in questo ambito, ovvero [[John Carmack]] di [[id Software]]. Quest'ultimo ha infatti affermato<ref>{{Cita web |url=https://techreport.com/etc/2005q3/carmack-quakecon/index.x?pg=1 |titolo=Link |accesso=3 maggio 2019 |urlarchivio=https://web.archive.org/web/20070815222143/http://techreport.com/etc/2005q3/carmack-quakecon/index.x?pg=1 |dataarchivio=15 agosto 2007 |urlmorto=sì }}</ref> al [[QuakeCon]] 2005 che la sua principale piattaforma di sviluppo sarà [[Xbox 360]], che infatti si appoggia a [[DirectX]].
<blockquote>Per avere ulteriori informazioni, si possono consultare le seguenti diapositive presentate al Microsoft Winhec:</blockquote>
 
== Note ==
<blockquote>"Windows Graphics Overview [WinHEC 2005; 171 KB]" [http://download.microsoft.com/download/9/8/f/98f3fe47-dfc3-4e74-92a3-088782200fe7/TWPR05007_WinHEC05.ppt http://download.microsoft.com/download/9/8/f/98f3fe47-dfc3-4e74-92a3-088782200fe7/TWPR05007_WinHEC05.ppt]</blockquote>
<references/>
 
== Bibliografia ==
<blockquote>"Advances in Display and Composition Architecture for Windows [WinHEC 2005; 422 KB]" [http://download.microsoft.com/download/9/8/f/98f3fe47-dfc3-4e74-92a3-088782200fe7/TWPR05005_WinHEC05.ppt http://download.microsoft.com/download/9/8/f/98f3fe47-dfc3-4e74-92a3-088782200fe7/TWPR05005_WinHEC05.ppt]</blockquote>
* OpenGL Architecture Review Board; Dave Shreiner. ''OpenGL Reference Manual: The Official Reference Document to OpenGL, Version 1.4 (4th Edition)'', Addison-Wesley Professional, 2004. ISBN 0-321-17383-X
* OpenGL Architecture Review Board; Dave Shreiner; Mason Woo; Jackie Neider; Tom Davis. ''OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 2 (5th Edition)''. Addison-Wesley Professional, 2005. ISBN 0-321-33573-2
* Randi J. Rost. ''OpenGL Shading Language'', Addison-Wesley Professional, 2004. ISBN 0-321-19789-5
 
== OpenGLVoci 2.0correlate ==
* [[Application programming interface]]
OpenGL 2.0 è stato concepito da [[3Dlabs]] per soddisfare le preoccupazioni che OpenGL fosse stagnane e mancasse di una forte direzione.
* [[Direct Rendering Infrastructure]]
3Dlabs ha proposto alcune grosse aggiunte allo standard, la più significativa delle quali fu [[GLSL]] (da ''Open<b>GL</b> <b>S</b>hading <b>L</b>anguage'', cioè il linguaggio di shading di OpenGL). Questo consentirebbe ai programmer di sostituire il codice prefissato di OpenGL per le pipeline di elaborazione dei vertici e dei frammenti con gli shader scritti in un linguaggio simile al [[Linguaggio_C|C]]. GLSL era notevole per il fatto di non adeguarsi all'hardware allora disponibile; questo era un ritorno alla tradizione di OpenGL di porsi degli obiettivi ambiziosi e proiettati al futuro per nuovi acceleratori 3D, invece di limitarsi a inseguire lo stato dell'hardware attualmente disponibile.
* [[Glscene]]
La specifica finale di OpenGL 2.0 [http://www.opengl.org/documentation/specs/version2.0/glspec20.pdf] comprendeva il supporto a GLSL, ma ometteva molte delle altre caratteristiche originalmente proposte - queste sono state differite a versioni future di OpenGL, sebbene alcune siano già disponibili come estensioni.
* [[OpenVG]]
* [[OpenGL ES]]
* [[VMGL]]
 
== Altri progetti ==
==Ulteriori letture==
{{interprogetto}}
*Fosner, Ron: ''OpenGL Programming for Windows 95 and Windows NT'', Addison Wesley, ISBN 0-201-40709-4
*OpenGL Architecture Review Board, et al: ''OpenGL Reference Manual: The Official Reference Document to OpenGL, Version 1.4'', Addison Wesley, ISBN 0-321-17383-X
*Rost, Randi J.: ''OpenGL Shading Language'', Addison Wesley, ISBN 0-321-19789-5
*OpenGL Architecture Review Board, et al: ''OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 1.4, Fourth Edition'', Addison Wesley, ISBN 0-321-17348-1
 
== Collegamenti esterni ==
* {{Collegamenti esterni}}
* [http://0waldo.com/scripts/get2D3D.cgi Routine di conversione di superfici da 2D a 3D e di manipolazione di texture]
* {{en}} [https://www.opengl.org/registry/ OpenGL Registry] - tutte le specifiche, gli header, le estensioni e la documentazione collegata
* [http://www.opengl.org/ Sito Web ufficiale]
* [http://nehe.gamedev.net/ Tutorial e materiale di apprendimento fornito da ''Neon Helium Productions'']
* [http://www.opengl.org/documentation/red_book_1.0/ Copia online di una vecchia edizione del libro ''The OpenGL Programming Guide'']
 
=== Risorse per programmatori ===
* {{en}} [httphttps://www.codesampleropengl.comorg/wiki/oglsrc.htm CodeSampler.comOpenGL Wiki] - EsempiWiki di codice e tutorial per la programmazioneufficiale di giochi in OpenGL.
* {{en}} [httphttps://wwwweb.pzetaarchive.org/openglweb/20071126072642/http://nehe.gamedev.net/ OpenGLNeHe DirectoryProductions] - RaccoltaTutorial diper risorsela eprogrammazione link sucon OpenGL.
* {{en}} [https://web.archive.org/web/20060116010741/http://www.codesampler.com/oglsrc.htm CodeSampler.com] - Esempi di codice e tutorial per la programmazione di giochi in OpenGL 1.2-2.0
* {{en}} [http://www.cs.unc.edu/~andrewz/comp236/hw5b/ Il modello di illuminazione di OpenGL]
* {{en}} [http://sjbaker.org/steve/omniv/opengl_lighting.html Illuminazione di base con OpenGL] - Una spiegazione dell'illuminazione standard di OpenGL 1.X-2.X
* {{en}} [http://openglsamples.sf.net Tutorial OpenGL] - Tutorial per la programmazione con OpenGL
* {{cita web|1=http://www.starstonesoftware.com/OpenGL/|2=The OpenGL SuperBible|lingua=en|accesso=8 febbraio 2008|urlarchivio=https://web.archive.org/web/20080110172622/http://www.starstonesoftware.com/OpenGL/|dataarchivio=10 gennaio 2008|urlmorto=sì}}
 
{{portale|software libero}}
[[Categoria:Computer grafica]]
[[Categoria:Interfacce grafiche]]
 
[[Categoria:Librerie grafiche]]
[[cs:OpenGL]]
[[da:OpenGL]]
[[de:OpenGL]]
[[en:OpenGL]]
[[es:OpenGL]]
[[fi:OpenGL]]
[[fr:OpenGL]]
[[ja:OpenGL]]
[[nl:OpenGL]]
[[pl:OpenGL]]
[[pt:OpenGL]]
[[sv:OpenGL]]
[[zh:OpenGL]]