DGL Wiki - Benutzerbeiträge [de]

Tutorial TexFilter

2012-04-08T03:52:40Z

Darkinsanity: Als Verb wird "Mipmapping" mit zwei P geschrieben

=Texturen-Feintuning=
==Einführung==

Hi,
eigentlich wollte ich ja nur ein Sample über Texture Compression schreiben. Als ich Phobeus davon erzählt habe, hat er mir nahegelgt, doch gleich ein ganzes Tutorial über Texture Filter, etc. zu schreiben. Ich hab mich dazu breitschlagen lassen*g*.
Es lässt sich nicht ganz umgehen, dass ich hier ein paar Basics zu den Tapeten wiederholen muss, aber ich denke das könnt ihr verkraften.

==Texturen filtern==

Filtern? Ein etwas ungewöhlicher Ausdruck für 3D Grafik. Kaffe kann man filtern, aber Texturen? Texturen sind gewöhnlich Quadrate oder Rechtecke. Wird ein Polygon, über das eine Textur geklebt ist, auf dem Bildschirm angezeigt, so entsprechen oft mehrere Texel einem Pixel(Minification) oder nur Teile eines Texels einem Pixel(Magnification):
[[Bild:Tutorial_TexFilter_magmin.gif|center]]

Für Beide Fälle stehen zwei Filtermethoden zur Verfügung:

'''GL_NEAREST'''
:Einem Pixel wird genau das Texel zugewiesen, dass dem Zentrum des Pixels am nächsten liegt. Dies führt häufig zu Bildschirmartefakten, ist aber die schnellere der beiden Varianten.
'''GL_LINEAR'''
:Dem Pixel wird der Durchschnitt eines 2x2 Arrays von Texeln, die dem Zentrum des Pixels am nächsten liegen, zugewiesen. Dies führt zu einem weicheren Ergebnis, ist aber auf den meisten OpenGL Geräten langsamer.

Wie wird nun aber ein Filter auf eine Textur angewendet? Nachdem eine Textur mit glBindTexture ausgewählt wurde, werden ihr mittels glTextParameteri die unterschiedlichen Filter zugewisen:

<source lang="pascal"> glBindTexture(GL_TEXTURE_2D, DemoTexture);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);</source>

Das Beispielt wählt für die DemoTextur den MAGnification Filter nearest und für den MINification Filter linear.

Filterergebnisse einer 8x8 Schachbrettextur(links: linear, rechts: nearest):
<div align="center">
{|{{Prettytable}}
|width="50%" |[[Bild:Tutorial_TexFilter_8x8checkerlinear.gif|center]]
|width="50%" |[[Bild:Tutorial_TexFilter_8x8checkernearest.gif|center]]
|-
|align="center" | GL_LINEAR
|align="center" | GL_NEAREST
|}
</div>

Filterergebnisse einer bunten Textur
<div align="center">
{|{{Prettytable}}
|width="33%" |[[Bild:Tutorial_TexFilter_colored.gif|center]]
|width="34%" |[[Bild:Tutorial_TexFilter_coloredlinear.gif|center]]
|width="33%" |[[Bild:Tutorial_TexFilter_colorednearest.gif|center]]
|-
|align="center" | Ausgangstextur
|align="center" | GL_LINEAR
|align="center" | GL_NEAREST
|}
</div>

==Mipmapping==

Mipmaps sind eine Art Level of Detail für Texturen. Die Seitenlänge der Originaltextur wird halbiert und dann als eigenes Bild im Speicher abgelegt. Das gleiche geschieht mit dem halbiertem Bild, bis nur noch eine Textur der größe 1x1 übrig bleibt. Wird nun eine Textur in großer Entfernung angezeigt, wird von der Textur eine kleinere Version gewählt, als wenn die Textur nur wenig Abstand zur Kamera hat. Dadurch kann die Bildqualität erheblich verbessert werden.

Zum erstellen der Mipmaps kommt in OpenGL meist gluBuild2DMipmaps zum Einsatz. Wird DevIL verwendet, hilft einem diese Funktion meist wenig(bei Texture Compression zeige ich wies trotzdem geht), besonders wenn Paletten zum Einsatz kommen. Hier gibt es die Funktion ilutGLBuildMipmaps. Beispielsweise ließen sich mit folgender Funktion Texturen laden:

<source lang="pascal">function LoadDevILTexture(Filename : String): TGLUInt;
var
id:TILInt;
begin
{$T-}
// Laden eines Texture in den Speicher
ilGenImages(1, @id);
ilBindImage(id);
ilLoadImage(PChar(Filename));

// Übergeben der Texture an OpenGL
Result := ilutGLBindMipmaps;
glBindTexture(GL_TEXTURE_2D, Result);
{Hier könnten die Filteroptionen stehen}

// Da OpenGL die Texture hat, können wir sie aus dem Speicher entfernen
ilDeleteImages(1, @Id);
{$T+}
end;</source>

Achtung:DevIL muss vor dem erstmaligem Aufruf noch initialisiert werden:

<source lang="pascal">ilInit;
ilutRenderer(IL_OPENGL);</source>

Nun stehen für den Minification Filter folgende neue Funktionen zur Verfügung: GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_NEAREST und GL_LINEAR_MIPMAP_LINEAR. Ergebnisse in genau dieser Reihenfolge, wobei der Magnification Filter bei allen auf nearest gesetzt ist:

<div align="center">
{|{{Prettytable}}
|width="50%" |[[Bild:Tutorial_TexFilter_nearestmipmapnearest.gif|center]]
|width="50%" |[[Bild:Tutorial_TexFilter_nearestmipmaplinear.gif|center]]
|-
|align="center" | GL_NEAREST_MIPMAP_NEAREST
|align="center" | GL_NEAREST_MIPMAP_LINEAR
|-
|
|
|-
|width="50%" |[[Bild:Tutorial_TexFilter_linearmipmapnearest.gif|center]]
|width="50%" |[[Bild:Tutorial_TexFilter_linearmipmaplinear.gif|center]]
|-
|align="center" | GL_LINEAR_MIPMAP_NEAREST
|align="center" | GL_LINEAR_MIPMAP_LINEAR
|}
</div>

==Texture Compression==

Hinter Texture Compression versteckt sich etwas sehr interessantes. Um Grafiken für das Web benutzen zu können, werden sie häufig komprimiert(z.B. JPEG), damit sie weniger Platz beanspruchen. Das Gleiche gibt es Unter OpenGl. Hier steht schließlich nicht unendlich viel Platz im Grafikkartenspeicher zur Verfügung. Wenn man also auch hier die Texturen komprimiert, dann kann man wesentlich mehr Texturen unterbringen. Nebenbei wird die Sache auch noch schneller, da beim Zugriff auf die Textur weniger Daten über den Bus laufen müssen. Möglich wird Texture Compression unter OpenGL durch eine Extension namens GL_ARB_TEXTURE_COMPRESSION. Um herauszufinden ob diese Extension vorliegt, müssen wir OpenGL12 anweisen, alle Extensions auszulesen:

<source lang="pascal">ClearExtensions;
ReadExtensions;</source>

Gewöhlich geschieht dies nach dem setzten des Pixelformats, etc. aber noch vor dem Laden irgendwelcher Texturen. Ist jetzt GL_ARB_texture_compression auf true gesetzt, können wir Texturkompression verwenden. Wenn an OpenGL die Texturdaten mittels glTexImage2D die Bilddaten übergeben werden, muss nun einfach als internalformat nicht GL_RGB angegeben werden, sondern GL_COMPRESSED_RGB_ARB. Klingt sehr simpel... Für DevIL müssen wir uns noch etwas spezielles einfallen lassen, denn wenn die Daten mithilfe einer Palette dargestellt werden bringen sie wenig. Sie müssen vorher konvertiert werden:

<source lang="pascal"> function LoadDevILTextureCompressed(Filename : String): TGLUInt;
var
id:TILInt;
imageInfo : TILInfo;
Data : PILUByte;
compressed : Integer;
begin
if not GL_ARB_texture_compression then
LoadDevILTexture(Filename);
{$T-}
// Laden einer Texture in den Speicher
ilGenImages(1, @id);
ilBindImage(id);
ilLoadImage(PChar(Filename)); // Loads into the current bound image

//Wir brauchen das Bild als IL_RGB oder IL_RGBA
ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);

// Übergeben der Texture an OpenGL
iluGetImageInfo(@ImageInfo);
Data := ilGetData();

glGenTextures(1, @Result);
glBindTexture(GL_TEXTURE_2D, Result);

//einfache textur
glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_ARB,
ImageInfo.Width, ImageInfo.Height, 0,
GL_RGB, GL_UNSIGNED_BYTE, Data);
//oder für mipmaps:
//gluBuild2DMipmaps(GL_TEXTURE_2D,
// GL_COMPRESSED_RGB_ARB,
// ImageInfo.Width, ImageInfo.Height,
// GL_RGBA, GL_UNSIGNED_BYTE, Data);

glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_ARB, @compressed);
if compressed <> 1 then
MessageDlg('Texture wurde nicht komprimiert', mtError, [mbOk], 0);

{Filteroptionen}

ilDeleteImages(1, @Id);
{$T+}
end;</source>

IL_RGB und GL_RGB können bei bedarf durch IL_RGBA und GL_RGBA ausgetauscht werden. Werden Mipmaps benötigt, so muss einfach vor gluBuild2DMipmaps die Kommentare gelöscht werden. Dem geübten Auge werden sicherlich die komprimierten Schmankerl auffallen, bewegt sich aber die Szenerie sehr schnell, wird es niemandem mehr auffallen:
[[Bild:Tutorial_TexFilter_compressed.gif|center]]

Euer
:'''Delphic'''

[[Kategorie:Tutorial|TexturFiltering]]

{{TUTORIAL_NAVIGATION|[[Tutorial Objektselektion]]| [[Tutorial Kamera1]]}}

Konvex

2012-04-05T20:16:58Z

Darkinsanity: Ergänzung der Definition konvex/konkav

= konvexe und konkave Polygone =

== Unterschiede ==

Konvexe und konkave Polygone unterscheiden sich in einem essenziell wichtigen Punkt. Wenn man eine Linie zwischen einem Eckpunkt und dessen übernächsten Nachbarn zieht, liegen bei konvexen Polygonen der übersprungene Eckpunkt immer außerhalb des "neuen" Polygons. Zieht man eine solche Linie für alle Eckpunkte eines Polygons und liegt mindestens ein übersprungener Punkt im "neuen" Polygon, so ist das Polygon konkav.
Wenn der übersprungene Eckpunkt '''auf''' der neu entstandenen Kante liegt, gilt das Polygone auch dann als konvex.

Eine andere einfache Unterscheidungsregel ist die folgende: Betrachtet man an jedem Eckpunkt des Polygons den Innenwinkel, so beträgt dieser bei konvexen Polygonen maximal 180°. Ist auch nur ein Innenwinkel des Polygons größer als 180°, so ist das Polygon konkav.

== Skizze ==

===Konvex===

[[Bild:Konvex normal.png|framed|center|Ein konvexes Polygon]]

===Konkav===
{|width="100%"
|[[Bild:Konvex konvex.png|framed|right|Der markierte Eckpunkt macht das Polygon konkav.]]
|[[Bild:Konvex konvex2.png|framed|left|Wird er übersprungen, liegt er im neu entstandenen Polygon.]]
|}

===Bedeutung===
Die Klassifizierung von Polygonen ist z.B. bei der [[Tesselierung]] von Bedeutung.

Auch die standard OpenGL Zeichenroutine (basierend auf [[glBegin]]) zeichnet ausschließlich konvexe Polygone richtig. Die falsche Darstellung äußert sich meist darin, dass eine zusätzliche Kante vom letzten Punkt zum ersten Punkt des Polygons gezogen wird.

Konvex

2012-04-05T20:12:59Z

Darkinsanity: /* Unterschiede */ Definition für konkave Polygone war nicht korrekt

= konvexe und konkave Polygone =

== Unterschiede ==

Konvexe und konkave Polygone unterscheiden sich in einem essenziell wichtigen Punkt. Wenn man eine Linie zwischen einem Eckpunkt und dessen übernächsten Nachbarn zieht, liegen bei konvexen Polygonen der übersprungene Eckpunkt immer außerhalb des "neuen" Polygons. Zieht man eine solche Linie für alle Eckpunkte eines Polygons und liegt mindestens ein übersprungener Punkt im "neuen" Polygon, so ist das Polygon konkav.

Wenn der übersprungene Eckpunkt '''auf''' der neu entstandenen Kante liegt, gilt das Polygone auch dann als konvex.

== Skizze ==

===Konvex===

[[Bild:Konvex normal.png|framed|center|Ein konvexes Polygon]]

===Konkav===
{|width="100%"
|[[Bild:Konvex konvex.png|framed|right|Der markierte Eckpunkt macht das Polygon konkav.]]
|[[Bild:Konvex konvex2.png|framed|left|Wird er übersprungen, liegt er im neu entstandenen Polygon.]]
|}

===Bedeutung===
Die Klassifizierung von Polygonen ist z.B. bei der [[Tesselierung]] von Bedeutung.

Auch die standard OpenGL Zeichenroutine (basierend auf [[glBegin]]) zeichnet ausschließlich konvexe Polygone richtig. Die falsche Darstellung äußert sich meist darin, dass eine zusätzliche Kante vom letzten Punkt zum ersten Punkt des Polygons gezogen wird.

wglSwapIntervalEXT

2012-01-03T21:32:14Z

Darkinsanity: Die Seite wurde neu angelegt: „= wglSwapIntervalEXT = == Name == '''wglSwapIntervalEXT''' - Setzt ein minimales Intervall für Buffer-Swaps. == Delphi-Spezifikation == function '''wglSwapI…“

= wglSwapIntervalEXT =

== Name ==
'''wglSwapIntervalEXT''' - Setzt ein minimales Intervall für Buffer-Swaps.

== Delphi-Spezifikation ==
function '''wglSwapIntervalEXT'''(''interval'': PGLint): PGLboolean;

== Parameter ==

{| border="1" rules="all"
! ''interval''
| Die Mindestanzahl der Refreshes, die bei einem Buffer-Swap gewartet werden soll.
|}

== Beschreibung ==
'''wglSwapIntervalEXT''' setzt die Mindestanzahl der Refreshes, die beim nächsten Buffer-Swap, ausgelöst durch [[SwapBuffers]], abgewartet werden sollen.
Durch die Angabe eins Intervalls, welches größer als Null ist, werden die Buffer-Swaps mit den Refreshes synchronisiert. Dieses erwünschte Verhalten wird als Vsync bezeichnet. Ist das angegebene Invervall höher als das von der Implementation maximal erlaubte Intervall, wird es ohne weiteres Feedback auf den nächstgelegenen unterstützten Wert gesetzt.
Wird ein Intervall von Null angegeben, werden die Buffer-Swaps nicht synchronisiert, d.h. Vsync ist ausgeschaltet.
Die Funktion liefert TRUE zurück, wenn der Vorgang erfolgreich war, andernfalls liefert sie FALSE zurück.

== Beispiel ==
Vsync einschalten:
wglSwapIntervalEXT(1);

Vsync ausschalten:
wglSwapIntervalEXT(0);

== Hinweise ==
Die Funktion '''wglSwapIntervalEXT''' ist Teil der '''WGL_EXT_swap_control'''-Extension und kein Bestandteil der [[WGL]]-Kernbefehle. Falls in der durch die Funktion [[wglGetExtensionsStringARB]] zurückgegebenen Zeichenkette '''WGL_EXT_swap_control''' enthalten ist, dann wird die Extension '''WGL_EXT_swap_control''' unterstützt.

== Fehlermeldungen ==
'''ERROR_INVALID_DATA''' wird generiert, wenn ''Intervall'' kleiner als Null ist.

'''ERROR_DC_NOT_FOUND''' wird generiert, wenn der Device-Kontext für den aufrufenden Thread nicht gefunden werden konnte.

== Siehe auch ==

[[Kategorie:WGL]]

glXSwapIntervalEXT

2012-01-03T21:26:31Z

Darkinsanity:

= glXSwapIntervalEXT =

== Name ==
'''glXSwapIntervalEXT''' - Setzt ein minimales Intervall für Buffer-Swaps.

== Delphi-Spezifikation ==
procedure '''glXSwapIntervalEXT'''(''dpy'': PDisplay; ''drawable'': GLXDrawable; ''interval'': PGLint);

== Parameter ==

{| border="1" rules="all"
! ''dpy''
| Gibt die Verbindung zum X-Server an
|-
! ''drawable''
| WRITE ME
|-
! ''interval''
| Die Mindestanzahl der Refreshes, die bei einem Buffer-Swap gewartet werden soll.
|}

== Beschreibung ==
'''glXSwapIntervalEXT''' setzt die Mindestanzahl der Refreshes, die beim nächsten Buffer-Swap, ausgelöst durch [[glXSwapBuffers]], abgewartet werden sollen.
Durch die Angabe eins Intervalls, welches größer als Null ist, werden die Buffer-Swaps mit den Refreshes synchronisiert. Dieses erwünschte Verhalten wird als Vsync bezeichnet. Ist das angegebene Invervall höher als das von der Implementation maximal erlaubte Intervall, wird es ohne weiteres Feedback auf den nächstgelegenen unterstützten Wert gesetzt.
Wird ein Intervall von Null angegeben, werden die Buffer-Swaps nicht synchronisiert, d.h. Vsync ist ausgeschaltet.

== Beispiel ==
Vsync einschalten:
glXSwapIntervalEXT(dpy, glXGetCurrentDrawable(), 1);

Vsync ausschalten:
glXSwapIntervalEXT(dpy, glXGetCurrentDrawable(), 0);

== Hinweise ==
Die Funktion '''glXSwapIntervalEXT''' ist Teil der '''GLX_EXT_swap_control'''-Extension und kein Bestandteil der [[GLX]]-Kernbefehle. Falls in der durch die Funktion [[glXQueryExtensionsString]] zurückgegebenen Zeichenkette '''GLX_EXT_swap_control''' enthalten ist, dann wird die Extension '''GLX_EXT_swap_control''' unterstützt.

== Fehlermeldungen ==
'''GLXBadValue''' wird generiert, wenn ''Intervall'' kleiner als Null ist.

'''GLXBadWindow''' wird generiert, wenn es sich bei ''drawable'' nicht um ein gültiges GLXDrawable-Objekt handelt.

== Siehe auch ==
[[glXCreateContext]], [[glXQueryVersion]], [[glXQueryExtensionsString]]

[[Kategorie:GLX]]

glXSwapIntervalEXT

2012-01-03T21:21:42Z

Darkinsanity: /* Name */

= glXSwapIntervalEXT =

== Name ==
'''glXSwapIntervalEXT''' - Setzt ein minimales Intervall für Buffer-Swaps.

== Delphi-Spezifikation ==
procedure '''glXSwapIntervalEXT'''(''dpy'': PDisplay; ''drawable'': GLXDrawable; ''interval'': PGLint);

== Parameter ==

{| border="1" rules="all"
! ''dpy''
| Gibt die Verbindung zum X-Server an
|-
! ''drawable''
| WRITE ME
|-
! ''interval''
| Die Mindestanzahl der Refreshes, die bei einem Buffer-Swap gewartet werden soll.
|}

== Beschreibung ==
'''glXSwapIntervalEXT''' setzt die Mindestanzahl der Refreshes, die beim nächsten Buffer-Swap, ausgelöst durch [[glXSwapBuffers]], abgewartet werden sollen.
Durch die Angabe eins Intervalls, welches größer als Null ist, werden die Buffer-Swaps mit den Refreshes synchronisiert. Dieses erwünschte Verhalten wird als Vsync bezeichnet. Ist das angegebene Invervall höher als das von der Implementation maximal erlaubte Intervall, wird es ohne weiteres Feedback auf den nächstgelegenen unterstützten Wert gesetzt.
Wird ein Intervall von Null angegeben, werden die Buffer-Swaps nicht synchronisiert, d.h. Vsync ist ausgeschaltet.

== Beispiel ==
Vsync einschalten:
glXSwapIntervalEXT(dpy, glXGetCurrentDrawable(), 1);

Vsync ausschalten:
glXSwapIntervalEXT(dpy, glXGetCurrentDrawable(), 0);

== Hinweise ==
Die Funktion '''glXSwapIntervalEXT''' ist Teil der '''EXT_swap_control'''-Extension und kein Bestandteil der [[GLX]]-Kernbefehle. Falls in der durch die Funktion [[glXQueryExtensionsString]] zurückgegebenen Zeichenkette '''EXT_swap_control''' enthalten ist, dann wird die Extension '''EXT_swap_control''' unterstützt.

== Fehlermeldungen ==
'''GLXBadValue''' wird generiert, wenn ''Intervall'' kleiner als Null ist.

'''GLXBadWindow''' wird generiert, wenn es sich bei ''drawable'' nicht um ein gültiges GLXDrawable-Objekt handelt.

== Siehe auch ==
[[glXCreateContext]], [[glXQueryVersion]], [[glXQueryExtensionsString]]

[[Kategorie:GLX]]

glXSwapIntervalEXT

2012-01-03T21:21:08Z

Darkinsanity: /* Beispiel */ kleiner Fehler

= glXSwapIntervalEXT =

== Name ==
'''glXSwapIntervalEXT''' - Setzt ein minimales Intervall für swaps.

== Delphi-Spezifikation ==
procedure '''glXSwapIntervalEXT'''(''dpy'': PDisplay; ''drawable'': GLXDrawable; ''interval'': PGLint);

== Parameter ==

{| border="1" rules="all"
! ''dpy''
| Gibt die Verbindung zum X-Server an
|-
! ''drawable''
| WRITE ME
|-
! ''interval''
| Die Mindestanzahl der Refreshes, die bei einem Buffer-Swap gewartet werden soll.
|}

== Beschreibung ==
'''glXSwapIntervalEXT''' setzt die Mindestanzahl der Refreshes, die beim nächsten Buffer-Swap, ausgelöst durch [[glXSwapBuffers]], abgewartet werden sollen.
Durch die Angabe eins Intervalls, welches größer als Null ist, werden die Buffer-Swaps mit den Refreshes synchronisiert. Dieses erwünschte Verhalten wird als Vsync bezeichnet. Ist das angegebene Invervall höher als das von der Implementation maximal erlaubte Intervall, wird es ohne weiteres Feedback auf den nächstgelegenen unterstützten Wert gesetzt.
Wird ein Intervall von Null angegeben, werden die Buffer-Swaps nicht synchronisiert, d.h. Vsync ist ausgeschaltet.

== Beispiel ==
Vsync einschalten:
glXSwapIntervalEXT(dpy, glXGetCurrentDrawable(), 1);

Vsync ausschalten:
glXSwapIntervalEXT(dpy, glXGetCurrentDrawable(), 0);

== Hinweise ==
Die Funktion '''glXSwapIntervalEXT''' ist Teil der '''EXT_swap_control'''-Extension und kein Bestandteil der [[GLX]]-Kernbefehle. Falls in der durch die Funktion [[glXQueryExtensionsString]] zurückgegebenen Zeichenkette '''EXT_swap_control''' enthalten ist, dann wird die Extension '''EXT_swap_control''' unterstützt.

== Fehlermeldungen ==
'''GLXBadValue''' wird generiert, wenn ''Intervall'' kleiner als Null ist.

'''GLXBadWindow''' wird generiert, wenn es sich bei ''drawable'' nicht um ein gültiges GLXDrawable-Objekt handelt.

== Siehe auch ==
[[glXCreateContext]], [[glXQueryVersion]], [[glXQueryExtensionsString]]

[[Kategorie:GLX]]

glXSwapIntervalEXT

2012-01-03T21:20:48Z

Darkinsanity: Die Seite wurde neu angelegt: „= glXSwapIntervalEXT = == Name == '''glXSwapIntervalEXT''' - Setzt ein minimales Intervall für swaps. == Delphi-Spezifikation == procedure '''glXSwapInter…“

= glXSwapIntervalEXT =

== Name ==
'''glXSwapIntervalEXT''' - Setzt ein minimales Intervall für swaps.

== Delphi-Spezifikation ==
procedure '''glXSwapIntervalEXT'''(''dpy'': PDisplay; ''drawable'': GLXDrawable; ''interval'': PGLint);

== Parameter ==

{| border="1" rules="all"
! ''dpy''
| Gibt die Verbindung zum X-Server an
|-
! ''drawable''
| WRITE ME
|-
! ''interval''
| Die Mindestanzahl der Refreshes, die bei einem Buffer-Swap gewartet werden soll.
|}

== Beschreibung ==
'''glXSwapIntervalEXT''' setzt die Mindestanzahl der Refreshes, die beim nächsten Buffer-Swap, ausgelöst durch [[glXSwapBuffers]], abgewartet werden sollen.
Durch die Angabe eins Intervalls, welches größer als Null ist, werden die Buffer-Swaps mit den Refreshes synchronisiert. Dieses erwünschte Verhalten wird als Vsync bezeichnet. Ist das angegebene Invervall höher als das von der Implementation maximal erlaubte Intervall, wird es ohne weiteres Feedback auf den nächstgelegenen unterstützten Wert gesetzt.
Wird ein Intervall von Null angegeben, werden die Buffer-Swaps nicht synchronisiert, d.h. Vsync ist ausgeschaltet.

== Beispiel ==
Vsync einschalten:
glXSwapIntervalEXT(dpy, glXGetCurrentDrawable(), 1);

Vsync ausschalten:
glXSwapIntervalEXT(dpy, glXGetCurrentDrawable(), 1);

== Hinweise ==
Die Funktion '''glXSwapIntervalEXT''' ist Teil der '''EXT_swap_control'''-Extension und kein Bestandteil der [[GLX]]-Kernbefehle. Falls in der durch die Funktion [[glXQueryExtensionsString]] zurückgegebenen Zeichenkette '''EXT_swap_control''' enthalten ist, dann wird die Extension '''EXT_swap_control''' unterstützt.

== Fehlermeldungen ==
'''GLXBadValue''' wird generiert, wenn ''Intervall'' kleiner als Null ist.

'''GLXBadWindow''' wird generiert, wenn es sich bei ''drawable'' nicht um ein gültiges GLXDrawable-Objekt handelt.

== Siehe auch ==
[[glXCreateContext]], [[glXQueryVersion]], [[glXQueryExtensionsString]]

[[Kategorie:GLX]]

glDeleteQueries

2012-01-03T20:59:28Z

Darkinsanity: /* Delphi-Spezifikation */ Semikolon

