„OpenGL“ – Versionsunterschied
[gesichtete Version] | [gesichtete Version] |
zurück auf Los Markierung: Manuelle Zurücksetzung |
|||
(46 dazwischenliegende Versionen von 33 Benutzern werden nicht angezeigt) | |||
Zeile 1: | Zeile 1: | ||
{{Infobox Software |
|||
{{Infobox_Software |
|||
|Name = OpenGL |
|Name = OpenGL |
||
|Logo = [[Datei:Opengl-logo.svg|250px|OpenGL Logo]] |
|Logo = [[Datei:Opengl-logo.svg|250px|OpenGL Logo]] |
||
⚫ | |||
|Screenshot = <!-- nur freie Software--> |
|||
⚫ | |||
|Beschreibung = |
|||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
|Lizenz = verschieden<ref>{{Internetquelle |url=https://www.sgi.com/products/software/opengl/license.html |titel=SGI - Products: Software: OpenGL: Licensing and Logos |datum=2012 |archiv-url=https://web.archive.org/web/20120114142126/https://www.sgi.com/products/software/opengl/license.html |archiv-datum=2012-01-14 |offline=ja |abruf=2022-02-07}}</ref> |
|||
⚫ | |||
⚫ | |||
⚫ | |||
|Lizenz = verschieden<ref>http://www.sgi.com/products/software/opengl/license.html</ref> |
|||
|Deutsch = |
|||
⚫ | |||
}} |
}} |
||
'''OpenGL''' ('''''Open''' '''G'''raphics '''L'''ibrary''; deutsch ''Offene Grafikbibliothek'') ist eine [[Spezifikation]] |
'''OpenGL''' ('''''Open''' '''G'''raphics '''L'''ibrary''; deutsch ''Offene Grafikbibliothek'') ist eine [[Spezifikation]] einer plattform- und programmiersprachenübergreifenden [[Programmierschnittstelle]] (API) zur Entwicklung von 2D- und 3D-[[Computergrafik]]anwendungen. Der OpenGL-Standard beschreibt etwa 250 Befehle, die die Darstellung komplexer 3D-Szenen in [[Echtzeit]] erlauben. Zudem können andere Organisationen (zumeist Hersteller von [[Grafikkarte]]n) [[proprietär]]e Erweiterungen definieren. |
||
Die [[Implementierung]] des OpenGL-API erfolgt in der Regel durch [[Programmbibliothek|Systembibliotheken]], auf einigen Betriebssystemen auch als Teil der Grafikkarten-[[Gerätetreiber|Treiber]]. Diese führen entsprechend Befehle der |
Die [[Implementierung]] des OpenGL-API erfolgt in der Regel durch [[Programmbibliothek|Systembibliotheken]], auf einigen Betriebssystemen auch als Teil der Grafikkarten-[[Gerätetreiber|Treiber]]. Diese führen entsprechend Befehle der Grafikkarte aus, insbesondere müssen auf der Grafikkarte nicht vorhandene Funktionen durch die [[Prozessor|CPU]] emuliert werden. |
||
Der Nachfolger von ''OpenGL'' ist ''[[Vulkan (API)|Vulkan]]''. |
|||
== Das Programmiermodell == |
== Das Programmiermodell == |
||
[[Datei:Pipeline OpenGL.svg|mini|500px| |
[[Datei:Pipeline OpenGL.svg|mini|500px|Diagramm der Grafikpipeline von OpenGL]] |
||
Viele Parameter können die Darstellung von [[Bildsynthese|gerenderten]] Objekten beeinflussen, beispielsweise können sie [[Textur (Computergrafik)|texturiert]] und beleuchtet sein, gestreckt, verschoben, transparent oder undurchsichtig, sie können eine raue oder glatte Oberfläche haben und so weiter. |
Viele Parameter können die Darstellung von [[Bildsynthese|gerenderten]] Objekten beeinflussen, beispielsweise können sie [[Textur (Computergrafik)|texturiert]] und beleuchtet sein, gestreckt, verschoben, transparent oder undurchsichtig, sie können eine raue oder glatte Oberfläche haben und so weiter. |
||
OpenGL wurde als [[Automat (Informatik)|Zustandsautomat]] entworfen, der nicht bei jedem Funktionsaufruf alle benötigten Parameter erhält, sondern so lange dieselben Werte verwendet, bis die entsprechenden Zustände geändert werden. Auf diese Weise |
OpenGL wurde als [[Automat (Informatik)|Zustandsautomat]] entworfen, der nicht bei jedem Funktionsaufruf alle benötigten Parameter erhält, sondern so lange dieselben Werte verwendet, bis die entsprechenden Zustände geändert werden. Auf diese Weise braucht man zum Beispiel nicht für jeden [[Vertex]] OpenGL die gewünschte Farbe mitzuteilen, sondern setzt einmalig eine Farbe, woraufhin alle folgenden Vertices in dieser Farbe dargestellt werden. Auf dieselbe Weise kann man global Lichtquellen an- oder ausschalten und viele weitere Zustände setzen. |
||
Der Grund für dieses Design ist, dass fast jede Änderung des Zeichenmodus |
Der Grund für dieses Design ist, dass fast jede Änderung des Zeichenmodus aufwendige Reorganisationen der [[Grafikpipeline]] nach sich zieht, daher vermeidet man diese lieber, so lange es sinnvoll möglich ist. Auch wäre es für den Programmierer ermüdend, dutzende Parameter immer wieder neu anzugeben. Oft können viele tausend Vertices bearbeitet werden, bevor wieder ein Zustand geändert werden muss, während manche Zustände sogar nie geändert werden. Beispielsweise bleiben die Lichtquellen meistens für alle Objekte einer Szene die gleichen. Viele Zustände werden zumindest für die Dauer des Renderns eines kompletten Objekts beibehalten, zum Beispiel wird ein Auto als Ganzes um einen bestimmten Vektor verschoben und nicht in seine Einzelteile zerlegt und diese einzeln verschoben. Auch in [[Direct3D]] verfolgt man dieses zustandsbasierte Konzept. |
||
== Erweiterungen == |
== Erweiterungen == |
||
Zeile 34: | Zeile 33: | ||
# Einigen sich dann mehrere Hersteller darauf, die gleiche Erweiterung anzubieten, bekommen die Funktionsnamen und Konstanten das Suffix EXT. |
# Einigen sich dann mehrere Hersteller darauf, die gleiche Erweiterung anzubieten, bekommen die Funktionsnamen und Konstanten das Suffix EXT. |
||
# Einigt sich schließlich das ARB (Architecture Review Board) darauf, die Erweiterung zu standardisieren, erhalten alle Namen das Suffix ARB. |
# Einigt sich schließlich das ARB (Architecture Review Board) darauf, die Erweiterung zu standardisieren, erhalten alle Namen das Suffix ARB. |
||
# Die meisten vom ARB standardisierten Erweiterungen werden in der folgenden OpenGL-Spezifikation dann |
# Die meisten vom ARB standardisierten Erweiterungen werden in der folgenden OpenGL-Spezifikation dann "core", das heißt, sie werden Bestandteil von OpenGL selbst und haben dann kein Suffix mehr. |
||
== Historische Entwicklung == |
== Historische Entwicklung == |
||
OpenGL entstand ursprünglich aus dem von [[Silicon Graphics]] (SGI) entwickelten [[IRIS GL]]. Im sogenannten ''Fahrenheit-Projekt'' versuchten [[Microsoft]] und SGI ihre 3D-Standards zu vereinheitlichen, das Projekt wurde jedoch wegen finanzieller Schwierigkeiten auf Seiten von SGI abgebrochen. |
OpenGL entstand ursprünglich aus dem von [[Silicon Graphics]] (SGI) entwickelten [[IRIS GL]]. Die Version OpenGL 1.0 wurde von Mark Segal und Kurt Akeley verfasst.<ref>{{Internetquelle |url=https://www.khronos.org/opengl/wiki/History_of_OpenGL#Overview |titel=History of OpenGL – OpenGL Wiki |sprache=en |abruf=2017-03-02}}</ref> Im sogenannten ''Fahrenheit-Projekt'' versuchten [[Microsoft]] und SGI ihre 3D-Standards zu vereinheitlichen, das Projekt wurde jedoch wegen finanzieller Schwierigkeiten auf Seiten von SGI abgebrochen. |
||
Der OpenGL-Standard wird vom ''OpenGL ARB'' (Architecture Review Board) festgelegt. Das ARB existiert seit 1992 und besteht aus einer Reihe von Firmen. Stimmberechtigte Mitglieder sind die Firmen [[3DLabs]], [[Apple]], [[ATI Technologies|AMD/ATI]], [[Dell]], [[IBM]], [[Intel]], [[Nvidia]], [[Silicon Graphics|SGI]] und [[Sun Microsystems|Sun]] (Stand Nov. 2004). Weiter mitwirkende Firmen sind |
Der OpenGL-Standard wird vom ''OpenGL ARB'' (Architecture Review Board) festgelegt. Das ARB existiert seit 1992 und besteht aus einer Reihe von Firmen. Stimmberechtigte Mitglieder sind die Firmen [[3DLabs]], [[Apple]], [[ATI Technologies|AMD/ATI]], [[Dell]], [[IBM]], [[Intel]], [[Nvidia]], [[Silicon Graphics|SGI]] und [[Sun Microsystems|Sun]] (Stand Nov. 2004). Weiter mitwirkende Firmen sind Evans & Sutherland, [[Imagination Technologies]], [[Matrox Electronic Systems|Matrox]], Quantum3D, [[S3 Graphics]], Spinor GmbH, Tungsten Graphics und Xi Graphics. [[Microsoft]], eines der Gründungsmitglieder, hat das ARB im März 2003 verlassen. |
||
Neue Funktionen in OpenGL werden meist zuerst als herstellerspezifische Erweiterungen eingeführt und gehen dann den Weg über herstellerübergreifende Erweiterungen und ARB-Erweiterungen zu Kernfunktionalität. Dies erlaubt es, neueste Möglichkeiten der Grafikhardware zu nutzen und dennoch OpenGL abstrakt genug zu halten. |
Neue Funktionen in OpenGL werden meist zuerst als herstellerspezifische Erweiterungen eingeführt und gehen dann den Weg über herstellerübergreifende Erweiterungen und ARB-Erweiterungen zu Kernfunktionalität. Dies erlaubt es, neueste Möglichkeiten der Grafikhardware zu nutzen und dennoch OpenGL abstrakt genug zu halten. |
||
Zeile 46: | Zeile 45: | ||
== Versionsgeschichte == |
== Versionsgeschichte == |
||
{{Version|t|zeige= |
{{Version|t|zeige=11100}} |
||
{| class="wikitable" |
{| class="wikitable" |
||
|- class="hintergrundfarbe5" |
|- class="hintergrundfarbe5" |
||
! Version |
! Version |
||
! style="min-width: |
! style="min-width:10em;"| Veröffentlichung |
||
! Beschreibung / Änderungen |
! Beschreibung / Änderungen |
||
|- |
|- |
||
Zeile 58: | Zeile 57: | ||
| erste Veröffentlichung |
| erste Veröffentlichung |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|1.1}} |
||
| Januar 1997 |
| Januar 1997 |
||
| |
| |
||
Zeile 65: | Zeile 64: | ||
* Polygon Offset |
* Polygon Offset |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|1.2}} |
||
| 16. März 1998 |
| 16. März 1998 |
||
| |
| |
||
Zeile 72: | Zeile 71: | ||
* [[Level of Detail|Level-Of-Detail]]-Texturen |
* [[Level of Detail|Level-Of-Detail]]-Texturen |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|1.2.1}} |
||
| 14. Oktober 1998 |
| 14. Oktober 1998 |
||
| |
| |
||
* ARB Extensions eingeführt |
* ARB Extensions eingeführt |
||
* ARB Multitexture |
* ARB Multitexture |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|1.3}} |
||
| 14. August 2001 |
| 14. August 2001 |
||
| |
| |
||
Zeile 85: | Zeile 84: | ||
* Multitexturing |
* Multitexturing |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|1.4}} |
||
| 24. Juli 2002 |
| 24. Juli 2002 |
||
| |
| |
||
* Tiefentexturen (für Shadow-Mapping) |
* Tiefentexturen (für Shadow-Mapping) |
||
* automatische [[Mip Mapping|Mip-Map]]-Erzeugung |
* automatische [[Mip Mapping|Mip-Map]]-Erzeugung |
||
* Nebelkoordinaten |
* Nebelkoordinaten |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|1.5}} |
||
| 29. Juli 2003 |
| 29. Juli 2003 |
||
| |
| |
||
* Pufferobjekte (Vorhalten von Daten im Grafikspeicher) |
* Pufferobjekte (Vorhalten von Daten im Grafikspeicher) |
||
* Occlusion Queries |
* Occlusion Queries |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|2.0}} |
||
| 7. September 2004 |
| 7. September 2004 |
||
| |
| |
||
* Shaderprogramme: [[OpenGL Shading Language]] |
* Shaderprogramme: [[OpenGL Shading Language]] |
||
* Multiple Render Targets |
* Multiple Render Targets |
||
* Texturen beliebiger Größe (nicht mehr 2<sup>n</sup> für Höhe und Breite) |
* Texturen beliebiger Größe (nicht mehr 2<sup>n</sup> für Höhe und Breite) |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|2.1}} |
||
| 2. August 2006 |
| 2. August 2006 |
||
| |
| |
||
Zeile 112: | Zeile 111: | ||
* sRGB-Texturen |
* sRGB-Texturen |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|3.0 „Longs Peak“}} |
||
| 11. August 2008 |
| 11. August 2008 |
||
| [ursprünglich geplante Ziele, nur teilweise umgesetzt] |
| [ursprünglich geplante Ziele, nur teilweise umgesetzt] |
||
Zeile 121: | Zeile 120: | ||
* erstmals weitestgehender Verzicht auf explizite Abwärtskompatibilität |
* erstmals weitestgehender Verzicht auf explizite Abwärtskompatibilität |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|3.1 „Longs Peak Reloaded“}} |
||
| 24. März 2009<ref>[http://www.opengl.org/registry/doc/glspec31.20090324.pdf OpenGL 3.1 Spezifikationen] (PDF; 2,2 MB)</ref> |
| 24. März 2009<ref>[http://www.opengl.org/registry/doc/glspec31.20090324.pdf OpenGL 3.1 Spezifikationen] (PDF; 2,2 MB)</ref> |
||
| |
| |
||
* weiteres Entfernen von Altlasten (z. B. Fixed-Function-Optionen, Direct-Mode und Color-Index-Mode), diese sind nur noch über die optionale „compatibility extension“ verfügbar |
* weiteres Entfernen von Altlasten (z. B. Fixed-Function-Optionen, Direct-Mode und Color-Index-Mode), diese sind nur noch über die optionale „compatibility extension“ verfügbar |
||
* OpenGL Shading Language 1.40 |
* OpenGL Shading Language 1.40 |
||
Zeile 132: | Zeile 131: | ||
* CopyBuffer API in Zusammenarbeit mit [[OpenCL]]. |
* CopyBuffer API in Zusammenarbeit mit [[OpenCL]]. |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|3.2}} |
||
| 3. August 2009<ref>http://www.opengl.org/registry/doc/glspec32.core.20090803.withchanges.pdf OpenGL Core Specification with changes marked</ref> |
| 3. August 2009<ref>[http://www.opengl.org/registry/doc/glspec32.core.20090803.withchanges.pdf opengl.org] (PDF; 2,4 MB) OpenGL Core Specification with changes marked</ref> |
||
| |
| |
||
* höhere Ausführungsgeschwindigkeit |
* höhere Ausführungsgeschwindigkeit |
||
* verbesserte Darstellungsqualität |
* verbesserte Darstellungsqualität |
||
Zeile 143: | Zeile 142: | ||
* fünf ARB-Erweiterungen |
* fünf ARB-Erweiterungen |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|3.3}} |
||
| 11. März 2010<ref name="registry">http://www.opengl.org/registry/</ref> |
| 11. März 2010<ref name="registry">[http://www.opengl.org/registry/ opengl.org]</ref> |
||
| |
| |
||
* Einbindung von OpenCL |
* Einbindung von OpenCL |
||
* OpenGL Shading Language 3.30 |
* OpenGL Shading Language 3.30 |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|4.0}} |
||
| 11. März 2010<ref name="registry" /> |
| 11. März 2010<ref name="registry" /> |
||
| |
| |
||
* Einbindung von OpenCL |
* Einbindung von OpenCL |
||
* Tessellation<ref> |
* Tessellation<ref>{{Internetquelle |url=https://community.khronos.org/?ubb=showflat&Number=273669 |titel=Khronos Forums |sprache=en |abruf=2023-08-29}}</ref> |
||
* OpenGL Shading Language 4.00 |
* OpenGL Shading Language 4.00 |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|4.1}} |
||
| 26. Juli 2010<ref name="registry" /> |
| 26. Juli 2010<ref name="registry" /> |
||
| |
| |
||
* Laden von binären Shader-Programmen, um Zeit zu sparen |
* Laden von binären Shader-Programmen, um Zeit zu sparen |
||
* 64-Bit Floating-Point-Komponenten bei Vertex-Shader-Eingabe für höhere Präzision |
* 64-Bit Floating-Point-Komponenten bei Vertex-Shader-Eingabe für höhere Präzision |
||
Zeile 164: | Zeile 163: | ||
* OpenGL Shading Language 4.10 |
* OpenGL Shading Language 4.10 |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|4.2}} |
||
| 8. August 2011<ref name="registry" /> |
| 8. August 2011<ref name="registry" /> |
||
| |
| |
||
* OpenGL Shading Language 4.20 |
* OpenGL Shading Language 4.20 |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|4.3}} |
||
| 6. August 2012<ref name="registry" /> |
| 6. August 2012<ref name="registry" /> |
||
| |
| |
||
* Compute Shader-Programme für universelle Berechnungen |
* Compute Shader-Programme für universelle Berechnungen |
||
* OpenGL Shading Language 4.30 |
* OpenGL Shading Language 4.30 |
||
Zeile 177: | Zeile 176: | ||
* Mehr Stabilität zwischen den OpenGL-Anwendungen |
* Mehr Stabilität zwischen den OpenGL-Anwendungen |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|4.4}} |
||
| 22. Juli 2013<ref name="registry" /> |
| 22. Juli 2013<ref name="registry" /> |
||
| |
| |
||
* Mehr Kontrolle über die Platzierung der |
* Mehr Kontrolle über die Platzierung der "buffer" im Speicher |
||
* OpenGL Shading Language 4.40 |
* OpenGL Shading Language 4.40 |
||
* Mehrere OpenGL-Objekte gleichzeitig an den Context binden |
* Mehrere OpenGL-Objekte gleichzeitig an den Context binden |
||
* Compute Shader mit variabler Work-Group |
* Compute Shader mit variabler Work-Group-Größe |
||
|- |
|- |
||
| {{Version| |
| {{Version|co|4.5}} |
||
| 11. August 2014<ref name="registry" /> |
| 11. August 2014<ref name="registry" /> |
||
| |
| |
||
* Direct State Access (DSA) |
* Direct State Access (DSA) |
||
* Flush Control |
* Flush Control |
||
Zeile 193: | Zeile 192: | ||
* OpenGL ES 3.1 API und Shader-Kompatibilität |
* OpenGL ES 3.1 API und Shader-Kompatibilität |
||
* DX11 Emulations Features |
* DX11 Emulations Features |
||
|- |
|||
| {{Version|c|4.6}} |
|||
| 31. Juli 2017<ref name="registry" /><ref name=":0">{{Internetquelle |url=https://www.khronos.org/news/press/khronos-releases-opengl-4.6-with-spir-v-support |titel=Khronos Releases OpenGL 4.6 with SPIR-V Support |werk=khronos.org |datum=2017-07-31 |sprache=en |abruf=2021-08-07}}</ref> |
|||
| |
|||
* Unterstützung von SPIR-V |
|||
|- |
|- |
||
|} |
|} |
||
Der große Sprung von OpenGL 1.5 auf 2.0 erklärt sich mit der Einführung der „OpenGL Shading Language“. Dies stellt eine so große Änderung und Erweiterung dar, dass sich das ARB zu diesem Schritt entschieden hat. Die Khronos Group hat die Spezifikation für OpenGL 3.0 am 11. August zur Siggraph 2008 bekanntgegeben. Die API wurde (weg von der Fixed-Function-Pipeline – hin zu den Shadern bzw. Programs, weg von der State Machine – hin zu einem objektbasierten System) umfassend überarbeitet. Dabei ist OpenGL zwar weiterhin abwärtskompatibel, doch es gibt keine neuen |
Der große Sprung von OpenGL 1.5 auf 2.0 erklärt sich mit der Einführung der „OpenGL Shading Language“. Dies stellt eine so große Änderung und Erweiterung dar, dass sich das ARB zu diesem Schritt entschieden hat. Die Khronos Group hat die Spezifikation für OpenGL 3.0 am 11. August zur Siggraph 2008 bekanntgegeben. Die API wurde (weg von der Fixed-Function-Pipeline – hin zu den Shadern bzw. Programs, weg von der State Machine – hin zu einem objektbasierten System) umfassend überarbeitet. Dabei ist OpenGL zwar weiterhin abwärtskompatibel, doch es gibt keine neuen Funktionalitäten für die alte API mehr. Das neue OpenGL hat erstmals mächtige Geometry-Shader des 3.0-Modells. |
||
Mit der raschen Veröffentlichung von OpenGL 4.0 und dessen Feature-Set – insbesondere der Einführung der Tesselation – konnte die Khronos Group seit längerer Zeit wieder gleichziehen und ist erneut mit [[DirectX]] (11) in Konkurrenz getreten.<ref> |
Mit der raschen Veröffentlichung von OpenGL 4.0 und dessen Feature-Set – insbesondere der Einführung der Tesselation – konnte die Khronos Group seit längerer Zeit wieder gleichziehen und ist erneut mit [[DirectX]] (11) in Konkurrenz getreten.<ref>{{Internetquelle |url=https://www.golem.de/sonstiges/zustimmung/auswahl.html?from=https%3A%2F%2Fwww.golem.de%2F1003%2F73785.html |titel=Golem.de: IT-News für Profis |abruf=2023-08-29}}</ref> |
||
Unter den Titeln OpenGL 2015 und OpenGL 2016 hat NVIDIA einige neue ARBs eingebracht. <ref>http://on-demand.gputechconf.com/siggraph/2016/presentation/sig1609-kilgard-jeffrey-keil-nvidia-opengl-in-2016.pdf</ref> |
Unter den Titeln OpenGL 2015 und OpenGL 2016 hat NVIDIA einige neue ARBs eingebracht. Ein Teil davon wurde mit OpenGL 4.6 zum Standard. 2017 und 2018 wurden für Pascal und Turing weitere Erweiterungen besonders für VR und Raytracing zur Verfügung gestellt.<ref>[http://on-demand.gputechconf.com/siggraph/2016/presentation/sig1609-kilgard-jeffrey-keil-nvidia-opengl-in-2016.pdf on-demand.gputechconf.com] (PDF; 7,1 MB)</ref><ref>[https://www.khronos.org/assets/uploads/events/Next-Generation-OpenGL-Dec14.pdf khronos.org] (PDF; 1,2 MB)</ref><ref>[https://www.khronos.org/assets/uploads/developers/library/2015-siggraph/3D-BOF-SIGGRAPH_Aug15.pdf khronos.org] (PDF; 5,4 MB)</ref><ref>{{Internetquelle |url=https://www.phoronix.com/news/NVIDIA-OpenGL-2015-Linux |titel=NVIDIA Releases "OpenGL 2015" + OpenGL ES 3.2 Linux Driver |sprache=en |abruf=2023-08-29}}</ref><ref>{{Internetquelle |url=https://developer.nvidia.com/opengl-driver |titel=OpenGL Driver Support |datum=2013-08-19 |sprache=en |abruf=2023-08-29}}</ref><ref>{{Internetquelle |url=https://community.khronos.org/t/nvidia-announces-opengl-2015-beta-drivers-for-windows-and-linux/73762 |titel=NVIDIA announces OpenGL 2015 beta drivers for Windows and Linux |datum=2015-08-10 |sprache=en |abruf=2023-08-29}}</ref><ref>[http://on-demand.gputechconf.com/siggraph/2016/presentation/sig1609-kilgard-jeffrey-keil-nvidia-opengl-in-2016.pdf on-demand.gputechconf.com]</ref><ref>{{Internetquelle |url=https://www.slideshare.net/Mark_Kilgard/nvgl17 |titel=NVIDIA OpenGL 4.6 in 2017 |sprache=de |abruf=2023-08-29}}</ref><ref>{{Internetquelle |url=https://developer.nvidia.com/vulkan-turing |titel=Turing Extensions for Vulkan and OpenGL |datum=2018-09-11 |sprache=en |abruf=2023-08-29}}</ref> |
||
== Longs Peak und die Kontroverse zu OpenGL 3.0 == |
== Longs Peak und die Kontroverse zu OpenGL 3.0 == |
||
Vor der Freigabe der Version OpenGL 3.0 am 11. August 2008 war diese Revision der API unter dem Codenamen „Longs Peak“ bekannt. Zum Zeitpunkt der ursprünglichen Ankündigung wurde Longs Peak als allererste umfangreiche und tiefgreifende Überarbeitung der API-Schnittstelle in der Geschichte von OpenGL präsentiert. Diese bestand aus einer grundsätzlichen Überarbeitung der Art und Weise, wie OpenGL arbeitet, was fundamentale Veränderungen an der API zur Folge haben sollte. Um trotz der angekündigten umfangreichen Veränderungen und revolutionären Neuerungen die Abwärtskompatibilität mit älterer Software zu gewährleisten, sollten ältere Versionen der API weiterhin verfügbar sein, jedoch keine neuen Funktionen mehr |
Vor der Freigabe der Version OpenGL 3.0 am 11. August 2008 war diese Revision der API unter dem Codenamen „Longs Peak“ bekannt. Zum Zeitpunkt der ursprünglichen Ankündigung wurde Longs Peak als allererste umfangreiche und tiefgreifende Überarbeitung der API-Schnittstelle in der Geschichte von OpenGL präsentiert. Diese bestand aus einer grundsätzlichen Überarbeitung der Art und Weise, wie OpenGL arbeitet, was fundamentale Veränderungen an der API zur Folge haben sollte. Um trotz der angekündigten umfangreichen Veränderungen und revolutionären Neuerungen die Abwärtskompatibilität mit älterer Software zu gewährleisten, sollten ältere Versionen der API weiterhin verfügbar sein, jedoch keine neuen Funktionen mehr dort einfließen. Dies hätte es erlaubt, alten Programmcode, wie z. B. in der Mehrzahl der [[CAD]]-Anwendungen vorhanden – welche ihre Codebasis seit Jahrzehnten nahezu unverändert nutzen – weiterhin mit älteren Versionen der OpenGL-API auszuführen, während andere Programme allmählich auf die neue Schnittstelle hin umgeschrieben oder portiert worden wären. |
||
Longs Peak sollte ursprünglich bereits im September 2007 unter dem Namen OpenGL 3.0 freigegeben werden. Dann jedoch gab die Khronos-Gruppe am 30. Oktober 2007 bekannt, dass sie auf verschiedene Problempunkte gestoßen sei, die sie gelöst haben wollte, bevor sie die Spezifikationen veröffentlichte. |
Longs Peak sollte ursprünglich bereits im September 2007 unter dem Namen OpenGL 3.0 freigegeben werden. Dann jedoch gab die Khronos-Gruppe am 30. Oktober 2007 bekannt, dass sie auf verschiedene Problempunkte gestoßen sei, die sie gelöst haben wollte, bevor sie die Spezifikationen veröffentlichte. |
||
Zeile 209: | Zeile 213: | ||
Als Resultat verschob sich die Veröffentlichung, und die Informationsquellen verstummten vollständig. Die Khronos-Gruppe war zur Koordination der Weiterentwicklung eingesetzt worden, da sich Neuerungen und Ideen durch die zahlreichen Mitglieder nur schwierig und sehr zeitaufwendig umsetzen ließen. Nach der Aufnahme ihrer Tätigkeiten strebte sie einen klaren und engen Zeitplan mit klar definierten Zielen an und verschrieb sich einer offeneren Kommunikation. |
Als Resultat verschob sich die Veröffentlichung, und die Informationsquellen verstummten vollständig. Die Khronos-Gruppe war zur Koordination der Weiterentwicklung eingesetzt worden, da sich Neuerungen und Ideen durch die zahlreichen Mitglieder nur schwierig und sehr zeitaufwendig umsetzen ließen. Nach der Aufnahme ihrer Tätigkeiten strebte sie einen klaren und engen Zeitplan mit klar definierten Zielen an und verschrieb sich einer offeneren Kommunikation. |
||
Die letztendlich verabschiedeten Spezifikationen erwiesen sich als weitaus weniger spektakulär als angekündigt. Weite Teile des Codes wurden doch beibehalten und der vorgestellte Objektmodus war nicht integriert. Auch sind keine Pläne bekannt, diesen in zukünftigen Versionen nachzureichen. Im Endeffekt ist die API weitgehend die gleiche geblieben, mit ein paar wenigen Erweiterungen an der Kernfunktionalität. |
Die letztendlich verabschiedeten Spezifikationen erwiesen sich als weitaus weniger spektakulär als angekündigt. Weite Teile des Codes wurden doch beibehalten, und der vorgestellte Objektmodus war nicht integriert. Auch sind keine Pläne bekannt, diesen in zukünftigen Versionen nachzureichen. Im Endeffekt ist die API weitgehend die gleiche geblieben, mit ein paar wenigen Erweiterungen an der Kernfunktionalität. |
||
Dieses enttäuschende Ergebnis verursachte Unzufriedenheit bei manchen |
Dieses enttäuschende Ergebnis verursachte Unzufriedenheit bei manchen Entwicklergruppen, hatte man sich doch bahnbrechende Neuerungen und ein ernstzunehmendes, zukunftsweisendes, plattformübergreifendes Konkurrenzprodukt zu Microsofts DirectX erhofft. Aus Protest drohten manche, zukünftig zu DirectX zu wechseln. Am meisten für die Enttäuschung machte man die geringe bis gar nicht vorhandene Kommunikation von Seiten Khronos’ verantwortlich. Man fühlte sich regelrecht ausgesperrt und im Dunkeln gelassen. Andere Kritik wurde an der Notwendigkeit von DirectX-10-fähiger Hardware geübt und dem Fehlen von Geometry-Shadern und Instanced-Rendering als Kernfunktionen. |
||
Andere Quellen geben an, dass die Reaktionen der |
Andere Quellen geben an, dass die Reaktionen der Entwicklergemeinschaft nicht ganz so schlimm ausfielen wie ursprünglich berichtet, da viele Verkäufer bereits geplante Unterstützung für die neue Version zeigten. |
||
== Vor- und Nachteile von OpenGL gegenüber Direct3D == |
== Vor- und Nachteile von OpenGL gegenüber Direct3D == |
||
; Vorteile |
; Vorteile |
||
* Client-Server-Modell |
* Client-Server-Modell |
||
* Draw-Aufrufe sind unter bestimmten Umständen leistungsfähiger als in Direct3D<ref> |
* Draw-Aufrufe sind unter bestimmten Umständen leistungsfähiger als in Direct3D<ref>{{Internetquelle |url=https://developer.nvidia.com/ |titel=NVIDIA Developer |sprache=en |abruf=2023-08-29}}</ref> |
||
* [[plattformübergreifend]] |
* [[plattformübergreifend]] |
||
* von Herstellern selbst erweiterbar |
* von Herstellern selbst erweiterbar |
||
* es gibt eine Vielzahl an |
* es gibt eine Vielzahl an Extensions für neue, noch nicht vom Standard unterstützte Funktionen |
||
* die verfügbaren Features sind von der GPU bzw. deren Treiber abhängig |
* die verfügbaren Features sind von der GPU bzw. deren Treiber abhängig, nicht vom Betriebssystem<ref>[https://developer.nvidia.com/sites/default/files/akamai/gameworks/events/gdc14/GDC_14_Bringing%20Unreal%20Engine%204%20to%20OpenGL.pdf Bringing Unreal Engine 4 to OpenGL] (PDF) Nvidia Developer. Abgerufen am 24. August 2014.</ref> |
||
; Nachteile |
; Nachteile |
||
* OpenGL |
* OpenGL hat eine teilweise veraltete und komplexer zu verwendende [[Programmierschnittstelle]] (API), die von manchen Entwicklern als umständlich angesehen wird.<ref>{{Internetquelle |autor=Rich Geldreich |url=http://richg42.blogspot.com/2014/05/things-that-drive-me-nuts-about-opengl.html |titel=Richard Geldreich's Blog: Things that drive me nuts about OpenGL |werk=Richard Geldreich's Blog |datum=2014-05-11 |abruf=2023-08-29}}</ref><ref>{{Internetquelle |url=http://www.joshbarczak.com/blog/?p=154 |titel=OpenGL Is Broken – The Burning Basis Vector |datum=2014-05-30 |sprache=en-US |abruf=2023-08-29}}</ref> |
||
== Schnittstellen zum System == |
== Schnittstellen zum System == |
||
Da es sich bei OpenGL um eine reine Grafikbibliothek handelt, kümmert sie sich nicht um die Verwaltung von Zeichenoberflächen (Fenster), weiteren Puffern (wie etwa dem [[Z-Buffer]] oder dem [[Stencilbuffer|Stencil-Buffer]]) oder |
Da es sich bei OpenGL um eine reine Grafikbibliothek handelt, kümmert sie sich nicht um die Verwaltung von Zeichenoberflächen (Fenster), weiteren Puffern (wie etwa dem [[Z-Buffer]] oder dem [[Stencilbuffer|Stencil-Buffer]]) oder Renderkontexten, um mit mehreren Anwendungen gleichzeitig die Schnittstelle nutzen zu können. Diese müssen mit Hilfe dafür vorgesehener, betriebssystemabhängiger Bibliotheken zur Verfügung gestellt werden. |
||
Es |
Es gibt mehrere Bibliotheken, die OpenGL mit dem darunter liegenden Betriebssystem verbinden: |
||
* |
* AGL und CGL, das entsprechende Gegenstück für [[macOS]], |
||
* |
* FreeGLUT, eine neuere Alternative zum nicht mehr weiterentwickelten GLUT, |
||
* |
* GLFW, ähnliche Bibliothek wie GLUT, die das darunterliegende Betriebssystem abstrahiert, |
||
* [[OpenGL Utility Toolkit|GLUT]], eine Bibliothek, die aufbauend auf OpenGL, GLU und je nach Plattform GLX, WGL oder AGL eine plattformübergreifende API für Ein-/Ausgabe, Erstellen von Rendering-Kontexten und dergleichen bietet, |
* [[OpenGL Utility Toolkit|GLUT]], eine Bibliothek, die aufbauend auf OpenGL, GLU und je nach Plattform GLX, WGL oder AGL eine plattformübergreifende API für Ein-/Ausgabe, Erstellen von Rendering-Kontexten und dergleichen bietet, |
||
* [[GLX]], die das Interface zwischen dem [[X Window System]] und OpenGL bildet, |
* [[GLX]], die das Interface zwischen dem [[X Window System]] und OpenGL bildet, |
||
* Mit GtkGLExt können OpenGL-Grafiken in [[GTK+]]-Programme eingebunden werden (plattformübergreifend),<ref>[http://gtkglext.sourceforge.net GTK+ OpenGL Extension]</ref> |
* Mit GtkGLExt können OpenGL-Grafiken in [[GTK+]]-Programme eingebunden werden (plattformübergreifend),<ref>[http://gtkglext.sourceforge.net/ GTK+ OpenGL Extension]</ref> |
||
* [[Lightweight Java Game Library |
* [[Lightweight Java Game Library|LWJGL]], Schnittstelle für die Programmierung mit Java, |
||
* [[Qt (Bibliothek)|Qt]], kann OpenGL-Kontexte erzeugen und bietet viele Interaktionsmöglichkeiten mit der eigenen Bibliothek |
* [[Qt (Bibliothek)|Qt]], kann OpenGL-Kontexte erzeugen und bietet viele Interaktionsmöglichkeiten mit der eigenen Bibliothek |
||
* [[Simple DirectMedia Layer|SDL]], kann ebenfalls plattformübergreifend einen OpenGL-Kontext erzeugen, |
* [[Simple DirectMedia Layer|SDL]], kann ebenfalls plattformübergreifend einen OpenGL-Kontext erzeugen, |
||
Zeile 247: | Zeile 251: | ||
[[Datei:OpenGL Kommando Syntax.svg|mini|OpenGL-Kommando-Syntax]] |
[[Datei:OpenGL Kommando Syntax.svg|mini|OpenGL-Kommando-Syntax]] |
||
OpenGL-Kommandos enthalten ein Präfix, an dem man erkennen kann, aus welcher Bibliothek der Befehl stammt, gefolgt von Wörtern, die jeweils mit Großbuchstaben beginnen:<ref>{{Literatur |
OpenGL-Kommandos enthalten ein Präfix, an dem man erkennen kann, aus welcher Bibliothek der Befehl stammt, gefolgt von Wörtern, die jeweils mit Großbuchstaben beginnen:<ref>{{Literatur |Autor=Alfred Nischwitz, Max Fischer, Peter Haberacker |Titel=Computergrafik und Bildverarbeitung |Auflage=2. |Verlag=[[Vieweg-Verlag]] |Ort= |Datum=2007 |ISBN=978-3-8348-0186-9 |Seiten=48}}</ref> |
||
| Autor=Alfred Nischwitz, Max Fischer, Peter Haberacker |
|||
| Titel=Computergrafik und Bildverarbeitung |
|||
| Auflage=2. |
|||
| Verlag=[[Vieweg-Verlag]] |
|||
| Ort= |
|||
| Jahr=2007 |
|||
⚫ | |||
| Seiten=48 |
|||
}}</ref> |
|||
{| class="wikitable |
{| class="wikitable" |
||
|- |
|- |
||
| gl* |
| gl* |
||
Zeile 264: | Zeile 259: | ||
| glut* |
| glut* |
||
|- |
|- |
||
| Basis-Befehl der |
| Basis-Befehl der OpenGL Library |
||
| Befehl der [[OpenGL Utility Library]] (GLU) |
| Befehl der [[OpenGL Utility Library]] (GLU) |
||
| Befehl des [[OpenGL Utility Toolkit]] (GLUT) |
| Befehl des [[OpenGL Utility Toolkit]] (GLUT) |
||
|- |
|- |
||
| z. B. < |
| z. B. <code>glShadeModelO</code> |
||
| z. B. < |
| z. B. <code>gluNurbsSurfaceO</code> |
||
| z. B. < |
| z. B. <code>glutCreateWindowO</code> |
||
|} |
|} |
||
Zeile 278: | Zeile 273: | ||
* [[Computerspiel]]e |
* [[Computerspiel]]e |
||
* [[Erweiterte Realität]] |
* [[Erweiterte Realität]] |
||
* [[Simulation]]en (ASAMGpu) |
* [[Simulation]]en (ASAMGpu)<ref>[https://core.ac.uk/download/pdf/35210480.pdf core.ac.uk] (PDF)</ref> |
||
* [[Virtuelle Realität]] |
* [[Virtuelle Realität]] |
||
* [[Virtual Reality Modeling Language|VRML]] |
* [[Virtual Reality Modeling Language|VRML]]-Authoring |
||
Durch die Kontinuität der Plattform laufen Programme heute im Vergleich |
Durch die Kontinuität der Plattform laufen Programme heute im Vergleich von AMD-Grafikkarten bis zu 40-mal schneller als vor 12 Jahren und mit bis zu 15-mal geringerem Verbrauch pro Aktion, ohne dass dazu der Programm-Code geändert werden muss.<ref>{{Internetquelle |url=https://www.phoronix.com/review/hd3850-r9fury-perf |titel=OpenGL Performance & Perf-Per-Watt From The Radeon HD 3850 Through R9 Fury Review |sprache=en |abruf=2023-08-29}}</ref> |
||
== Unterstützte Plattformen == |
== Unterstützte Plattformen == |
||
OpenGL wird von vielen Betriebssystemen unterstützt, darunter auch |
OpenGL wird von vielen Betriebssystemen unterstützt, darunter auch den meisten führenden: |
||
* [[BeOS]] |
|||
* [[Haiku (Betriebssystem)|Haiku]] |
* [[Haiku (Betriebssystem)|Haiku]] |
||
* [[ |
* [[macOS]] (Mac OS X), [[Mac OS 9]] (Classic)<!--: OpenGL 4.1.--> |
||
* [[Microsoft Windows]]: OpenGL ist Bestandteil seit [[Microsoft Windows 98|Windows 98]] und [[Microsoft Windows NT |
* [[Microsoft Windows]]: OpenGL ist Bestandteil seit [[Microsoft Windows 98|Windows 98]] und [[Microsoft Windows NT 3.5|NT 3.5]] (für [[Microsoft Windows 95|Windows 95]] wurde noch ein Patch benötigt). |
||
* [[X Window System]]: OpenGL wird vom X Window System auf folgenden Plattformen unterstützt: |
* [[X Window System]]: OpenGL wird vom X Window System auf folgenden Plattformen unterstützt: |
||
** [[AIX]] ([[IBM]]) |
** [[AIX]] ([[IBM]]) |
||
Zeile 295: | Zeile 289: | ||
** [[HP-UX]] ([[Hewlett-Packard]]) |
** [[HP-UX]] ([[Hewlett-Packard]]) |
||
** [[IRIX]] ([[Silicon Graphics]]) |
** [[IRIX]] ([[Silicon Graphics]]) |
||
** [[Linux]]: OpenGL und GLX sind in den meisten [[Linux-Distribution|Distributionen]] |
** [[Linux]]: OpenGL und GLX sind in den meisten [[Linux-Distribution|Distributionen]] durch [[Mesa 3D]] implementiert. |
||
** [[Solaris (Betriebssystem)|Solaris]] ([[Sun Microsystems]]) |
** [[Solaris (Betriebssystem)|Solaris]] ([[Sun Microsystems]]) |
||
** [[Tru64 UNIX]] ([[Hewlett-Packard]]) |
** [[Tru64 UNIX]] ([[Hewlett-Packard]]) |
||
* [[ZETA]]: OpenGL-Unterstützung wird mittels [[Mesa 3D|MESA]] für diverse [[Nvidia]]-Grafikkarten geliefert. |
|||
[[Open Graphics Library for Embedded Systems]] (OpenGL ES) gibt es für folgende Plattformen: |
[[Open Graphics Library for Embedded Systems]] (OpenGL ES) gibt es für folgende Plattformen: |
||
* [[Acorn]] [[RISC OS]] |
* [[Acorn]] [[RISC OS]] |
||
* [[Amiga]] (StormMesa) und |
* [[Amiga]] (StormMesa) und Amiga MiniGL |
||
* [[AmigaOS]] MiniGL |
* [[AmigaOS]] MiniGL |
||
* [[Android (Betriebssystem)|Android]] |
* [[Android (Betriebssystem)|Android]] |
||
Zeile 339: | Zeile 332: | ||
* [[OpenAL]], eine plattformübergreifende 3D-Audio-API, die eine Art Audio-Erweiterung zu OpenGL darstellt und vom Aufbau, Programmierstil und Namenskonventionen an OpenGL angelehnt ist. |
* [[OpenAL]], eine plattformübergreifende 3D-Audio-API, die eine Art Audio-Erweiterung zu OpenGL darstellt und vom Aufbau, Programmierstil und Namenskonventionen an OpenGL angelehnt ist. |
||
* [[Simple DirectMedia Layer]] (SDL), eine plattformübergreifende API für Grafik, Audio und Eingabegeräte inklusive OpenGL-spezifischer Funktionalität. |
* [[Simple DirectMedia Layer]] (SDL), eine plattformübergreifende API für Grafik, Audio und Eingabegeräte inklusive OpenGL-spezifischer Funktionalität. |
||
* [[Vulkan (API)|Vulkan]], Nachfolger von OpenGL. |
|||
== Literatur == |
== Literatur == |
||
* {{Literatur |
|||
* {{Literatur | Autor= Graham Sellers, Richard S. Wright und Nicholas Haemel | Titel=OpenGL Superbible: Comprehensive Tutorial and Reference | Verlag=Addison-Wesley Longman | Ort= Amsterdam | Jahr= 2015 |ISBN=978-0-672-33747-5}} |
|||
|Autor=Graham Sellers, Richard S. Wright und Nicholas Haemel |
|||
⚫ | |||
|Titel=OpenGL Superbible: Comprehensive Tutorial and Reference |
|||
* {{Literatur | Autor=Dave Shreiner, Graham Sellers, John Kessenich und Bill Licea-Kane | Titel=OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.3 | Verlag=Addison-Wesley Longman | Ort= Amsterdam | Jahr= 2013 |ISBN=978-0-321-77303-6}} |
|||
|Verlag=Addison-Wesley Longman |
|||
|Ort=Amsterdam |
|||
|Datum=2015 |
|||
⚫ | |||
* {{Literatur |
|||
|Autor=Lorenz Burggraf |
|||
⚫ | |||
|Verlag=Markt+Technik |
|||
|Ort=München |
|||
|Datum=2003 |
|||
|ISBN=3-8272-6237-2}} |
|||
* {{Literatur |
|||
|Autor=Dave Shreiner, Graham Sellers, John Kessenich und Bill Licea-Kane |
|||
|Titel=OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.3 |
|||
|Verlag=Addison-Wesley Longman |
|||
|Ort=Amsterdam |
|||
|Datum=2013 |
|||
|ISBN=978-0-321-77303-6}} |
|||
== Weblinks == |
== Weblinks == |
||
* [http://www.opengl.org/ www.OpenGL.org] |
* [http://www.opengl.org/ www.OpenGL.org] (englisch) |
||
* [http://www.sgi.com/products/software/opengl/ SGI: ''OpenGL Homepage''] (englisch) |
* [http://www.sgi.com/products/software/opengl/ SGI: ''OpenGL Homepage''] (englisch) |
||
* [http://www.delphigl.com/ DelphiGL] – deutsche OpenGL-Community für viele Programmiersprachen (Schwerpunkt [[Embarcadero Delphi|Delphi]]). |
* [http://www.delphigl.com/ DelphiGL] – deutsche OpenGL-Community für viele Programmiersprachen (Schwerpunkt [[Embarcadero Delphi|Delphi]]). |
||
Zeile 356: | Zeile 368: | ||
<references /> |
<references /> |
||
{{SORTIERUNG:Opengl}} |
|||
[[Kategorie:Khronos Group]] |
[[Kategorie:Khronos Group]] |
||
[[Kategorie:Grafikbibliothek]] |
[[Kategorie:Grafikbibliothek]] |
Aktuelle Version vom 3. Januar 2024, 19:56 Uhr
OpenGL
| |
---|---|
Basisdaten
| |
Entwickler | Khronos Group |
Erscheinungsjahr | 1992 |
Aktuelle Version | 4.6 (31. Juli 2017[1]) |
Betriebssystem | plattformübergreifend |
Programmiersprache | C, GLSL |
Kategorie | API |
Lizenz | verschieden[2] |
www.opengl.org |
OpenGL (Open Graphics Library; deutsch Offene Grafikbibliothek) ist eine Spezifikation einer plattform- und programmiersprachenübergreifenden Programmierschnittstelle (API) zur Entwicklung von 2D- und 3D-Computergrafikanwendungen. Der OpenGL-Standard beschreibt etwa 250 Befehle, die die Darstellung komplexer 3D-Szenen in Echtzeit erlauben. Zudem können andere Organisationen (zumeist Hersteller von Grafikkarten) proprietäre Erweiterungen definieren.
Die Implementierung des OpenGL-API erfolgt in der Regel durch Systembibliotheken, auf einigen Betriebssystemen auch als Teil der Grafikkarten-Treiber. Diese führen entsprechend Befehle der Grafikkarte aus, insbesondere müssen auf der Grafikkarte nicht vorhandene Funktionen durch die CPU emuliert werden.
Der Nachfolger von OpenGL ist Vulkan.
Das Programmiermodell
Viele Parameter können die Darstellung von gerenderten Objekten beeinflussen, beispielsweise können sie texturiert und beleuchtet sein, gestreckt, verschoben, transparent oder undurchsichtig, sie können eine raue oder glatte Oberfläche haben und so weiter.
OpenGL wurde als Zustandsautomat entworfen, der nicht bei jedem Funktionsaufruf alle benötigten Parameter erhält, sondern so lange dieselben Werte verwendet, bis die entsprechenden Zustände geändert werden. Auf diese Weise braucht man zum Beispiel nicht für jeden Vertex OpenGL die gewünschte Farbe mitzuteilen, sondern setzt einmalig eine Farbe, woraufhin alle folgenden Vertices in dieser Farbe dargestellt werden. Auf dieselbe Weise kann man global Lichtquellen an- oder ausschalten und viele weitere Zustände setzen.
Der Grund für dieses Design ist, dass fast jede Änderung des Zeichenmodus aufwendige Reorganisationen der Grafikpipeline nach sich zieht, daher vermeidet man diese lieber, so lange es sinnvoll möglich ist. Auch wäre es für den Programmierer ermüdend, dutzende Parameter immer wieder neu anzugeben. Oft können viele tausend Vertices bearbeitet werden, bevor wieder ein Zustand geändert werden muss, während manche Zustände sogar nie geändert werden. Beispielsweise bleiben die Lichtquellen meistens für alle Objekte einer Szene die gleichen. Viele Zustände werden zumindest für die Dauer des Renderns eines kompletten Objekts beibehalten, zum Beispiel wird ein Auto als Ganzes um einen bestimmten Vektor verschoben und nicht in seine Einzelteile zerlegt und diese einzeln verschoben. Auch in Direct3D verfolgt man dieses zustandsbasierte Konzept.
Erweiterungen
Eine wichtige Eigenschaft von OpenGL ist dessen Erweiterbarkeit. Einzelne Anbieter (typischerweise Grafikkartenhersteller) können die Zustandsmaschine von OpenGL um weitere Zustände erweitern. Dabei wird eine vierstufige Vorgehensweise verfolgt:
- Wenn ein Hersteller eine Erweiterung realisieren möchte, so liefert er eine C-Headerdatei aus, in der er die Erweiterung mit den nötigen Konstanten und evtl. Funktionsprototypen definiert. Die Funktionsnamen und Konstanten erhalten ein herstellerspezifisches Suffix (z. B. NV für Nvidia oder ATI für ATI).
- Einigen sich dann mehrere Hersteller darauf, die gleiche Erweiterung anzubieten, bekommen die Funktionsnamen und Konstanten das Suffix EXT.
- Einigt sich schließlich das ARB (Architecture Review Board) darauf, die Erweiterung zu standardisieren, erhalten alle Namen das Suffix ARB.
- Die meisten vom ARB standardisierten Erweiterungen werden in der folgenden OpenGL-Spezifikation dann "core", das heißt, sie werden Bestandteil von OpenGL selbst und haben dann kein Suffix mehr.
Historische Entwicklung
OpenGL entstand ursprünglich aus dem von Silicon Graphics (SGI) entwickelten IRIS GL. Die Version OpenGL 1.0 wurde von Mark Segal und Kurt Akeley verfasst.[3] Im sogenannten Fahrenheit-Projekt versuchten Microsoft und SGI ihre 3D-Standards zu vereinheitlichen, das Projekt wurde jedoch wegen finanzieller Schwierigkeiten auf Seiten von SGI abgebrochen.
Der OpenGL-Standard wird vom OpenGL ARB (Architecture Review Board) festgelegt. Das ARB existiert seit 1992 und besteht aus einer Reihe von Firmen. Stimmberechtigte Mitglieder sind die Firmen 3DLabs, Apple, AMD/ATI, Dell, IBM, Intel, Nvidia, SGI und Sun (Stand Nov. 2004). Weiter mitwirkende Firmen sind Evans & Sutherland, Imagination Technologies, Matrox, Quantum3D, S3 Graphics, Spinor GmbH, Tungsten Graphics und Xi Graphics. Microsoft, eines der Gründungsmitglieder, hat das ARB im März 2003 verlassen.
Neue Funktionen in OpenGL werden meist zuerst als herstellerspezifische Erweiterungen eingeführt und gehen dann den Weg über herstellerübergreifende Erweiterungen und ARB-Erweiterungen zu Kernfunktionalität. Dies erlaubt es, neueste Möglichkeiten der Grafikhardware zu nutzen und dennoch OpenGL abstrakt genug zu halten.
Seit dem 31. Juli 2006 liegt die Weiterentwicklung der OpenGL-API in der Hand der Khronos Group.
Versionsgeschichte
Legende: | Ältere Version; nicht mehr unterstützt | Ältere Version; noch unterstützt | Aktuelle Version |
---|
Version | Veröffentlichung | Beschreibung / Änderungen |
---|---|---|
1.0 | Januar 1992 | erste Veröffentlichung |
1.1 | Januar 1997 |
|
1.2 | 16. März 1998 |
|
1.2.1 | 14. Oktober 1998 |
|
1.3 | 14. August 2001 |
|
1.4 | 24. Juli 2002 |
|
1.5 | 29. Juli 2003 |
|
2.0 | 7. September 2004 |
|
2.1 | 2. August 2006 |
|
3.0 „Longs Peak“ | 11. August 2008 | [ursprünglich geplante Ziele, nur teilweise umgesetzt]
|
3.1 „Longs Peak Reloaded“ | 24. März 2009[4] |
|
3.2 | 3. August 2009[5] |
|
3.3 | 11. März 2010[6] |
|
4.0 | 11. März 2010[6] |
|
4.1 | 26. Juli 2010[6] |
|
4.2 | 8. August 2011[6] |
|
4.3 | 6. August 2012[6] |
|
4.4 | 22. Juli 2013[6] |
|
4.5 | 11. August 2014[6] |
|
4.6 | 31. Juli 2017[6][1] |
|
Der große Sprung von OpenGL 1.5 auf 2.0 erklärt sich mit der Einführung der „OpenGL Shading Language“. Dies stellt eine so große Änderung und Erweiterung dar, dass sich das ARB zu diesem Schritt entschieden hat. Die Khronos Group hat die Spezifikation für OpenGL 3.0 am 11. August zur Siggraph 2008 bekanntgegeben. Die API wurde (weg von der Fixed-Function-Pipeline – hin zu den Shadern bzw. Programs, weg von der State Machine – hin zu einem objektbasierten System) umfassend überarbeitet. Dabei ist OpenGL zwar weiterhin abwärtskompatibel, doch es gibt keine neuen Funktionalitäten für die alte API mehr. Das neue OpenGL hat erstmals mächtige Geometry-Shader des 3.0-Modells.
Mit der raschen Veröffentlichung von OpenGL 4.0 und dessen Feature-Set – insbesondere der Einführung der Tesselation – konnte die Khronos Group seit längerer Zeit wieder gleichziehen und ist erneut mit DirectX (11) in Konkurrenz getreten.[8]
Unter den Titeln OpenGL 2015 und OpenGL 2016 hat NVIDIA einige neue ARBs eingebracht. Ein Teil davon wurde mit OpenGL 4.6 zum Standard. 2017 und 2018 wurden für Pascal und Turing weitere Erweiterungen besonders für VR und Raytracing zur Verfügung gestellt.[9][10][11][12][13][14][15][16][17]
Longs Peak und die Kontroverse zu OpenGL 3.0
Vor der Freigabe der Version OpenGL 3.0 am 11. August 2008 war diese Revision der API unter dem Codenamen „Longs Peak“ bekannt. Zum Zeitpunkt der ursprünglichen Ankündigung wurde Longs Peak als allererste umfangreiche und tiefgreifende Überarbeitung der API-Schnittstelle in der Geschichte von OpenGL präsentiert. Diese bestand aus einer grundsätzlichen Überarbeitung der Art und Weise, wie OpenGL arbeitet, was fundamentale Veränderungen an der API zur Folge haben sollte. Um trotz der angekündigten umfangreichen Veränderungen und revolutionären Neuerungen die Abwärtskompatibilität mit älterer Software zu gewährleisten, sollten ältere Versionen der API weiterhin verfügbar sein, jedoch keine neuen Funktionen mehr dort einfließen. Dies hätte es erlaubt, alten Programmcode, wie z. B. in der Mehrzahl der CAD-Anwendungen vorhanden – welche ihre Codebasis seit Jahrzehnten nahezu unverändert nutzen – weiterhin mit älteren Versionen der OpenGL-API auszuführen, während andere Programme allmählich auf die neue Schnittstelle hin umgeschrieben oder portiert worden wären.
Longs Peak sollte ursprünglich bereits im September 2007 unter dem Namen OpenGL 3.0 freigegeben werden. Dann jedoch gab die Khronos-Gruppe am 30. Oktober 2007 bekannt, dass sie auf verschiedene Problempunkte gestoßen sei, die sie gelöst haben wollte, bevor sie die Spezifikationen veröffentlichte.
Als Resultat verschob sich die Veröffentlichung, und die Informationsquellen verstummten vollständig. Die Khronos-Gruppe war zur Koordination der Weiterentwicklung eingesetzt worden, da sich Neuerungen und Ideen durch die zahlreichen Mitglieder nur schwierig und sehr zeitaufwendig umsetzen ließen. Nach der Aufnahme ihrer Tätigkeiten strebte sie einen klaren und engen Zeitplan mit klar definierten Zielen an und verschrieb sich einer offeneren Kommunikation.
Die letztendlich verabschiedeten Spezifikationen erwiesen sich als weitaus weniger spektakulär als angekündigt. Weite Teile des Codes wurden doch beibehalten, und der vorgestellte Objektmodus war nicht integriert. Auch sind keine Pläne bekannt, diesen in zukünftigen Versionen nachzureichen. Im Endeffekt ist die API weitgehend die gleiche geblieben, mit ein paar wenigen Erweiterungen an der Kernfunktionalität.
Dieses enttäuschende Ergebnis verursachte Unzufriedenheit bei manchen Entwicklergruppen, hatte man sich doch bahnbrechende Neuerungen und ein ernstzunehmendes, zukunftsweisendes, plattformübergreifendes Konkurrenzprodukt zu Microsofts DirectX erhofft. Aus Protest drohten manche, zukünftig zu DirectX zu wechseln. Am meisten für die Enttäuschung machte man die geringe bis gar nicht vorhandene Kommunikation von Seiten Khronos’ verantwortlich. Man fühlte sich regelrecht ausgesperrt und im Dunkeln gelassen. Andere Kritik wurde an der Notwendigkeit von DirectX-10-fähiger Hardware geübt und dem Fehlen von Geometry-Shadern und Instanced-Rendering als Kernfunktionen.
Andere Quellen geben an, dass die Reaktionen der Entwicklergemeinschaft nicht ganz so schlimm ausfielen wie ursprünglich berichtet, da viele Verkäufer bereits geplante Unterstützung für die neue Version zeigten.
Vor- und Nachteile von OpenGL gegenüber Direct3D
- Vorteile
- Client-Server-Modell
- Draw-Aufrufe sind unter bestimmten Umständen leistungsfähiger als in Direct3D[18]
- plattformübergreifend
- von Herstellern selbst erweiterbar
- es gibt eine Vielzahl an Extensions für neue, noch nicht vom Standard unterstützte Funktionen
- die verfügbaren Features sind von der GPU bzw. deren Treiber abhängig, nicht vom Betriebssystem[19]
- Nachteile
- OpenGL hat eine teilweise veraltete und komplexer zu verwendende Programmierschnittstelle (API), die von manchen Entwicklern als umständlich angesehen wird.[20][21]
Schnittstellen zum System
Da es sich bei OpenGL um eine reine Grafikbibliothek handelt, kümmert sie sich nicht um die Verwaltung von Zeichenoberflächen (Fenster), weiteren Puffern (wie etwa dem Z-Buffer oder dem Stencil-Buffer) oder Renderkontexten, um mit mehreren Anwendungen gleichzeitig die Schnittstelle nutzen zu können. Diese müssen mit Hilfe dafür vorgesehener, betriebssystemabhängiger Bibliotheken zur Verfügung gestellt werden.
Es gibt mehrere Bibliotheken, die OpenGL mit dem darunter liegenden Betriebssystem verbinden:
- AGL und CGL, das entsprechende Gegenstück für macOS,
- FreeGLUT, eine neuere Alternative zum nicht mehr weiterentwickelten GLUT,
- GLFW, ähnliche Bibliothek wie GLUT, die das darunterliegende Betriebssystem abstrahiert,
- GLUT, eine Bibliothek, die aufbauend auf OpenGL, GLU und je nach Plattform GLX, WGL oder AGL eine plattformübergreifende API für Ein-/Ausgabe, Erstellen von Rendering-Kontexten und dergleichen bietet,
- GLX, die das Interface zwischen dem X Window System und OpenGL bildet,
- Mit GtkGLExt können OpenGL-Grafiken in GTK+-Programme eingebunden werden (plattformübergreifend),[22]
- LWJGL, Schnittstelle für die Programmierung mit Java,
- Qt, kann OpenGL-Kontexte erzeugen und bietet viele Interaktionsmöglichkeiten mit der eigenen Bibliothek
- SDL, kann ebenfalls plattformübergreifend einen OpenGL-Kontext erzeugen,
- SFML, nutzt genauso plattformübergreifend einen OpenGL-Rendering-Kontext zum Zeichnen in Fenster,
- WebKit nutzt zur Hardwarebeschleunigung OpenGL,
- WGL, die Windows Graphics Library, die OpenGL und Windows verbindet.
Kommando-Syntax
OpenGL-Kommandos enthalten ein Präfix, an dem man erkennen kann, aus welcher Bibliothek der Befehl stammt, gefolgt von Wörtern, die jeweils mit Großbuchstaben beginnen:[23]
gl* | glu* | glut* |
Basis-Befehl der OpenGL Library | Befehl der OpenGL Utility Library (GLU) | Befehl des OpenGL Utility Toolkit (GLUT) |
z. B. glShadeModelO
|
z. B. gluNurbsSurfaceO
|
z. B. glutCreateWindowO
|
Typische Anwendungen für OpenGL
- Bildschirmschoner
- CAD
- Computerspiele
- Erweiterte Realität
- Simulationen (ASAMGpu)[24]
- Virtuelle Realität
- VRML-Authoring
Durch die Kontinuität der Plattform laufen Programme heute im Vergleich von AMD-Grafikkarten bis zu 40-mal schneller als vor 12 Jahren und mit bis zu 15-mal geringerem Verbrauch pro Aktion, ohne dass dazu der Programm-Code geändert werden muss.[25]
Unterstützte Plattformen
OpenGL wird von vielen Betriebssystemen unterstützt, darunter auch den meisten führenden:
- Haiku
- macOS (Mac OS X), Mac OS 9 (Classic)
- Microsoft Windows: OpenGL ist Bestandteil seit Windows 98 und NT 3.5 (für Windows 95 wurde noch ein Patch benötigt).
- X Window System: OpenGL wird vom X Window System auf folgenden Plattformen unterstützt:
- AIX (IBM)
- FreeBSD
- HP-UX (Hewlett-Packard)
- IRIX (Silicon Graphics)
- Linux: OpenGL und GLX sind in den meisten Distributionen durch Mesa 3D implementiert.
- Solaris (Sun Microsystems)
- Tru64 UNIX (Hewlett-Packard)
Open Graphics Library for Embedded Systems (OpenGL ES) gibt es für folgende Plattformen:
- Acorn RISC OS
- Amiga (StormMesa) und Amiga MiniGL
- AmigaOS MiniGL
- Android
- Apple iOS
- Bada
- HP webOS
- MorphOS TinyGL
- PlayStation 2/3/4
- Pocket PC
- QNX
- Symbian
- VxWorks
- Xbox 360
Plattformübergreifend (Windows, Mac OS, Solaris und Linux) wird OpenGL auch durch die Zusätze JOGL oder LWJGL der Java-Plattform unterstützt, die als Wrapper zwischen Java und der nativen Implementierung des Betriebssystems fungieren.
WebGL
WebGL ist ein auf OpenGL ES aufbauender Bestandteil von Webbrowsern, mit dessen Hilfe hardwarebeschleunigte 3D-Grafiken direkt dargestellt werden können.
Vulkan
Am 3. März 2015 wurde auf der Game Developers Conference (GDC) der Nachfolger von OpenGL vorgestellt. Die neue API, zunächst bekannt unter dem Namen Next Generation OpenGL oder auch glNext, heißt Vulkan.
Siehe auch
- DevIL, eine plattformübergreifende API zum schnellen Laden und Speichern von Grafiken. Ehemals OpenIL. Arbeitet sehr gut mit OpenGL zusammen, da es möglich ist, mit einem einzigen Funktionsaufruf eine Bilddatei in eine OpenGL-Textur zu laden oder Bildschirmfotos („screen shot“) abzuspeichern.
- Direct Rendering Infrastructure
- OpenGL Utility Library (GLU), die vom ARB standardisiert und Teil jeder OpenGL-Implementierung ist.
- Java 3D, eine Bibliothek von Java-Klassen zur Erzeugung, Manipulation und Darstellung dreidimensionaler Grafiken innerhalb von Java-Applikationen und -Applets. Nutzt je nach Plattform und Implementierung OpenGL oder Direct3D.
- AMD Mantle, eine vom Unternehmen AMD entwickelte Programmierschnittstelle für Grafikausgaben.
- Open Inventor, eine freie objektorientierte C++-Programmbibliothek zur Erstellung von 3D-Grafiken.
- OpenAL, eine plattformübergreifende 3D-Audio-API, die eine Art Audio-Erweiterung zu OpenGL darstellt und vom Aufbau, Programmierstil und Namenskonventionen an OpenGL angelehnt ist.
- Simple DirectMedia Layer (SDL), eine plattformübergreifende API für Grafik, Audio und Eingabegeräte inklusive OpenGL-spezifischer Funktionalität.
- Vulkan, Nachfolger von OpenGL.
Literatur
- Graham Sellers, Richard S. Wright und Nicholas Haemel: OpenGL Superbible: Comprehensive Tutorial and Reference. Addison-Wesley Longman, Amsterdam 2015, ISBN 978-0-672-33747-5.
- Lorenz Burggraf: Jetzt lerne ich OpenGL. Der einfache Einstieg in die Schnittstellenprogrammierung. Markt+Technik, München 2003, ISBN 3-8272-6237-2.
- Dave Shreiner, Graham Sellers, John Kessenich und Bill Licea-Kane: OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.3. Addison-Wesley Longman, Amsterdam 2013, ISBN 978-0-321-77303-6.
Weblinks
- www.OpenGL.org (englisch)
- SGI: OpenGL Homepage (englisch)
- DelphiGL – deutsche OpenGL-Community für viele Programmiersprachen (Schwerpunkt Delphi).
- DGL-Wiki – deutschsprachiges OpenGL-Nachschlagewerk
- TinyGL auf der Website von Fabrice Bellard (englisch)
- OpenGLsamples OpenGL codes (englisch)
Einzelnachweise
- ↑ a b Khronos Releases OpenGL 4.6 with SPIR-V Support. In: khronos.org. 31. Juli 2017, abgerufen am 7. August 2021 (englisch).
- ↑ SGI - Products: Software: OpenGL: Licensing and Logos. 2012, archiviert vom (nicht mehr online verfügbar) am 14. Januar 2012; abgerufen am 7. Februar 2022.
- ↑ History of OpenGL – OpenGL Wiki. Abgerufen am 2. März 2017 (englisch).
- ↑ OpenGL 3.1 Spezifikationen (PDF; 2,2 MB)
- ↑ opengl.org (PDF; 2,4 MB) OpenGL Core Specification with changes marked
- ↑ a b c d e f g h opengl.org
- ↑ Khronos Forums. Abgerufen am 29. August 2023 (englisch).
- ↑ Golem.de: IT-News für Profis. Abgerufen am 29. August 2023.
- ↑ on-demand.gputechconf.com (PDF; 7,1 MB)
- ↑ khronos.org (PDF; 1,2 MB)
- ↑ khronos.org (PDF; 5,4 MB)
- ↑ NVIDIA Releases "OpenGL 2015" + OpenGL ES 3.2 Linux Driver. Abgerufen am 29. August 2023 (englisch).
- ↑ OpenGL Driver Support. 19. August 2013, abgerufen am 29. August 2023 (englisch).
- ↑ NVIDIA announces OpenGL 2015 beta drivers for Windows and Linux. 10. August 2015, abgerufen am 29. August 2023 (englisch).
- ↑ on-demand.gputechconf.com
- ↑ NVIDIA OpenGL 4.6 in 2017. Abgerufen am 29. August 2023.
- ↑ Turing Extensions for Vulkan and OpenGL. 11. September 2018, abgerufen am 29. August 2023 (englisch).
- ↑ NVIDIA Developer. Abgerufen am 29. August 2023 (englisch).
- ↑ Bringing Unreal Engine 4 to OpenGL (PDF) Nvidia Developer. Abgerufen am 24. August 2014.
- ↑ Rich Geldreich: Richard Geldreich's Blog: Things that drive me nuts about OpenGL. In: Richard Geldreich's Blog. 11. Mai 2014, abgerufen am 29. August 2023.
- ↑ OpenGL Is Broken – The Burning Basis Vector. 30. Mai 2014, abgerufen am 29. August 2023 (amerikanisches Englisch).
- ↑ GTK+ OpenGL Extension
- ↑ Alfred Nischwitz, Max Fischer, Peter Haberacker: Computergrafik und Bildverarbeitung. 2. Auflage. Vieweg-Verlag, 2007, ISBN 978-3-8348-0186-9, S. 48.
- ↑ core.ac.uk (PDF)
- ↑ OpenGL Performance & Perf-Per-Watt From The Radeon HD 3850 Through R9 Fury Review. Abgerufen am 29. August 2023 (englisch).