OpenGL (Open Graphics Library) è 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 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 CAD, realtà virtuale, e CAE. È lo standard di fatto per la computer grafica 3D in ambiente Unix.
Aggiornamenti:
OpenGL window and compositing manager.
Cambiamenti per le versioni:
1:0.8.6-0ubuntu9.1
1:0.8.6-0ubuntu9.2
Versione 1:0.8.6-0ubuntu9.2:
* Upstream patch, 438868_Dont-grant-override_redirect-windows-focus,
from 0.8.8 branch; (LP: #438868)
Cambiamenti per le versioni:
1:0.8.6-0ubuntu9.1
1:0.8.6-0ubuntu9.2
Versione 1:0.8.6-0ubuntu9.2:
* Upstream patch, 438868_Dont-grant-override_redirect-windows-focus,
from 0.8.8 branch; (LP: #438868)
Versione 1:0.8.6-0ubuntu9.2:
* Upstream patch, 438868_Dont-grant-override_redirect-windows-focus,
from 0.8.8 branch; (LP: #438868)
Compiz brings to life a variety of visual effects that make the Linux desktop easier to use, more powerful and intuitive, and more accessible for users with special needs.
Compiz combines together a window manager and a composite manager using OpenGL for rendering. A "window manager" allows the manipulation of the multiple applications and dialog windows that are presented on the screen. A "composite manager" allows windows and other graphics to be combined together to create composite images. Compiz achieves its stunning effects by doing both of these functions.
Compiz brings to life a variety of visual effects that make the Linux desktop easier to use, more powerful and intuitive, and more accessible for users with special needs.
This metapackage provides the components necessary for running compiz. It provides the compiz core, a set of standard plugins, a window decorator using the Gtk toolkit and the files necessary to integrate compiz with the GNOME desktop environment.
OpenGL window and compositing manager. Gnome window decorator
Cambiamenti per le versioni:
1:0.8.6-0ubuntu9.1
1:0.8.6-0ubuntu9.2
Versione 1:0.8.6-0ubuntu9.2:
* Upstream patch, 438868_Dont-grant-override_redirect-windows-focus,
from 0.8.8 branch; (LP: #438868)
Compiz brings to life a variety of visual effects that make the Linux desktop easier to use, more powerful and intuitive, and more accessible for users with special needs.
This package contains files needed to integrate compiz with the GNOME desktop environment.
OpenGL window and compositing manager. Plugins.
Cambiamenti per le versioni:
1:0.8.6-0ubuntu9.1
1:0.8.6-0ubuntu9.2
Versione 1:0.8.6-0ubuntu9.2:
* Upstream patch, 438868_Dont-grant-override_redirect-windows-focus,
from 0.8.8 branch; (LP: #438868)
Compiz brings to life a variety of visual effects that make the Linux desktop easier to use, more powerful and intuitive, and more accessible for users with special needs.
This package contains the standard plugins that come with compiz. Compiz without these plugins is not very useful.
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 ove possibile. I produttori devono comunque superare dei test specifici per poter fregiare i loro prodotti della qualifica di implementazioni OpenGL.
Esistono implementazioni efficienti di OpenGL (che sfruttano in modo più o meno completo le GPU) per Microsoft Windows, Linux, molte piattaforme Unix, Playstation 3 e Mac OS. 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, 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 è stata inizialmente supervisionata dall'OpenGL Architecture Review Board (ARB), formatosi nel 1992. 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 Computer, ATI Technologies, Dell, IBM, Intel, NVIDIA, 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
OpenGL assolve a due compiti fondamentali:
* nascondere la complessità di interfacciamento con acceleratori 3D differenti, offrendo al programmatore una 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 (EN) OpenGL state machine. 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 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.
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
Rilasciato nel 1992.
La prima specifica di OpenGL fu rilasciata da Mark Segal e Kurt Akeley.
OpenGL 1.1
Rilasciato nel gennaio 1997.
OpenGL 1.1 si prefigge di supportare funzioni texture e formati texture su GPU hardware.
* Schede: tutte
OpenGL 1.2
Rilasciato 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
Rilasciato il 14 ottobre 1998.
OpenGL 1.2.1 è un rilascio intermedio 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
Rlasciato 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
Rlasciato 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
Rilasciato 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 rilasciate 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 OpenGL Shading Language, 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 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 [1] 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
Rilasciato il 7 settembre 2004.
OpenGL 2.0 aggiunge il supporto per un vero linguaggio assembly, basato sulle 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
Rilasciato 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
* 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
Rilasciato 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)[3] .
* Schede: Radeon HD series; GeForce 8000, 9000, GTX 100, GTX 200, e GTX 300 series.
OpenGL 3.1
Rilasciato 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[4]; introduce anche una revisione 1.40 del linguaggio OpenGL Shading Language.
* Schede:
OpenGL 3.2
Rilasciato 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
Rilasciato 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 ed iPhone OS)
OpenGL 4.0
Rilasciato 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.
OpenGL 4.1
Rilasciato il 26 luglio 2010.
Questa versione migliora l'interoperabilità con OpenCL e introduce la compatibilità con OpenGL ES 2.0.
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 proprietaria glCombinerParameterfvNV() e la loro costante GL_NORMAL_MAP_NV. Può succedere che più produttori si accordino per implementare la stessa funzionalità estesa.
In tal caso, si usa l'abbreviazione EXT. Può anche accadere che l'ARB approvi l'estensione. Allora essa diventa nota come una estensione standard, e si usa l'abbreviazione ARB. La prima estensione ARB è stata la GL_ARB_multitexture. 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.
Varie librerie sono state costruite sopra OpenGL per fornire funzionalità non disponibili in OpenGL stesso:
* GLU
* GLUT
* 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 real-time.
Ricerca personalizzata
Se ti è piaciuto l'articolo , iscriviti al feed cliccando sull'immagine sottostante per tenerti sempre aggiornato sui nuovi contenuti del blog:
Nessun commento:
Posta un commento
Non inserire link cliccabili altrimenti il commento verrà eliminato. Metti la spunta a Inviami notifiche per essere avvertito via email di nuovi commenti.