= glDeleteQueries =

== Name ==
'''glDeleteQueries''' - Löscht [[Occlusion Query]]-Objekte.

== Delphi-Spezifikation ==
procedure '''glDeleteQueries'''(''n'': GLsizei; ''ids'': PGLuint);

== Parameter ==

{| border="1" rules="all"
! ''n''
| Anzahl der Query-Objektnamen, die gelöscht werden sollen.
|-
! ''ids''
| Zeiger auf ein Array, welches mit den zu löschenden Query-Objektnamen gefüllt ist.
|}

== Beschreibung ==
'''glDeleteQueries''' versucht alle Occlusion-Query-Objekte zu löschen, die im ''n''-elementigen Feld ''ids'' definiert wurden.

Nachdem ein Query-Objekt gelöscht wurde, ist dessen Name unbenutzt und kann zur Erzeugung neuer Query-Objekte verwendet werden.

Unbenutzte Namen im Feld ''ids'' werden beim Löschen ignoriert.

== Hinweise ==
'''glDeleteQueries''' ist erst ab OpenGL 1.5 oder höher verfügbar.

== Fehlermeldungen ==
'''GL_INVALID_OPERATION''' wird generiert, wenn '''glDeleteQueries''' innerhalb eines [[glBegin]]-[[glEnd]]-Blocks aufgerufen wurde.

'''GL_INVALID_OPERATION''' wird generiert, falls eine beliebige Query aktiv ist (d.h. Query wurde mit [[glBeginQuery]] gestartet, aber noch nicht mit [[glEndQuery]] beendet).

'''GL_INVALID_VALUE''' wird generiert, falls ''n'' negativ ist.

== Zugehörige Wertrückgaben ==
[[glGetQuery]] mit Token '''GL_CURRENT_QUERY''' gibt die momentan aktive Query-ID zurück.

[[glGetQuery]] mit Token '''GL_QUERY_COUNTER_BITS''' gibt die Anzahl der Bits des Occlusion-Query-Zählers zurück.

== Siehe auch ==
[[glBeginQuery]], [[glEndQuery]], [[glGenQueries]], [[glGetQuery]], [[glGetQueryObject]], [[glIsQuery]],

[[Kategorie:GL|DeleteQueries]]
[[Kategorie:GL1.5|DeleteQueries]]
[[Kategorie:GL3]]

OpenGL-Funktionsübersicht

2011-12-18T21:00:48Z

Darkinsanity: glXSwapInterval ergänzt

[[Bild:Opengl_logo.png|right|200px]]
== Hinweise für Helfer ==

=== Was hier hinein gehört ===

Um eine Funktionsübersicht aller OpenGL Funktionen zu erreichen die inhaltlich korrekt ist, sollten die [http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz orginal Spezifikationen] von OpenGL.org übersetzt werden([[Link#OpenGL_Funktionen|Alternative Quellen]]).

Allerdings sind hier auch glu-/wgl- und glx-Funktionen erlaubt. Konstanten bitte nicht hier im Inhaltsverzeichnis einfügen, genausowenig wie [[OpenGL-Extensions]].

Die Funktionen sind bereits nach Gruppen sortiert (GL/GLU/etc.). Sollten Funktionen noch nicht in der Übersicht auftauchen, welche aber definitiv existieren, können diese nachgetragen werden. Funktionen die es in verschiedenen Ausprägungen gibt, werden ohne Parameterangabe eingetragen (also glVertex statt glVertex3f).

Bitte haltet euch bei der Formatierung der Befehlsbeschreibung an die [[Funktionsvorlage]] (ich führe hier mal glBegin als Beispiel an), und erklärt nicht mehr als nötig.
Wenn ihr also einen Befehl habt der etwas mit VertexArrays zu tun hat, dann gehört dort '''nicht''' hinein was ein VertexArray ist oder bringt. Das gehört dann nach [[Techniken und Algorithmen]] oder [[Hintergrundwissen]] (je nach Thematik) und sollte dann in der Funktionsbeschreibung als ''interner Link'' untergebracht werden.

'''Zu aller erst sollte die Orginalspezifikation übersetzt werden''' und erst dann eigene Hinweise untergebracht werden (z.B. Erfahrungen, typische Fehler etc.)

===Artikel-Vorlage===
'''Wichtiger Hinweis ''' : Bei der Funktionsübersicht ist v.a. eine einheitliche Gliederung der Artikel wichtig. Deshalb haltet euch bitte an '''[[Funktionsvorlage|folgende Vorlage]]'''!

===Kategorisieren von Artikeln===
Das Wiki ermöglicht es einen Artikel einer Kategorie zuzuordnen. Diese Möglichkeit sollte von Artikelschreibern genutzt werden.
Man ordnet einen Artikel einer Kategorie zu, in dem man '''am Ende des Artikels einen Link zu der Kategrie erstellt''' der er zugeordnet werden soll:

{| border="1" cellspacing="0"
|+Beispiel
|
{| border="0" cellspacing="4"
|<nowiki>[[Kategorie:GL|Name ohne "gl"]]</nowiki>
|}
|}

Das sind die neuen Kategorien:
*[[:Kategorie:GL]]
*[[:Kategorie:GLU]]
*[[:Kategorie:GLX]]
*[[:Kategorie:WGL]]

Falls die Funktion bereits zum GL-Kern gehört kommt noch folgender Eintrag hinzu: <nowiki>[[Kategorie:GLx.x]]</nowiki> wobei das x.x durch die GL-Versionsnummer (z.B. "1.2" oder "2.0"), seit dem die Funktion dabei ist, ersetzt wird.

== [[:Kategorie:GL|GL]] ==
Abkürzung für '''G'''raphics '''L'''ibrary, hierunter fallen alle Funktionen die direkter Bestandteil (entweder als Kernfunktion oder über Extensions) der OpenGL sind.
Hartnäckige Gerüchte, '''GL''' stünde für Glide und somit OpenGL für Open Glide, sind schlichtweg falsch, erfreuen sich jedoch immernoch großer Beliebtheit.

=== Versionsspezifische Listen ===
Hier findet ihre Listen von Funktionen die in einer bestimmten OpenGL Version verfügbar sind. Wenn ihr also z.B. ein Programm für OpenGL3.0 schreiben wollt, dürft ihr nur die Funktionen verwenden, die in der 3.0-Liste enthalten sind.

*[[OpenGL2.1-Funktionsübersicht]]
*[[OpenGL3-Funktionsübersicht]]
*[[OpenGL4-Funktionsübersicht]]

=== A ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glAccum]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glActiveStencilFaceEXT]]''' || - || - || [[glActiveStencilFaceEXT]] || -
|-
|'''[[glActiveTexture]]''' || {{Version_1_3}} || [[glActiveTextureARB]]{{altIcon}} || - || -
|-
|'''[[glAddSwapHintRectWIN]]''' || - || - || - || [[glAddSwapHintRectWIN]]
|-
|'''[[glAlphaFunc]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glApplyTextureEXT]]''' || - || - || [[glApplyTextureEXT]] || -
|-
|'''[[glAreTexturesResident]]''' || {{Version_1_1}} || - || [[glAreTexturesResidentEXT]]{{altIcon}} || -
|-
|'''[[glArrayElement]]''' || {{Version_1_1}} || - || [[glArrayElementEXT]]{{altIcon}} || -
|-
|'''[[glAttachShader]]''' || {{Version_2_0}} || [[glAttachObjectARB]]{{altIcon}} || - || -
|-
|}

=== B ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glBegin]]'''{{excIcon}} || {{Version_1_0}} || - || - || -
|-
|'''[[glBeginConditionalRender]]''' || {{Version_3_0}} || - || - || [[glBeginConditionalRenderNV]]{{altIcon}}
|-
|'''[[glBeginQuery]]''' || {{Version_1_5}} || [[glBeginQueryARB]]{{altIcon}} || - || -
|-
|'''[[glBeginSceneEXT]]''' || - || - || [[glBeginSceneEXT]] || -
|-
|'''[[glBeginTransformFeedback]]''' || {{Version_3_0}} || - || [[glBeginTransformFeedbackEXT]]{{altIcon}} || [[glBeginTransformFeedbackNV]]{{altIcon}}
|-
|'''[[glBeginVertexShaderEXT]]''' || - || - || [[glBeginVertexShaderEXT]] || -
|-
|'''[[glBindAttribLocation]]''' || {{Version_2_0}} || [[glBindAttribLocationARB]]{{altIcon}} || - || -
|-
|'''[[glBindBuffer]]''' || {{Version_1_5}} || [[glBindBufferARB]]{{altIcon}} || - || -
|-
|'''[[glBindBufferBase]]''' || {{Version_3_0}} || - || [[glBindBufferBaseEXT]]{{altIcon}} || [[glBindBufferBaseNV]]{{altIcon}}
|-
|'''[[glBindBufferOffsetEXT]]''' || - || - || [[glBindBufferOffsetEXT]] || [[glBindBufferOffsetNV]]{{altIcon}}
|-
|'''[[glBindBufferRange]]''' || {{Version_3_0}} || - || [[glBindBufferRangeEXT]]{{altIcon}} || [[glBindBufferRangeNV]]{{altIcon}}
|-
|'''[[glBindFragDataLocation]]''' || {{Version_3_0}} || - || [[glBindFragDataLocationEXT]]{{altIcon}} || -
|-
|'''[[glBindFragDataLocationIndexed]]''' || {{Version_3_0}} || - || - || -
|-
|'''[[glBindFramebuffer]]''' || {{Version_3_0}} || - || [[glBindFramebufferEXT]]{{altIcon}} || -
|-
|'''[[glBindLightParameterEXT]]''' || - || - || [[glBindLightParameterEXT]] || -
|-
|'''[[glBindMaterialParameterEXT]]''' || - || - || [[glBindMaterialParameterEXT]] || -
|-
|'''[[glBindMultiTextureEXT]]''' || - || - || [[glBindMultiTextureEXT]] || -
|-
|'''[[glBindParameterEXT]]''' || - || - || [[glBindParameterEXT]] || -
|-
|'''[[glBindProgramARB]]''' || - || [[glBindProgramARB]] || - || [[glBindProgramNV]]{{altIcon}}
|-
|'''[[glBindRenderbuffer]]''' || {{Version_3_0}} || - || [[glBindRenderbufferEXT]]{{altIcon}} || -
|-
|'''[[glBindSampler]]''' || {{Version_3_3}} || - || - || -
|-
|'''[[glBindTexGenParameterEXT]]''' || - || - || [[glBindTexGenParameterEXT]] || -
|-
|'''[[glBindTexture]]''' || {{Version_1_1}} || - || [[glBindTextureEXT]]{{altIcon}} || -
|-
|'''[[glBindTextureUnitParameterEXT]]''' || - || - || [[glBindTextureUnitParameterEXT]] || -
|-
|'''[[glBindVertexArray]]''' || {{Version_3_0}} || - || - || [[glBindVertexArrayAPPLE]]{{altIcon}}
|-
|'''[[glBindVertexShaderEXT]]''' || - || - || [[glBindVertexShaderEXT]] || -
|-
|'''[[glBinormalPointerEXT]]''' || - || - || [[glBinormalPointerEXT]] || -
|-
|'''[[glBitmap]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glBlendColor]]''' || {{Version_1_2}} || - || [[glBlendColorEXT]]{{altIcon}} || -
|-
|'''[[glBlendEquation]]''' || {{Version_1_2}} || - || [[glBlendEquationEXT]]{{altIcon}} || -
|-
|'''[[glBlendEquationSeparate]]''' || {{Version_2_0}} || - || [[glBlendEquationSeparateEXT]]{{altIcon}} || -
|-
|'''[[glBlendFunc]]'''{{excIcon}} || {{Version_1_0}} || - || - || -
|-
|'''[[glBlendFuncSeparate]]''' || {{Version_1_4}} || - || [[glBlendFuncSeparateEXT]]{{altIcon}} || -
|-
|'''[[glBlitFramebuffer]]''' || {{Version_3_0}} || - || [[glBlitFramebufferEXT]]{{altIcon}} || -
|-
|'''[[glBufferData]]''' || {{Version_1_5}} || [[glBufferDataARB]]{{altIcon}} || - || -
|-
|'''[[glBufferRegionEnabledEXT]]''' || - || - || [[glBufferRegionEnabledEXT]] || -
|-
|'''[[glBufferSubData]]''' || {{Version_1_5}} || [[glBufferSubDataARB]]{{altIcon}} || - || -
|-
|}

=== C ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glCallList]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glCallLists]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glCheckFramebufferStatus]]''' || {{Version_3_0}} || - || [[glCheckFramebufferStatusEXT]]{{altIcon}} || -
|-
|'''[[glCheckNamedFramebufferStatusEXT]]''' || - || - || [[glCheckNamedFramebufferStatusEXT]] || -
|-
|'''[[glClampColor]]''' || {{Version_3_0}} || [[glClampColorARB]]{{altIcon}} || - || -
|-
|'''[[glClear]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glClearAccum]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glClearBuffer]]''' || {{Version_3_0}} || - || - || -
|-
|'''[[glClearColor]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glClearDepth]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glClearIndex]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glClearStencil]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glClientActiveTexture]]''' || {{Version_1_3}} || [[glClientActiveTextureARB]]{{altIcon}} || - || -
|-
|'''[[glClientAttribDefaultEXT]]''' || - || - || [[glClientAttribDefaultEXT]] || -
|-
|'''[[glClientWaitSync]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glClipPlane]]'''{{excIcon}} || {{Version_1_0}} || - || - || -
|-
|'''[[glColor]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glColorMask]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glColorMaskIndexedEXT]]''' || - || - || [[glColorMaskIndexedEXT]] || -
|-
|'''[[glColorMaterial]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glColorPointer]]''' || {{Version_1_1}} || - || [[glColorPointerEXT]]{{altIcon}} || [[glColorPointerINTEL]]{{altIcon}}
|-
|'''[[glColorSubTable]]''' || {{Version_1_2}} || - || [[glColorSubTableEXT]]{{altIcon}} || -
|-
|'''[[glColorTable]]''' || {{Version_1_2}} || - || [[glColorTableEXT]]{{altIcon}} || [[glColorTableSGI]]{{altIcon}}
|-
|'''[[glColorTableParameter]]''' || {{Version_1_2}}|| - || - || [[glColorTableParameterSGI]]{{altIcon}}
|-
|'''[[glCompileShader]]''' || {{Version_2_0}} || [[glCompileShaderARB]]{{altIcon}} || - || -
|-
|'''[[glCompressedMultiTexImageEXT]]''' || - || - || [[glCompressedMultiTexImageEXT]] || -
|-
|'''[[glCompressedMultiTexSubImageEXT]]''' || - || - || [[glCompressedMultiTexSubImageEXT]] || -
|-
|'''[[glCompressedTexImage]]''' || {{Version_1_3}} || [[glCompressedTexImageARB]]{{altIcon}} || - || -
|-
|'''[[glCompressedTexSubImage]]''' || {{Version_1_3}} || [[glCompressedTexSubImageARB]]{{altIcon}} || - || -
|-
|'''[[glCompressedTextureImageEXT]]''' || - || - || [[glCompressedTextureImageEXT]] || -
|-
|'''[[glCompressedTextureSubImageEXT]]''' || - || - || [[glCompressedTextureSubImageEXT]] || -
|-
|'''[[glConvolutionFilter1D]]''' || {{Version_1_2}} || - || [[glConvolutionFilter1DEXT]]{{altIcon}} || -
|-
|'''[[glConvolutionFilter2D]]''' || {{Version_1_2}} || - || [[glConvolutionFilter2DEXT]]{{altIcon}} || -
|-
|'''[[glConvolutionParameter]]''' || {{Version_1_2}} || - || [[glConvolutionParameterEXT]]{{altIcon}} || -
|-
|'''[[glCopyBufferSubData]]''' || {{Version_3_1}} || - || - || -
|-
|'''[[glCopyColorSubTable]]''' || {{Version_1_2}} || - || [[glCopyColorSubTableEXT]] || -
|-
|'''[[glCopyColorTable]]''' || {{Version_1_2}} || - || - || [[glCopyColorTableSGI]]{{altIcon}}
|-
|'''[[glCopyConvolutionFilter]]''' || {{Version_1_2}} || - || [[glCopyConvolutionFilterEXT]]{{altIcon}} || -
|-
|'''[[glCopyMultiTexImageEXT]]''' || - || - || [[glCopyMultiTexImageEXT]] || -
|-
|'''[[glCopyMultiTexSubImageEXT]]''' || - || - || [[glCopyMultiTexSubImageEXT]] || -
|-
|'''[[glCopyPixels]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glCopyTexImage1D]]''' || {{Version_1_1}} || - || [[glCopyTexImage1DEXT]]{{altIcon}} || -
|-
|'''[[glCopyTexImage2D]]''' || {{Version_1_1}} || - || [[glCopyTexImage2DEXT]]{{altIcon}} || -
|-
|'''[[glCopyTexSubImage1D]]''' || {{Version_1_1}} || - || [[glCopyTexSubImage1DEXT]]{{altIcon}} || -
|-
|'''[[glCopyTexSubImage2D]]''' || {{Version_1_1}} || - || [[glCopyTexSubImage2DEXT]]{{altIcon}} || -
|-
|'''[[glCopyTexSubImage3D]]''' || {{Version_1_2}} || - || [[glCopyTexSubImage3DEXT]]{{altIcon}} || -
|-
|'''[[glCopyTextureImageEXT]]''' || - || - || [[glCopyTextureImageEXT]] || -
|-
|'''[[glCopyTextureSubImageEXT]]''' || - || - || [[glCopyTextureSubImageEXT]] || -
|-
|'''[[glCreateProgram]]''' || {{Version_2_0}} || [[glCreateProgramObjectARB]]{{altIcon}} || - || -
|-
|'''[[glCreateShader]]''' || {{Version_2_0}} || [[glCreateShaderObjectARB]]{{altIcon}} || - || -
|-
|'''[[glCullFace]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glCullParameterEXT]]''' || - || - || [[glCullParameterEXT]] || -
|-
|'''[[glCurrentPaletteMatrixARB]]''' || - || [[glCurrentPaletteMatrixARB]] || - || -
|-
|}

=== D ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glDeleteBufferRegionEXT]]''' || - || - || [[glDeleteBufferRegionEXT]] || -
|-
|'''[[glDeleteBuffers]]''' || {{Version_1_5}} || [[glDeleteBuffersARB]]{{altIcon}} || - || -
|-
|'''[[glDeleteFramebuffers]]''' || {{Version_3_0}} || - || [[glDeleteFramebuffersEXT]]{{altIcon}} || -
|-
|'''[[glDeleteLists]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glDeleteProgram]]''' || {{Version_2_0}} || [[glDeleteObjectARB]] {{altIcon}} || - || -
|-
|'''[[glDeleteProgramsARB]]''' || - || [[glDeleteProgramsARB]] || - || [[glDeleteProgramsNV]]{{altIcon}}
|-
|'''[[glDeleteQueries]]''' || {{Version_1_5}} || [[glDeleteQueriesARB]]{{altIcon}} || - || -
|-
|'''[[glDeleteRenderbuffers]]''' || {{Version_3_0}} || - || [[glDeleteRenderbuffersEXT]]{{altIcon}} || -
|-
|'''[[glDeleteSamplers]]''' || {{Version_3_3}} || - || - || -
|-
|'''[[glDeleteShader]]''' || {{Version_2_0}} || [[glDeleteObjectARB]] {{altIcon}} || - || -
|-
|'''[[glDeleteSync]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glDeleteTextures]]''' || {{Version_1_1}} || - || [[glDeleteTexturesEXT]]{{altIcon}} || -
|-
|'''[[glDeleteVertexArrays]]''' || {{Version_3_0}} || - || - || [[glDeleteVertexArraysAPPLE]]{{altIcon}}
|-
|'''[[glDeleteVertexShaderEXT]]''' || - || - || [[glDeleteVertexShaderEXT]] || -
|-
|'''[[glDepthBoundsEXT]]''' || - || - || [[glDepthBoundsEXT]] || [[glDepthBoundsNV]]{{altIcon}}
|-
|'''[[glDepthFunc]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glDepthMask]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glDepthRange]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glDetachShader]]''' || {{Version_2_0}} || [[glDetachObjectARB]]{{altIcon}} || - || -
|-
|'''[[glDisable]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glDisableClientState]]''' || {{Version_1_1}} || - || - || -
|-
|'''[[glDisableClientStateIndexedEXT]]''' || - || - || [[glDisableClientStateIndexedEXT]] || -
|-
|'''[[glDisableIndexedEXT]]''' || - || - || [[glDisableIndexedEXT]] || -
|-
|'''[[glDisableVariantClientStateEXT]]''' || - || - || [[glDisableVariantClientStateEXT]] || -
|-
|'''[[glDisableVertexAttribArray]]''' || {{Version_2_0}} || [[glDisableVertexAttribArrayARB]]{{altIcon}} || - || -
|-
|'''[[glDrawArrays]]''' || {{Version_1_1}} || - || [[glDrawArraysEXT]]{{altIcon}} || -
|-
|'''[[glDrawArraysInstanced]]''' || {{Version_3_1}} || [[glDrawArraysInstancedARB]] || [[glDrawArraysInstancedEXT]]{{altIcon}} || -
|-
|'''[[glDrawBuffer]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glDrawBufferRegionEXT]]''' || - || - || [[glDrawBufferRegionEXT]] || -
|-
|'''[[glDrawBuffers]]''' || {{Version_2_0}} || [[glDrawBuffersARB]]{{altIcon}} || - || [[glDrawBuffersATI]]{{altIcon}}
|-
|'''[[glDrawElements]]''' || {{Version_1_1}} || - || - || -
|-
|'''[[glDrawElementsBaseVertex]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glDrawElementsInstanced]]''' || {{Version_3_1}} || [[glDrawElementsInstancedARB]] || [[glDrawElementsInstancedEXT]]{{altIcon}} || -
|-
|'''[[glDrawElementsInstancedBaseVertex]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glDrawPixels]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glDrawRangeElements]]''' || {{Version_1_2}} || - || [[glDrawRangeElementsEXT]]{{altIcon}} || -
|-
|'''[[glDrawRangeElementsBaseVertex]]''' || {{Version_3_2}} || - || - || -
|}

=== E ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glEdgeFlag]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glEdgeFlagPointer]]''' || {{Version_1_1}} || - || [[glEdgeFlagPointerEXT]]{{altIcon}} || -
|-
|'''[[glEnable]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glEnableClientState]]''' || {{Version_1_1}} || - || - || -
|-
|'''[[glEnableClientStateIndexedEXT]]''' || - || - || [[glEnableClientStateIndexedEXT]] || -
|-
|'''[[glEnableIndexedEXT]]''' || - || - || [[glEnableIndexedEXT]] || -
|-
|'''[[glEnableVariantClientStateEXT]]''' || - || - || [[glEnableVariantClientStateEXT]] || -
|-
|'''[[glEnableVertexAttribArray]]''' || {{Version_2_0}} || [[glEnableVertexAttribArrayARB]]{{altIcon}} || - || -
|-
|'''[[glEnd]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glEndConditionalRender]]''' || {{Version_3_0}} || - || - || [[glEndConditionalRenderNV]]{{altIcon}}
|-
|'''[[glEndList]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glEndQuery]]''' || {{Version_1_5}} || [[glEndQueryARB]]{{altIcon}} || - || -
|-
|'''[[glEndSceneEXT]]''' || - || - || [[glEndSceneEXT]] || -
|-
|'''[[glEndTransformFeedback]]''' || {{Version_3_0}} || - || [[glEndTransformFeedbackEXT]]{{altIcon}} || [[glEndTransformFeedbackNV]]{{altIcon}}
|-
|'''[[glEndVertexShaderEXT]]''' || - || - || [[glEndVertexShaderEXT]] || -
|-
|'''[[glEvalCoord]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glEvalMesh]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glEvalPoint]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glExtractComponentEXT]]''' || - || - || [[glExtractComponentEXT]] || -
|}

=== F ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glFeedbackBuffer]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glFenceSync]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glFinish]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glFlush]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glFlushMappedBufferRange]]''' || {{Version_3_0}} || - || - || [[glFlushMappedBufferRangeAPPLE]]{{altIcon}}
|-
|'''[[glFog]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glFogCoord]]''' || {{Version_1_4}} || - || [[glFogCoordEXT]]{{altIcon}} || [[glFogCoordNV]]{{altIcon}}
|-
|'''[[glFogCoordPointer]]''' || {{Version_1_4}} || - || [[glFogCoordPointerEXT]]{{altIcon}} || -
|-
|'''[[glFragmentColorMaterialEXT]]''' || - || - || [[glFragmentColorMaterialEXT]] || [[glFragmentColorMaterialSGIX]]{{altIcon}}
|-
|'''[[glFragmentLightEXT]]''' || - || - || [[glFragmentLightEXT]] || [[glFragmentLightSGIX]]{{altIcon}}
|-
|'''[[glFragmentLightModelEXT]]''' || - || - || [[glFragmentLightModelEXT]] || [[glFragmentLightModelSGIX]]{{altIcon}}
|-
|'''[[glFragmentMaterialEXT]]''' || - || - || [[glFragmentMaterialEXT]] || [[glFragmentMaterialSGIX]]{{altIcon}}
|-
|'''[[glFramebufferDrawBufferEXT]]''' || - || - || [[glFramebufferDrawBufferEXT]] || -
|-
|'''[[glFramebufferDrawBuffersEXT]]''' || - || - || [[glFramebufferDrawBuffersEXT]] || -
|-
|'''[[glFramebufferReadBufferEXT]]''' || - || - || [[glFramebufferReadBufferEXT]] || -
|-
|'''[[glFrameBufferRenderBuffer]]''' || {{Version_3_0}} || - || [[glFrameBufferRenderBufferEXT]]{{altIcon}} || -
|-
|'''[[glFramebufferTexture]]''' || {{Version_3_0}} || [[glFramebufferTextureARB]]{{altIcon}} || [[glFramebufferTextureEXT]]{{altIcon}} || -
|-
|'''[[glFrameBufferTexture1D]]''' || {{Version_3_0}} || - || [[glFrameBufferTexture1DEXT]]{{altIcon}} || -
|-
|'''[[glFrameBufferTexture2D]]''' || {{Version_3_0}} || - || [[glFrameBufferTexture2DEXT]]{{altIcon}} || -
|-
|'''[[glFrameBufferTexture3D]]''' || {{Version_3_0}} || - || [[glFrameBufferTexture3DEXT]]{{altIcon}} || -
|-
|'''[[glFramebufferTextureFaceARB]]''' || - || [[glFramebufferTextureFaceARB]] || [[glFramebufferTextureFaceEXT]]{{altIcon}} || -
|-
|'''[[glFramebufferTextureLayer]]''' || {{Version_3_0}} || [[glFramebufferTextureLayerARB]]{{altIcon}} || [[glFramebufferTextureLayerEXT]]{{altIcon}} || -
|-
|'''[[glFrontFace]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glFrustum]]''' || {{Version_1_0}} || - || - || -
|}

=== G ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glGenBuffers]]''' || {{Version_1_5}} || [[glGenBuffersARB]]{{altIcon}} || - || -
|-
|'''[[glGenerateMipmap]]''' || {{Version_3_0}} || - || [[glGenerateMipmapEXT]]{{altIcon}} || -
|-
|'''[[glGenerateMultiTexMipmapEXT]]''' || - || - || [[glGenerateMultiTexMipmapEXT]] || -
|-
|'''[[glGenerateTextureMipmapEXT]]''' || - || - || [[glGenerateTextureMipmapEXT]] || -
|-
|'''[[glGenFramebuffers]]''' || {{Version_3_0}} || - || [[glGenFramebuffersEXT]]{{altIcon}} || -
|-
|'''[[glGenLists]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGenProgramsARB]]''' || - || [[glGenProgramsARB]] || - || [[glGenProgramsNV]]{{altIcon}}
|-
|'''[[glGenQueries]]''' || {{Version_1_5}} || [[glGenQueriesARB]]{{altIcon}} || - || -
|-
|'''[[glGenRenderbuffers]]''' || {{Version_3_0}} || - || [[glGenRenderbuffersEXT]]{{altIcon}} || -
|-
|'''[[glGenSamplers]]''' || {{Version_3_3}} || - || - || -
|-
|'''[[glGenSymbolsEXT]]''' || - || - || [[glGenSymbolsEXT]] || -
|-
|'''[[glGenTextures]]''' || {{Version_1_1}} || - || [[glGenTexturesEXT]]{{altIcon}} || -
|-
|'''[[glGenVertexArrays]]''' || {{Version_3_0}} || - || - || [[glGenVertexarraysAPPLE]]{{altIcon}}
|-
|'''[[glGenVertexShadersEXT]]''' || - || - || [[glGenVertexShadersEXT]] || -
|-
|'''[[glGet]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetActiveAttrib]]''' || {{Version_2_0}} || [[glGetActiveAttribARB]]{{altIcon}} || - || -
|-
|'''[[glGetActiveSubroutineName]]''' || {{Version_4_0}} || - || - || -
|-
|'''[[glGetActiveSubroutineUniform]]''' || {{Version_4_0}} || - || - || -
|-
|'''[[glGetActiveSubroutineUniformName]]''' || {{Version_4_0}} || - || - || -
|-
|'''[[glGetActiveUniform]]''' || {{Version_2_0}} || [[glGetActiveUniformARB]] {{altIcon}}|| - || -
|-
|'''[[glGetActiveUniformBlock]]''' || {{Version_3_1}} || - || - || -
|-
|'''[[glGetActiveUniformBlockName]]''' || {{Version_3_1}} || - || - || -
|-
|'''[[glGetActiveUniformName]]''' || {{Version_3_1}} || - || - || -
|-
|'''[[glGetActiveUniforms]]''' || {{Version_3_1}} || - || - || -
|-
|'''[[glGetAttachedShaders]]''' || {{Version_2_0}} || [[glGetAttachedObjectsARB]]{{altIcon}} || - || -
|-
|'''[[glGetAttribLocation]]''' || {{Version_2_0}} || [[glGetAttribLocationARB]]{{altIcon}} || - || -
|-
|'''[[glGetBooleanv]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetBooleanIndexedEXT]]''' || - || - || [[glGetBooleanIndexedEXT]] || -
|-
|'''[[glGetBufferParameter]]''' || {{Version_1_5}} || [[glGetBufferParameterARB]]{{altIcon}} || - || -
|-
|'''[[glGetBufferPointerv]]''' || {{Version_1_5}} || [[glGetBufferPointerARB]]{{altIcon}} || - || -
|-
|'''[[glGetBufferSubData]]''' || {{Version_1_5}} || [[glGetBufferSubDataARB]]{{altIcon}} || - || -
|-
|'''[[glGetClipPlane]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetColorTable]]''' || {{Version_1_2}} || - || [[glGetColorTableEXT]]{{altIcon}} || [[glGetColorTableSGI]]{{altIcon}}
|-
|'''[[glGetColorTableParameter]]''' || {{Version_1_2}} || - || [[glGetColorTableParameterEXT]]{{altIcon}} || [[glGetColorTableParameterSGI]]{{altIcon}}
|-
|'''[[glGetCompressedMultiTexImageEXT]]''' || - || - || [[glGetCompressedMultiTexImageEXT]] || -
|-
|'''[[glGetCompressedTexImage]]''' || {{Version_1_3}} || [[glGetCompressedTexImageARB]]{{altIcon}} || - || -
|-
|'''[[glGetCompressedTextureImageEXT]]''' || - || - || [[glGetCompressedTextureImageEXT]] || -
|-
|'''[[glGetConvolutionFilter]]''' || {{Version_1_2}} || - || [[glGetConvolutionFilterEXT]]{{altIcon}} || -
|-
|'''[[glGetConvolutionParameter]]''' || {{Version_1_2}} || - || [[glGetConvolutionParameterEXT]]{{altIcon}} || -
|-
|'''[[glGetDoublev]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetDoubleIndexedEXT]]''' || - || - || [[glGetDoubleIndexedEXT]] || -
|-
|'''[[glGetError]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetFloatv]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetFloatIndexedEXT]]''' || - || - || [[glGetFloatIndexedEXT]] || -
|-
|'''[[glGetFragDataLocation]]''' || {{Version_3_0}} || - || [[glGetFragDataLocationEXT]]{{altIcon}} || -
|-
|'''[[glGetFragmentLightEXT]]''' || - || - || [[glGetFragmentLightEXT]] || [[glGetFragmentLightSGIX]]{{altIcon}}
|-
|'''[[glGetFragmentMaterialEXT]]''' || - || - || [[glGetFragmentMaterialEXT]] || [[glGetFragmentMaterialSGIX]]{{altIcon}}
|-
|'''[[glGetFramebufferAttachmentParameter]]''' || {{Version_3_0}} || - || [[glGetFramebufferAttachmentParameterEXT]]{{altIcon}} || -
|-
|'''[[glGetFramebufferParameterEXT]]''' || - || - || [[glGetFramebufferParameterEXT]] || -
|-
|''als Parameter von [[glGet#GL_CURRENT_PROGRAM|glGet]]'' || {{Version_2_0}} || [[glGetHandleARB]]{{altIcon}} || - || -
|-
|'''[[glGetHistogram]]''' || {{Version_1_2}} || - || [[glGetHistogramEXT]]{{altIcon}} || -
|-
|'''[[glGetHistogramParameter]]''' || {{Version_1_2}} || - || [[glGetHistogramParameterEXT]]{{altIcon}} || -
|-
|'''[[glGetIntegerv]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetIntegerIndexedEXT]]''' || - || - || [[glGetIntegerIndexedEXT]] || -
|-
|'''[[glGetInvariantBooleanEXT]]''' || - || - || [[glGetInvariantBooleanEXT]] || -
|-
|'''[[glGetInvariantFloatEXT]]''' || - || - || [[glGetInvariantFloatEXT]] || -
|-
|'''[[glGetInvariantIntegerEXT]]''' || - || - || [[glGetInvariantIntegerEXT]] || -
|-
|'''[[glGetLight]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetLocalConstantBooleanEXT]]''' || - || - || [[glGetLocalConstantBooleanEXT]] || -
|-
|'''[[glGetLocalConstantFloatEXT]]''' || - || - || [[glGetLocalConstantFloatEXT]] || -
|-
|'''[[glGetLocalConstantIntegerEXT]]''' || - || - || [[glGetLocalConstantIntegerEXT]] || -
|-
|'''[[glGetMap]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetMaterial]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetMinmax]]''' || {{Version_1_2}} || - || [[glGetMinmaxEXT]]{{altIcon}} || -
|-
|'''[[glGetMinmaxParameter]]''' || {{Version_1_2}} || - || [[glGetMinmaxParameterEXT]]{{altIcon}} || -
|-
|'''[[glGetMultisample]]''' || {{Version_3_2}} || - || - || [[glGetMultisampleNV]]{{altIcon}}
|-
|'''[[glGetMultiTexEnvEXT]]''' || - || - || [[glGetMultiTexEnvEXT]] || -
|-
|'''[[glGetMultiTexGenEXT]]''' || - || - || [[glGetMultiTexGenEXT]] || -
|-
|'''[[glGetMultiTexImageEXT]]''' || - || - || [[glGetMultiTexImageEXT]] || -
|-
|'''[[glGetMultiTexLevelParameterEXT]]''' || - || - || [[glGetMultiTexLevelParameterEXT]] || -
|-
|'''[[glGetMultiTexParameterEXT]]''' || - || - || [[glGetMultiTexParameterEXT]] || -
|-
|'''[[glGetNamedBufferParameterEXT]]''' || - || - || [[glGetNamedBufferParameterEXT]] || -
|-
|'''[[glGetNamedBufferPointerEXT]]''' || - || - || [[glGetNamedBufferPointerEXT]] || -
|-
|'''[[glGetNamedBufferSubDataEXT]]''' || - || - || [[glGetNamedBufferSubDataEXT]] || -
|-
|'''[[glGetNamedFramebufferAttachmentParameterEXT]]''' || - || - || [[glGetNamedFramebufferAttachmentParameterEXT]] || -
|-
|'''[[glGetNamedProgramEXT]]''' || - || - || [[glGetNamedProgramEXT]] || -
|-
|'''[[glGetNamedProgramLocalParameterEXT]]''' || - || - || [[glGetNamedProgramLocalParameterEXT]] || -
|-
|'''[[glGetNamedProgramStringEXT]]''' || - || - || [[glGetNamedProgramStringEXT]] || -
|-
|'''[[glGetNamedRenderbufferParameterEXT]]''' || - || - || [[glGetNamedRenderbufferParameterEXT]] || -
|-
|'''[[glGetPixelMap]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetPixelTransformParameterEXT]]''' || - || - || [[glGetPixelTransformParameterEXT]] || -
|-
|'''[[glGetPointerv]]''' || {{Version_1_1}} || - || [[glGetPointervEXT]]{{altIcon}} || -
|-
|'''[[glGetPointerIndexedEXT]]''' || - || - || [[glGetPointerIndexedEXT]] || -
|-
|'''[[glGetPolygonStipple]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetProgram]]''' || {{Version_2_0}} || [[glGetObjectParameterARB]]{{altIcon}} || - || -
|-
|'''[[glGetProgramARB]]''' || - || [[glGetProgramARB]] || - || [[glGetProgramNV]]{{altIcon}}
|-
|'''[[glGetProgramEnvParameterARB]]''' || - || [[glGetProgramEnvParameterARB]] || - || -
|-
|'''[[glGetProgramInfoLog]]''' || {{Version_2_0}} || [[glGetInfoLogARB]]{{altIcon}} || - || -
|-
|'''[[glGetProgramLocalParameterARB]]''' || - || [[glGetProgramLocalParameterARB]] || - || -
|-
|'''[[glGetProgramStage]]''' || {{Version_4_0}} || - || - || -
|-
|'''[[glGetProgramStringARB]]''' || - || [[glGetProgramStringARB]] || - || [[glGetProgramStringNV]]{{altIcon}}
|-
|'''[[glGetQueryiv]]''' || {{Version_1_5}} || [[glGetQueryARB]]{{altIcon}} || - || -
|-
|'''[[glGetQueryObject]]''' || {{Version_1_5}} || [[glGetQueryObjectARB]]{{altIcon}} || [[glGetQueryObjectEXT]]{{altIcon}} || -
|-
|'''[[glGetRenderbufferParameter]]''' || {{Version_3_0}} || - || [[glGetRenderbufferParameterEXT]]{{altIcon}} || -
|-
|'''[[glGetSamplerParameter]]''' || {{Version_3_3}} || - || - || -
|-
|'''[[glGetSeparableFilter]]''' || {{Version_1_2}} || - || [[glGetSeparableFilterEXT]]{{altIcon}} || -
|-
|'''[[glGetShader]]''' || {{Version_2_0}} || [[glGetObjectParameterARB]]{{altIcon}} || - || -
|-
|'''[[glGetShaderInfoLog]]''' || {{Version_2_0}} || [[glGetInfoLogARB]]{{altIcon}} || - || -
|-
|'''[[glGetShaderSource]]''' || {{Version_2_0}} || [[glGetShaderSourceARB]]{{altIcon}} || - || -
|-
|'''[[glGetString]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetSubroutineIndex]]''' || {{Version_4_0}} || - || - || -
|-
|'''[[glGetSubroutineUniformLocation]]''' || {{Version_4_0}} || - || - || -
|-
|'''[[glGetSync]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glGetTexEnv]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetTexGen]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetTexImage]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetTexLevelParameter]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glGetTexParameter]]''' || {{Version_1_0}} || - || [[glGetTexParameterEXT]]{{altIcon}} || -
|-
|'''[[glGetTextureImageEXT]]''' || - || - || [[glGetTextureImageEXT]] || -
|-
|'''[[glGetTextureLevelParameterEXT]]''' || - || - || [[glGetTextureLevelParameterEXT]] || -
|-
|'''[[glGetTextureParameterEXT]]''' || - || - || [[glGetTextureParameterEXT]] || -
|-
|'''[[glGetTransformFeedbackVarying]]''' || {{Version_3_0}} || - || [[glGetTransformFeedbackVaryingEXT]]{{altIcon}} || [[glGetTransformFeedbackVaryingNV]]{{altIcon}}
|-
|'''[[glGetUniform]]''' || {{Version_2_0}} || [[glGetUniformARB]]{{altIcon}} || [[glGetUniformEXT]]{{altIcon}} || -
|-
|'''[[glGetUniformBlockIndex]]''' || {{Version_3_1}} || - || - || -
|-
|'''[[glGetUniformBufferSizeEXT]]''' || - || - || [[glGetUniformBufferSizeEXT]] || -
|-
|'''[[glGetUniformIndices]]''' || {{Version_3_1}} || - || - || -|
|-
|'''[[glGetUniformLocation]]''' || {{Version_2_0}} || [[glGetUniformLocationARB]]{{altIcon}} || - || -
|-
|'''[[glGetUniformOffsetEXT]]''' || - || - || [[glGetUniformOffsetEXT]] || -
|-
|'''[[glGetUniformSubroutine]]''' || {{Version_4_0}} || - || - || -
|-
|'''[[glGetVariantBooleanEXT]]''' || - || - || [[glGetVariantBooleanEXT]] || -
|-
|'''[[glGetVariantFloatEXT]]''' || - || - || [[glGetVariantFloatEXT]] || -
|-
|'''[[glGetVariantIntegerEXT]]''' || - || - || [[glGetVariantIntegerEXT]] || -
|-
|'''[[glGetVariantPointerEXT]]''' || - || - || [[glGetVariantPointerEXT]] || -
|-
|'''[[glGetVertexAttrib]]''' || {{Version_2_0}} || [[glGetVertexAttribARB]]{{altIcon}} || [[glGetVertexAttribEXT]] || [[glGetVertexAttribNV]]{{altIcon}}
|-
|'''[[glGetVertexAttribPointer]]''' || {{Version_2_0}} || [[glGetVertexAttribPointerARB]]{{altIcon}} || - || [[glGetVertexAttribPointerNV]]{{altIcon}}
|}

=== H ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glHint]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glHistogram]]''' || {{Version_1_2}} || - || [[glHistogramEXT]]{{altIcon}} || -
|}

=== I ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glIndex]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glIndexFuncEXT]]''' || - || - || [[glIndexFuncEXT]] || -
|-
|'''[[glIndexMask]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glIndexMaterialEXT]]''' || - || - || [[glIndexMaterialEXT]] || -
|-
|'''[[glIndexPointer]]''' || {{Version_1_1}} || - || [[glIndexPointerEXT]]{{altIcon}} || -
|-
|'''[[glInitNames]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glInsertComponentEXT]]''' || - || - || [[glInsertComponentEXT]] || -
|-
|'''[[glInterleavedArrays]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glIsBuffer]]''' || {{Version_1_5}} || [[glIsBufferARB]]{{altIcon}} || - || -
|-
|'''[[glIsEnabled]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glIsEnabledIndexedEXT]]''' || - || - || [[glIsEnabledIndexedEXT]] || -
|-
|'''[[glIsFramebuffer]]''' || {{Version_3_0}} || - || [[glIsFramebufferEXT]]{{altIcon}} || -
|-
|'''[[glIsList]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glIsProgram]]''' || {{Version_2_0}} || [[glIsProgramARB]]{{altIcon}} || - || [[glIsProgramNV]]{{altIcon}}
|-
|'''[[glIsQuery]]''' || {{Version_1_5}} || [[glIsQueryARB]]{{altIcon}} || - || -
|-
|'''[[glIsRenderbuffer]]''' || {{Version_3_0}} || - || [[glIsRenderbufferEXT]]{{altIcon}} || -
|-
|'''[[glIsSampler]]''' || {{Version_3_3}} || - || - || -
|-
|'''[[glIsShader]]''' || {{Version_2_0}} || - || - || -
|-
|'''[[glIsSync]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glIsTexture]]''' || {{Version_1_0}} || - || [[glIsTextureEXT]]{{altIcon}} || -
|-
|'''[[glIsVariantEnabledEXT]]''' || - || - || [[glIsVariantEnabledEXT]] || -
|-
|'''[[glIsVertexArray]]''' || {{Version_3_0}} || - || - || [[glIsVertexArrayAPPLE]]{{altIcon}}
|}

=== L ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glLight]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glLightEnvEXT]]''' || - || - || [[glLightEnvEXT]] || -
|-
|'''[[glLightModel]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glLineStipple]]'''{{excIcon}} || {{Version_1_0}} || - || - || -
|-
|'''[[glLineWidth]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glLinkProgram]]''' || {{Version_2_0}} || [[glLinkProgramARB]]{{altIcon}} || - || -
|-
|'''[[glListBase]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glLoadIdentity]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glLoadMatrix]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glLoadName]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glLoadTransposeMatrix]]''' || {{Version_1_3}} || [[glLoadTransposeMatrixARB]]{{altIcon}} || - || -
|-
|'''[[glLockArraysEXT]]''' || - || - || [[glLockArraysEXT]] || -
|-
|'''[[glLogicOp]]''' || {{Version_1_0}} || - || - || -
|}

=== M ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glMap1]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glMap2]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glMapBuffer]]''' || {{Version_1_5}} || [[glMapBufferARB]]{{altIcon}} || - || -
|-
|'''[[glMapBufferRange]]''' || {{Version_3_0}} || - || - || -
|-
|'''[[glMapGrid]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glMapNamedBufferEXT]]''' || - || - || [[glMapNamedBufferEXT]] || -
|-
|'''[[glMaterial]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glMatrixIndexARB]]''' || - || [[glMatrixIndexARB]] || - || -
|-
|'''[[glMatrixIndexPointerARB]]''' || - || [[glMatrixIndexPointerARB]] || - || -
|-
|'''[[glMatrixFrustumEXT]]''' || - || - || [[glMatrixFrustumEXT]] || -
|-
|'''[[glMatrixLoadEXT]]''' || - || - || [[glMatrixLoadEXT]] || -
|-
|'''[[glMatrixLoadIdentityEXT]]''' || - || - || [[glMatrixLoadIdentityEXT]] || -
|-
|'''[[glMatrixLoadTransposedEXT]]''' || - || - || [[glMatrixLoadTransposedEXT]] || -
|-
|'''[[glMatrixMode]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glMatrixMultEXT]]''' || - || - || [[glMatrixMultEXT]] || -
|-
|'''[[glMatrixMultTransposedEXT]]''' || - || - || [[glMatrixMultTransposedEXT]] || -
|-
|'''[[glMatrixOrthoEXT]]''' || - || - || [[glMatrixOrthoEXT]] || -
|-
|'''[[glMatrixPopEXT]]''' || - || - || [[glMatrixPopEXT]] || -
|-
|'''[[glMatrixPushEXT]]''' || - || - || [[glMatrixPushEXT]] || -
|-
|'''[[glMatrixRotateEXT]]''' || - || - || [[glMatrixRotateEXT]] || -
|-
|'''[[glMatrixScaleEXT]]''' || - || - || [[glMatrixScaleEXT]] || -
|-
|'''[[glMatrixTranslateEXT]]''' || - || - || [[glMatrixTranslateEXT]] || -
|-
|'''[[glMinmax]]''' || {{Version_1_2}} || - || [[glMinmaxEXT]]{{altIcon}} || -
|-
|'''[[glMultiDrawArrays]]''' || {{Version_1_4}} || - || [[glMultiDrawArraysEXT]]{{altIcon}} || -
|-
|'''[[glMultiDrawElements]]''' || {{Version_1_4}} || - || [[glMultiDrawElementsEXT]]{{altIcon}} || -
|-
|'''[[glMultiDrawElementsBaseVertex]]''' || {{Version_3_3}} || - || - || -
|-
|'''[[glMultiTexBufferEXT]]''' || - || - || [[glMultiTexBufferEXT]] || -
|-
|'''[[glMultiTexCoord]]''' || {{Version_1_3}} || [[glMultiTexCoordARB]]{{altIcon}} || - || [[glMultiTexCoordNV]]{{altIcon}}
|-
|'''[[glMultiTexCoordPointerEXT]]''' || - || - || [[glMultiTexCoordPointerEXT]] || -
|-
|'''[[glMultiTexEnvEXT]]''' || - || - || [[glMultiTexEnvEXT]] || -
|-
|'''[[glMultiTexGenEXT]]''' || - || - || [[glMultiTexGenEXT]] || -
|-
|'''[[glMultiTexImageEXT]]''' || - || - || [[glMultiTexImageEXT]] || -
|-
|'''[[glMultiTexParameterEXT]]''' || - || - || [[glMultiTexParameterEXT]] || -
|-
|'''[[glMultiTexRenderbufferEXT]]''' || - || - || [[glMultiTexRenderbufferEXT]] || -
|-
|'''[[glMultiTexSubImageEXT]]''' || - || - || [[glMultiTexSubImageEXT]] || -
|-
|'''[[glMultMatrix]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glMultTransposeMatrix]]''' || {{Version_1_3}} || [[glMultTransposeMatrixARB]]{{altIcon}} || - || -
|}

=== N ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glNamedBufferDataEXT]]''' || - || - || [[glNamedBufferDataEXT]] || -
|-
|'''[[glNamedBufferSubDataEXT]]''' || - || - || [[glNamedBufferSubDataEXT]] || -
|-
|'''[[glNamedFramebufferRenderbufferEXT]]''' || - || - || [[glNamedFramebufferRenderbufferEXT]] || -
|-
|'''[[glNamedFramebufferTextureEXT]]''' || - || - || [[glNamedFramebufferTextureEXT]] || -
|-
|'''[[glNamedFramebufferTexture1DEXT]]''' || - || - || [[glNamedFramebufferTexture1DEXT]] || -
|-
|'''[[glNamedFramebufferTexture2DEXT]]''' || - || - || [[glNamedFramebufferTexture2DEXT]] || -
|-
|'''[[glNamedFramebufferTexture3DEXT]]''' || - || - || [[glNamedFramebufferTexture3DEXT]] || -
|-
|'''[[glNamedFramebufferTextureFaceEXT]]''' || - || - || [[glNamedFramebufferTextureFaceEXT]] || -
|-
|'''[[glNamedFramebufferTextureLayerEXT]]''' || - || - || [[glNamedFramebufferTextureLayerEXT]] || -
|-
|'''[[glNamedProgramLocalParameterEXT]]''' || - || - || [[glNamedProgramLocalParameterEXT]] || -
|-
|'''[[glNamedProgramStringEXT]]''' || - || - || [[glNamedProgramStringEXT]] || -
|-
|'''[[glNamedRenderbufferStorageEXT]]''' || - || - || [[glNamedRenderbufferStorageEXT]] || -
|-
|'''[[glNamedRenderbufferStorageMultisampleEXT]]''' || - || - || [[glNamedRenderbufferStorageMultisampleEXT]] || -
|-
|'''[[glNamedRenderbufferStorageMultisampleCoverageEXT]]''' || - || - || [[glNamedRenderbufferStorageMultisampleCoverageEXT]] || -
|-
|'''[[glNewBufferRegionEXT]]''' || - || - || [[glNewBufferRegionEXT]] || -
|-
|'''[[glNewList]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glNormal]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glNormalPointer]]''' || {{Version_1_1}} || - || [[glNormalPointerEXT]]{{altIcon}} || [[glNormalPointerINTEL]]{{altIcon}}
|}

=== 0 ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glOrtho]]''' || {{Version_1_0}} || - || - || -
|}

=== P ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glPassThrough]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPatchParameter]]''' || {{Version_4_0}} || - || - || -
|-
|'''[[glPixelMap]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPixelStore]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPixelTransfer]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPixelTransformParameterEXT]]''' || - || - || [[glPixelTransformParameterEXT]] || -
|-
|'''[[glPixelZoom]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPointParameter]]''' || {{Version_1_4}} || [[glPointParameterARB]]{{altIcon}} || [[glPointParameterEXT]]{{altIcon}} || [[glPointParameterNV]]{{altIcon}}
|-
|'''[[glPointSize]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPolygonMode]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPolygonOffset]]''' || {{Version_1_0}} || - || [[glPolygonOffsetEXT]] || -
|-
|'''[[glPolygonStipple]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPopAttrib]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPopClientAttrib]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPopMatrix]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPopName]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPrimitiveRestart]]''' || {{Version_3_1}} || - || - || [[glPrimitiveRestartNV]]{{altIcon}}
|-
|'''[[glPrimitiveRestartIndex]]''' || {{Version_3_1}} || - || - || [[glPrimitiveRestartIndexNV]]{{altIcon}}
|-
|'''[[glPrioritizeTextures]]''' || {{Version_1_0}} || - || [[glPrioritizeTexturesEXT]]{{altIcon}} || -
|-
|'''[[glProgramEnvParameterARB]]''' || - || [[glProgramEnvParameterARB]] || [[glProgramEnvParameterEXT]]{{altIcon}} || [[glProgramEnvParameterNV]]{{altIcon}}
|-
|'''[[glProgramLocalParameterARB]]''' || - || [[glProgramLocalParameterARB]] || [[glProgramLocalParameterEXT]]{{altIcon}} || [[glProgramLocalParameterNV]]{{altIcon}}
|-
|'''[[glProgramParameterARB]]''' || - || [[glProgramParameterARB]] || [[glProgramParameterEXT]]{{altIcon}} || [[glProgramParameterNV]]{{altIcon}}
|-
|'''[[glProgramStringARB]]''' || - || [[glProgramStringARB]] || - || -
|-
|'''[[glProgramUniformEXT]]''' || - || - || [[glProgramUniformEXT]] || -
|-
|'''[[glProgramUniformMatrixEXT]]''' || - || - || [[glProgramUniformMatrixEXT]] || -
|-
|'''[[glProvokingVertex]]''' || {{Version_3_2}} || - || [[glProvokingVertexEXT]]{{altIcon}} || -
|-
|'''[[glPushAttrib]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPushClientAttrib]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPushClientAttribDefaultEXT]]''' || - || - || [[glPushClientAttribDefaultEXT]] || -
|-
|'''[[glPushMatrix]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glPushName]]''' || {{Version_1_0}} || - || - || -
|}

=== Q ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glQueryCounter]]''' || {{Version_3_3}} || - || - || -
|}

=== R ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glRasterPos]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glReadBuffer]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glReadBufferRegionEXT]]''' || - || - || [[glReadBufferRegionEXT]] || -
|-
|'''[[glReadPixels]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glRect]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glRenderbufferStorage]]''' || {{Version_3_0}} || - || [[glRenderbufferStorageEXT]]{{altIcon}} || -
|-
|'''[[glRenderbufferStorageMultisample]]''' || {{Version_3_0}} || - || [[glRenderbufferStorageMultisampleEXT]]{{altIcon}} || -
|-
|'''[[glRenderMode]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glResetHistogram]]''' || {{Version_1_2}} || - || [[glResetHistogramEXT]]{{altIcon}} || -
|-
|'''[[glResetMinmax]]''' || {{Version_1_2}} || - || [[glResetMinmaxEXT]]{{altIcon}} || -
|-
|'''[[glRotate]]''' || {{Version_1_0}} || - || - || -
|}

=== S ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glSampleCoverage]]''' || {{Version_1_3}} || [[glSampleCoverageARB]]{{altIcon}} || - || -
|-
|'''[[glSampleMask]]''' || {{Version_3_2}} || - || [[glSampleMaskEXT]]{{altIcon}} || [[glSampleMaskSGIS]]{{altIcon}}
|-
|'''[[glSamplePatternEXT]]''' || - || - || [[glSamplePatternEXT]] || [[glSamplePatternSGIS]]{{altIcon}}
|-
|'''[[glSamplerParameter]]''' || {{Version_3_3}} || - || - || -
|-
|'''[[glScale]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glScissor]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glSecondaryColor]]''' || {{Version_1_4}} || - || [[glSecondaryColorEXT]]{{altIcon}} || [[glSecondaryColorNV]]{{altIcon}}
|-
|'''[[glSecondaryColorPointer]]''' || {{Version_1_4}} || - || [[glSecondaryColorPointerEXT]]{{altIcon}} || -
|-
|'''[[glSelectBuffer]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glSeparableFilter2D]]''' || {{Version_1_2}} || - || [[glSeparableFilter2DEXT]]{{altIcon}} || -
|-
|'''[[glSetInvariantEXT]]''' || - || - || [[glSetInvariantEXT]] || -
|-
|'''[[glSetLocalConstantEXT]]''' || - || - || [[glSetLocalConstantEXT]] || -
|-
|'''[[glShadeModel]]'''{{excIcon}} || {{Version_1_0}} || - || - || -
|-
|'''[[glShaderOp1EXT]]''' || - || - || [[glShaderOp1EXT]] || -
|-
|'''[[glShaderOp2EXT]]''' || - || - || [[glShaderOp2EXT]] || -
|-
|'''[[glShaderOp3EXT]]''' || - || - || [[glShaderOp3EXT]] || -
|-
|'''[[glShaderSource]]''' || {{Version_2_0}} || [[glShaderSourceARB]]{{altIcon}} || - || -
|-
|'''[[glStencilFunc]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glStencilFuncSeparate]]''' || {{Version_2_0}} || - || - || [[glStencilFuncSeparateATI]]{{altIcon}}
|-
|'''[[glStencilMask]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glStencilMaskSeparate]]''' || {{Version_2_0}} || - || - || -
|-
|'''[[glStencilOp]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glStencilOpSeparate]]''' || {{Version_2_0}} || - || - || [[glStencilOpSeparateATI]]{{altIcon}}
|-
|'''[[glSwizzleEXT]]''' || - || - || [[glSwizzleEXT]] || -
|}

=== T ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glTangentPointerEXT]]''' || - || - || [[glTangentPointerEXT]] || -
|-
|'''[[glTexBuffer]]''' || {{Version_3_1}} || [[glTexBufferARB]]{{altIcon}} || [[glTexBufferEXT]]{{altIcon}} || -
|-
|'''[[glTexCoord]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glTexCoordPointer]]''' || {{Version_1_1}} || - || [[glTexCoordPointerEXT]]{{altIcon}} || [[glTexCoordPointerINTEL]]{{altIcon}}
|-
|'''[[glTexEnv]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glTexGen]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glTexImage1D]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glTexImage2D]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glTexImage2DMultisample]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glTexImage3D]]''' || {{Version_1_2}} || - || [[glTexImage3DEXT]]{{altIcon}} || -
|-
|'''[[glTexImage3DMultisample]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glTexParameter]]''' || {{Version_1_0}} || - || [[glTexParameterIEXT]] || -
|-
|'''[[glTexSubImage1D]]''' || {{Version_1_0}} || - || [[glTexSubImage1DEXT]]{{altIcon}} || -
|-
|'''[[glTexSubImage2D]]''' || {{Version_1_0}} || - || [[glTexSubImage2DEXT]]{{altIcon}} || -
|-
|'''[[glTexSubImage3D]]''' || {{Version_1_2}} || - || [[glTexSubImage3DEXT]]{{altIcon}} || -
|-
|'''[[glTextureBufferEXT]]''' || - || - || [[glTextureBufferEXT]] || -
|-
|'''[[glTextureImageEXT]]''' || - || - || [[glTextureImageEXT]] || -
|-
|'''[[glTextureLightEXT]]''' || - || - || [[glTextureLightEXT]] || -
|-
|'''[[glTextureMaterialEXT]]''' || - || - || [[glTextureMaterialEXT]] || -
|-
|'''[[glTextureNormalEXT]]''' || - || - || [[glTextureNormalEXT]] || -
|-
|'''[[glTextureParameterEXT]]''' || - || - || [[glTextureParameterEXT]] || -
|-
|'''[[glTextureRenderbufferEXT]]''' || - || - || [[glTextureRenderbufferEXT]] || -
|-
|'''[[glTextureSubImageEXT]]''' || - || - || [[glTextureSubImageEXT]] || -
|-
|'''[[glTransformFeedbackVaryings]]''' || {{Version_3_0}} || - || [[glTransformFeedbackVaryingsEXT]]{{altIcon}} || [[glTransformFeedbackVaryingsNV]]{{altIcon}}
|-
|'''[[glTranslate]]''' || {{Version_1_0}} || - || - || -
|}

=== U ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glUniform]]''' || {{Version_2_0}} || [[glUniformARB]]{{altIcon}} || [[glUniformEXT]]{{altIcon}} || -
|-
|'''[[glUniformBlockBinding]]''' || {{Version_3_1}} || - || - || -
|-
|'''[[glUniformBufferEXT]]''' || - || - || [[glUniformBufferEXT]] || -
|-
|'''[[glUniformMatrix]]''' || {{Version_2_0}} || [[glUniformMatrixARB]]{{altIcon}} || - || -
|-
|'''[[glUniformSubroutines]]''' || {{Version_4_0}} || - || - || -
|-
|'''[[glUnlockArraysEXT]]''' || - || - || [[glUnlockArraysEXT]] || -
|-
|'''[[glUnmapBuffer]]''' || {{Version_1_5}} || [[glUnmapBufferARB]]{{altIcon}} || - || -
|-
|'''[[glUnmapNamedBufferEXT]]''' || - || - || [[glUnmapNamedBufferEXT]] || -
|-
|'''[[glUseProgram]]''' || {{Version_2_0}} || [[glUseProgramObjectARB]]{{altIcon}} ||- || -
|}

=== V ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glValidateProgram]]''' || {{Version_2_0}} || [[glValidateProgramARB]]{{altIcon}} || - || -
|-
|'''[[glVariantEXT]]''' || - || - || [[glVariantEXT]] || -
|-
|'''[[glVariantPointerEXT]]''' || - || - || [[glVariantPointerEXT]] || -
|-
|'''[[glVertex]]''' || {{Version_1_0}} || - || - || -
|-
|'''[[glVertexAttrib]]''' || {{Version_2_0}} || [[glVertexAttribARB]]{{altIcon}} || [[glVertexAttribEXT]]{{altIcon}} || [[glVertexAttribNV]]{{altIcon}}
|-
|'''[[glVertexAttribDivisor]]''' || {{Version_3_3}} || [[glVertexAttribDivisorARB]] || - || -
|-
|'''[[glVertexAttribPointer]]''' || {{Version_2_0}} || [[glVertexAttribPointerARB]]{{altIcon}} || [[glVertexAttribPointerEXT]]{{altIcon}} || [[glVertexAttribPointerNV]]{{altIcon}}
|-
|'''[[glVertexBlendARB]]''' || - || [[glVertexBlendARB]] || - || -
|-
|'''[[glVertexPointer]]''' || {{Version_1_1}} || - || [[glVertexPointerEXT]]{{altIcon}} || [[glVertexPointerINTEL]]{{altIcon}}
|-
|'''[[glVertexWeightEXT]]''' || - || - || [[glVertexWeightEXT]] || [[glVertexWeightNV]]{{altIcon}}
|-
|'''[[glVertexWeightPointerEXT]]''' || - || - || [[glVertexWeightPointerEXT]] || -
|-
|'''[[glViewport]]''' || {{Version_1_0}} || - || - || -
|}

=== W ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glWaitSync]]''' || {{Version_3_2}} || - || - || -
|-
|'''[[glWeightARB]]''' || - || [[glWeightARB]] || - || -
|-
|'''[[glWeightPointerARB]]''' || - || [[glWeightPointerARB]] || - || -
|-
|'''[[glWindowPos]]''' || {{Version_1_4}} || [[glWindowPosARB]]{{altIcon}} || - || [[glWindowPosMESA]]{{altIcon}}
|-
|'''[[glWriteMaskEXT]]''' || - || - || [[glWriteMaskEXT]] || -
|}

=== OpenGL Parameter-Tabellen ===
Die nachfolgenden Listen enthalten Parameter- bzw. Typbeschreibungen, die bei vielen OpenGL-Funktionen immer wieder auftauchen.

[[internes Pixelformat|interne Pixelformate]]<br>
[[Pixelformat|Pixelformate]]<br>
[[Pixeldatentyp|Datentypen für Pixel]]<br>

== [[:Kategorie:GLU|GLU]] ==
(Was ist die [[GLU]]?)

=== B ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluBeginCurve]]''' || - || - || - || -
|-
|'''[[gluBeginPolygon]]''' || - || - || - || -
|-
|'''[[gluBeginSurface]]''' || - || - || - || -
|-
|'''[[gluBeginTrim]]''' || - || - || - || -
|-
|'''[[gluBuild1DMipmaps]]''' || - || - || - || -
|-
|'''[[gluBuild2DMipmaps]]''' || - || - || - || -
|-
|'''[[gluBuild3DMipmaps]]''' || - || - || - || -
|}

=== C ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluCylinder]]''' || - || - || - || -
|}

=== D ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluDeleteNurbsRenderer]]''' || - || - || - || -
|-
|'''[[gluDeleteQuadric]]''' || - || - || - || -
|-
|'''[[gluDeleteTess]]''' || - || - || - || -
|-
|'''[[gluDisk]]''' || - || - || - || -
|}

=== E ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluEndCurve]]''' || - || - || - || -
|-
|'''[[gluEndPolygon]]''' || - || - || - || -
|-
|'''[[gluEndSurface]]''' || - || - || - || -
|-
|'''[[gluEndTrim]]''' || - || - || - || -
|-
|'''[[gluErrorString]]''' || - || - || - || -
|}

=== G ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluGetNurbsProperty]]''' || - || - || - || -
|-
|'''[[gluGetString]]''' || - || - || - || -
|-
|'''[[gluGetTessProperty]]''' || - || - || - || -
|}

=== L ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluLoadSamplingMatrices]]''' || - || - || - || -
|-
|'''[[gluLookAt]]''' || - || - || - || -
|}

=== N ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluNewNurbsRenderer]]''' || - || - || - || -
|-
|'''[[gluNewQuadric]]''' || - || - || - || -
|-
|'''[[gluNewTess]]''' || - || - || - || -
|-
|'''[[gluNextContour]]''' || - || - || - || -
|-
|'''[[gluNurbsCallback]]''' || - || - || - || -
|-
|'''[[gluNurbsCurve]]''' || - || - || - || -
|-
|'''[[gluNurbsProperty]]''' || - || - || - || -
|-
|'''[[gluNurbsSurface]]''' || - || - || - || -
|}

=== O ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluOrtho2D]]''' || - || - || - || -
|}

=== P ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluPartialDisk]]'''{{excIcon}} || - || - || - || -
|-
|'''[[gluPerspective]]''' || - || - || - || -
|-
|'''[[gluPickMatrix]]''' || - || - || - || -
|-
|'''[[gluProject]]''' || - || - || - || -
|-
|'''[[gluPwlCurve]]''' || - || - || - || -
|}

=== Q ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluQuadricCallback]]''' || - || - || - || -
|-
|'''[[gluQuadricDrawStyle]]'''{{excIcon}} || - || - || - || -
|-
|'''[[gluQuadricNormals]]''' || - || - || - || -
|-
|'''[[gluQuadricOrientation]]''' || - || - || - || -
|-
|'''[[gluQuadricTexture]]''' || - || - || - || -
|}

=== S ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluScaleImage]]''' || - || - || - || -
|-
|'''[[gluSphere]]'''{{excIcon}} || - || - || - || -
|}

=== T ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluTessBeginContour]]''' || - || - || - || -
|-
|'''[[gluTessBeginPolygon]]''' || - || - || - || -
|-
|'''[[gluTessCallback]]''' || - || - || - || -
|-
|'''[[gluTessEndContour]]''' || - || - || - || -
|-
|'''[[gluTessEndPolygon]]''' || - || - || - || -
|-
|'''[[gluTessNormal]]''' || - || - || - || -
|-
|'''[[gluTessProperty]]''' {{icpIcon}} || - || - || - || -
|-
|'''[[gluTessVertex]]''' || - || - || - || -
|}

=== U ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[gluUnProject]]''' || - || - || - || -
|}

== [[:Kategorie:GLX|GLX]] ==
(Was ist die [[GLX]]?)

''Als Quelle für die Übersetzung weiterer Befehlsspezifikationen kann diese Sammlung verwendet werden: [http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org GLX Manpages]''

=== C ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXChooseFBConfig]]''' || - || - || - || -
|-
|'''[[glXChooseVisual]]''' || - || - || - || -
|-
|'''[[glXCopyContext]]''' || - || - || - || -
|-
|'''[[glXCreateContext]]''' || - || - || - || -
|-
|'''[[glXCreateGLXPixmap]]''' || - || - || - || -
|-
|'''[[glXCreateNewContext]]''' || - || - || - || -
|-
|'''[[glXCreatePbuffer]]''' || - || - || - || -
|-
|'''[[glXCreatePixmap]]''' || - || - || - || -
|-
|'''[[glXCreateWindow]]''' || - || - || - || -
|}

=== D ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXDestroyContext]]''' || - || - || - || -
|-
|'''[[glXDestroyGLXPixmap]]''' || - || - || - || -
|-
|'''[[glXDestroyPbuffer]]''' || - || - || - || -
|-
|'''[[glXDestroyPixmap]]''' || - || - || - || -
|-
|'''[[glXDestroyWindow]]''' || - || - || - || -
|}

=== F ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXFreeContextEXT]]''' || - || - || - || -
|}

=== G ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXGetClientString]]''' || - || - || - || -
|-
|'''[[glXGetConfig]]''' || - || - || - || -
|-
|'''[[glXGetCurrentContextIDEXT]]''' || - || - || - || -
|-
|'''[[glXGetCurrentContext]]''' || - || - || - || -
|-
|'''[[glXGetCurrentDisplay]]''' || - || - || - || -
|-
|'''[[glXGetCurrentDrawable]]''' || - || - || - || -
|-
|'''[[glXGetCurrentReadDrawable]]''' || - || - || - || -
|-
|'''[[glXGetFBConfigAttrib]]''' || - || - || - || -
|-
|'''[[glXGetFBConfigs]]''' || - || - || - || -
|-
|'''[[glXGetProcAddress]]''' || - || - || - || -
|-
|'''[[glXGetSelectedEvent]]''' || - || - || - || -
|-
|'''[[glXGetVisualFromFBConfig]]''' || - || - || - || -
|}

=== I ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXImportContextEXT]]''' || - || - || - || -
|-
|'''[[glXIntro]]''' || - || - || - || -
|-
|'''[[glXIsDirect]]''' || - || - || - || -
|}

=== M ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXMakeContextCurrent]]''' || - || - || - || -
|-
|'''[[glXMakeCurrent]]''' || - || - || - || -
|}

=== Q ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXQueryContext]]''' || - || - || - || -
|-
|'''[[glXQueryContextInfoEXT]]''' || - || - || [[glXQueryContextInfoEXT]] || -
|-
|'''[[glXQueryDrawable]]''' || - || - || - || -
|-
|'''[[glXQueryExtension]]''' || - || - || - || -
|-
|'''[[glXQueryExtensionsString]]''' || - || - || - || -
|-
|'''[[glXQueryServerString]]''' || - || - || - || -
|-
|'''[[glXQueryVersion]]''' || - || - || - || -
|}

=== S ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXSelectEvent]]''' || - || - || - || -
|-
|'''[[glXSwapBuffers]]''' || - || - || - || -
|-
|'''[[glXSwapIntervalEXT]]''' || - || - || [[glXSwapIntervalEXT]] || -
|}

=== U ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXUseXFont]]''' || - || - || - || -
|}

=== W ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[glXWaitGL]]''' || - || - || - || -
|-
|'''[[glXWaitX]]''' || - || - || - || -
|}

== [[:Kategorie:WGL|WGL]] ==
(Was ist die [[WGL]]?)

''Als Quelle für die Übersetzung weiterer Befehlsspezifikationen kann diese Sammlung verwendet werden: [http://floyd.atc.no/Docs/OpenGL/man-pages/WGLmanpages/ floyd.atc.no WGL Manpages]''

=== C ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[wglChoosePixelFormatARB]]''' || - || [[wglChoosePixelFormatARB]] || - || -
|-
|'''[[wglCopyContext]]''' || - || - || - || -
|-
|'''[[wglCreateContext]]''' || - || - || - || -
|-
|'''[[wglCreateBufferRegionEXT]]''' || - || - || [[wglCreateBufferRegionEXT]] || -
|-
|'''[[wglCreateLayerContext]]''' || - || - || - || -
|-
|'''[[wglCreatePbufferARB]]''' || - || [[wglCreatePbufferARB]] || - || -
|}

=== D ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[wglDeleteBufferRegionEXT]]''' || - || - || [[wglDeleteBufferRegionEXT]] || -
|-
|'''[[wglDeleteContext]]''' || - || - || - || -
|-
|'''[[wglDestroyPbufferARB]]''' || - || [[wglDestroyPbufferARB]] || - || -
|-
|'''[[wglDescribeLayerPlane]]''' || - || - || - || -
|}

=== G ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[wglGetCurrentContext]]''' || - || - || - || -
|-
|'''[[wglGetCurrentDC]]''' || - || - || - || -
|-
|'''[[wglGetCurrentReadDC]]''' || - || - || - || -
|-
|'''[[wglGetExtensionsStringARB]]''' || - || [[wglGetExtensionsStringARB]] || - || -
|-
|'''[[wglGetLayerPaletteEntries]]''' || - || - || - || -
|-
|'''[[wglGetPbufferDCARB]]''' || - || [[wglGetPbufferDCARB]] || - || -
|-
|'''[[wglGetPixelFormatAttribARB]]''' || - || [[wglGetPixelFormatAttribARB]] || - || -
|-
|'''[[wglGetPixelFormatAttribEXT]]''' || - || - || [[wglGetPixelFormatAttrixEXT]] || -
|-
|'''[[wglGetProcAddress]]''' || - || - || - || -
|}
=== M ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[wglMakeCurrent]]''' || - || - || - || -
|-
|'''[[wglMakeCurrentContextEXT]]''' || - || - || [[wglMakeCurrentContextEXT]] || -
|}

=== Q ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[wglQueryPbufferARB]]''' || - || [[wglQueryPbufferARB]] || - || -
|}

=== R ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[wglRealizeLayerPalette]]''' || - || - || - || -
|-
|'''[[wglReleasePbufferDCARB]]''' || - || [[wglReleasePbufferDCARB]] || - || -
|-
|'''[[wglRestoreBufferRegionEXT]]''' || - || - || [[wglRestoreBufferRegionEXT]] || -
|}

=== S ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[wglSaveBufferRegionEXT]]''' || - || - || [[wglSaveBufferRegionEXT]] || -
|-
|'''[[wglSetLayerPaletteEntries]]''' || - || - || - || -
|-
|'''[[wglShareLists]]''' || - || - || - || -
|-
|'''[[wglSwapIntervalEXT]]''' || - || - || [[wglSwapIntervalEXT]] || -
|-
|'''[[wglSwapLayerBuffers]]''' || - || - || - || -
|}

=== U ===
{|{{Prettytable_B1}} style="width:100%"
!width="25%"|Aktuelle Version
!width="15%"|Kernfunktion (seit)
!width="20%"|ARB Entsprechung
!width="20%"|EXT Entsprechung
!width="20%"|Herstellerspezifisch
|-
|'''[[wglUseFontBitmaps]]''' || - || - || - || -
|-
|'''[[wglUseFontOutlines]]''' || - || - || - || -
|}

== Externe Funktionen ==
Hier sind alle Funktionen zu finden, die zwar direkt nichts mit OpenGL zu tun haben, aber trotzdem im Normalfall zur Nutzung der GL benötigt werden.

=== Win32 Funktionen ===
{|{{Prettytable_B1}}
|-
|'''[[ChoosePixelFormat]]'''
|-
|'''[[DescribePixelFormat]]'''
|-
|'''[[GetLastError]]'''
|-
|'''[[getObject]]'''
|-
|'''[[GetPixelFormat]]'''
|-
|'''[[SetPixelFormat]]'''
|-
|'''[[SwapBuffers]]'''
|}

=== Linux / Unix Funktionen ===
{|{{Prettytable_B1}}
|-
|'''[[XCloseDisplay]]'''
|-
|'''[[XDefaultScreen]]'''
|-
|'''[[XOpenDisplay]]'''
|}

===Siehe auch===
[[OpenAL-Funktionsübersicht]], [[SDL-Funktionsübersicht]]

Diskussion:Tutorial WebGL

2011-06-13T00:01:40Z

Darkinsanity: mein Satzbau war mal wieder phänomenal

== Updates ==
Im Februar kam ja die Version 1.0 der Spezifikation, von daher könnte man das Tutorial evtl. etwas aufräumen und auf den neuesten Stand bringen. Der Kompatibilitäts-Code war ja schon seit einigen Nightly-Builds des Firefox nicht mehr nötig und sollte jetzt eigentlich überflüssig sein. Auch die Initialisierung kann vereinfacht werden - leider halten sich die Browser noch nicht so ganz an den Standard, sonst würde es überall per canvas.getContext("webgl") funktionieren, aber alle benutzen mittlerweile entweder "webgl" (hab ich noch nicht gesehen, steht aber so in der Spezifikation) oder "experimental-webgl" (Firefox, Chrome, WebKit). [[Benutzer:Darkinsanity|Darkinsanity]] 02:00, 13. Jun. 2011 (CEST)

Diskussion:Tutorial WebGL

2011-06-13T00:00:44Z

Darkinsanity: Updates für Tutorial?

== Updates ==
Im Februar kam ja die Version 1.0 der Spezifikation, von daher könnte man das Tutorial evtl. etwas aufräumen und auf den neuesten Stand bringen. Der Kompatibilitäts-Code war ja schon seit nicht mehr nötig und sollte jetzt eigentlich überflüssig sein. Auch die Initialisierung kann vereinfacht werden - leider halten sich die Browser noch nicht so ganz an den Standard, sonst würde es überall per canvas.getContext("webgl") funktionieren, aber alle benutzen mittlerweile entweder "webgl" (hab ich noch nicht gesehen, steht aber so in der Spezifikation) oder "experimental-webgl" (Firefox, Chrome, WebKit). [[Benutzer:Darkinsanity|Darkinsanity]] 02:00, 13. Jun. 2011 (CEST)

Tutorial WebGL

2011-06-12T23:43:39Z

Darkinsanity: Update für Firefox-Infos

WebGL ist der neue Standard für OpenGL im Browser. Der Standard ermöglicht es hardwarebeschleunigte 3D-Grafik mit Shadern im Browser darzustellen, ohne dabei auf spezielle Plugins angewiesen zu sein.

In diesem Tutorial werden die wesentlichen Besonderheiten von WebGL gegenüber anderen OpenGL-Anwendungen vorgestellt. Kenntnisse in [http://de.wikipedia.org/wiki/JavaScript JavaScript] und [http://www.khronos.org/opengles/2_X/ OpenGL ES 2.0], also insbesondere [[GLSL]] und [[VBO]]s werden vorausgesetzt. Es sei darauf hingewiesen, dass WebGL im Augenblick noch hochgradig experimentell ist und bisher auch nicht wirklich dokumentiert ist. Neben diesem Tutorial existieren auch einige andere [[#Links|Tutorials]], aber ein Blick in den Quellcode der verfügbaren Demos kann nie schaden.

WebGL ist im wesentlichen ein JavaScript-Binding für OpenGL ES 2.0 und wird bisher von den aktuellen Entwickler-Versionen von Firefox, Google Chrome und Safari unterstützt. Weitere Browser auf Gecko- bzw. Webkit-Basis werden sicher bald folgen. Bisher wird der WebGL-Standard von den folgenden Browsern unterstützt (Stand Dezember 2009):

* Gecko-Engine
** Mozilla Firefox 4.0 ([http://www.mozilla-europe.org/de/ Homepage])
*** WebGL muss über die Einstellung <tt>about:config</tt> -> <tt>webgl.enabled_for_all_sites</tt> aktiviert werden. Unter Windows kann es einige Probleme geben, wenn kein OpenGL verfügbar ist, in dem Fall muss [http://hacks.mozilla.org/2009/09/webgl-for-firefox/ in den Softwaremodus geschaltet] werden.
*** Es ist möglich verschiedene Firefox-Versionen parallel zu verwenden. Es ist aber ratsam dafür getrennte Profile anzulegen. Das Ausführen von <tt>firefox -help</tt> in der Konsole dürfte in diesem Zusammenhang hilfreich sein, insbesondere die Optionen <tt>-P</tt>, <tt>-ProfileManager</tt> und <tt>-no-remote</tt>.
* WebKit ([http://nightly.webkit.org/ Nightly Build])
** Google Chrome 4.0.221.8 ([http://build.chromium.org/buildbot/snapshots/ Nightly-Build])
*** mit den Parametern <tt>--enable-webgl</tt> und <tt>--no-sandbox</tt> starten
** Safari (Nightly Build, ab ca. 23.9.2009)
* <span style="color:grey;">...bitte ergänzen...</span>

__TOC__

==Demos==
Zunächst einmal ein paar Demos um die Funktionalität des eigenen Browsers zu testen.
{|{{Prettytable_B1}}
| [[Bild:webgl-sporeviewer.jpg|320px]]<br />[http://people.mozilla.com/~vladimir/webgl/spore/sporeview.html Spore Creature Viewer]
| [[Bild:webgl-metatunnel.jpg|320px]]<br />[http://cs.helsinki.fi/u/ilmarihe/metatunnel.html Metatunnel]
|}

==WebGL==

===Context===
Um WebGL nutzen zu können benötigt man zunächst einmal ein HTML5 Canvas-Element, welchem wir passender weise die ID "canvas" geben. Wir können die Anwendung beispielsweise über das <tt>onload</tt>-Event des <tt>body</tt>-Elements startet. Genauso gut kann man natürlich auch einen Link oder Button verwenden.

<source lang="html4strict">
<html>
<head>
<script type="text/javascript">

</script>
</head>
<body onload="init()">
<div style="text-align: center">
<canvas id="canvas" width="640" height="480"></canvas>
</div>
</body>
</html>
</source>

Von unserem Canvas erhalten wir zum einen die spätere Viewportgröße und zum anderen einen sogenannten Context. Das Context-Objekt erlaubt uns sämtliche OpenGL ES 2.0 Funktionen aufzurufen.

<source lang="javascript">
// our WebGL rendering context, it might be useful to use a global variable for this
var gl = null;

// grab the canvas object and its dimensions
var canvas = document.getElementById("canvas");
var viewportWidth = canvas.width;
var viewportHeight = canvas.height;

// request rendering context from the canvas
var names = [ "webgl", "experimental-webgl", "moz-webgl", "webkit-3d" ];
for (var i=0; i<names.length; i++) {
try {
gl = canvas.getContext(names[i]);
if (gl) { break; }
} catch (e) { }
}
if (!gl) {
alert("No known OpenGL context detected! Is it enabled?");
return;
}

// since WebGL is still experimental, we need some compatibility code
compatibilityCode();
</source>

Da die verschiedenen Implementierungen noch nicht alle auf dem selben Stand sind ist im Augenblick noch etwas Kompatibilitätscode erforderlich. In Zukunft wird dies hoffentlich nicht mehr notwendig sein. Die Funktion <tt>compatibilityCode()</tt> findest du in der [[Tutorial_WebGL_Sample|Beispiel-Implementierung]] dieses Tutorials.

===Shader===
In OpenGL ES 2.0 herrscht Shader-Zwang, eine [[Feste Funktionspipeline|feste Funktionspipeline]] existiert nicht. Stehen der verfügbaren Grafikhardware keine GLSL-Shader zur Verfügung, muss OpenGL ES in den Softwaremodus geschaltet werden und wird entsprechend langsam. Das Laden von GLSL-Shadern geschieht wie gewohnt. Zuerst werden Vertex- und Fragmentshader geladen und compiliert. Beide Shader werden dann an ein Program-Objekt angehängt und gelinkt.

<source lang="javascript">
function loadShader(shaderType, shaderSource) {
var shader = gl.createShader(shaderType);
if (!shader) { return null; }
gl.shaderSource(shader, shaderSource);
gl.compileShader(shader);

if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
alert(gl.getShaderInfoLog(shader));
return null;
}

return shader;
}

var vertexShaderSource = "...Vertexshader als String...";
var fragmentShaderSource = "...Fragmentshader als String...";

var vertexShader = loadShader(gl.VERTEX_SHADER, vertexShaderSource);
var fragmentShader = loadShader(gl.FRAGMENT_SHADER, fragmentShaderSource);
if (!vertexShader || !fragmentShader) {
alert("Shader problem");
}

// create program object
var program = gl.createProgram();

// attach our two shaders to the program
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);

// setup attributes (optional)
gl.bindAttribLocation(program, 0, "aPosition");
gl.bindAttribLocation(program, 1, "aNormal");
gl.bindAttribLocation(program, 2, "aTexCoord");

// linking
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
alert(gl.getProgramInfoLog(program));
}

// setup uniforms (optional)
gl.useProgram(program);
gl.uniform1i(gl.getUniformLocation(program, "uTexture"), 0);
</source>

Im obigen Beispiel wird der Shader-Quellcode fest als String in den JavaScript-Code integriert. Das ist natürlich ziemlich unübersichtlich. Vom Prinzip spielt es keine Rolle wo der String herkommt. Beispielsweise kann man ihn mit einem HTTP-Request in einer Shader-Datei vom Server laden. Es ist aber auch möglich den Shader-Code als spezielles Script-Element in die HTML-Datei einzubinden.

<source lang="html4strict">
<script id="shader-vs" type="x-shader/x-vertex">
attribute vec3 aPosition;
attribute vec3 aNormal;
attribute vec2 aTexCoord;
varying vec3 vNormal;
varying vec2 vTexCoord;
void main() {
gl_Position = vec4(aPosition, 1.0);
vTexCoord = aTexCoord;
vNormal = aNormal;
}
</script>

<script id="shader-fs" type="x-shader/x-fragment">
varying vec3 vNormal;
varying vec2 vTexCoord;
uniform sampler2D uTexture;
void main() {
gl_FragColor = texture2D(uTexture, vTexCoord);
}
</script>
</source>

Der Browser hat vom Script-Typ <tt>"x-shader/x-vertex"</tt> natürlich noch nie etwas gehört und wird das Element entsprechend einfach ignorieren. Mit einer einfachen JavaScript-Funktion kann man aber trotzdem an den Inhalt gelangen.

<source lang="javascript">
function getShaderSource(id) {
var script = document.getElementById(id);
if (!script) { return null; }

var source = "";
var child = script.firstChild;
while (child) {
// node is a "textnode" ?
// see: http://de.selfhtml.org/javascript/objekte/node.htm#node_type
if (child.nodeType == 3) {
source += child.textContent;
}
child = child.nextSibling;
}
return source;
}

var vertexShaderSource = getShaderSource("shader-vs");
var fragmentShaderSource = getShaderSource("shader-fs");
</source>

===VertexBufferObjects===
VertexArrays scheinen zumindest im Firefox bisher nicht implementiert zu sein. Das mag damit zusammenhängen, dass Arrays in JavaScript sehr langsam sind. Arrays müssen nämlich in JavaScript nicht zwangsläufig wirkliche zusammenhängende Arrays sein, sondern können auch als HashMap realisiert sein.

Um Geometrie zu rendern muss also zumindest im Augenblick auf VertexBufferObjects ([[VBO]]s) zurückgegriffen werden. Diese können im wesentlichen wie gewohnt benutzt werden. Es gibt eine spezielle Wrapper-Klasse <tt>WebGLFloatArray</tt> die ein JavaScript-Array mit Werten in ein richtiges float-Array umwandelt. Dieses <tt>WebGLFloatArray</tt> wird dann an OpenGL übergeben. Zusätzlich gibt es auch die Klassen <tt>WebGLByteArray</tt>, <tt>WebGLShortArray</tt> und <tt>WebGLIntArray</tt>. Außerdem existieren auch <tt>WebGLUnsignedByteArray</tt>, <tt>WebGLUnsignedShortArray</tt> und <tt>WebGLUnsignedIntArray</tt>.

Leider existiert im Zusammenhang mit [[glVertexAttribPointer]] ein Bug in der aktuellen Firefox-Implementierung. Aus Sicherheitsgründen wird die mindestens notwendige Größe eines Vertexbuffers geprüft bevor darauf zugegriffen werden kann. Sofern wie im Beispiel ein Interleaved-VBO verwendet wird, wird diese [https://bugzilla.mozilla.org/show_bug.cgi?id=521667 Größe leider falsch berechnet]. Um den Bug zu umgehen müssen im Augenblick Indices benutzt werden.

<source lang="javascript">
// define some vertexdata
var vertices = [
// position XYZ, normal XYZ, texcoord UV => 8 floats per vertex
-0.5, 0.5, 0.0, 0.6, 0.0, 0.8, 0.0, 0.0,
0.5, 0.5, 0.0, 0.6, 0.0, 0.8, 1.0, 0.0,
-0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0,
0.5, -0.5, 0.0, 0.0, 0.6, 0.8, 1.0, 1.0,
];
// we need also some indices because of this annoying Firefox-Bug:
// https://bugzilla.mozilla.org/show_bug.cgi?id=521667
var indices = [
0, 1, 2, 2, 1, 3
];
// create VBO & IBO
var vbo = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
gl.bufferData(gl.ARRAY_BUFFER, new WebGLFloatArray(vertices), gl.STATIC_DRAW);
var ibo = gl.createBuffer();
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new WebGLUnsignedShortArray(indices), gl.STATIC_DRAW);

// ...

// setup interleaved VBO and IBO
gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
gl.enableVertexAttribArray(0);
gl.enableVertexAttribArray(1);
gl.enableVertexAttribArray(2);
gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 8*4, 0*4); // position
gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 8*4, 3*4); // normal
gl.vertexAttribPointer(2, 2, gl.FLOAT, false, 8*4, 6*4); // texcoord

// draw the buffer
gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
</source>

Der schnellste Weg ein Mesh zu laden ist dessen Vertex- und Indexbuffer direkt als JavaScript-Array anzugeben. Die Daten können so nativ vom Browser geladen werden. Größere Meshes hat man natürlich ungern direkt im Quellcode und möchte diese auch vielleicht nicht direkt beim Start der Anwendung laden. Hier bietet sich eine eigene Datei an, die dann über ein [http://www.w3schools.com/XML/xml_http.asp XMLHttpRequest]-Objekt (Stichwort: [http://de.wikipedia.org/wiki/AJAX AJAX]) in JavaScript nachgeladen und anschließend dem Browser zum Parsen übergeben wird. So kann das Laden im Hintergrund realisiert werden.

Ein Problem ist natürlich das Dateiformat. Bisher hat nach meinem Wissen noch niemand einen Benchmark versucht, aber das manuelle Parsen der Daten dauert bei einer JavaScript-Implementierung wahrscheinlich vergleichsweise lange. Außerdem dürfte es in JavaScript schwierig werden Binärdaten zu lesen. Wenn man Daten aus einer externen Datei laden möchte, bietet sich das JSON-Format an. Dieses kann mit der JavaScript-Funktion <tt>eval()</tt> extrem schnell (da nativ) verarbeitet werden. Die folgenden Loader bzw. Konverter sind bekannt:
* Der [http://people.mozilla.com/~vladimir/webgl/spore/sporeview.html Spore Creature Viewer] lädt aus dem Spiel [http://www.spore.com/ Spore] exportierte Meshes direkt mit JavaScript. Spore benutzt das [http://www.collada.org/ COLLADA]-Format.
* Konverter für [http://en.wikipedia.org/wiki/Obj Wavefront OBJ] zu JavaScript-Arrays: [http://www.c3dl.org/index.php/c3dl-dev/wavefront-obj-file-to-javascript-arrays/ Beschreibung], [http://www.c3dl.org/index.php/download/ Download]
* Maxscript ([http://de.wikipedia.org/wiki/3ds_Max Autodesk 3ds Max]) welches JavaScript-Arrays exportiert: [http://www.c3dl.org/index.php/download/ Download]
* [http://www.khronos.org/message_boards/viewtopic.php?f=44&t=2171 Thread im Khronos-Forum] der sich mit dem effizienten Laden von Geometriedaten aus XML- und JSON-Formaten beschäftigt.

Es lohnt sich übrigens diese großen JavaScript-Arrays so kompakt wie möglich zu schreiben. Alleine durch das Weglassen von unnötigen Leerzeichen spart man schnell einige 10 oder 100 kB bei der Dateigröße. Des weiteren erlaubt das HTTP-Protokoll auch die Übertragung mit GZIP-komprimierter Daten. Aktuelle Browser sollten dies nativ unterstützen, so dass keine eigene Implementierung der Komprimierung erforderlich ist. Allerdings muss der HTTP-Server entsprechend konfiguriert sein.

===Texturen===
Das Laden von Texturen ist relativ einfach, da der Browser bereits über die nötige Infrastruktur zum Laden von Bildern in vielen Formaten bereitstellt. Etwas ungewohnt ist der asynchrone Ladevorgang: Ein Bild steht nicht sofort zur Verfügung, da dieses ja möglicherweise zuerst vom Server geladen werden muss. Sobald aber das Bild verfügbar ist wird das <tt>onload</tt>-Event ausgelöst. Was im Fehlerfall geschehen soll wird über das <tt>onerror</tt>-Event festgelegt.
<source lang="javascript">
function loadTexture(filename) {
// preparations
var texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
var image = new Image();

// register event handlers
image.onload = function() {
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.texImage2D(gl.TEXTURE_2D, 0, image);
gl.generateMipmap(gl.TEXTURE_2D);
draw(); // texture now available, we can redraw the scene
}
image.onerror = function() {
alert("error while loading image '"+filename+"'.");
}

// request image from server
image.src = filename;

// return texture object (asynchronous loading, texture NOT available yet!)
return texture;
}
</source>

===Ressourcen und Mathematik===
Dadurch das Ressourcen (Meshes, Texturen, Shader, ...) im Browser asynchron geladen werden, wird entsprechendes Management dieser Ressourcen erforderlich. Eine Ressource darf erst verwendet werden, wenn sie auch wirklich initialisiert wurde. Entsprechend müssen die zugehörigen Callbacks abgewartet werden.

Eine einfache Lösung für dieses Problem ist ein Ressourcenmanager der alle Daten lädt oder zumindest weiß welche Ressourcen noch geladen werden müssen. Zu Beginn wird einfach nur der Text <tt>"Loading..."</tt> angezeigt. Jede Ressource meldet sich beim Manager sobald sie verfügbar ist. Sobald alles korrekt initialisiert wurde kann der Ressourcenmanager die eigentliche Anwendung starten.

Genau wie OpenGL 3.1 besitzt auch OpenGL ES 2.0 keine eigenen Mathematikfunktionen mehr. Einen guten Ansatz bietet hierbei das [http://wiki.delphigl.com/index.php/Tutorial_OpenGL3_Lineare_Algebra Lineare Algebra Tutorial von TAK2004]. Beliebt im Zusammenhang mit WebGL ist im Augenblick die [http://sylvester.jcoglan.com/ JavaScript-Bibliothek Sylvester] die grundlegende Vektor und Matrix Operationen bereitstellt. Die [http://bjartr.blogspot.com/2009/10/webgl-what-is-it-and-how-can-i-use-it_04.html WebGLU Library] versucht unter Rückgriff auf Sylvester die aus OpenGL 2.0 (und älter) bekannten Funktionen wie den Matrix-Stack zurückzubringen.

Soweit von mir, im Anschluss findet ihr noch ein Beispiel sowie eine Liste von Links die nach Möglichkeit aktuell gehalten wird.

'''Coolcat'''
{{TUTORIAL_NAVIGATION|[[Tutorial_GLScene]]|-}}

[[Kategorie:Tutorial|WebGL]]

==Beispiel==
Eine [[Tutorial_WebGL_Sample|Beispielanwendung]] die die hier vorgestellten Code-Schnippsel zusammenfügt ist [[Tutorial_WebGL_Sample|hier]] verfügbar.

[[Bild:webgl-sample.jpg|320px]]

==Links==
* Offizielle Dokumentation
** [https://cvs.khronos.org/svn/repos/registry/trunk/public/webgl/doc/spec/WebGL-spec.html WebGL Specification, Working Draft 10 December 2009]
** [http://www.khronos.org/opengles/2_X/ OpenGL ES 2.X and the OpenGL ES Shading Language]
** [http://www.khronos.org/registry/gles/ Khronos OpenGL ES API Registry]
** [http://www.khronos.org/registry/gles/specs/2.0/es_full_spec_2.0.24.pdf OpenGL ES 2.0.24 Full Specification]
** [http://www.khronos.org/registry/gles/specs/2.0/GLSL_ES_Specification_1.0.17.pdf OpenGL ES Shading Language 1.0.17]
** [http://www.khronos.org/developers/resources/webgl/ WebGL Implementations, Tutorials and Sample Code]
** [http://www.khronos.org/message_boards/viewforum.php?f=35 Offizielles WebGL Forum]
* Bibliotheken
** [http://bjartr.blogspot.com/2009/10/webgl-what-is-it-and-how-can-i-use-it_04.html WebGL Tutorial and WebGLU Library]
** [http://sylvester.jcoglan.com/ Sylvester - Vector and Matrix math for JavaScript]
* Portierung der NeHe OpenGL Tutorials zu WebGL:
** [http://learningwebgl.com/blog/?p=11 Lesson 0: Getting started]
** [http://learningwebgl.com/blog/?p=28 Lesson 1: A triangle and a square]
** [http://learningwebgl.com/blog/?p=134 Lesson 2: Adding colour]
** [http://learningwebgl.com/blog/?p=239 Lesson 3: A bit of movement]
** [http://learningwebgl.com/blog/?p=370 Lesson 4: Some real 3D objects]
** [http://learningwebgl.com/blog/?p=507 Lesson 5: Introducing textures]
** [http://learningwebgl.com/blog/?p=571 Lesson 6: Keyboard input and texture filters]
** [http://learningwebgl.com/blog/?p=684 Lesson 7: Basic directional and ambient lighting]
** [http://learningwebgl.com/blog/?p=859 Lesson 8: The depth buffer, transparency and blending]
** [http://learningwebgl.com/blog/?p=1008 Lesson 9: Improving the code structure with lots of moving objects]
** [http://learningwebgl.com/blog/?p=1067 Lesson 10: Loading a world, and the most basic kind of camera]

* Demos
** [http://people.mozilla.com/~vladimir/webgl/spore/sporeview.html Spore Creature Viewer], ein Viewer für [http://www.collada.org/ COLLADA]-Meshes, allerdings nur für aus dem Spiel [http://www.spore.com/ Spore] exportierte Meshes.
** [http://cs.helsinki.fi/u/ilmarihe/metatunnel.html Metatunnel]
** [http://code.google.com/p/chromium/source/browse/trunk/samples/webgl Beispiele für Chromium], funktionieren scheinbar nicht mit Firefox
** [http://learningwebgl.com/blog/?p=205 Zooming into the Mandelbrot set in a WebGL fragment shader]
** [http://bjartr.blogspot.com/2009/10/interactive-shader-editing-with-webgl.html Interactive Shader Editing with WebGL and the WebGLU Library]
* Sonstiges
** [http://www.planet-webgl.org/ Planet WebGL], eine Aggregation verschiedener Blogs über WebGL

Vorlage:dglOpenGL History

2011-03-15T10:22:29Z

Darkinsanity: typo

<pascal>Version 1.0 - Initial Release

Version 1.1 - Added PPointer in Tpyessection for compatibility with Delphi
versions lower than 7 (SW)
- Added a function named RaiseLastOSError including a comment
on how to make it run under Delphi versions lower than 7 (SW)
- Added some data types according to the GL-Syntax (SW)

Version 1.2 - Fixed some problems with getting the addresses of some
Extensions (e.g. glTexImage3D) where the EXT/ARB did work
but not the core-functions (SW)

Version 1.3 - A second call to ReadimplementationProperties won't
revert to the default libs anymore (MW)
- Libraries now will be released if necessary (MW)

Version 1.3a - Small fixes for glSlang-functions (SW)

Version 1.3b - Fixed a small bug with GL_ARB_shader_objects, that lead
lead to that extension not loaded correctly (SW)

Version 1.3c - More GL 1.5 compliance by FOG_COORD_xx and
ARB-less VBO and occlusion query routines (MW)

Version 1.3d - Fixed linebreaks (should now be corrected under D5) (SW)

Version 1.4 - Changed header to correspond to the OpenGL-Shading
- Language specification 1.10 :
- Added new GL_SAMPLER_*-Constants
- Added Constant GL_SHADING_LANGUAGE_VERSION_ARB
- Added Constant GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB
- Added Constant GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB (SW)

Version 1.4a - Fixed a missing stdcall for glBindAttribLocationARB (SW)

Version 1.4b - Fixed declaration for glUniform*(f/i)vARB (added count) (MW)
- glCompileShaderARB changed from function to procedure (MW)

Version 1.5 - Added support for FreePascal (BR)
- Added type TGLVectorf3/TGLVector3f (SW)

Version 1.6 - Added Extension GL_EXT_framebuffer_object (SX)

Version 1.7 - Added Extension GL_ARB_fragment_program_shadow (SX)
- Added Extension GL_ARB_draw_buffers (SX)
- Added Extension GL_ARB_texture_rectangle (SX)
- Added Extension GL_ARB_color_buffer_float (SX)
- Added Extension GL_ARB_half_float_pixel (SX)
- Added Extension GL_ARB_texture_float (SX)
- Added Extension GL_ARB_pixel_buffer_object (SX)
- Added Extension GL_EXT_depth_bounds_test (SX)
- Added Extension GL_EXT_texture_mirror_clamp (SX)
- Added Extension GL_EXT_blend_equation_separate (SX)
- Added Extension GL_EXT_pixel_buffer_object (SX)
- Added Extension GL_EXT_texture_compression_dxt1 (SX)
- Added Extension GL_NV_fragment_program_option (SX)
- Added Extension GL_NV_fragment_program2 (SX)
- Added Extension GL_NV_vertex_program2_option (SX)
- Added Extension GL_NV_vertex_program3 (SX)

Version 1.8 - Added explicit delegate type definitions (LM)
- Added .Net 1.1 Support (LM)
- Added .Net overloaded functions (LM)
- Added delayed extension loading and stubs (LM)
- Added automatic InitOpenGL call in CreateRenderingContext(LM)
- Added extra Read_* function (LM)

Version 2.0 - fixed some Problem with version string and damn drivers.
String 1.15 identified as OpenGL 1.5 not as OpenGL 1.1 (SX)
- Removed unexisting extension GL_ARB_texture_mirror_repeat(SX)
- Added Extension WGL_ARB_pixel_format_float (SX)
- Added Extension GL_EXT_stencil_clear_tag (SX)
- Added Extension GL_EXT_texture_rectangle (SX)
- Added Extension GL_EXT_texture_edge_clamp (SX)
- Some 1.5 Core Consts added (now completed) (SX)
- gluProject need pointer for not .net (SX)
- gluUnProject need pointer for not .net (SX)
- wglUseFontOutlines* need pointer for not .net (SX)
- wglSwapMultipleBuffers need pointer for not .net (SX)
- Bug with wglGetExtensionsStringEXT removed
different type for .net (SX)
- Added OpenGL 2.0 Core (SX)

Version 2.0.1 - fixed some problems with glGetActiveAttrib in 2.0 Core (SX)
- fixes some problems with gluProject (SX)
- fixes some problems with gluUnProject (SX)
- fixes some problems with gluTessVertex (SX)
- fixes some problems with gluLoadSamplingMatrices (SX)

Version 2.1 - Removed .NET Support (SX)
- Better support for Linux (SX)
- Better Codeformation (SX)
- Added some more Vector/Matrix types (SX)
- Added OpenGL 2.1 Core (SX)
- Added Extension GL_EXT_packed_depth_stencil (SX)
- Added Extension GL_EXT_texture_sRGB (SX)
- Added Extension GL_EXT_framebuffer_blit (SX)
- Added Extension GL_EXT_framebuffer_multisample (SX)
- Added Extension GL_EXT_timer_query (SX)
- Added Extension GL_EXT_gpu_program_parameters (SX)
- Added Extension GL_EXT_bindable_uniform (SX)
- Added Extension GL_EXT_draw_buffers2 (SX)
- Added Extension GL_EXT_draw_instanced (SX)
- Added Extension GL_EXT_framebuffer_sRGB (SX)
- Added Extension GL_EXT_geometry_shader4 (SX)
- Added Extension GL_EXT_gpu_shader4 (SX)
- Added Extension GL_EXT_packed_float (SX)
- Added Extension GL_EXT_texture_array (SX)
- Added Extension GL_EXT_texture_buffer_object (SX)
- Added Extension GL_EXT_texture_compression_latc (SX)
- Added Extension GL_EXT_texture_compression_rgtc (SX)
- Added Extension GL_EXT_texture_integer (SX)
- Added Extension GL_EXT_texture_shared_exponent (SX)
- Added Extension GL_NV_depth_buffer_float (SX)
- Added Extension GL_NV_fragment_program4 (SX)
- Added Extension GL_NV_framebuffer_multisample_coverage (SX)
- Added Extension GL_NV_geometry_program4 (SX)
- Added Extension GL_NV_gpu_program4 (SX)
- Added Extension GL_NV_parameter_buffer_object (SX)
- Added Extension GL_NV_transform_feedback (SX)
- Added Extension GL_NV_vertex_program4 (SX)

Version 3.0 - fixed some consts of GL_EXT_texture_shared_exponent (SX)
- possible better support for mac (SX)
- Added OpenGL 3.0 Core (SX)
- Added Extension GL_ARB_depth_buffer_float (SX)
- Added Extension GL_ARB_draw_instanced (SX)
- Added Extension GL_ARB_framebuffer_object (SX)
- Added Extension GL_ARB_framebuffer_sRGB (SX)
- Added Extension GL_ARB_geometry_shader4 (SX)
- Added Extension GL_ARB_half_float_vertex (SX)
- Added Extension GL_ARB_instanced_arrays (SX)
- Added Extension GL_ARB_map_buffer_range (SX)
- Added Extension GL_ARB_texture_buffer_object (SX)
- Added Extension GL_ARB_texture_compression_rgtc (SX)
- Added Extension GL_ARB_texture_rg (SX)
- Added Extension GL_ARB_vertex_array_object (SX)
- Added Extension GL_NV_conditional_render (SX)
- Added Extension GL_NV_present_video (SX)
- Added Extension GL_EXT_transform_feedback (SX)
- Added Extension GL_EXT_direct_state_access (SX)
- Added Extension GL_EXT_vertex_array_bgra (SX)
- Added Extension GL_EXT_texture_swizzle (SX)
- Added Extension GL_NV_explicit_multisample (SX)
- Added Extension GL_NV_transform_feedback2 (SX)
- Added Extension WGL_ARB_create_context (SX)
- Added Extension WGL_NV_present_video (SX)
- Added Extension WGL_NV_video_out (SX)
- Added Extension WGL_NV_swap_group (SX)
- Added define DGL_TINY_HEADER to suppress automatic
function loading (SX)
- glProcedure renamed to dglGetProcAddress and now it's
visible from outside the unit to custom load functions (SX)
- dglCheckExtension added to check if an extension exists (SX)
- Read_GL_ARB_buffer_object renamed to
Read_GL_ARB_vertex_buffer_object (SX)

Version 3.0.1 - fixed a problem with fpc (SX)

Version 3.0.2 - fixed a problem with WGL_ARB_create_context (SX)

Version 3.2 - Functions from GL_VERSION_3_0 where updated (SX)
- Functions from GL_ARB_map_buffer_range where updated (SX)
- Functions from GL_NV_present_video where added (SX)
- Added consts of GL_ARB_instanced_arrays (SX)
- Defines to identify Delphi was changed (prevent for
feature maintenance) (SX)
- Added Extension GL_ATI_meminfo (SX)
- Added Extension GL_AMD_performance_monitor (SX)
- Added Extension GL_AMD_texture_texture4 (SX)
- Added Extension GL_AMD_vertex_shader_tesselator (SX)
- Added Extension GL_EXT_provoking_vertex (SX)
- Added Extension WGL_AMD_gpu_association (SX)
- Added OpenGL 3.1 Core (SX)
- All deprecated stuff can be disabled if you undef the
define DGL_DEPRECATED (SX)
- Added Extension GL_ARB_uniform_buffer_object (SX)
- Added Extension GL_ARB_compatibility (SX)
- Added Extension GL_ARB_copy_buffer (SX)
- Added Extension GL_ARB_shader_texture_lod (SX)
- Remove function from GL_NV_present_video (SX)
- Added Extension WGL_3DL_stereo_control (SX)
- Added Extension GL_EXT_texture_snorm (SX)
- Added Extension GL_AMD_draw_buffers_blend (SX)
- Added Extension GL_APPLE_texture_range (SX)
- Added Extension GL_APPLE_float_pixels (SX)
- Added Extension GL_APPLE_vertex_program_evaluators (SX)
- Added Extension GL_APPLE_aux_depth_stencil (SX)
- Added Extension GL_APPLE_object_purgeable (SX)
- Added Extension GL_APPLE_row_bytes (SX)
- Added OpenGL 3.2 Core (SX)
- Added Extension GL_ARB_depth_clamp (SX)
- Added Extension GL_ARB_draw_elements_base_vertex (SX)
- Added Extension GL_ARB_fragment_coord_conventions (SX)
- Added Extension GL_ARB_provoking_vertex (SX)
- Added Extension GL_ARB_seamless_cube_map (SX)
- Added Extension GL_ARB_sync (SX)
- Added Extension GL_ARB_texture_multisample (SX)
- Added Extension GL_ARB_vertex_array_bgra (SX)
- Added Extension GL_ARB_draw_buffers_blend (SX)
- Added Extension GL_ARB_sample_shading (SX)
- Added Extension GL_ARB_texture_cube_map_array (SX)
- Added Extension GL_ARB_texture_gather (SX)
- Added Extension GL_ARB_texture_query_lod (SX)
- Added Extension WGL_ARB_create_context_profile (SX)
- Added GLX Core up to Version 1.4 (SX)
- Added Extension GLX_ARB_multisample (SX)
- Added Extension GLX_ARB_fbconfig_float (SX)
- Added Extension GLX_ARB_get_proc_address (SX)
- Added Extension GLX_ARB_create_context (SX)
- Added Extension GLX_ARB_create_context_profile (SX)
- Added Extension GLX_EXT_visual_info (SX)
- Added Extension GLX_EXT_visual_rating (SX)
- Added Extension GLX_EXT_import_context (SX)
- Added Extension GLX_EXT_fbconfig_packed_float (SX)
- Added Extension GLX_EXT_framebuffer_sRGB (SX)
- Added Extension GLX_EXT_texture_from_pixmap (SX)

Version 3.2.1 - Fixed some problems with Delphi < 6 (SX)

Version 3.2.2 - Added Extension GL_APPLE_rgb_422 (SX)
- Added Extension GL_EXT_separate_shader_objects (SX)
- Added Extension GL_NV_video_capture (SX)
- Added Extension GL_NV_copy_image (SX)
- Added Extension GL_NV_parameter_buffer_object2 (SX)
- Added Extension GL_NV_shader_buffer_load (SX)
- Added Extension GL_NV_vertex_buffer_unified_memory (SX)
- Added Extension GL_NV_texture_barrier (SX)
- Variable GL_EXT_texture_snorm will be filled (SX)
- Variable GL_APPLE_row_bytes will be filled (SX)
- Added Extension WGL_NV_video_capture (SX)
- Added Extension WGL_NV_copy_image (SX)
- WGL_NV_video_out now named WGL_NV_video_output (SX)
- Added Extension GLX_EXT_swap_control (SX)

Version 3.2.3 - Fixed a Problem with glGetAttribLocation (SX)
- Added const GL_UNIFORM_BUFFER_EXT (SX)
- Functions of GL_NV_texture_barrier now will be loaded (SX)

Version 4.0 - Changes on Extension GL_ARB_texture_gather (SX)
- Changes on Extension GL_NV_shader_buffer_load (SX)
- Added OpenGL 3.3 Core (SX)
- Added OpenGL 4.0 Core (SX)
- Added Extension GL_AMD_shader_stencil_export (SX)
- Added Extension GL_AMD_seamless_cubemap_per_texture (SX)
- Added Extension GL_ARB_shading_language_include (SX)
- Added Extension GL_ARB_texture_compression_bptc (SX)
- Added Extension GL_ARB_blend_func_extended (SX)
- Added Extension GL_ARB_explicit_attrib_location (SX)
- Added Extension GL_ARB_occlusion_query2 (SX)
- Added Extension GL_ARB_sampler_objects (SX)
- Added Extension GL_ARB_shader_bit_encoding (SX)
- Added Extension GL_ARB_texture_rgb10_a2ui (SX)
- Added Extension GL_ARB_texture_swizzle (SX)
- Added Extension GL_ARB_timer_query (SX)
- Added Extension GL_ARB_vertex_type_2_10_10_10_rev (SX)
- Added Extension GL_ARB_draw_indirect (SX)
- Added Extension GL_ARB_gpu_shader5 (SX)
- Added Extension GL_ARB_gpu_shader_fp64 (SX)
- Added Extension GL_ARB_shader_subroutine (SX)
- Added Extension GL_ARB_tessellation_shader (SX)
- Added Extension GL_ARB_texture_buffer_object_rgb32 (SX)
- Added Extension GL_ARB_transform_feedback2 (SX)
- Added Extension GL_ARB_transform_feedback3 (SX)

Version 4.1 - Possible fix some strange linux behavior (SX)
- All function uses GL instead of TGL types (SX)
- GL_AMD_vertex_shader_tesselator will be read now (SX)
- GL_AMD_draw_buffers_blend will be read now (SX)
- Changes on glStencilFuncSeparate (GL_2_0) (SX)
- Changes on GL_VERSION_3_2 (SX)
- Changes on GL_VERSION_3_3 (SX)
- Changes on GL_VERSION_4_0 (SX)
- Changes on GL_ARB_sample_shading (SX)
- Changes on GL_ARB_texture_cube_map_array (SX)
- Changes on GL_ARB_gpu_shader5 (SX)
- Changes on GL_ARB_transform_feedback3 (SX)
- Changes on GL_ARB_sampler_objects (SX)
- Changes on GL_ARB_gpu_shader_fp64 (SX)
- Changes on GL_APPLE_element_array (SX)
- Changes on GL_APPLE_vertex_array_range (SX)
- Changes on GL_NV_transform_feedback (SX)
- Changes on GL_NV_vertex_buffer_unified_memory (SX)
- Changes on GL_EXT_multi_draw_arrays (SX)
- Changes on GL_EXT_direct_state_access (SX)
- Changes on GL_AMD_performance_monitor (SX)
- Changes on GL_AMD_seamless_cubemap_per_texture (SX)
- Changes on GL_EXT_geometry_shader4 (SX)
- Added OpenGL 4.1 Core (SX)
- Added Extension GL_ARB_ES2_compatibility (SX)
- Added Extension GL_ARB_get_program_binary (SX)
- Added Extension GL_ARB_separate_shader_objects (SX)
- Added Extension GL_ARB_shader_precision (SX)
- Added Extension GL_ARB_vertex_attrib_64bit (SX)
- Added Extension GL_ARB_viewport_array (SX)
- Added Extension GL_ARB_cl_event (SX)
- Added Extension GL_ARB_debug_output (SX)
- Added Extension GL_ARB_robustness (SX)
- Added Extension GL_ARB_shader_stencil_export (SX)
- Added Extension GL_AMD_conservative_depth (SX)
- Added Extension GL_EXT_shader_image_load_store (SX)
- Added Extension GL_EXT_vertex_attrib_64bit (SX)
- Added Extension GL_NV_gpu_program5 (SX)
- Added Extension GL_NV_gpu_shader5 (SX)
- Added Extension GL_NV_shader_buffer_store (SX)
- Added Extension GL_NV_tessellation_program5 (SX)
- Added Extension GL_NV_vertex_attrib_integer_64bit (SX)
- Added Extension GL_NV_multisample_coverage (SX)
- Added Extension GL_AMD_name_gen_delete (SX)
- Added Extension GL_AMD_debug_output (SX)
- Added Extension GL_NV_vdpau_interop (SX)
- Added Extension GL_AMD_transform_feedback3_lines_triangles (SX)
- Added Extension GL_AMD_depth_clamp_separate (SX)
- Added Extension GL_EXT_texture_sRGB_decode (SX)
- Added Extension WGL_ARB_framebuffer_sRGB (SX)
- Added Extension WGL_ARB_create_context_robustness (SX)
- Added Extension WGL_EXT_create_context_es2_profile (SX)
- Added Extension WGL_NV_multisample_coverage (SX)
- Added Extension GLX_ARB_vertex_buffer_object (SX)
- Added Extension GLX_ARB_framebuffer_sRGB (SX)
- Added Extension GLX_ARB_create_context_robustness (SX)
- Added Extension GLX_EXT_create_context_es2_profile (SX)

Version 4.1a - Fix for dglGetProcAddress with FPC and linux (def param) (SW)
</pascal>

XMapWindow

2011-03-08T13:51:04Z

Darkinsanity: kleiner Fehler

= XMapWindow =

== Name ==
'''XMapWindow''' - Mapt ein Fenster

== Delphi-Spezifikation ==
function '''XMapWindow'''(''dpy'': PDisplay; ''w'': Window): Integer;

== Parameter ==

{| border="1" rules="all"
! ''dpy''
| Gibt die Verbindung zum X-Server an
|-
! ''w''
| Gibt das Fenster an, welches gemapt werden soll
|}

== Beschreibung ==
Die Funktion '''XMapWindow''' mapt das angegebene Fenster und alle seine Subfenster die eine Mapping-Anfrage gesendet haben. Das Mappen eines Fensters, dessen Elternfenster nicht gemappt ist, lässt das Fenster nicht erscheinen, jedoch wird es angezeigt sobald alle Elternfenster gemappt sind. Solch ein Fenster nennt man unsichtbar. Wenn alle Elternfenster gemappt wurden, wird das Fenster sichtbar, wird es, sofern es nicht von einem anderen Fenster verdeckt wird, auf dem Bildschirm angezeigt. Diese Funktion hat keinen Effekt wenn das Fenster bereits gemappt ist.

Wenn das override-redirect-Flag des Fensters '''''False''''' ist und ein anderer Client '''''SubstructureRedirectMask''''' für das Elternfenster ausgewählt hat, generiert der X-Server ein '''''MapRequest''''' Ereignis und das Fenster wird von der Funktion '''XMapWindow''' nicht gemappt. Andernfalls wird das Fenster gemappt und der X-Server generiert ein '''''MapNotify'''''-Ereignis.

== Fehlermeldungen ==
'''BadWindow''' wird generiert, wenn ''w'' kein gültiges Fenster ist.

== Siehe auch ==
[[XChangeWindowAttributes]], [[XConfigureWindow]], [[XCreateWindow]], [[XDestroyWindow]], [[XMoveWindow]], [[XMoveResizeWindow]], [[XRaiseWindow]], [[XResizeWindow]], [[XSetWindowBorderWidth]], [[XUnmapWindow]]

[[Kategorie:X|MapWindow]]

XUnmapWindow

2011-03-08T13:50:46Z

Darkinsanity: kleiner Fehler

= XUnmapWindow =

== Name ==
'''XUnmapWindow''' - Unmapt ein Fenster

== Delphi-Spezifikation ==
function '''XUnmapWindow'''(''dpy'': PDisplay; ''w'': Window): Integer;

== Parameter ==

{| border="1" rules="all"
! ''dpy''
| Gibt die Verbindung zum X-Server an
|-
! ''w''
| Gibt das Fenster an, welches geunmapt werden soll
|}

== Beschreibung ==
Die Funktion '''XUnmapWindow''' unmapt das angegebene Fenster und lässt den X-Server ein '''''UnmapNotify'''''-Ereignis generieren. Wenn das angegebene Fenster bereits ungemappt ist, hat '''XUnmapWindow''' keinen Effekt. Normale Sichtbarkeitsberechnungen von vorher verdeckten Fenstern werden durchgeführt. Jegliche Untefenster sind nicht mehr sichtbar bis das Elternfenster wieder gemappt wird. In anderen Worten: Die Unterfenster sind immernoch gemappt, jedoch nicht sichtbar bis das Elternfenster wieder gemappt wird. Das Unmappen eines Fenster generiert '''''Exposure'''''-Ereignisse für Fenster die vom angegebenen Fenster vorher verdeckt wurden.

== Fehlermeldungen ==
'''BadWindow''' wird generiert, wenn ''w'' kein gültiges Fenster ist.

== Siehe auch ==
[[XChangeWindowAttributes]], [[XConfigureWindow]], [[XCreateWindow]], [[XDestroyWindow]], [[XMapWindow]], [[XMoveResizeWindow]], [[XRaiseWindow]], [[XResizeWindow]], [[XSetWindowBorderWidth]], [[XMoveWindow]]

[[Kategorie:X|UnmapWindow]]

XRaiseWindow

2011-03-08T13:49:55Z

Darkinsanity: Komplett übersetzt

= XRaiseWindow =

== Name ==
'''XUnmapWindow''' - Bringt ein Fenster in den Vordergrund

== Delphi-Spezifikation ==
function '''XRaiseWindow'''(''dpy'': PDisplay; ''w'': Window): Integer;

== Parameter ==

{| border="1" rules="all"
! ''dpy''
| Gibt die Verbindung zum X-Server an
|-
! ''w''
| Gibt das Fenster an, welches nach vorne geholt werden soll
|}

== Beschreibung ==
Die Funktion '''XRaiseWindow''' holt das angegebene Fenster nach oben auf den Stapel, so dass kein Geschwisterfenster es mehr überlappt. Wenn die Fenster als ein Stapel Papier auf dem Schreibtisch betrachtet werden, dann ist das nach vorne holen eines Fensters analog zum obendrauflegen eines bestimmten Blattes auf den Stapel, wenn die X- und Y-Koordinaten auf dem Tisch gleich bleiben. Das nach vorne holen eines Fensters kann '''''Exposure'''''-Ereignisse für das Fenster und seine gemappten Subfenster erzeugen, wenn sie vorher verdeckt waren.

Wenn das override-redirect-Flag des Fensters '''''False''''' ist und ein anderer Client '''''SubstructureRedirectMask''''' für das Elternfenster ausgewählt hat, generiert der X-Server ein '''''ConfigureRequest''''' Ereignis und nichts geschieht. Andernfalls wird das Fenster nach vorne geholt.

== Fehlermeldungen ==
'''BadWindow''' wird generiert, wenn ''w'' kein gültiges Fenster ist.

== Siehe auch ==
[[XChangeWindowAttributes]], [[XConfigureWindow]], [[XCreateWindow]], [[XDestroyWindow]], [[XMapWindow]], [[XMoveResizeWindow]], [[XUnampWindow]], [[XResizeWindow]], [[XSetWindowBorderWidth]], [[XMoveWindow]]

[[Kategorie:X|RaiseWindow]]

XUnmapWindow

2011-03-08T13:39:39Z

Darkinsanity: Komplett übersetzt. Vielleicht etwas zu wörtlich.

XMapWindow

2011-03-08T13:27:27Z

Darkinsanity: Die ersten zwei Absätze übersetzt

= XMapWindow =

== Name ==
'''XMapWindow''' - Mapt ein Fenster

== Delphi-Spezifikation ==
function '''XMapWindow'''(''dpy'': PDisplay; ''w'': Window): Integer;

== Parameter ==

{| border="1" rules="all"
! ''dpy''
| Gibt die Verbindung zum X-Server an
|-
! ''w''
| Gibt das Fenster an, welches gemapt werden soll
|}

== Beschreibung ==
Die Funktion '''XMapWindow''' mapt das angegebene Fenster und alle seine Subfenster die eine Mapping-Anfrage gesendet haben. Das Mappen eines Fensters, dessen Elternfenster nicht gemappt ist, lässt das Fenster nicht erscheinen, jedoch wird es angezeigt sobald alle Elternfenster gemappt sind. Solch ein Fenster nennt man unsichtbar. Wenn alle Elternfenster gemappt wurden, wird das Fenster sichtbar, wird es, sofern es nicht von einem anderen Fenster verdeckt wird, auf dem Bildschirm angezeigt. Diese Funktion hat keinen Effekt wenn das Fenster bereits gemappt ist.

Wenn das override-redirect-Flag des Fensters '''''False''''' ist und ein anderer Client '''''SubstructureRedirectMask''''' für das Elternfenster ausgewählt hat, generiert der X-Server ein '''''MapRequest''''' Ereignis und das Fenster wird von der Funktion '''XMapWindow''' nicht gemappt. Andernfalls wird das Fenster gemappt und der X-Server generiert ein '''''MapNotify'''''-Ereignis.

== Fehlermeldungen ==
'''BadWindow''' wird generiert, wenn ''w'' kein gültiges Fenster ist.

== Siehe auch ==
[[XChangeWindowAttributes]], [[XConfigureWindow]], [[XCreateWindow]], [[XDestroyWindow]], [[XMapWindow]], [[XMoveResizeWindow]], [[XRaiseWindow]], [[XResizeWindow]], [[XSetWindowBorderWidth]], [[XUnmapWindow]]

[[Kategorie:X|MoveWindow]]

dglOpenGL.pas/en

2011-03-08T13:05:45Z

Darkinsanity: typo

{{Warnung| '''Delphi is already shipping with an OpenGL header, but that header is ''outdated and also buggy''. Therefore we ''urge everyone to NOT use that header, especially as it lacks most of OpenGL's current functionality.'''''}}

<div align="center">[[Bild:Flag_german.gif]][[dglOpenGL.pas| Gehe zur deutschen Version dieser Seite ]][[Bild:Flag_german.gif]]</div>

=The DelphiGL header=
So to compensate for the flaws of the outdated and buggy default header that is shipped with Delphi, the [http://www.delphigl.com (german) Delphi OpenGL Community] is providing it's own header that's permanently updated to provide steady support for new OpenGL features and functionality. This makes updating to a new header version easy (usually backwards compatibility is preserved), and it's even possible to use the header with other pascal compilers like Freepascal.

It includes all OpenGL functions (currently up-to and including OpenGL 4.1) as well as all GLU ('''OpenGL Utility Libary''') functions and supports all ARB, EXT, NV and ATI extensions. It also includes additional, though lesser common extensions from other vendors like Apple, HP and SGI.

A special feature of this header are boolean variables for each included extension that are flagged upon initialisation (those boolean vars carry the same as their corresponding extensions), so you can quickly check whether an extension is support or not (instead of checking the strings returned by [[glGetString/en]]).

==Licence/Terms of use==
The '''dglOpenGL.pas''' is distributed unter the terms and conditions of the '''Mozilla Public License Version 1.1'''. You can grab a copy of that licence [http://www.mozilla.org/MPL/MPL-1.1.html here].

<code>The contents of the dglOpenGL.pas are used with permission, subject to<br>
the Mozilla Public License Version 1.1 (the "License"); you may<br>
not use this file except in compliance with the License. You may<br>
obtain a copy of the License at<br>
http://www.mozilla.org/MPL/MPL-1.1.html<br>
<br>
Software distributed under the License is distributed on an<br>
"AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or<br>
implied. See the License for the specific language governing<br>
rights and limitations under the License.</code>

==.NET support==
Due to lack of interest, .NET support has been removed as of header version 2.1!

{{Hinweis|The .Net header won't be developed any further, but reported errors may be fixed. So new OpenGL functionality can only be found in the normal header.}}

==Initializing function pointers (crucial)==
Along with the removal of .NET support, support for loading methods dynamically has also been removed and is no longer possible with the standard header. So it's crucial to call either '''AtivateRenderingContext''' or '''ReadExtensions''' alongside with '''ReadImplementationProperties''' in your application before accessing any of the OpenGL functions. Otherwise you'll likely be prompted with an access violation at address 0x00000000.

''So if you get such an access violation please check if you called the above functions!''

Example for '''initializing''' the OpenGL function pointers (''needs to be called before you access any OpenGL functions'') :
<source lang="pascal">procedure OpenGLInit;
begin
InitOpenGL; // Don't forget, or first gl-Call will result in an access violation!
MyDC := GetDC(...);
MyRC := CreateRenderingContext(...);
ActivateRenderingContext(MyDC, MyRC); // Necessary, will also load function pointers for all extension
...
end;</source>

Example for '''finishing''' the OpenGL render context (''should be called before quitting your application'') :
<source lang="pascal">procedure OpenGLFinish;
begin
DeactivateRenderingContext; // Deactivates the current context
wglDeleteContext(myRC);
ReleaseDC(Handle, myDC);
end;</source>

==Download==

<div align="center">
'''{{ArchivLink|file=dglOpenGL|text=Current dglOpenGL.pas}}'''

(Supports ''OpenGL 4.1'', works with Delphi 4 and up and Freepascal))

''{{ArchivLink|file=dglOpenGL_net|text=Last dglOpenGL.pas wit .NET support}} (Supports ''OpenGL 2.1'')''

''(Note : This header is'nt developed any further)''

'''For Delphi 3 users :'''
''[[Benutzer:Mars|Mars]] has posted a version of the dglOpenGL.pas that will work with Delphi 3, you can get it here :<br>
[http://www.delphigl.com/forum/viewtopic.php?p=26697#25642 dglOpenGL.pas for Delphi 3] <br>
''(You need to be registered on the forums to download it)''

''There is also an inofficial version of this [http://www.delphigl.com/forum/viewtopic.php?t=4216 headers for C++].''
</div>

== History ==
{{dglOpenGL_History}}

Tool

2011-03-07T18:35:11Z

Darkinsanity: Letzter Verweis im Wiki auf NovodeX gegen PhysX getauscht

== Kostenlose Tools ==

Kostenlose für OpenGL/3D-Spieleprogrammierung/3D-Grafik relevante Tools und Programme.

=== OpenGL ===
{| {{Prettytable_B1}}
!width="25%"| Name, Link
!width="75%"| Beschreibung
|-
![http://www.realtech-vr.com/glview/ GLView]
|Tool welches Informationen über die auf einem Rechner vorhandene GL Implementation extrahiert und anzeigt. Unter anderem von welchem Hersteller die Implementation stammt und welche Extensions/GL-Version unterstützt wird.
|-
![http://delphi3d.net/hardware/index.php GLinfo]
|Tool welches Informationen über die auf einem Rechner vorhandene GL Implementation extrahiert und anzeigt. Es werden auch technische Informationen wie maximal zulässige Texturgröße angezeigt. Das Tool generiert ein Logfile was, wenn gewünscht, auch in die '''OpenGL Hardware Registry''' eingetragen werden kann.
|-
![http://www.gremedy.com/ gDEBugger]
| Mächtiger OpenGL/OpenCL Debugger, Profiler und Memory Analyzer.
|}

=== Mathematik/Physik ===
{| {{Prettytable_B1}}
!width="25%"| Name, Link
!width="75%"| Beschreibung
|-
![http://www.amd.com/acml/ ACML]
| Bibliothek mit hochoptimierten Befehlen für Mathematische Berechnungen (C++, gut dokumentiert, AMD-optimiert)
|-
! [http://math-atlas.sourceforge.net/ ATLAS]
| Bibliothek basierend auf BLAS und LAPACK (C++/Fortran)
|-
! [http://www.netlib.org/blas/ BLAS]
| Bibliothek mit optimierten Befehlen für lineare Algebra (Fortran 77)
|-
! [http://www.partow.net/projects/fastgeo/index.html FastGeo]
| Bibiothek mit optimierten mathematischen Funktionen die direkt für Delphi/FreePascal entwickelt wurde. Prozedural aufgebaut (nicht OOP)
|-
! [http://www.fftw.org/ FFTW]
| Bibliothek mit optimierten Befehlen für FFTs (als DLL mit C++/Pascal-Header erhältlich)
|-
! [http://www.netlib.org/lapack/ LAPACK]
| Bibliothek mit optimierten Befehlen für lineare Algebra (Fortran 77)
|-
! [http://www.nvidia.de/object/nvidia_physx_de.html PhysX Engine]
| Eine der größten Physik-Engines
|-
! [http://www.library.cornell.edu/nr/bookcpdf.html Numerical Recipes]
| Dokumentation mit vielen Beispielen zur Funktionsweise verschiedenster Algorythmen; die Bibel der Numeriker schlechthin
|}

=== 2D/Texturen-Tools ===

{| {{Prettytable_B1}}
!width="25%"| Name, Link
!width="75%"| Beschreibung
|-
! [http://www.lmnopc.com/bitmapfontbuilder/ Bitmap Font Builder]
| Erstellt 2D-Fonttexturen, mit diversen Einstellungsmöglichkeiten. Exportiert zudem auch noch die Dimensionen der Buchstaben.
|-
! [http://www.saschawillems.de/?page_id=253 Explosion Texture Generator]
| Erstellt eine 2D-Textur mit einer animierten Explosion. Ideal für animierte Billboard-Explosionen.
|-
! [http://www.planetside.co.uk/terragen/ Terragen]
| Ein besseres Tool zum Erstellen realistischer Skybox-Texturen gibt es nicht.
|-
! [http://www.planetside.co.uk/terragen/tg2/tech_preview.shtml Terragen 2 Technology Preview]
| Obwohl noch die Technology Preview schon gut geeignet um sowohl Skyboxes als auch Terrain-Texturen mit Normalmaps zu rendern.
|-
! [http://www.saschawillems.de/?page_id=92 TerrTexGen]
| Tool zur Erstellung von Terraintexturen. Oft und gerne genutzt.
|-
! [http://www.bundysoft.com/L3DT/ L3DT]
| Der 'Large 3D Terrain Generator' (L3DT) erzeugt hochwertige 16bit Graustufen [[Heightmap|Heightmaps]] sowie Alphamaps und darf auch in der kostenlosen Version kommerziell genutzt werden.
|-
! [http://www.texturesynthesis.com/texture.htm MRFsynthesis]
| Automatische Generierung von hochwertigen, kachelbaren Texturen mit beliebiger Auflösung aus Fotos oder anderen Quelltexturen. Ausführliche Beschreibung im [[Texturesynthesis|Texturesynthesis-Artikel]].
|-
! [http://www.logarithmic.net/pfh/resynthesizer Resynthesizer]
| Ein Plugin für '''GIMP''' mit ähnlichen Funktionen wie '''MRFsynthesis''', jedoch mehr Features und höherer Geschwindigkeit. Ausführliche Beschreibung im [[Texturesynthesis|Texturesynthesis-Artikel]].
|-
! [http://www.gimp.org/ GIMP]
| GNU Image Manipulation Tool. Gutes kostenloses Bildbearbeitungsprogramm das sich nicht unbedingt vor Photoshop & Co. (mal abgesehen von der UI) verstecken muss.
|-
! [http://web.bethere.co.uk/terabit/ Tattoo]
| Ein sog. 3D-Paint Tool, mit dem man direkt auf ein Modell zeichnen kann und so Texturen erstellen kann. Besonders für Leute die Probleme haben 2D-Texturen für komplexe Modelle zu erstellen ein tolles Programm. Das Tool unterstützt viele Modell- und Texturformate und ist für die nicht-kommerzielle Nutzung umsonst.
|-
! [http://www.lysator.liu.se/~kand/caustics/ Caustics Generator]
| Ein sehr schönes Programm, dass Relief-Texturen aller Colleur erzeugen kann. Das Programm eignet sich auch zum automatischen Berechnen animierter Sequenzen, wie zum Beispiel einer Wasserbewegung in 30 Frames. Sowohl die Ränder als auch die Übergänge zeitlich werden so erstellt, dass alle Übergänge fließend wirken.
|-
! [http://neotextureedit.sourceforge.net/index.html NeoTextureEdit]
| NeoTextureEdit ist ein einfach zu benutzender, graphenbasierter OpenSource-Textureditor/-generator. Auf Basis von kontinuierlichen Funktionen und Filtern kann man Texturen beliebiger Größe und Auflösung erzeugen.
|}

=== 3D-Tools ===

{| {{Prettytable_B1}}
!width="25%"| Name, Link
!width="75%"| Beschreibung
|-
! [http://www.delgine.com/ DeleD]
| Mit Delphi entwickelter 3D-Editor, der speziell auf Spieleentwickler ausgerichtet ist. Zwar noch in Entwicklung, aber bereits mehr als brauchbar.
|-
! [http://www.anim8or.com/ Anim8or]
| Kostenloser 3D-Modeller, allerdings fehlen (noch) einige nützliche Features wie z.B. UVW-Mapping.
|-
! [http://sourceforge.net/projects/wings/ Wings 3D]
| Freeware Polygon Modeller. Obwohl ihm noch einige Features fehlen, ist er einen Blick wert.
|-
! [http://www.blender3d.org/ Blender3D]
| Sehr ausgereiftes und komplexes 3D Tool mit frei gestaltbarer Oberfläche.
* [http://blendpolis.serverpool.org/f/article.php blend.polis]- Deutsche Blender Seite mit Tutorials
* umfangreiches [http://www.trcoding.de/informatik/blender/index.html Einsteiger Tutorial]
* '''sehr gute''' [http://blenderunderground.com/category/video-tutorials/ Video-Tutorials] (englisch)
|-
! [http://www.fluidstudios.com/ FSRad]
|Auf Lightmaps spezialisierter Radiosity Prozessor.
|-
! [http://www.delphigl.com/forum/viewtopic.php?t=2421 gl3ds]
| '''3ds''' Model-Loader (DGL-Projekt)
|}

=== Shaderentwicklung ===

{| {{Prettytable_B1}}
!width="25%"| Name, Link
!width="75%"| Beschreibung
|-
! [http://www.ati.com/developer/rendermonkey/index.html RenderMonkey 1.5]
| ATI's HLSL-Shader IDE. Jetzt auch endlich mit Support für glSlang.
|-
! [http://www.opengl.org/sdk/tools/ShaderDesigner/ OpenGL Shader Designer]
| Gute Shader IDE für glSlang.
|}

=== Sound ===

{| {{Prettytable_B1}}
!width="25%"| Name, Link
!width="75%"| Beschreibung
|-
! [http://www.buzzmachines.com/ BUZZ]
| Komplettes Soundstudio für E-Sounds. Es existieren unmengen Plugins welche das verhalten von allen denkbaren Soundeffekten und Soundgeneratoren imitieren können.
|-
! [http://www.bluemoon.ee/history/scwin/index.html Sound Club]
| Eine Art "Tracker" mit recht vielen Features, der dass Erstellen von Musik einfach macht. War mal Shareware, ist inzwischen aber als Freeware erhältlich.
|-
! [http://www-personal.monash.edu.au/~myless/catnap/pamela/index.html PAMELA]
| Vergleicht in Waveform abgespeicherte Sprache mit einem eingegebenem Text und ermittelt an welchem Zeitpunkt welche Laute vorkommen, und erstellt daraus eine Liste. Mit Hilfe dieser Liste kann man seine Figuren lippensynchron animieren.
|-
! [http://www.madtracker.org/ MadTracker]
| Sehr ausgereifter, professioneller Tracker. Kann auch FastTracker-Module (*.xm) bearbeiten. Wer modulbasierte Musik in seinen Programmen nutzen will, sollte sich MadTracker auf jeden Fall ansehen.
|-
! [http://www.modplug.com/ ModPlugTracker]
| Sehr ausgereifter und vielseitiger Tracker. Kann alle gängigen Module (*.mod, *.nst, *.s3m, *.stm, *.xm, *.it, *.mtm, *.okt, *.mdl, *.669, *.far) bearbeiten, sowie Midis und Waves importieren und exportieren. Auch einen Download wert: ModPlugPlayer, der kleine Bruder vom Tracker, der die oben genannten Module abspielen kann und das mit einer Vielzahl von Funktionen. So kann z.B. der Resampling-Mode eingestellt werden, oder die Geschwindigkeit des abgespielten Mods, sowie die Tonhöhe über Schieberegler verändern. Die beiden Programme können auch komprimierte Mods (*.mdz, *.s3z, *.xmz, *.itz), sowie die Unreal-Module (*.utx) bearbeiten.
|}

=== Programmierung/IDE/Allgemein ===

{| {{Prettytable_B1}}
!width="25%"| Name, Link
!width="75%"| Beschreibung
|-
! [http://www.prestosoft.com/ps.asp?page=edp_examdiff ExamDiff]
| Beschreibung: Visuelles Vergleichsprogramm für Text/Quellcode Dateien um Veränderungen an solchen Dateien zu suchen. (Freeware nur Pro Version kostenpflichtig)
|-
! [http://www.gexperts.org/ GExperts]
| Geniale IDE-Erweiterung (inkl. diverser Tools) um die Produktivität bzw. Funktionalität von Delphi zu verbessern/erweitern.
|-
! [http://www.automatedqa.com/downloads/memproof.asp MemProof]
| Ein Tool für diverse Borland Entwicklungsumgebungen, welches nach Speicherlecks sucht.
|-
! [http://www.winmerge.org/ WinMerge]
| Externes Datei-Vergleichen zum visuellen Zusammenführen von Konflikten.
|}

Linuxpfad

2011-03-05T13:00:24Z

Darkinsanity: Den Namen von Linus Torvalds falsch zu schreiben grenzt ja schon an Ketzerei ;)

=Einführung=
Zuerst sollte man den Begriff Linux näher erläutern, denn dieser wird doch häufig falsch genutzt.
Mit Linux ist der Kernel von Linus Torvalds gemeint und nicht eine Distribution.

==Was ist der Unterschied zwischen einer Distribution und dem Linux-Kernel?==

Der Linux-Kernel ist das Herzstück, er enthält alle Treiber und Module für das Ansprechen und Verwalten der Hardware.
So enthält dieser z.B. Scheduler für CPU und Festplatte, Speichermanager und sogar Dateisysteme wie ext2.
Eine Distribution ist z.B. RedHat Server, Fedora, Ubuntu, BSD, Gentoo, myOS, SLAX ... .
Diese bieten auf den Kernel aufbauende und vorgefertigte (teilweise vorkompiliert, vorkonfiguriert, gepatchte) Pakete.
Die Distributionen unterscheiden sich in vielerlei Hinsicht, einige wollen minimalistisch sein, andere wollen Windows von Microsoft nachahmen und andere wiederum bieten Serverlösungen an.
Hinter Distributionen stecken oft Communities, einzelne Leute oder im Falle von RedHat Server und Fedora größere Firmen.
Diese Distributionen verwenden in der Regel unterschiedliche Packetmanagmentsysteme(apt, emerge,...), unterschiedliche Bibliotheken und Desktop Systeme (xfc, gnome, kde, ...).

== Exkursion: Welche Distribution für wenn? ==
Für viele Distributionen ist die wichtigste Regel nur Opensource-Pakete zu enthalten um den Geist von Opensource zu wahren. Andere wie z.B. Ubuntu halten es mit dieser Regel nicht so genau und liefern Binärtreiber von z.B. Nvidia oder ATI mit. Diese sind bei den anderen Distributionen nicht dabei und müssen von Hand installiert werden.

Für Einsteiger ist dies oft schon zuviel erwartet und dann auch das ganze Rechtesystem mit root, usern und einiges mehr, Ubuntu hat in der Richtung vieles vereinfacht und kann somit locken.
Für erfahrende Linuxer ist Ubuntu mehr schlecht als recht, da diese dann einiges an Arbeit reinstecken müssen, um das System an ihre Wünsche anzupassen.
Diese setzen dann je nach Bedarf auf Distribution wie Fedora, Gentoo, Debian,... .

Genug Worte über Distributionen, Kernel und Paketen, wer noch mehr wissen will, der kann [http://karmarama.developer-alliance.org/?site=artikel diesem] Link folgen und sich über die Suchmaschine des Vertrauens weiter schlau machen.

=Einstieg in die Linuxprogrammierung=
An dieser Stelle wird erwartet, dass die Distribution der Wahl sowie den entsprechenden Grafikkartentreiber installiert ist. Wenn letzterer nicht installiert ist, läuft OpenGL automatisch unter Mesa.
Mesa ist ein Software Renderer, der eine volle OpenGL 3.0 Unterstützung auf der CPU realisiert.

Wenn man OpenGL programmiert, dann lädt man die Funktionen aus der OpenGL32.dll (Windows) oder aus der libGL.so (Linux). Diese sind jedoch nur Wrapper, die auf die entsprechenden Funktionen in Mesa oder aus dem Hardwaretreiber (z.B. nvogl32.dll, /usr/lib/ati/libGL.so) zeigt.
Wenn wir unter Linux programmieren, dann werden wir immer wieder auf den Buchstaben X oder auf X11 stossen. X steht hier für den Desktop Manager, das X-Window-System. Er stellt uns Fenster, Rendercontext, Pixelformat, Maus und andere Dinge zur Verfügung.
In OpenGL gibt es wgl... für Windows-basierte und glX... für X11(Linux) basierte Befehle.

{{Hinweis|Siehe [[GLX]]}}

Die wichtigsten X11 Befehle sind:
*[[glXChooseVisual]]
*[[glXCreateContext]]
*[[glXDestroyContext]]
*[[glXMakeCurrent]]
*[[glXSwapBuffers]]

*[[XCreateSimpleWindow]]
*[[XDestroyWindow]]
*[[XMapWindow]]
*[[XCreateBitmapFromData]]
*[[XFreeCursor]]
*[[XCreatePixmapCursor]]
*[[XFreePixmap]]
*[[XChangeWindowAttributes]]
*[[XInternAtom]]
*[[XSetWMProtocols]]
*[[XStoreName]]
*[[XResizeWindow]]
*[[XFlush]]
*[[XMoveWindow]]
*[[XUndefineCursor]]
*[[XOpenDisplay]]
*[[XCloseDisplay]]
*[[XDefaultScreen]]
*[[XPending]]
*[[XNextEvent]]
*[[XGetAtomName]]
*[[XSync]]

*[[XF86VidModeSwitchToMode]]
*[[XF86VidModeSetViewPort]]
*[[XF86VidModeGetAllModeLines]]

Zum Start mit OpenGL unter X11 braucht man gerademal einen Bruchteil der aufgelisteten Funktionen.
Wenn man einen eigenen Cursor oder gar keinen Cursor haben will, die Auflösung verändern möchte, Fenster positionieren, auf einen der Displays verschieben oder die Überschrift und Ausmaße des Fenster ändern will, dann hat man bereits alle Funktionen.
Die Befehle befinden sich in den Units x, glx, xlib, xutil und xf86vmode, welche alle mit Freepascal ausgeliefert werden. Delphi selber läuft nur unter Windows, Kylix (der Linuxcompiler von Borland) wurde eingestellt und ist veraltet. Somit ist für plattformunabhängige Entwicklung darauf zu achten, dass der Code auch mit den Freepascal-Compiler (im Delphimodus) kompiliert. Für die C/C++ler gelten folgende Header: includes <X11/Xlib.h>,<GL/glx.h> und <X11/extensions/xf86vmode.h>.

Lazarus bietet für die plattformübergreifende Verwendung von OpenGL eine Komponente "TOpenGLContext" an, die sich um die Initialisierung eines OpenGL-Kontexts kümmert.

=Nützliche Links=
*[http://www.xfree86.org/current/manindex3.html Manual für C/C++]
*[http://www.freepascal.org/docs-html/packages/opengl/glx/index-6.html glX für FPC]
*[https://svn.linuxprofessionals.org/filedetails.php?repname=karmarama&path=%2Fprerelease%2Fwrapper%2FKar_XLib.pas Kar_XLib.pas]
*[https://svn.linuxprofessionals.org/filedetails.php?repname=karmarama&path=%2Ftrunk%2Fsrc%2Flinux%2Fkar_x11.cpp kar_x11.cpp]
*[https://svn.linuxprofessionals.org/filedetails.php?repname=karmarama&path=%2Ftrunk%2Finclude%2Flinux%2Fkar_x11.hpp kar_x11.hpp]

[[Kategorie:Trampelpfad]]

Physik

2011-03-05T12:40:44Z

Darkinsanity: ageia NovodeX Link gegen nVidia PhysX getauscht

{{Hinweis|Physik in Spielen ist sehr vielfältig. Dieser Artikel beschreibt einige Fasetten und kann keinesfalls als Vollständig gelten.}}
Die Physik ist mittlerweile in fast allen Spiele-Genres zum wichtigen Bestandteil geworden.
Da in den letzten Jahren die Grafik massiv in den Mittelpunkt geraten ist, haben wir heute schon nahe Photorealistische Spiele aber darunter haben andere Teile, wie z.B. Physik und KI gelitten.
Ein Spiel kann aber nur so gut sein, wie sein schlechtestes Modul.
Wenn die KI gegen die Wand läuft, über eine Kiste nicht rüber oder vorbei kommt, dann hilft auch die beste Grafik nichts.
Der Spieler wurde unschön aus der Spielwelt rausgerissen und nun hat er Zeit zu überlegen, was er nun tut(z.B. das Spiel beenden).
Die Physik arbeitet für die KI vor, denn die KI braucht Wissen über die Umgebung.
Also hat die Physik einen wichtigen Platz in der Gameengine.
Mittlerweile werden sogar Hardware-Physik-Beschleuniger entwickelt (siehe [http://www.ageia.com/ Ageia]), die, wie Grafikkarten, die CPU bei speziellen Berechnungen entlasten sollen.
Parallisierung ist ebenfalls ein wichtiger Schritt und neue Algorythmen, zur schnelleren Kollisionserkennung, sortierung und reaktion auf Kollisionen.

== Kollisionskontrolle ==

Ein Egoshooter, bei dem man durch Wände laufen kann, ein Echtzeitstrategiespiel, bei sich Einheiten durch Gebäude bewegen, all dies kommt der Realität nicht so wirklich nahe.

Deshalb verfügen selbst einfachste Jump&Run-Spiele über eine Kollisionskontrolle. Diese verhindert, dass sich Objekte ungebremst durch andere Objekte bewegen können.
Überprüft wird hierbei, ob ein Objekt A (z.B. der Spieler) ein Objekt B (z.B. die Wand) berührt. Ist dies der Fall, wird die Bewegung des Objektes A in die Richtung des Objektes B blockiert, und die Routine für das Verhalten bei Kollisionen aufgerufen.

Da diese Berechnung bei Objekten mit vielen Polygonen sehr rechenintensiv ist, werden in der Praxis meist so genannte Bounding Volumes verwendet(z.B. [[Bounding_Box|Bounding-Boxes]]). Dabei wird für die Kollisionskontrolle nicht das Objekt mit vielen Polygonen verwendet, sondern ein Objekt aus geometrischen Formeln. So kann der Spieler in einem 3D-Shooter durch fünf einfache Quader (Rumpf & Kopf, Arme, Beine) simuliert werden. In den meisten Fällen ist solch eine einfache [[Bounding_Box|Bounding-Box]] bereits ausreichend.

{{Hinweis|Kollisionsberechnung und auch Bounding Volumes werden im 3 teiligen [[Tutorial Kollision1|DGL Tutorial zum Thema "Kollision"]] behandelt.}}

== Bounding Volumes ==

Bounding Volumes erleichtern das ausschliessen von Objektkollisionen, da diese durch einfache Mathematische Formeln sehr schnell geprüft werden. Hierbei wird z.B. eine Bounding Sphere, um das Objekt, gespannt und durch das prüfen der Distanz und Radius zwischen 2 BoundingSpheres eine Kollision festgestellt. Man verwendet im ersten Pass(im regelfall) eine Bounding Sphere, gibt es eine Kollision dann wird eine genauere prüfung durchgeführt, z.B. Bounding Box und dann Triangle basiert. Eine gute Möglichkeit ist auch das verwenden von einem spatial partition system(z.B. Octree oder BSP). Hierbei wird ein Triangle basiertes Objekt in einen Octree zerlegt und somit sind bei sehr hoch Polygonierten Models, die entsprechenden Triangle einfach zu finden. Eine andere Möglichkeit, komplexe Models zu verarbeiten, ist das berechnen einer Hülle. Die Hülle ist wieder eine abstraktere Variante aber reicht oft als Lösung.

== Gravitation ==

Gerade bei neueren Spielen, in denen viele frei bewegliche Objekte vorhanden sind, ist die Simulation der Schwerkraft sehr wichtig. Hier ein kurzes Beispiel:

Der Spieler läuft durch einen Gang, in dem mehrere Kisten stehen. Er schießt auf eine Kiste. Durch die Wucht der Geschosse wird die Kiste in die Luft geschleudert.

Ohne die Gravitation würde diese Kiste nun ewig im Raum rumschweben.
Durch die Gravitation jedoch fällt die Kiste wieder zu Boden, was der Realität auf der Erde doch näher kommt. Für den Einsatz der Gravitation, muss jedem Objekt eine Masse zugewiesen werden.

Durch Gravitation wirkt die Reibung stärker und Objekte lassen sich schwerer bewegen, können sogar bei größerer Masse ein anderes Objekt deformieren oder kaputt machen.
Je Höher die Masse und Dichte eines Objektes, des so höher die Gravitation, die davon ausgeht.

== Plastische Verformungen ==

Plastische Verformungen sind meist das Ergebnis einer Kollision. Das wohl beste Beispiel für den Einsatz von plastischen Verformungen ist das Schadensmodell der Autos in Rennspielen, bei denen die Fahrzeuge bei Crashs Kratzer und Dellen bekommen.
Diese wurden in der Vergangenheit vorher modeliert und dann einfach die Models ausgetauscht aber heute werden auch hier die Methoden komplexer. So werden z.B. die Models über die unterschiedlichsten Varianten verändert. Das zerlegen der Spielewelt, wie es in RedFaction zum ersten mal groß bekannt wurde, hat man z.B. in die neueste Unreal Engine 3 Subversion übernommen.
Eine gängige Methoden ist z.B. das erfassen des Einflussradius(der Zerstörung), spannen eines Octrees,entfernen von Nodes und dann die neuberechnung der Hülle.
Diese Variante ist natürlich höchstgradig ungenau aber mit steigender Rechenpower kann man hier minimalistische Simulationen einbringen. So könnte man z.B. an die Funktion, zum entfernen von Nodes, weitere komplexe Bedingungen(absorbation von Engergie, durch die einzelnen Materialien) knüpfen.
Eine verwendung, der Grundlagen von Schallausbreitung, könnte hier auch einiges für Explosionen bringen.

== Ragdoll ==

Unter Ragdoll-Simulationen versteht man die Simulation des Zubodengehens einer Spielfigur. Diese Technik wird meist in 3D-Shootern verwendet, um darzustellen wie z.B. die Gegner von den Treffern des Spielers nach hinten geworfen werden, vom Balkon fallen und dabei an Ästen hängen bleiben wobei sich ihr Körper weiter verformt.
Diese physikalisch korrekt berechnete Simulation des Todes ist gerade in Deutschland sehr umstritten.

== Fertige Physikbibliotheken ==

Wer keine Zeit, Lust oder Geduld hat, eine eigene Physikbibliothek zu erstellen findet hier eine kleine Auswahl an fertigen:
# Havok (http://www.havok.com/) (Windows)
# Newton (http://newtondynamics.com/) (Windows, Linux, MacOS X)
# PhysX (http://www.nvidia.de/object/nvidia_physx_de.html) (Windows)
# ODE (http://www.ode.org/) (Windows, Linux, MacOS X)
# Bullet physics (http://www.bulletphysics.com/) (alle gängigen Plattformen und OS)

Enginepfad

2011-03-05T12:27:16Z

Darkinsanity: Ageia NovodeX ist schon seit einiger Zeit nVidia PhysX

=Der Enginepfad=

==Einführung==
Willkommen auf dem '''Enginepfad''' des DelphiGL-Wikis. Dieser Pfad soll euch zeigen wie man eine Engine von Grund auf konzipieren und realisieren kann.

Wie funktioniert der Trampelpfad? Im nachfolgenden Abschnitt findet ihr einen Text, der euch etwas über Engines erzählen soll. Dieser Text ist durchsetzt mit Schlagwörtern, welche Links auf andere Artikel im Wiki sind. Wenn ihr diesen Links folgt, erfahrt ihr mehr zu den entsprechenden Themen.

Sinn des Trampelpfades ist es, euch die Artikel aufzuzeigen, welche ihr gelesen haben solltet und welche nützlich für den Einstieg in OpenGL sind. Am Ende dieses Trampelpfades findet ihr noch Links, die euch die Materie genauer erklären werden.

==Der Trampelpfad==
Am Beginn steht bei den meisten Anfängern zum Thema [[Engine]] die Frage "Was brauch' ich um eine Engine zu entwickeln?". Je nach dem welches Betriebsystem ihr als Plattform gewählt habt, können sich die Hilfsmittel unterscheiden.

Weiterhin ist die Wahl der Sprache zu treffen.
Wenn ihr mit Object Pascal in seinen vielen Varianten (z.B. '''Delphi''') arbeiten wollt, dann ist der [[DGLOpenGL.pas]]-Header genau das richtige für euch. Wenn es eine andere Sprache sein soll, müsst ihr euch dann nach einen aktuellen Header in Google umschauen. Es ist im vorhinein schon zu erwähnen, dass dieses Wiki Object Pascal in seiner Vielfalt verwendet.

==Vorbereitung==
Als erstes muss uns klar werden, welches Ausmaß die Engine erreichen soll. Davon abhängig ist unsere Planung zu gestalten:
:1. Es ist ratsam mit der Plattformunterstützung anzufangen, da diese unsere unterste Schicht bilden wird.
:Hier ist als erstes zu sagen, je mehr Plattformen unterstütz werden sollen, desto aufwendiger wird das Projekt.
:Mit Plattformen sind hier z.B. PC mit 32Bit/64Bit, Konsolen (PS1-3, XBox-360, Wii, GP2X, ...) und mobile Geräte (Palm, PSP,...) gemeint.
:Für jede Plattform gibt es eine oder mehrere Betriebssysteme zur Ansteuerung der Hardware.
:Hier eine kleine Liste mit verschiedenen Betriebssystemen:
:*Windows
:*Linux
:*MacOS X

:2. Abhängig davon wählen wir nun unseren Compiler.
:*[http://www.borland.de/delphi/ Delphi] (Windows 32Bit)
:*[http://www.freepascal.org/ FreePascal] (Unterstützung für alle erwähnten Plattformen und OS)
:*[http://www.gnu.org/software/gcc/gcc.html gcc] (Unterstützungen für alle erwähnten Plattformen und OS)
:*[http://www.borland.de/kylix/ Kylix] (Linux 32Bit) (Veraltet, nicht mehr in Entwicklung)
:*[http://msdn.microsoft.com/visualc/ VisualC++] (Windows 32/64Bit WinCE)

:3. Nun sollten wir entscheiden, welche Bibliothek wir für das Ansprechen der Grafikkarte verwenden:
:Es gibt einige wie z.B. DirectX, GDI, AGG und Mesa aber wir wollen uns mit [[OpenGL]] auseinander setzen, denn dieses ist ein OpenGL Wiki.
{{Hinweis|Dieser [[OpenGL Verwendungspfad|Verweis]] führt Sie auf den Verwendungspfad in diesem Wiki und soll zeigen wie man OpenGL unter den einzelnen OS nutzten kann}}

:4. Nun kommen wir zu allgemeinen Bibliotheken für das Ansteuern unserer Hardware.
:Im Voraus ist zu sagen, dass ALSA und OSS Treiber unter Linux sind, die das Abspielen von Sound ermöglichen. Nur nur ein Bruchteil der Bibliotheken ist für 3D Sound ausgelegt und man müsste bei Bedarf noch einen eigene Dopplereffekt hinzufügen.
:Sound:
:*ALSA (Linux)
:*[http://www.un4seen.com/ BASS]
:*[[Direct Sound]] (Windows)
:*[http://www.fmod.org/ FMOD]
:*[[OpenAL]]
:*OSS (Nur Linux)
:*[[SDL]]
:Netzwerk:
:*DirectX Net (Windows)
:*[[SDL_Net]]
:*Raknet

:5. Jetzt sollte man entscheiden, ob und welche Bibliotheken man zur Erleichterung der nicht hardwarebezogenen Aufgaben wählt. Um den Rahmen nicht zu sprengen nur ein paar Beispiele.
:Physik:
:*[http://www.havok.com/ Havok]
:*[http://newtondynamics.com/ Newton]
:*[http://www.nvidia.de/object/nvidia_physx_de.html PhysX]
:*[http://www.ode.org/ ODE]
:Fenster:
:*[http://www.gtk.org/ GTK]
:*[http://www.wxwidget.org/ wxWidget]
:*[[SDL]]
:*Win API (Windows)
:Kompression:
:*[http://www.zlib.net/ zLib]
:Künstliche Intelligenz:
:*[http://opensteer.sourceforge.net/ openSteer]

:6. Nun beachten wir unser eventuell eingeplantes Budget (normalerweise 0 ^_^) und gehen die Liste oben nochmal durch.

:7. Ein Programm teilt sich in der Regel in 3 Teilbereiche (im Bereich Software Engineering auch Pakete genannt), diese sind die GUI, die Programmlogik und die Datenbank.
:GUI:
:*Die GUI sorgt dafür, dass alle Informationen dem User grafisch dargestellt werden. Dabei geht dieses natürlich auch in die Gegenrichtung. Also der User gibt Informationen an den Computer.
:Logik:
:*Die Logik ist der größte Teil vom Programm, denn hier ist der ganze Code angesiedelt, der das Programm zum laufen bringt.
:Datenbank:
:*Das Datenbank Paket, ist der Part wo alle Daten, die das Programm benötigt, zwischengespeichert werden. Das wären z.B. Variablen, Texturdaten, Spielerinformationen und so weiter.

:Wer sich in der Material nur ausprobieren will, kann anfangen, so viel wie möglich selber zu programmieren. Wenn es aber darum geht, eine Engine zu schreiben, welche man auch benutzten will, dann sollte man versuchen, so viel Code wie möglich wieder zu verwerten. Viele Programmierer haben schon Funktionen, Strukturen und Lösungen geschrieben und diese gilt es so gut wie möglich wieder zu verwerten. Dies hat viele Vorteile, denn man spart Zeit, man kann sich sicher sein, dass der Code standardmässig läuft und man hat sich viel Zeit mit der Konzeptphase gespart. Man muss in der konstruktiven Entwicklung nicht mehr das Rad neu erfinden. Der Trend in der professionellen Programmierung geht seit vielen Jahren in diese Richtung. [[SDL]], [[OpenAL]], DirectX, [[OpenGL]], zLib und viele andere Bibliotheken haben sich so ihren Stellenwert erkämpft.

==Helfende Tools==

Wenn man ein Projekt beginnt, dann sollte man auch entsprechend ausgerüstet sein, denn eine gute Toolchain erspart viel Zeit.

===Versionierung===
Unabhängig von der Größe eines Projektes sollte der Quellcode und die damit verbundenen Ressourcen Versioniert werden, damit keine Daten verloren gehen. Hier mal eine Liste mit Versionierungstools.
*[http://subversion.tigris.org/ SVN](frei,OpenSource,cross platform, der Nachfolger von CVS)
*[http://git.or.cz/ git](frei,OpenSource,cross platform, der Linuxkernel wird darüber verwaltet)
*[http://www.nongnu.org/cvs/ CVS](frei,OpenSource,cross platform, weit verbreitet)
*[http://www.perforce.com/ Perforce](kommerziel ab 2 Nutzern,closed Source,cross platform, im Komerziellen Bereich verbreitet z.B. UnrealEngine3)

===Unit Test===
Hierfür gibt es je nach Sprache und geschmack mehere Möglichkeiten.
*Frameworks([http://junit.sourceforge.net/ JUnit], [http://camelos.sourceforge.net/fpcUnit.html FPCUnit], [http://sourceforge.net/projects/cppunit CPPUnit], [http://dunit.sourceforge.net/ DUnit])
*komplett eigener Code
Ein Unittest dient dazu, einen einzelne Funktion aus dem großen ganzen zu testen und alle Unittests zusammen ergeben dann die benötigte Funktionalität der Software.
Schlagen einige Unittests fehl, tut die Software nicht mehr das, was sie eigentlich Leisten sollte.
Wenn wir z.B. eine Aufgabe haben "berechne Hashwert von einer Datei", dann würden wir unsere Funktion, die einen Hashwert berechnet, in mehrere Unit Tests zerlegen und einen Unit Test anlegen, der die Hashfunktion auf eine Dummy File IO Klasse testet.
Die Dummyklasse ist in der Regel ein Interface, welcher Konstante Daten enthält und somit eine 100% funktionierende Netzwerkverbindung, Datenbank, Dateisystem oder ähnliches Simuliert. Das hat den Vorteil, dass unsere Unittest auf jedem System laufen, auch wenn garkeine Netzwerkkarte da ist. Denn wir wollen ja die Funktionalität testen und nicht die Lauffähigkeit auf irgendwelchen Systemen.
Mehr zum Thema ist [http://de.wikipedia.org/wiki/Modultest hier] zu finden.

===Automatisierte Builds können sehr Hilfreich sein.===
Ein Automatisierter Build wird verwendet, um z.B. Nightbuilds, Dailybuilds zu erstellen, Unittest, Systemtest und so weiter zu machen.
Die komplexität von Buildsystemen ist hierbei sehr unterschiedlich.
Hier ein paar Tools.
*make
*[http://www.scons.org/ scons](python basierte toolchain, cross platform)
*[http://www.cmake.org/ CMake](Projektdatei Generator für viele Buildsysteme)
*[http://ant.apache.org/ Ant](java basierte toolchain, cross platform)
So kann man z.B. sein Projekt in einer makefile umsetzen, indem man sogenannte Targets für Kompilieren, Aufräumen, Unittests einbaut.
Wenn man dann als Programmierer den Sourcecode lädt, kann man einfach make machen und man bekommt ein fertiges Build zurück.
Damit hat man den ersten Stein für den Weg, zur nutzung der Software, gelegt.
Der neue Programmierer will sich nicht erst mit den ganzen Konfigurationen, abhängigkeiten und Flags beschäftigen und wenn man als Entwickler der Software nach 1Jahr wieder den Code generieren will und die Befehle nicht mehr weiß, hat man sogar selber die Probleme.
Daher lohnt es sich schon gleich zum anfang sich ein Generierungssystem auszusuchen und diese mit neuen Datein immer zu aktualisieren.

===Komplexe Buildsystem===
Wer vor hat an ein größeren Projekt zu arbeiten, der sollte sich ein Buildsystem zulegen, welches über make und anderen hinaus geht.
Eines der weit verbreitesten Systeme ist CruiseControl.
CruiseControl ist ein Buildsystem, im welchen man Projekte anlegen kann, diesen bestimmte Aufgaben zuweist und es selbständig für sie Arbeit verrichtet.
So kann man das erstellen von Binaries, UnitTest und Systemtest durchführen, Installer erstellen, E-Mails versenden und noch vieles mehr.
Mehr zu CruiseControl findet man [[BuildGrids|hier]].

===Systemtests===
Systemtests sind Tests, die auf eine möglichen Zielumgebung ausgeführt werden, um zu sehen ob noch Funktionen in der Software fehlen. Wenn z.B. die Netzwerkverbindung mittem beim Senden zusammenbricht und daraus ein Fehler entsteht.
Der Unittest testet ja nur die Funktion selber erfolgreich aber nicht System oder Fremdcode Fehler.
Buildtools wie Ant in Verbindung mit CruiseControl können Systemtests sehr angenehm zu testen machen und vorallem automatisiert.

===Design Brainstorming===
Wenn es mal wieder Zeit ist und ein neues Feature implementiert werden soll, dann sollte man sich erstmal einem Brainstorming unterziehen und dazu sind Tools hilfreich, die einfach nur die Gedanken wiederspiegeln und nicht auf UML oder ähnliche Konzepte basieren. Denn man will in dieser Phase noch nichts konkretes sondern nur Lösungsansätze.
Hierfür gibt es komerzielle und freie Tools, die entsprechend unterschiedlich viel können und arbeiten.
*[http://freemind.sourceforge.net/wiki/index.php/Main_Page FreeMind](freies OpenSource Tool, cross platform)
*[http://www.gnome.org/~dscorgie/labyrinth.html Labyrinth](freies OpenSource Tool, Linux only)

==Planung==
Wir gehen mal von ein "AllInOne Wonder" aus und nutzen FreePascal aufgrund der Plattformunabhängigkeit, SDL und sämtliche Zusatzpakete zur plattformunabhängigen Fensterinitialisierung sowie zum Laden von etlichen Bildformaten. Für die Soundausgabe werden wir aufgrund von Kostengründen auf OpenAL setzen. Für die Physik ist eine vorhandene Bibliothek wie zum Beispiel ODE zu favorisieren, da diese schon ausgereifter als eine selbst entwickelte ist. Doch kann im Gegenzug eine eigene Physik-Bibliothek eventuell schneller und viel schlanker sein, wenn man nur eine handvoll Dinge benötigt.

Geht's nun Los?

Na ja, nun kommt der wahrscheinlich unangenehmste Satz für alle:

Die Entwicklung einer Engine bedarf einer ausführlichen Planung, was kurz und knapp ein [[Softwarecycle]] bedeutet. Nun sollte man die einzelnen Schritte eines Softwarecycles abarbeiten und ganz am Ende, wenn viel Zeit rum ist, kann man dann endlich anfangen den Compiler flott zu machen. Kleiner Tipp: Macht euch die Mühe, da diese sich umso mehr auszahlt, je grösser das Projekt ist(für ein Packman Clon ist es aber eher Zeitverschwendung). Das Allerwichtigste bei großen Projekten ist, dass Aufgabenpakete/Module geschnürt werden. Diese sollten nach dem [[Blackbox]]-Prinzip erstellt werden. Dadurch können die Module unabhängig voneinander von verschiedenen Personen erstellt werden. Um so etwas realisieren zu können, ist natürlich klar, dass in die Planung der [[Schnittstelle|Schnittstellen]] zwischen den Modulen sehr viel Zeit eingesetzt werden sollte. Änderungen in den Modulen sind kein Problem, Änderungen an der Schnittstelle können Einfluss auf das gesamte Projekt haben. Eine Engine kann entweder auf Low-Level oder High-Level API aufsetzen, idealerweiser sollte man eine Zwischenlösung nutzen, hierzu finden Sie unter [[Low/High-Level|High/Low-Level API]] weitere Informationen.

In der Industrie verwendet man in größeren Engines Wrapper. Dieser ist dazu da, dass OpenGL/SDL und DirectX über eine eigene API angesteuert werden kann und somit ist es möglich die Engine mit den verschiedensten Plattformen (PC, Konsole, etc.) zurecht kommt. Laut einer neueren Umfrage schreiben 75% alle amerikanischen Publisher ihren Entwicklerteams vor, dass sie eine Engine mit genau dieser Eigenschaft nutzen. Des weiteren ist es auch immer häufiger, dass Publisher auf der ganzen Welt ihren Entwicklerteams vorschreiben, dass sie eine fertige Engine (Middleware) zu verwenden haben. Dies hat den Grund, dass der Publisher somit das Risiko eines Spiels vermindert und Geld spart - schließlich kostet das Entwickeln einer Engine eine große Summe an Geld und die Künstler sitzen währenddessen ohne Arbeit herum. Diese kalkulierten Kosten sind in der Summe höher als der Preis einer aktuellen Engine, wie zum Beispiel die "Vision" oder "Source" Engine.

Wenn Sie es noch nicht getan haben, dann schauen Sie sich am besten noch ein Buch oder Artikel über Pattern/Muster an. So sind [[Adapter_Muster|Adapter]], [[Singleton_Muster|Singleton]], [[Observer_Muster|Observer]] Muster sehr sinnvoll zu kennen.
So kann man z.B. für Materials, Texturen, Shader, Models, Animationen und alle anderen auf Daten basierte Komponenten mit dem [[Adapter Muster]] sehr flexibel sein.
Für ein SceneGraph kann man das Observer Muster prima anwenden und Singleton kann man für alle Manager verwenden.

{{Hinweis|Siehe die Tutorial Reihe [[Tutorial_Softwareentwicklung1|Softwareentwicklung]]}}

==Die ersten Schritte in eine nicht reelle Welt==
Nachdem man weiß, was das Projekt einmal enthalten soll, besteht der erste Schritt darin, Manager zu erstellen, die die Arbeit erleichtern. Bei 3D-Spielen ist z.B. ein Leveleditor kein Feature, was am Ende entwickelt wird, sondern der Editor ist fertig, noch bevor das Spiel getestet wird. Deshalb gibt es in Firmen Programmierer, die nichts anderes machen als Tools/Manager für die Erstellung der Inhalte zu fertigen. Dazu gehören:

# [[Leveleditoren]] um die "Welt" zu erstellen.
# '''Texturmanager''' um den Programmierern den Zugriff auf die Texturen so einfach wie möglich zu machen.
# '''Soundmanager''' (siehe vorheriges)
# '''Lademanager''' für eigene Dateiformate.

Nun ist es so weit, wir wissen was wir wollen und haben alles durchdacht.
Nun gilt es die einzelnen Module in die Tat um zu setzen.
Einige Module die es 3D Anwendungen/Spielen geben könnte:

'''Grundlagen:'''
#[[Template]]
#[[Kamera]]
#[[Schrift]]
#[[IODevice|Input]] (Maus/Tastatur)
#[[Adapter Muster]]

'''Fortgeschrittene Grundlagen:'''
#[[Sound]]
#[[Physik]]
#[[Texturen]]
#[[Levelformat]]
#[[Modelformat]]
#[[Console]] (Laufzeit-Schnittstelle zur Engine)
#[[DGL GUI|GUI]] (Game User Interface)
#[[Netzwerk]]

'''Fortgeschritten:'''
#[[Shader]]
#[[Materials]]
#[[Packformate]]
#[[VFS]] (Virtual File System)
#[[Soundformat-Erweiterungen]]
#[[KI]]
#[[Script]]
#[[Scene Graph]]

Sieht doch eigentlich nach nicht so viel aus oder?

Doch der Schein trügt. In großen Firmen sitzen meist mehrere Programmierer, die in diesen Gebiet erfahren sind, an nur ein, maximal 2 Modulen. Wie ist es dann möglich, dass es trotzdem so viele Spiele/Engines gibt, die nicht von Firmen sind ?
#die Planung wird bei weitem nicht so groß ausfallen wie in Grossfirmen
#die Koordination von vielen Person ist sehr schwer und es kann zu großen Zeitlücken kommen
#meistens wird die Planung sowieso nicht in die Tat umzusetzen sein, es gibt immer ein Problem
#ein kleines Team kann sich im besten Fall gegenseitig hochpushen und zu mehr anspornen
#Großfirmen haben selten die Möglichkeit, mal einen Codefetzen in Foren zu setzen und verbessern zu lassen
#das Nutzen von Bibliotheken ist sehr zeitsparend

==Die Engine ist fertig oder doch nicht?==
Es gibt ein Unterschied zwischen der Entwicklung von einer Engine und der Entwicklung einer Engine für ein Spiel.
Die Engine für ein Spiel ist festgelegt und hat ein Endpunkt, was sie leisten soll.
Eine Engine als selbststehendes Projekt wird hingegen nie fertig, man kann sie immer wieder optimieren und erweitern.
Doch kommt der Punkt, wo die Qualität den Ansprüchen völlig ausreichend ist.
Man sollte nun noch überlegen, ob man eventuell ein Tool zur leichteren Handhabung der Engine entwickelt.
So kann ein GUI-Editor oder Material-Editor die Arbeit um vieles erleichtern, wenn es dann heißt die Engine auch zu nutzen. Diese Tools nennt man dann die Toolchain einer Engine und dort gehören dann neben den Editoren auch Compiler, Libs und Ressourcen hinzu.

Nun bleibt es nur noch zu sagen: viel Glück und Erfolg mit der Entwicklung einer eigenen Engine. Mögen die bereitgestellten Links zur Erleuchtung führen.

==Links==
[http://karmarama.linuxprofessionals.org Karmarama Engine]

[http://www.omorphia.de Projekt omorphia]

[http://andorra.sourceforge.net/ Andorra 2D]

[[Kategorie:Trampelpfad]]

OpenAL

2011-01-03T02:46:56Z

Darkinsanity:

'''OpenAL''' ('''Open A'''udio '''L'''ibrary) ist eine plattformunabhängige [[3D Audio|3D Audio-API]]. Sie ist das Audio-Pendant zu [[OpenGL]] und somit die offene Konkurrenz zu DirectSound.

Dieses Wiki verfügt über eine deutschsprachige Übersetzung der OpenAL Spezifikation. Diese ist unter [[OpenAL-Funktionsübersicht]] zu finden.

==Spezifikation==
Ähnlich [[OpenGL]], handelt es sich bei OpenAL lediglich um die Spezifikation einer Schnittstelle. Diese sieht unter anderem das Positionieren von Soundquellen im 3D-Raum vor. OpenAL ist zudem in der Lage Lautstärke und Tonhöhe jeder Soundquelle zu verändern und zudem den [[Dopplereffekt]] zu simulieren.

Die OpenAL-Spezifikation wurde von Creative herausgegeben und ist als direkter Konkurrent zu Microsoft's Direct Sound zu sehen. Ähnlich OpenGL ist eine Schnittstelle zur Benutzung von Erweiterungen vorhanden.

Neben hardwarebeschleunigten Implementierungen der Schnittstelle finden sich auch zahlreiche Softwarerenderer, zum Beispiel [http://kcat.strangesoft.net/openal.html OpenAL Soft]. OpenAL ist plattformunabhängig und es existieren Bindings für verschiedene Programmiersprachen.

OpenAL wird bereits in zahlreichen Spieletiteln verwendet.

==Vor- und Nachteile==
Zwar bietet OpenAL meist (unter Windows >= Vista) die einzige Möglichkeit hardwarebeschleunigten 3D-Sound auszugeben, jedoch ist noch bei weitem nicht für jede Soundkarte eine direkte hardwarebeschleunigte Ausgabe verfügbar. Für die meisten (OnBoard-)Soundkarten bildet OpenAL eine weitere Abstraktionsschicht über weiteren Audioschnittstellen wie WaveOut, DirectSound, ALSA, PulseAudio, OSS etc. Dies ist nicht unbedingt der Latenzzeit zuträglich, in der Praxis jedoch vernachlässigbar.

Ein wichtiger Vorteil ist die Portabilität von OpenAL, denn im Gegensatz zu Microsofts DirectSound ist OpenAL nicht nur unter Windows, sondern auch auf zahlreichen anderen Betriebssystemen und Plattformen vertreten.

==Alternativen==
* [http://msdn.microsoft.com/en-us/library/ee416960%28VS.85%29.aspx DirectSound] - von Microsoft entwickelte Schnittstelle für die Ausgabe von (3D-)Audio, nur unter Windows lauffähig
* [[SDL]] beinhaltet ebenfalls eine Bibliothek zur Audioausgabe
* [http://audorra.sourceforge.net/ Audorra] - eine Plattformübergreifende Audiobibliothek für Pascal (noch in der Entwicklung)

==Siehe auch==
* [http://de.wikipedia.org/wiki/OpenAL Wikipedia-Artikel zu OpenAL]
* [http://connect.creativelabs.com/openal/default.aspx Offizielle Website zu OpenAL]
* [http://www.noeska.com/doal Bindings für Pascal, Windows und Linux]

Checkliste Allgemein

2010-08-31T07:52:39Z

Darkinsanity:

Hier gibt es eine allgemeine Checkliste, wenn ihr nichts oder nicht das seht, was ihr sehen wollt.

==Grundlagen==
*'''Benutzen Sie eine funktionierende Programmgrundlage (Template)?'''
:Wurde ein [[Template]] von DelphiGL.com benutzt, oder wurde das Template bereits erfolgreich getestet dann kann von einer Funktionierenden Programmgrundlage ausgegangen werden.

*'''Läuft das Programm ohne OpenGL-Fehler zu produzieren?'''
:Mittels eines Error-Handler wie er im "[[Tutorial_quickstart]]" beschrieben wird dies überprüfen.

==Was machen wenn...?==
* '''"Ich sehe nur schwarz"'''
** Hintergrundfarbe mal auf etwas anderes als schwarz stellen um zu schauen, ob das Objekt eventuell schwarz gezeichnet wird. Wenn ja:
*** Ist versehentlich eine Textur gesetzt? --> glDisable(GL_TEXTURE_2D)
*** Versehentlich die falsche Farbe eingestellt? --> glColor4f(1.0, 1.0, 1.0, 1.0)
** Folgende Tests testweise deaktivieren:
*** Tiefentest (GL_DEPTH_TEST)
*** Backfaceculling (GL_CULL_FACE)
*** Alphatest (GL_ALPHA_TEST)

* '''"Ich sehe nur die Hintergrundfarbe"'''
** Wenn diese schwarz ist, bitte oben nachschauen
** Ist die Projektionsmatrix richtig gesetzt ([[glOrtho]], [[gluPerspective]])?
** Ist der Viewport richtig gesetzt ([[glViewport]])?
** Ist Culling aktiviert? Werden die Vertices in der richtigen Reihenfolge übergeben? ([[Tutorial_Lektion_5]])

OpenAL

2010-03-14T00:46:44Z

Darkinsanity: /* Vor- und Nachteile */ Hardwarebeschleunigung ist nicht teuren Karten vorbehalten / Plattformunabhängigkeit / Satzbau / Grammatik

'''OpenAL''' ('''Open A'''udio '''L'''ibrary) ist eine plattformunabhängige [[3D Audio|3D Audio-API]]. Sie ist das Sound-Pendant zu [[OpenGL]] und somit die offene Konkurrenz zu DirectSound.

Dieses Wiki verfügt über eine deutschsprachige Übersetzung der OpenAL Spezifikation. Diese ist unter [[OpenAL-Funktionsübersicht]] zu finden.

==Spezifikation==
Ähnlich [[OpenGL]], handelt es sich bei OpenAL lediglich um die Spezifikation einer Schnittstelle. Diese sieht unter anderem das Positionieren von Audioquellen im 3D-Raum vor. Implementierungen sind zudem in der Lage Lautstärke und Tonhöhe jeder Audioquelle zu verändern und zudem den [[Dopplereffekt]] zu simulieren.

Die OpenAL-Spezifikation wurde von Creative herausgegeben und ist als direkter Konkurent zu Microsoft's Direct Sound zu sehen. Ähnlich OpenGL ist eine Schnittstelle zum Einfügen von Erweiterungen vorgesehen.

Neben Hardwarebeschleunigten implementierungen der Bibliothek finden sich auch zahlreiche Softwarerenderer, zum Beispiel [http://kcat.strangesoft.net/openal.html OpenAL-Soft]. OpenAL ist leicht auf verschiedene Plattformen zu portieren und es existieren Bindings für verschiedene Programmiersprachen.

OpenAL wird bereits in zahlreichen Spieletiteln verwendet.

==Vor- und Nachteile==
Zwar bietet OpenAL meist (unter Windows >= Vista) die einzige Möglichkeit hardwarebeschleunigtes 3D-Audio auszugeben, jedoch ist noch bei weitem nicht für jede Soundkarte eine direkte hardwarebeschleunigte Ausgabe verfügbar. Für die meisten (OnBoard-)Soundkarten bildet OpenAL eine weitere Abstraktionsschicht über weiteren Audioschnittstellen wie WaveOut, DirectSound, ALSA, PulseAudio, OSS etc. Dies ist nicht unbedingt der Latenzzeit zuträglich, in der Praxis jedoch vernachlässigbar.

Ein wichtiger Vorteil ist die Portabilität von OpenAL, denn im Gegensatz zu Microsofts DirectSound ist OpenAL nicht nur unter Windows, sondern auch auf zahlreichen anderen Betriebssystemen und Plattformen vertreten.

==Alternativen==
* [http://msdn.microsoft.com/en-us/library/ee416960%28VS.85%29.aspx DirectSound] - von Microsoft entwickelte Schnittstelle für die Ausgabe von (3D-)Audio, nur unter Windows lauffähig
* [[SDL]] beinhaltet ebenfalls eine Bibliothek zur Audioausgabe
* [http://audorra.sourceforge.net/ Audorra] - eine Plattformübergreifende Audiobibliothek für Pascal (noch in der Entwicklung)

==Siehe auch==
* [http://de.wikipedia.org/wiki/OpenAL Wikipedia-Artikel zu OpenAL]
* [http://connect.creativelabs.com/openal/default.aspx Offizielle Website zu OpenAL]
* [http://www.noeska.com/doal Bindings für Pascal, Windows und Linux]