https://wiki.delphigl.com/api.php?action=feedcontributions&user=Traude&feedformat=atomDGL Wiki - Benutzerbeiträge [de]2024-03-28T10:06:34ZBenutzerbeiträgeMediaWiki 1.27.4https://wiki.delphigl.com/index.php?title=VBO_ohne_glInterleavedArrays&diff=25767VBO ohne glInterleavedArrays2013-04-06T20:00:01Z<p>Traude: /* 4. Nachher reinen Tisch machen */ Klarstellung, was "Reinen Tisch machen" bedeutet</p>
<hr />
<div>(Voraussetzung: mindestens OpenGL 1.5)<br />
<br />
"VBO" ist die Abkürzung von "Vertex Buffer Object" und ist eine Möglichkeit der Darstellung von Objekten mit OpenGL.<br />
<br />
Es gibt mehrere Möglichkeiten, einen VBO zu verwenden. Die Variante, die ich unten erkläre, ist also nicht die einzige.<br />
<br />
<br />
==VBO mit frei definierter Datenstruktur, ohne glInterleavedArrays==<br />
<br />
Der untenstehende Pascal-Code zeichnet das Opengl-Dreieck mit einem VBO. Ich hatte beim Erzeugen dieses Code-Stücks eine steile Lernkurve und jede Menge Frust, denn beim Ändern einzelner Teile sind dann natürlich auch korrespondierende Teile anderswo zu ändern, aber da kann man leicht etwas übersehen, speziell wenn es gegen vier Uhr morgens geht. :)<br />
<br />
<br />
<br />
===1. Zunächst die globalen Deklarationen===<br />
<br />
Typen<br />
<source lang="pascal"><br />
TVector4D = Packed Record X,Y,Z,W: Single; End; <br />
<br />
TVBOVertex = Packed Record <br />
Position,<br />
Color,<br />
Empty: TVector4D;<br />
End;<br />
<br />
TVBOBuffer = Array Of TVBOVertex;<br />
TIndexBuffer = Array Of Word;<br />
</source><br />
<br />
Konstanten<br />
<source lang="pascal"><br />
POS_OFFSET = Pointer(0); // Position-Offset als Zeiger<br />
COL_OFFSET = Pointer(SizeOf(TVector4D)); // Color-Offset als Zeiger<br />
STRIDE = SizeOf(TVBOVertex);<br />
</source><br />
<br />
Variablen<br />
<source lang="pascal"><br />
VBOBuffer: TVBOBuffer; // VBO-Daten<br />
IndexBuffer: TIndexBuffer; // VBO-Indices<br />
VertexBufSize, // VBO-Daten: Puffergröße<br />
IndexBufSize, // VBO-Indices: Puffergröße <br />
IndexCount, // Anzahl der Indices<br />
IDVbo,IDIndex: Cardinal; // Opengl-"Handles" für VBO- und Indexpuffer<br />
</source><br />
<br />
Bei dieser Variante des VBO kann man sein eigenes Vertex definieren und ist nicht auf vorgegebene Datenstrukturen beschränkt wie bei den glInterleavedArrays. Der "Empty"-Vektor im TVBOVertex soll darauf hinweisen, dass man vorgegebene Vertexattribute mit benutzerdefinierten mischen kann. Das wird hier aber nicht behandelt. <br />
<br />
Ihr könnt die Typen definieren, wie Ihr wollt, aber es ergeben sich daraus Konsequenzen. Die Datendeklaration hat unmittelbaren Einfluss auf den untenstehenden Initialisierungs- und Rendercode. Wenn also der Datentyp geändert wird, muss man den ganzen untenstehenden Code auf notwendige Anpassungen untersuchen. Wie sich gezeigt hat, habe ich dabei immer wieder das eine oder andere vergessen. :(<br />
<br />
===2. Dann das Hochladen der Daten aus dem Hauptspeicher in den Grafikkartenspeicher===<br />
<source lang="pascal"><br />
IndexCount:= 3;<br />
<br />
VertexBufSize:= IndexCount*SizeOf(TVBOVertex);<br />
IndexBufSize:= IndexCount*SizeOf(Word);<br />
</source><br />
<br />
Vertexpuffer erzeugen,initialisieren und mit Daten bestücken<br />
<source lang="pascal"><br />
SetLength(VBOBuffer,IndexCount);<br />
FillChar(VBOBuffer[0],Length(VBOBuffer)*SizeOf(TVBOVertex),#0);<br />
<br />
With VBOBuffer[0] Do<br />
Begin<br />
With Position Do Begin X:=-1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+1.0; Y:=+0.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[1] Do<br />
Begin<br />
With Position Do Begin X:=+1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[2] Do<br />
Begin<br />
With Position Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+0.0; Z:=+1.0; W:=+1.0; End;<br />
End;<br />
</source><br />
<br />
Vertexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDVbo);<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
glBufferData(GL_ARRAY_BUFFER,VertexBufSize,@VBOBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Dasselbe mit dem Indexpuffer<br />
<source lang="pascal"><br />
SetLength(IndexBuffer,IndexCount);<br />
<br />
IndexBuffer[0]:= 0;<br />
IndexBuffer[1]:= 1;<br />
IndexBuffer[2]:= 2;<br />
</source><br />
<br />
Indexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDIndex);<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
glBufferData(GL_ELEMENT_ARRAY_BUFFER,IndexBufSize,@IndexBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Ich habe hier für den VBO einen Record genommen, weil bei den Demos im Netz normalerweise immer Arrays benutzt werden. Der Recordtyp ist zusätzlich viel selbsterklärender als ein Array und man kann ihn auch noch durch treffende Namensgebung verbessern. <br />
<br />
Abgesehen von der Entscheidung, welchen Datentyp man nehmen soll, ist das der einfachere Teil des Ganzen. Und damit es nicht ganz trivial wird, habe ich noch einen winzigen Indexbuffer definiert, damit ich zum Zeichnen glDrawElements verwenden kann. <br />
<br />
In den Beispielen, die man im Web finden kann, gibt es außerdem noch die Variante, wo glBufferdata nur zur Definition der Puffer-Parameter benutzt wird, aber für das Hochladen der Daten auf die Grafikkarte wird glBufferSubdata verwendet. Damit kann man entweder den ganzen Puffer oder auch nur Teile davon neu beschicken. <br />
<br />
<br />
<br />
===3. Der Rendercode===<br />
<br />
Vertexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
</source><br />
<br />
Nötige Zeiger setzen<br />
<source lang="pascal"><br />
glVertexPointer(4, GL_FLOAT, STRIDE, POS_OFFSET);<br />
glColorPointer(4, GL_FLOAT, STRIDE, COL_OFFSET);<br />
</source><br />
<br />
Indexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
</source><br />
<br />
Zeichnen<br />
<source lang="pascal"><br />
glEnableClientState(GL_VERTEX_ARRAY);<br />
glEnableClientState(GL_COLOR_ARRAY);<br />
<br />
glDrawElements(GL_TRIANGLES,IndexCount,GL_UNSIGNED_SHORT,NIL);<br />
<br />
glDisableClientState(GL_COLOR_ARRAY);<br />
glDisableClientState(GL_VERTEX_ARRAY);<br />
</source><br />
<br />
Über das Binden der Puffer gibt es eigentlich nicht viel zu sagen. Die OpenGL-Pufferobjekte sind alle ziemlich ähnlich.<br />
<br />
Aber bei den Zeigern kann man eine Menge falsch machen. Etliche Leute im Netz haben z.B. nachgeforscht, wie man den Parameter "Stride" zu interpretieren hat. Ich habe Stride ganz oben im Defnitionsteil als Konstante definiert: STRIDE = SizeOf(TVBOVertex); damit ist klar, dass hier die gesamte Blockgröße des Vertex gemeint ist. Die "Offset"-Parameter habe ich als Konstanten definiert weil sie von der Struktur des Vertex abhängen und daher vermutlich nicht dauernd geändert werden. "Offset" ist hier genau das richtige Wort. Zwischen dem Beginn des Vertex und der Color liegt eine Position mit dem Typ "TVector4D", daher ist der Offset der Color SizeOf(TVector4D). '''Ganz wichtig''': die Offsets müssen an die gl*Pointer-Funktionen als Zeiger übergeben werden, siehe oben Definition der Offsets.<br />
<br />
Ich habe hier zwar kein nächstes Vertex-Element, aber wenn ich eines hätte, dann wäre dessen Offset COL_OFFSET+SizeOf(TVector4D) oder auch in Pseudoschreibweise: Offset(Color)+Size(Color).<br />
<br />
Nach dem Binden des Indexpuffers muss man den VBO Client-seitig aktivieren, und zwar für jeden Attribut-Typ extra. Wenn Ihr also eine Texturkoordinate ergänzen wollt - dazu muss man natürlich die Vertex-Definition ändern -, dann vergeßt bloß nicht das "glEnableClientState(GL_TEXTURE_COORD_ARRAY)" nachzutragen.<br />
<br />
So, jetzt kann man endlich zeichnen. Die Typangabe im glDrawElements beschreibt den Index und der letzte Parameter muss "NIL" sein, denn in unserem Fall ist dieser Parameter überflüssig (er wird in einem anderen Zusammenhang zum Nachladen der Daten benutzt).<br />
<br />
<br />
<br />
===4. Nachher reinen Tisch machen===<br />
<source lang="pascal"><br />
SetLength(IndexBuffer,0);<br />
SetLength(VBOBuffer,0);<br />
glDeleteBuffers(1,@IDVbo);<br />
glDeleteBuffers(1,@IDIndex);<br />
</source><br />
<br />
Am Ende werden die Daten freigegeben, sowohl im RAM (mit SetLength(Buffer,0)) als auch im GRAM (mit glDeleteBuffers).<br />
<br />
<br />
Und, naja, wenn man etwas auf eine solche Art zeichnet, sollte es natürlich nicht grade ein Dreieck sein. Das wäre nämlich so, als ob man um die Ecke in den Supermarkt gehen wollte und dazu einen Jumbojet benutzt. :) <br />
<br />
Insgesamt fand ich am Ende, dass ich Euch vielleicht ein wenig Zeit und Frust ersparen kann, wenn ich das Ganze ins DGL-Wiki stelle. <br />
<br />
Ich hoffe, es hilft.<br><br />
Viele Grüße,<br><br />
[[Benutzer:Traude|Traude]]<br />
<br />
<br />
''Fragen und Verbesserungsvorschläge wie immer ins Feedback-Forum bei DelphiGL.com.''</div>Traudehttps://wiki.delphigl.com/index.php?title=VBO_ohne_glInterleavedArrays&diff=25766VBO ohne glInterleavedArrays2013-04-06T19:53:15Z<p>Traude: /* VBO mit frei definierter Datenstruktur, ohne glInterleavedArrays */ Mini-Kommentar zu den Zeiger-Offsets</p>
<hr />
<div>(Voraussetzung: mindestens OpenGL 1.5)<br />
<br />
"VBO" ist die Abkürzung von "Vertex Buffer Object" und ist eine Möglichkeit der Darstellung von Objekten mit OpenGL.<br />
<br />
Es gibt mehrere Möglichkeiten, einen VBO zu verwenden. Die Variante, die ich unten erkläre, ist also nicht die einzige.<br />
<br />
<br />
==VBO mit frei definierter Datenstruktur, ohne glInterleavedArrays==<br />
<br />
Der untenstehende Pascal-Code zeichnet das Opengl-Dreieck mit einem VBO. Ich hatte beim Erzeugen dieses Code-Stücks eine steile Lernkurve und jede Menge Frust, denn beim Ändern einzelner Teile sind dann natürlich auch korrespondierende Teile anderswo zu ändern, aber da kann man leicht etwas übersehen, speziell wenn es gegen vier Uhr morgens geht. :)<br />
<br />
<br />
<br />
===1. Zunächst die globalen Deklarationen===<br />
<br />
Typen<br />
<source lang="pascal"><br />
TVector4D = Packed Record X,Y,Z,W: Single; End; <br />
<br />
TVBOVertex = Packed Record <br />
Position,<br />
Color,<br />
Empty: TVector4D;<br />
End;<br />
<br />
TVBOBuffer = Array Of TVBOVertex;<br />
TIndexBuffer = Array Of Word;<br />
</source><br />
<br />
Konstanten<br />
<source lang="pascal"><br />
POS_OFFSET = Pointer(0); // Position-Offset als Zeiger<br />
COL_OFFSET = Pointer(SizeOf(TVector4D)); // Color-Offset als Zeiger<br />
STRIDE = SizeOf(TVBOVertex);<br />
</source><br />
<br />
Variablen<br />
<source lang="pascal"><br />
VBOBuffer: TVBOBuffer; // VBO-Daten<br />
IndexBuffer: TIndexBuffer; // VBO-Indices<br />
VertexBufSize, // VBO-Daten: Puffergröße<br />
IndexBufSize, // VBO-Indices: Puffergröße <br />
IndexCount, // Anzahl der Indices<br />
IDVbo,IDIndex: Cardinal; // Opengl-"Handles" für VBO- und Indexpuffer<br />
</source><br />
<br />
Bei dieser Variante des VBO kann man sein eigenes Vertex definieren und ist nicht auf vorgegebene Datenstrukturen beschränkt wie bei den glInterleavedArrays. Der "Empty"-Vektor im TVBOVertex soll darauf hinweisen, dass man vorgegebene Vertexattribute mit benutzerdefinierten mischen kann. Das wird hier aber nicht behandelt. <br />
<br />
Ihr könnt die Typen definieren, wie Ihr wollt, aber es ergeben sich daraus Konsequenzen. Die Datendeklaration hat unmittelbaren Einfluss auf den untenstehenden Initialisierungs- und Rendercode. Wenn also der Datentyp geändert wird, muss man den ganzen untenstehenden Code auf notwendige Anpassungen untersuchen. Wie sich gezeigt hat, habe ich dabei immer wieder das eine oder andere vergessen. :(<br />
<br />
===2. Dann das Hochladen der Daten aus dem Hauptspeicher in den Grafikkartenspeicher===<br />
<source lang="pascal"><br />
IndexCount:= 3;<br />
<br />
VertexBufSize:= IndexCount*SizeOf(TVBOVertex);<br />
IndexBufSize:= IndexCount*SizeOf(Word);<br />
</source><br />
<br />
Vertexpuffer erzeugen,initialisieren und mit Daten bestücken<br />
<source lang="pascal"><br />
SetLength(VBOBuffer,IndexCount);<br />
FillChar(VBOBuffer[0],Length(VBOBuffer)*SizeOf(TVBOVertex),#0);<br />
<br />
With VBOBuffer[0] Do<br />
Begin<br />
With Position Do Begin X:=-1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+1.0; Y:=+0.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[1] Do<br />
Begin<br />
With Position Do Begin X:=+1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[2] Do<br />
Begin<br />
With Position Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+0.0; Z:=+1.0; W:=+1.0; End;<br />
End;<br />
</source><br />
<br />
Vertexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDVbo);<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
glBufferData(GL_ARRAY_BUFFER,VertexBufSize,@VBOBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Dasselbe mit dem Indexpuffer<br />
<source lang="pascal"><br />
SetLength(IndexBuffer,IndexCount);<br />
<br />
IndexBuffer[0]:= 0;<br />
IndexBuffer[1]:= 1;<br />
IndexBuffer[2]:= 2;<br />
</source><br />
<br />
Indexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDIndex);<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
glBufferData(GL_ELEMENT_ARRAY_BUFFER,IndexBufSize,@IndexBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Ich habe hier für den VBO einen Record genommen, weil bei den Demos im Netz normalerweise immer Arrays benutzt werden. Der Recordtyp ist zusätzlich viel selbsterklärender als ein Array und man kann ihn auch noch durch treffende Namensgebung verbessern. <br />
<br />
Abgesehen von der Entscheidung, welchen Datentyp man nehmen soll, ist das der einfachere Teil des Ganzen. Und damit es nicht ganz trivial wird, habe ich noch einen winzigen Indexbuffer definiert, damit ich zum Zeichnen glDrawElements verwenden kann. <br />
<br />
In den Beispielen, die man im Web finden kann, gibt es außerdem noch die Variante, wo glBufferdata nur zur Definition der Puffer-Parameter benutzt wird, aber für das Hochladen der Daten auf die Grafikkarte wird glBufferSubdata verwendet. Damit kann man entweder den ganzen Puffer oder auch nur Teile davon neu beschicken. <br />
<br />
<br />
<br />
===3. Der Rendercode===<br />
<br />
Vertexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
</source><br />
<br />
Nötige Zeiger setzen<br />
<source lang="pascal"><br />
glVertexPointer(4, GL_FLOAT, STRIDE, POS_OFFSET);<br />
glColorPointer(4, GL_FLOAT, STRIDE, COL_OFFSET);<br />
</source><br />
<br />
Indexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
</source><br />
<br />
Zeichnen<br />
<source lang="pascal"><br />
glEnableClientState(GL_VERTEX_ARRAY);<br />
glEnableClientState(GL_COLOR_ARRAY);<br />
<br />
glDrawElements(GL_TRIANGLES,IndexCount,GL_UNSIGNED_SHORT,NIL);<br />
<br />
glDisableClientState(GL_COLOR_ARRAY);<br />
glDisableClientState(GL_VERTEX_ARRAY);<br />
</source><br />
<br />
Über das Binden der Puffer gibt es eigentlich nicht viel zu sagen. Die OpenGL-Pufferobjekte sind alle ziemlich ähnlich.<br />
<br />
Aber bei den Zeigern kann man eine Menge falsch machen. Etliche Leute im Netz haben z.B. nachgeforscht, wie man den Parameter "Stride" zu interpretieren hat. Ich habe Stride ganz oben im Defnitionsteil als Konstante definiert: STRIDE = SizeOf(TVBOVertex); damit ist klar, dass hier die gesamte Blockgröße des Vertex gemeint ist. Die "Offset"-Parameter habe ich als Konstanten definiert weil sie von der Struktur des Vertex abhängen und daher vermutlich nicht dauernd geändert werden. "Offset" ist hier genau das richtige Wort. Zwischen dem Beginn des Vertex und der Color liegt eine Position mit dem Typ "TVector4D", daher ist der Offset der Color SizeOf(TVector4D). '''Ganz wichtig''': die Offsets müssen an die gl*Pointer-Funktionen als Zeiger übergeben werden, siehe oben Definition der Offsets.<br />
<br />
Ich habe hier zwar kein nächstes Vertex-Element, aber wenn ich eines hätte, dann wäre dessen Offset COL_OFFSET+SizeOf(TVector4D) oder auch in Pseudoschreibweise: Offset(Color)+Size(Color).<br />
<br />
Nach dem Binden des Indexpuffers muss man den VBO Client-seitig aktivieren, und zwar für jeden Attribut-Typ extra. Wenn Ihr also eine Texturkoordinate ergänzen wollt - dazu muss man natürlich die Vertex-Definition ändern -, dann vergeßt bloß nicht das "glEnableClientState(GL_TEXTURE_COORD_ARRAY)" nachzutragen.<br />
<br />
So, jetzt kann man endlich zeichnen. Die Typangabe im glDrawElements beschreibt den Index und der letzte Parameter muss "NIL" sein, denn in unserem Fall ist dieser Parameter überflüssig (er wird in einem anderen Zusammenhang zum Nachladen der Daten benutzt).<br />
<br />
<br />
<br />
===4. Nachher reinen Tisch machen===<br />
<source lang="pascal"><br />
Finalize(IndexBuffer);<br />
Finalize(VBOBuffer);<br />
glDeleteBuffers(1,@IDVbo);<br />
glDeleteBuffers(1,@IDIndex);<br />
</source><br />
<br />
<br />
Und, naja, wenn man etwas auf eine solche Art zeichnet, sollte es natürlich nicht grade ein Dreieck sein. Das wäre nämlich so, als ob man um die Ecke in den Supermarkt gehen wollte und dazu einen Jumbojet benutzt. :) <br />
<br />
Insgesamt fand ich am Ende, dass ich Euch vielleicht ein wenig Zeit und Frust ersparen kann, wenn ich das Ganze ins DGL-Wiki stelle. <br />
<br />
Ich hoffe, es hilft.<br><br />
Viele Grüße,<br><br />
[[Benutzer:Traude|Traude]]<br />
<br />
<br />
''Fragen und Verbesserungsvorschläge wie immer ins Feedback-Forum bei DelphiGL.com.''</div>Traudehttps://wiki.delphigl.com/index.php?title=VBO_ohne_glInterleavedArrays&diff=25765VBO ohne glInterleavedArrays2013-04-06T19:43:31Z<p>Traude: /* 1. Zunächst die globalen Deklarationen */ Definition Offsets als Zeiger</p>
<hr />
<div>(Voraussetzung: mindestens OpenGL 1.5)<br />
<br />
"VBO" ist die Abkürzung von "Vertex Buffer Object" und ist eine Möglichkeit der Darstellung von Objekten mit OpenGL.<br />
<br />
Es gibt mehrere Möglichkeiten, einen VBO zu verwenden. Die Variante, die ich unten erkläre, ist also nicht die einzige.<br />
<br />
<br />
==VBO mit frei definierter Datenstruktur, ohne glInterleavedArrays==<br />
<br />
Der untenstehende Pascal-Code zeichnet das Opengl-Dreieck mit einem VBO. Ich hatte beim Erzeugen dieses Code-Stücks eine steile Lernkurve und jede Menge Frust, denn beim Ändern einzelner Teile sind dann natürlich auch korrespondierende Teile anderswo zu ändern, aber da kann man leicht etwas übersehen, speziell wenn es gegen vier Uhr morgens geht. :)<br />
<br />
<br />
<br />
===1. Zunächst die globalen Deklarationen===<br />
<br />
Typen<br />
<source lang="pascal"><br />
TVector4D = Packed Record X,Y,Z,W: Single; End; <br />
<br />
TVBOVertex = Packed Record <br />
Position,<br />
Color,<br />
Empty: TVector4D;<br />
End;<br />
<br />
TVBOBuffer = Array Of TVBOVertex;<br />
TIndexBuffer = Array Of Word;<br />
</source><br />
<br />
Konstanten<br />
<source lang="pascal"><br />
POS_OFFSET = Pointer(0); // Position-Offset als Zeiger<br />
COL_OFFSET = Pointer(SizeOf(TVector4D)); // Color-Offset als Zeiger<br />
STRIDE = SizeOf(TVBOVertex);<br />
</source><br />
<br />
Variablen<br />
<source lang="pascal"><br />
VBOBuffer: TVBOBuffer; // VBO-Daten<br />
IndexBuffer: TIndexBuffer; // VBO-Indices<br />
VertexBufSize, // VBO-Daten: Puffergröße<br />
IndexBufSize, // VBO-Indices: Puffergröße <br />
IndexCount, // Anzahl der Indices<br />
IDVbo,IDIndex: Cardinal; // Opengl-"Handles" für VBO- und Indexpuffer<br />
</source><br />
<br />
Bei dieser Variante des VBO kann man sein eigenes Vertex definieren und ist nicht auf vorgegebene Datenstrukturen beschränkt wie bei den glInterleavedArrays. Der "Empty"-Vektor im TVBOVertex soll darauf hinweisen, dass man vorgegebene Vertexattribute mit benutzerdefinierten mischen kann. Das wird hier aber nicht behandelt. <br />
<br />
Ihr könnt die Typen definieren, wie Ihr wollt, aber es ergeben sich daraus Konsequenzen. Die Datendeklaration hat unmittelbaren Einfluss auf den untenstehenden Initialisierungs- und Rendercode. Wenn also der Datentyp geändert wird, muss man den ganzen untenstehenden Code auf notwendige Anpassungen untersuchen. Wie sich gezeigt hat, habe ich dabei immer wieder das eine oder andere vergessen. :(<br />
<br />
===2. Dann das Hochladen der Daten aus dem Hauptspeicher in den Grafikkartenspeicher===<br />
<source lang="pascal"><br />
IndexCount:= 3;<br />
<br />
VertexBufSize:= IndexCount*SizeOf(TVBOVertex);<br />
IndexBufSize:= IndexCount*SizeOf(Word);<br />
</source><br />
<br />
Vertexpuffer erzeugen,initialisieren und mit Daten bestücken<br />
<source lang="pascal"><br />
SetLength(VBOBuffer,IndexCount);<br />
FillChar(VBOBuffer[0],Length(VBOBuffer)*SizeOf(TVBOVertex),#0);<br />
<br />
With VBOBuffer[0] Do<br />
Begin<br />
With Position Do Begin X:=-1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+1.0; Y:=+0.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[1] Do<br />
Begin<br />
With Position Do Begin X:=+1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[2] Do<br />
Begin<br />
With Position Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+0.0; Z:=+1.0; W:=+1.0; End;<br />
End;<br />
</source><br />
<br />
Vertexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDVbo);<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
glBufferData(GL_ARRAY_BUFFER,VertexBufSize,@VBOBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Dasselbe mit dem Indexpuffer<br />
<source lang="pascal"><br />
SetLength(IndexBuffer,IndexCount);<br />
<br />
IndexBuffer[0]:= 0;<br />
IndexBuffer[1]:= 1;<br />
IndexBuffer[2]:= 2;<br />
</source><br />
<br />
Indexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDIndex);<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
glBufferData(GL_ELEMENT_ARRAY_BUFFER,IndexBufSize,@IndexBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Ich habe hier für den VBO einen Record genommen, weil bei den Demos im Netz normalerweise immer Arrays benutzt werden. Der Recordtyp ist zusätzlich viel selbsterklärender als ein Array und man kann ihn auch noch durch treffende Namensgebung verbessern. <br />
<br />
Abgesehen von der Entscheidung, welchen Datentyp man nehmen soll, ist das der einfachere Teil des Ganzen. Und damit es nicht ganz trivial wird, habe ich noch einen winzigen Indexbuffer definiert, damit ich zum Zeichnen glDrawElements verwenden kann. <br />
<br />
In den Beispielen, die man im Web finden kann, gibt es außerdem noch die Variante, wo glBufferdata nur zur Definition der Puffer-Parameter benutzt wird, aber für das Hochladen der Daten auf die Grafikkarte wird glBufferSubdata verwendet. Damit kann man entweder den ganzen Puffer oder auch nur Teile davon neu beschicken. <br />
<br />
<br />
<br />
===3. Der Rendercode===<br />
<br />
Vertexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
</source><br />
<br />
Nötige Zeiger setzen<br />
<source lang="pascal"><br />
glVertexPointer(4, GL_FLOAT, STRIDE, POS_OFFSET);<br />
glColorPointer(4, GL_FLOAT, STRIDE, COL_OFFSET);<br />
</source><br />
<br />
Indexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
</source><br />
<br />
Zeichnen<br />
<source lang="pascal"><br />
glEnableClientState(GL_VERTEX_ARRAY);<br />
glEnableClientState(GL_COLOR_ARRAY);<br />
<br />
glDrawElements(GL_TRIANGLES,IndexCount,GL_UNSIGNED_SHORT,NIL);<br />
<br />
glDisableClientState(GL_COLOR_ARRAY);<br />
glDisableClientState(GL_VERTEX_ARRAY);<br />
</source><br />
<br />
Über das Binden der Puffer gibt es eigentlich nicht viel zu sagen. Die OpenGL-Pufferobjekte sind alle ziemlich ähnlich.<br />
<br />
Aber bei den Zeigern kann man eine Menge falsch machen. Etliche Leute im Netz haben z.B. nachgeforscht, wie man den Parameter "Stride" zu interpretieren hat. Ich habe Stride ganz oben im Defnitionsteil als Konstante definiert: STRIDE = SizeOf(TVBOVertex); damit ist klar, dass hier die gesamte Blockgröße des Vertex gemeint ist. Die "Offset"-Parameter habe ich als Konstanten definiert weil sie von der Struktur des Vertex abhängen und daher vermutlich nicht dauernd geändert werden. "Offset" ist hier genau das richtige Wort. Zwischen dem Beginn des Vertex und der Color liegt eine Position mit dem Typ "TVector4D", daher ist der Offset der Color SizeOf(TVector4D). <br />
<br />
Ich habe hier zwar kein nächstes Vertex-Element, aber wenn ich eines hätte, dann wäre dessen Offset COL_OFFSET+SizeOf(TVector4D) oder auch in Pseudoschreibweise: Offset(Color)+Size(Color).<br />
<br />
Nach dem Binden des Indexpuffers muss man den VBO Client-seitig aktivieren, und zwar für jeden Attribut-Typ extra. Wenn Ihr also eine Texturkoordinate ergänzen wollt - dazu muss man natürlich die Vertex-Definition ändern -, dann vergeßt bloß nicht das "glEnableClientState(GL_TEXTURE_COORD_ARRAY)" nachzutragen.<br />
<br />
So, jetzt kann man endlich zeichnen. Die Typangabe im glDrawElements beschreibt den Index und der letzte Parameter muss "NIL" sein, denn in unserem Fall ist dieser Parameter überflüssig (er wird in einem anderen Zusammenhang zum Nachladen der Daten benutzt).<br />
<br />
<br />
<br />
===4. Nachher reinen Tisch machen===<br />
<source lang="pascal"><br />
Finalize(IndexBuffer);<br />
Finalize(VBOBuffer);<br />
glDeleteBuffers(1,@IDVbo);<br />
glDeleteBuffers(1,@IDIndex);<br />
</source><br />
<br />
<br />
Und, naja, wenn man etwas auf eine solche Art zeichnet, sollte es natürlich nicht grade ein Dreieck sein. Das wäre nämlich so, als ob man um die Ecke in den Supermarkt gehen wollte und dazu einen Jumbojet benutzt. :) <br />
<br />
Insgesamt fand ich am Ende, dass ich Euch vielleicht ein wenig Zeit und Frust ersparen kann, wenn ich das Ganze ins DGL-Wiki stelle. <br />
<br />
Ich hoffe, es hilft.<br><br />
Viele Grüße,<br><br />
[[Benutzer:Traude|Traude]]<br />
<br />
<br />
''Fragen und Verbesserungsvorschläge wie immer ins Feedback-Forum bei DelphiGL.com.''</div>Traudehttps://wiki.delphigl.com/index.php?title=glBindAttribLocation&diff=25437glBindAttribLocation2011-12-18T18:25:08Z<p>Traude: /* Parameter */ 'unterminierten' zu 'nullterminierten' geändert</p>
<hr />
<div>= glBindAttribLocation (glBindAttribLocationARB) =<br />
<br />
<br />
== Name ==<br />
'''glBindAttribLocation''' - Verbindet ein generisches Vertex-Attribut mit einer Attribut-Variable.<br />
<br />
<br />
== Delphi-Spezifikation ==<br />
procedure '''glBindAttribLocation'''(''program'', ''index'' : GLuint; ''name'' : PGLchar)<br />
procedure '''glBindAttribLocationARB'''(''program'' : GLhandleARB; ''index'' : GLuint; ''name'' : PGLcharARB)<br />
<br />
<br />
<br />
== Parameter ==<br />
<br />
{| border="1" rules="all"<br />
! ''program'' <br />
| Gibt das Handle des Shader-Programm-Objekts an, in dem das Verbinden des generischen Vertex-Attributs mit der Attribut-Variable vollzogen werden soll.<br />
|-<br />
! ''index'' <br />
| Gibt den Index des generischen Vertex-Attributes an, das gebunden werden soll.<br />
|-<br />
! ''name''<br />
| Gibt einen nullterminierten String an, der den Namen der Vertexshader-Attribut-Variable enthält, an die ''index'' gebunden werden soll.<br />
|}<br />
<br />
== Beschreibung ==<br />
'''glBindAttribLocation''' wird verwendet, um einen generischen Vertexshader-Attribut-Index mit einer Vertexshader-Attribut-Variable zu verknüpfen. Der Name der Vertexshader-Attribut-Variable wird als ein unterminierter String in ''name'' übergeben. Das generische Vertex-Attribut, das an diese Variable gebunden werden soll, wird mit ''index'' spezifiziert. Wenn der/die auszuführende(n) Shader, auf die ''program'' zeigt, Teil des akteuellen Status werden, verändern die Werte, die durch den generischen Vertex-Attribut-Index übergeben werden, den Wert der durch ''name'' spezifizierten Vertexshader-Attribut-Variable.<br />
<br />
<br />
<br />
Wenn sich ''name'' auf eine Matrix-Attribut-Variable bezieht, bezieht sich ''index'' auf die erste Spalte der Matrix. Die anderen Spalten werden dann automatisch an die Positionen ''index''+1 (für mat2), ''index''+1 und ''index''+2 (für mat3) und ''index''+1, ''index''+2 und ''index''+3 (für mat4) gebunden.<br />
<br />
<br />
<br />
Dieser Befehl macht es möglich, dass Vertexshader anschauliche Namen für Attribut-Variablen anstatt generischer Namen, nummeriert von 0 bis '''GL_MAX_VERTEX_ATTRIBS''' - 1. Die Werte, die an jeden generischen Attribut-Index gesendet werden, sind Teil das aktuellen Zustands, genauso wie Standard-Vertex-Attribute wie Farbe, Normale und Vertex-Position. Wird ein anderes Shaderprogramm-Objekt durch den Aufruf von [[glUseProgram]] aktuell, wird das ganze so gedeichselt (sorry, der musste sein *zwinker*), dass der Wert des generischen Vertex-Attributs '''i''' im neuen Shaderprogramm-Objekt der gleiche ist wie der Wert des generischen Vertex-Attributs '''i''' im alten Shaderprogramm-Objekt.<br />
<br />
<br />
<br />
Attribut-Verknüpfungen treten solange nicht in Effekt, bis [[glLinkProgramARB]] aufgerufen wird. Sobald ein Shaderprogramm-Objekt erfolgreich gelinkt worden, bleiben die Index-Werte für Attribut-Variablen bis zum nächsten Link-Auruf gleich.<br />
<br />
<br />
<br />
Es ist nicht erlaubt, irgendeinen der Standard-OpenGL-Vertexattribute mit Hilfe dieser Funktion zu verknüfen, da sie automatisch bei Bedarf verknüpft werden.<br />
<br />
<br />
<br />
== Hinweise ==<br />
'''glBindAttribLocation''' kann aufgerufen werden, bevor ein Vertexshader-Objekt an sein Programmobjekt gebunden wird.<br />
<br />
Es ist auch zulässig, einen generischen Attribut-Index an einen Attribut-Variablen-Namen zu binden, der niemals im Vertexshader verwendet wird. Trotzdem wird aber einer der verfügbaren generischen Vertex-Attribut-Slots verbraucht.<br />
<br />
Es ist erlaubt, das mehr als ein Vertexshader-Attribut-Name mit dem selben generischen Vertex-Attribut-Index verknüpft wird. Das wird "Aliasing" genannt, und es ist nur zulässig, wenn nur einer der "aliased" Attribute im ausgeführten Programm aktiv ist. Der Compiler und der Linker dürfen annehmen, dass kein "Aliasing" verwendet wird und es steht ihnen frei, Optimierungen anzuwenden, die nur in der Abwesenheit von "Aliasing" funktionieren. OpenGL-Implementationen müssen keine Überprüfung vornehmen, ob "Aliasing" angwendet werden könnte. <br />
<br />
Da es nicht möglich ist, Standard-Attribute zu verknüpfen, ist es folglich auch nicht möglich, generische Attribute mit konventionellen zu verbinden.<br />
<br />
Aktive Attribute, die nicht explizit verknüpft werden, werden verknüpft, wenn [[glLinkProgram]] aufgerufen wird. Die zugewiesenen Positionen können mit [[glGetAttribLocatio]] abgefragt werden.<br />
<br />
'''glBindAttribLocation''' ist seit OpenGL Version 2.0 eine Kernfunktion. Davor war nur die ARB-Variante verfügbar.<br />
<br />
== Fehlermeldungen ==<br />
'''GL_INVALID_VALUE''' wird generiert, wenn ''index'' größer oder gleich '''GL_MAX_VERTEX_ATTRIBS_ARB''' ist.<br />
<br />
'''GL_INVALID_OPERATION''' wird generiert, wenn ''name'' mit dem reservierten Präfix "gl_" beginnt.<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn ''program'' kein von OpenGL erzeugtes Programmhandle ist.<br />
<br />
'''GL_INVALID_OPERATION''' wird generiert, wenn ''program'' nicht vom Typ '''GL_PROGRAM_OBJECT_ARB''' ist.<br />
<br />
'''GL_INVALID_OPERATION''' wird generiert, wenn '''glBindAttribLocation''' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird. <br />
<br />
<br />
<br />
== Zugehörige Wertrückgaben ==<br />
[[glGetActiveAttrib]] mit Argument ''program''<br />
<br />
[[glGetAttribLocation]] mit den Argumenten ''program'' und ''name''<br />
<br />
[[glGet]] mit Token [[GL_MAX_VERTEX_ATTRIBS_ARB|GL_MAX_VERTEX_ATTRIBS_ARB]]<br />
<br />
<br />
<br />
== Siehe auch ==<br />
[[glDisableVertexAttribArray]], [[glEnableVertexAttribArray]], [[glUseProgram]], [[glVertexAttrib]], [[glVertexAttribPointer]]<br />
<br />
[[Kategorie:GL|BindAttribLocation]]<br />
[[Kategorie:GL2.0|BindAttribLocation]]<br />
[[Kategorie:GL3]]</div>Traudehttps://wiki.delphigl.com/index.php?title=Physik&diff=24936Physik2010-09-06T09:16:17Z<p>Traude: Änderung eines falschen Links für Newton</p>
<hr />
<div>{{Hinweis|Physik in Spielen ist sehr vielfältig. Dieser Artikel beschreibt einige Fasetten und kann keinesfalls als Vollständig gelten.}}<br />
Die Physik ist mittlerweile in fast allen Spiele-Genres zum wichtigen Bestandteil geworden.<br />
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.<br />
Ein Spiel kann aber nur so gut sein, wie sein schlechtestes Modul.<br />
Wenn die KI gegen die Wand läuft, über eine Kiste nicht rüber oder vorbei kommt, dann hilft auch die beste Grafik nichts.<br />
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).<br />
Die Physik arbeitet für die KI vor, denn die KI braucht Wissen über die Umgebung.<br />
Also hat die Physik einen wichtigen Platz in der Gameengine.<br />
Mittlerweile werden sogar Hardware-Physik-Beschleuniger entwickelt (siehe [http://www.ageia.com/ Ageia]), die, wie Grafikkarten, die CPU bei speziellen Berechnungen entlasten sollen.<br />
Parallisierung ist ebenfalls ein wichtiger Schritt und neue Algorythmen, zur schnelleren Kollisionserkennung, sortierung und reaktion auf Kollisionen.<br />
<br />
== Kollisionskontrolle ==<br />
<br />
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.<br />
<br />
Deshalb verfügen selbst einfachste Jump&Run-Spiele über eine Kollisionskontrolle. Diese verhindert, dass sich Objekte ungebremst durch andere Objekte bewegen können. <br />
Ü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.<br />
<br />
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.<br />
<br />
{{Hinweis|Kollisionsberechnung und auch Bounding Volumes werden im 3 teiligen [[Tutorial Kollision1|DGL Tutorial zum Thema "Kollision"]] behandelt.}}<br />
<br />
== Bounding Volumes ==<br />
<br />
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.<br />
<br />
== Gravitation ==<br />
<br />
Gerade bei neueren Spielen, in denen viele frei bewegliche Objekte vorhanden sind, ist die Simulation der Schwerkraft sehr wichtig. Hier ein kurzes Beispiel:<br />
<br />
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. <br />
<br />
Ohne die Gravitation würde diese Kiste nun ewig im Raum rumschweben. <br />
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.<br />
<br />
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.<br />
Je Höher die Masse und Dichte eines Objektes, des so höher die Gravitation, die davon ausgeht.<br />
<br />
== Plastische Verformungen ==<br />
<br />
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. <br />
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.<br />
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.<br />
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.<br />
Eine verwendung, der Grundlagen von Schallausbreitung, könnte hier auch einiges für Explosionen bringen.<br />
<br />
<br />
== Ragdoll ==<br />
<br />
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.<br />
Diese physikalisch korrekt berechnete Simulation des Todes ist gerade in Deutschland sehr umstritten.<br />
<br />
<br />
== Fertige Physikbibliotheken ==<br />
<br />
Wer keine Zeit, Lust oder Geduld hat, eine eigene Physikbibliothek zu erstellen findet hier eine kleine Auswahl an fertigen:<br />
# Havok (http://www.havok.com/) (Windows)<br />
# Newton (http://newtondynamics.com/) (Windows, Linux, MacOS X)<br />
# NovodeX (http://www.ageia.com/novodex.html) (Windows)<br />
# ODE (http://www.ode.org/) (Windows, Linux, MacOS X)<br />
# Bullet physics (http://www.bulletphysics.com/) (alle gängigen Plattformen und OS)</div>Traudehttps://wiki.delphigl.com/index.php?title=Enginepfad&diff=24857Enginepfad2010-05-19T15:21:05Z<p>Traude: /* Link auf Newton Physics Engine richtiggestellt */</p>
<hr />
<div>=Der Enginepfad=<br />
<br />
==Einführung==<br />
Willkommen auf dem '''Enginepfad''' des DelphiGL-Wikis. Dieser Pfad soll euch zeigen wie man eine Engine von Grund auf konzipieren und realisieren kann.<br />
<br />
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. <br />
<br />
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.<br />
<br />
==Der Trampelpfad==<br />
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.<br />
<br />
<br />
Weiterhin ist die Wahl der Sprache zu treffen.<br />
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.<br />
<br />
==Vorbereitung==<br />
Als erstes muss uns klar werden, welches Ausmaß die Engine erreichen soll. Davon abhängig ist unsere Planung zu gestalten:<br />
:1. Es ist ratsam mit der Plattformunterstützung anzufangen, da diese unsere unterste Schicht bilden wird.<br />
:Hier ist als erstes zu sagen, je mehr Plattformen unterstütz werden sollen, desto aufwendiger wird das Projekt.<br />
:Mit Plattformen sind hier z.B. PC mit 32Bit/64Bit, Konsolen (PS1-3, XBox-360, Wii, GP2X, ...) und mobile Geräte (Palm, PSP,...) gemeint.<br />
:Für jede Plattform gibt es eine oder mehrere Betriebssysteme zur Ansteuerung der Hardware.<br />
:Hier eine kleine Liste mit verschiedenen Betriebssystemen:<br />
:*Windows<br />
:*Linux<br />
:*MacOS X<br />
<br />
<br />
:2. Abhängig davon wählen wir nun unseren Compiler. <br />
:*[http://www.borland.de/delphi/ Delphi] (Windows 32Bit)<br />
:*[http://www.freepascal.org/ FreePascal] (Unterstützung für alle erwähnten Plattformen und OS)<br />
:*[http://www.gnu.org/software/gcc/gcc.html gcc] (Unterstützungen für alle erwähnten Plattformen und OS)<br />
:*[http://www.borland.de/kylix/ Kylix] (Linux 32Bit) (Veraltet, nicht mehr in Entwicklung)<br />
:*[http://msdn.microsoft.com/visualc/ VisualC++] (Windows 32/64Bit WinCE)<br />
<br />
<br />
:3. Nun sollten wir entscheiden, welche Bibliothek wir für das Ansprechen der Grafikkarte verwenden:<br />
: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.<br />
{{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}}<br />
<br />
<br />
:4. Nun kommen wir zu allgemeinen Bibliotheken für das Ansteuern unserer Hardware.<br />
: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.<br />
:Sound:<br />
:*ALSA (Linux)<br />
:*[http://www.un4seen.com/ BASS]<br />
:*[[Direct Sound]] (Windows)<br />
:*[http://www.fmod.org/ FMOD]<br />
:*[[OpenAL]]<br />
:*OSS (Nur Linux)<br />
:*[[SDL]]<br />
:Netzwerk:<br />
:*DirectX Net (Windows)<br />
:*[[SDL_Net]]<br />
:*Raknet<br />
<br />
<br />
: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.<br />
:Physik:<br />
:*[http://www.havok.com/ Havok]<br />
:*[http://newtondynamics.com/ Newton]<br />
:*[http://www.ageia.com/novodex.html NovodeX]<br />
:*[http://www.ode.org/ ODE]<br />
:Fenster:<br />
:*[http://www.gtk.org/ GTK]<br />
:*[http://www.wxwidget.org/ wxWidget]<br />
:*[[SDL]]<br />
:*Win API (Windows)<br />
:Kompression:<br />
:*[http://www.zlib.net/ zLib]<br />
:Künstliche Intelligenz:<br />
:*[http://opensteer.sourceforge.net/ openSteer]<br />
<br />
<br />
:6. Nun beachten wir unser eventuell eingeplantes Budget (normalerweise 0 ^_^) und gehen die Liste oben nochmal durch.<br />
<br />
<br />
: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.<br />
:GUI:<br />
:*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.<br />
:Logik:<br />
:*Die Logik ist der größte Teil vom Programm, denn hier ist der ganze Code angesiedelt, der das Programm zum laufen bringt.<br />
:Datenbank:<br />
:*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.<br />
<br />
<br />
: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.<br />
<br />
==Helfende Tools==<br />
<br />
Wenn man ein Projekt beginnt, dann sollte man auch entsprechend ausgerüstet sein, denn eine gute Toolchain erspart viel Zeit.<br />
<br />
===Versionierung===<br />
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.<br />
*[http://subversion.tigris.org/ SVN](frei,OpenSource,cross platform, der Nachfolger von CVS)<br />
*[http://git.or.cz/ git](frei,OpenSource,cross platform, der Linuxkernel wird darüber verwaltet)<br />
*[http://www.nongnu.org/cvs/ CVS](frei,OpenSource,cross platform, weit verbreitet)<br />
*[http://www.perforce.com/ Perforce](kommerziel ab 2 Nutzern,closed Source,cross platform, im Komerziellen Bereich verbreitet z.B. UnrealEngine3)<br />
<br />
===Unit Test===<br />
Hierfür gibt es je nach Sprache und geschmack mehere Möglichkeiten.<br />
*Frameworks([http://junit.sourceforge.net/ JUnit], [http://camelos.sourceforge.net/fpcUnit.html FPCUnit], [http://sourceforge.net/projects/cppunit CPPUnit], [http://dunit.sourceforge.net/ DUnit])<br />
*komplett eigener Code<br />
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.<br />
Schlagen einige Unittests fehl, tut die Software nicht mehr das, was sie eigentlich Leisten sollte.<br />
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.<br />
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.<br />
Mehr zum Thema ist [http://de.wikipedia.org/wiki/Modultest hier] zu finden.<br />
<br />
===Automatisierte Builds können sehr Hilfreich sein.===<br />
Ein Automatisierter Build wird verwendet, um z.B. Nightbuilds, Dailybuilds zu erstellen, Unittest, Systemtest und so weiter zu machen.<br />
Die komplexität von Buildsystemen ist hierbei sehr unterschiedlich.<br />
Hier ein paar Tools.<br />
*make<br />
*[http://www.scons.org/ scons](python basierte toolchain, cross platform)<br />
*[http://www.cmake.org/ CMake](Projektdatei Generator für viele Buildsysteme)<br />
*[http://ant.apache.org/ Ant](java basierte toolchain, cross platform)<br />
So kann man z.B. sein Projekt in einer makefile umsetzen, indem man sogenannte Targets für Kompilieren, Aufräumen, Unittests einbaut.<br />
Wenn man dann als Programmierer den Sourcecode lädt, kann man einfach make machen und man bekommt ein fertiges Build zurück.<br />
Damit hat man den ersten Stein für den Weg, zur nutzung der Software, gelegt.<br />
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.<br />
Daher lohnt es sich schon gleich zum anfang sich ein Generierungssystem auszusuchen und diese mit neuen Datein immer zu aktualisieren.<br />
<br />
===Komplexe Buildsystem===<br />
Wer vor hat an ein größeren Projekt zu arbeiten, der sollte sich ein Buildsystem zulegen, welches über make und anderen hinaus geht.<br />
Eines der weit verbreitesten Systeme ist CruiseControl.<br />
CruiseControl ist ein Buildsystem, im welchen man Projekte anlegen kann, diesen bestimmte Aufgaben zuweist und es selbständig für sie Arbeit verrichtet.<br />
So kann man das erstellen von Binaries, UnitTest und Systemtest durchführen, Installer erstellen, E-Mails versenden und noch vieles mehr.<br />
Mehr zu CruiseControl findet man [[BuildGrids|hier]].<br />
<br />
===Systemtests===<br />
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.<br />
Der Unittest testet ja nur die Funktion selber erfolgreich aber nicht System oder Fremdcode Fehler.<br />
Buildtools wie Ant in Verbindung mit CruiseControl können Systemtests sehr angenehm zu testen machen und vorallem automatisiert.<br />
<br />
===Design Brainstorming===<br />
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.<br />
Hierfür gibt es komerzielle und freie Tools, die entsprechend unterschiedlich viel können und arbeiten.<br />
*[http://freemind.sourceforge.net/wiki/index.php/Main_Page FreeMind](freies OpenSource Tool, cross platform)<br />
*[http://www.gnome.org/~dscorgie/labyrinth.html Labyrinth](freies OpenSource Tool, Linux only)<br />
<br />
==Planung==<br />
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.<br />
<br />
<br />
Geht's nun Los?<br />
<br />
<br />
Na ja, nun kommt der wahrscheinlich unangenehmste Satz für alle:<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
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.<br />
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.<br />
Für ein SceneGraph kann man das Observer Muster prima anwenden und Singleton kann man für alle Manager verwenden.<br />
<br />
{{Hinweis|Siehe die Tutorial Reihe [[Tutorial_Softwareentwicklung1|Softwareentwicklung]]}}<br />
<br />
==Die ersten Schritte in eine nicht reelle Welt==<br />
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:<br />
<br />
# [[Leveleditoren]] um die "Welt" zu erstellen.<br />
# '''Texturmanager''' um den Programmierern den Zugriff auf die Texturen so einfach wie möglich zu machen.<br />
# '''Soundmanager''' (siehe vorheriges)<br />
# '''Lademanager''' für eigene Dateiformate.<br />
<br />
<br />
Nun ist es so weit, wir wissen was wir wollen und haben alles durchdacht.<br />
Nun gilt es die einzelnen Module in die Tat um zu setzen.<br />
Einige Module die es 3D Anwendungen/Spielen geben könnte:<br />
<br />
<br />
'''Grundlagen:'''<br />
#[[Template]]<br />
#[[Kamera]]<br />
#[[Schrift]]<br />
#[[IODevice|Input]] (Maus/Tastatur)<br />
#[[Adapter Muster]]<br />
<br />
<br />
'''Fortgeschrittene Grundlagen:'''<br />
#[[Sound]]<br />
#[[Physik]]<br />
#[[Texturen]]<br />
#[[Levelformat]]<br />
#[[Modelformat]]<br />
#[[Console]] (Laufzeit-Schnittstelle zur Engine)<br />
#[[DGL GUI|GUI]] (Game User Interface)<br />
#[[Netzwerk]]<br />
<br />
<br />
'''Fortgeschritten:'''<br />
#[[Shader]]<br />
#[[Materials]]<br />
#[[Packformate]]<br />
#[[VFS]] (Virtual File System)<br />
#[[Soundformat-Erweiterungen]]<br />
#[[KI]]<br />
#[[Script]]<br />
#[[Scene Graph]]<br />
<br />
<br />
<br />
Sieht doch eigentlich nach nicht so viel aus oder?<br />
<br />
<br />
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 ?<br />
#die Planung wird bei weitem nicht so groß ausfallen wie in Grossfirmen<br />
#die Koordination von vielen Person ist sehr schwer und es kann zu großen Zeitlücken kommen<br />
#meistens wird die Planung sowieso nicht in die Tat umzusetzen sein, es gibt immer ein Problem<br />
#ein kleines Team kann sich im besten Fall gegenseitig hochpushen und zu mehr anspornen<br />
#Großfirmen haben selten die Möglichkeit, mal einen Codefetzen in Foren zu setzen und verbessern zu lassen<br />
#das Nutzen von Bibliotheken ist sehr zeitsparend<br />
<br />
==Die Engine ist fertig oder doch nicht?==<br />
Es gibt ein Unterschied zwischen der Entwicklung von einer Engine und der Entwicklung einer Engine für ein Spiel.<br />
Die Engine für ein Spiel ist festgelegt und hat ein Endpunkt, was sie leisten soll.<br />
Eine Engine als selbststehendes Projekt wird hingegen nie fertig, man kann sie immer wieder optimieren und erweitern.<br />
Doch kommt der Punkt, wo die Qualität den Ansprüchen völlig ausreichend ist.<br />
Man sollte nun noch überlegen, ob man eventuell ein Tool zur leichteren Handhabung der Engine entwickelt.<br />
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.<br />
<br />
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.<br />
<br />
==Links==<br />
[http://karmarama.linuxprofessionals.org Karmarama Engine]<br />
<br />
[http://www.omorphia.de Projekt omorphia]<br />
<br />
[http://andorra.sourceforge.net/ Andorra 2D]<br />
<br />
<br />
[[Kategorie:Trampelpfad]]</div>Traudehttps://wiki.delphigl.com/index.php?title=VBO_ohne_glInterleavedArrays&diff=24801VBO ohne glInterleavedArrays2010-03-29T08:46:47Z<p>Traude: Behauptung, VBO ist in OpenGL3 die einzige Art zu Zeichnen, entfernt.</p>
<hr />
<div>(Voraussetzung: mindestens OpenGL 1.5)<br />
<br />
"VBO" ist die Abkürzung von "Vertex Buffer Object" und ist eine Möglichkeit der Darstellung von Objekten mit OpenGL.<br />
<br />
Es gibt mehrere Möglichkeiten, einen VBO zu verwenden. Die Variante, die ich unten erkläre, ist also nicht die einzige.<br />
<br />
<br />
==VBO mit frei definierter Datenstruktur, ohne glInterleavedArrays==<br />
<br />
Der untenstehende Pascal-Code zeichnet das Opengl-Dreieck mit einem VBO. Ich hatte beim Erzeugen dieses Code-Stücks eine steile Lernkurve und jede Menge Frust, denn beim Ändern einzelner Teile sind dann natürlich auch korrespondierende Teile anderswo zu ändern, aber da kann man leicht etwas übersehen, speziell wenn es gegen vier Uhr morgens geht. :)<br />
<br />
<br />
<br />
===1. Zunächst die globalen Deklarationen===<br />
<br />
Typen<br />
<source lang="pascal"><br />
TVector4D = Packed Record X,Y,Z,W: Single; End; <br />
<br />
TVBOVertex = Packed Record <br />
Position,<br />
Color,<br />
Empty: TVector4D;<br />
End;<br />
<br />
TVBOBuffer = Array Of TVBOVertex;<br />
TIndexBuffer = Array Of Word;<br />
</source><br />
<br />
Konstanten<br />
<source lang="pascal"><br />
POS_OFFSET = 0;<br />
COL_OFFSET = SizeOf(TVector4D);<br />
STRIDE = SizeOf(TVBOVertex);<br />
</source><br />
<br />
Variablen<br />
<source lang="pascal"><br />
VBOBuffer: TVBOBuffer; // VBO-Daten<br />
IndexBuffer: TIndexBuffer; // VBO-Indices<br />
VertexBufSize, // VBO-Daten: Puffergröße<br />
IndexBufSize, // VBO-Indices: Puffergröße <br />
IndexCount, // Anzahl der Indices<br />
IDVbo,IDIndex: Cardinal; // Opengl-"Handles" für VBO- und Indexpuffer<br />
</source><br />
<br />
Bei dieser Variante des VBO kann man sein eigenes Vertex definieren und ist nicht auf vorgegebene Datenstrukturen beschränkt wie bei den glInterleavedArrays. Der "Empty"-Vektor im TVBOVertex soll darauf hinweisen, dass man vorgegebene Vertexattribute mit benutzerdefinierten mischen kann. Das wird hier aber nicht behandelt. <br />
<br />
Ihr könnt die Typen definieren, wie Ihr wollt, aber es ergeben sich daraus Konsequenzen. Die Datendeklaration hat unmittelbaren Einfluss auf den untenstehenden Initialisierungs- und Rendercode. Wenn also der Datentyp geändert wird, muss man den ganzen untenstehenden Code auf notwendige Anpassungen untersuchen. Wie sich gezeigt hat, habe ich dabei immer wieder das eine oder andere vergessen. :(<br />
<br />
<br />
<br />
<br />
===2. Dann das Hochladen der Daten aus dem Hauptspeicher in den Grafikkartenspeicher===<br />
<source lang="pascal"><br />
IndexCount:= 3;<br />
<br />
VertexBufSize:= IndexCount*SizeOf(TVBOVertex);<br />
IndexBufSize:= IndexCount*SizeOf(Word);<br />
</source><br />
<br />
Vertexpuffer erzeugen,initialisieren und mit Daten bestücken<br />
<source lang="pascal"><br />
SetLength(VBOBuffer,IndexCount);<br />
FillChar(VBOBuffer[0],Length(VBOBuffer)*SizeOf(TVBOVertex),#0);<br />
<br />
With VBOBuffer[0] Do<br />
Begin<br />
With Position Do Begin X:=-1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+1.0; Y:=+0.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[1] Do<br />
Begin<br />
With Position Do Begin X:=+1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[2] Do<br />
Begin<br />
With Position Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+0.0; Z:=+1.0; W:=+1.0; End;<br />
End;<br />
</source><br />
<br />
Vertexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDVbo);<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
glBufferData(GL_ARRAY_BUFFER,VertexBufSize,@VBOBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Dasselbe mit dem Indexpuffer<br />
<source lang="pascal"><br />
SetLength(IndexBuffer,IndexCount);<br />
<br />
IndexBuffer[0]:= 0;<br />
IndexBuffer[1]:= 1;<br />
IndexBuffer[2]:= 2;<br />
</source><br />
<br />
Indexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDIndex);<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
glBufferData(GL_ELEMENT_ARRAY_BUFFER,IndexBufSize,@IndexBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Ich habe hier für den VBO einen Record genommen, weil bei den Demos im Netz normalerweise immer Arrays benutzt werden. Der Recordtyp ist zusätzlich viel selbsterklärender als ein Array und man kann ihn auch noch durch treffende Namensgebung verbessern. <br />
<br />
Abgesehen von der Entscheidung, welchen Datentyp man nehmen soll, ist das der einfachere Teil des Ganzen. Und damit es nicht ganz trivial wird, habe ich noch einen winzigen Indexbuffer definiert, damit ich zum Zeichnen glDrawElements verwenden kann. <br />
<br />
In den Beispielen, die man im Web finden kann, gibt es außerdem noch die Variante, wo glBufferdata nur zur Definition der Puffer-Parameter benutzt wird, aber für das Hochladen der Daten auf die Grafikkarte wird glBufferSubdata verwendet. Damit kann man entweder den ganzen Puffer oder auch nur Teile davon neu beschicken. <br />
<br />
<br />
<br />
===3. Der Rendercode===<br />
<br />
Vertexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
</source><br />
<br />
Nötige Zeiger setzen<br />
<source lang="pascal"><br />
glVertexPointer(4, GL_FLOAT, STRIDE, POS_OFFSET);<br />
glColorPointer(4, GL_FLOAT, STRIDE, COL_OFFSET);<br />
</source><br />
<br />
Indexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
</source><br />
<br />
Zeichnen<br />
<source lang="pascal"><br />
glEnableClientState(GL_VERTEX_ARRAY);<br />
glEnableClientState(GL_COLOR_ARRAY);<br />
<br />
glDrawElements(GL_TRIANGLES,IndexCount,GL_UNSIGNED_SHORT,NIL);<br />
<br />
glDisableClientState(GL_COLOR_ARRAY);<br />
glDisableClientState(GL_VERTEX_ARRAY);<br />
</source><br />
<br />
Über das Binden der Puffer gibt es eigentlich nicht viel zu sagen. Die OpenGL-Pufferobjekte sind alle ziemlich ähnlich.<br />
<br />
Aber bei den Zeigern kann man eine Menge falsch machen. Etliche Leute im Netz haben z.B. nachgeforscht, wie man den Parameter "Stride" zu interpretieren hat. Ich habe Stride ganz oben im Defnitionsteil als Konstante definiert: STRIDE = SizeOf(TVBOVertex); damit ist klar, dass hier die gesamte Blockgröße des Vertex gemeint ist. Die "Offset"-Parameter habe ich als Konstanten definiert weil sie von der Struktur des Vertex abhängen und daher vermutlich nicht dauernd geändert werden. "Offset" ist hier genau das richtige Wort. Zwischen dem Beginn des Vertex und der Color liegt eine Position mit dem Typ "TVector4D", daher ist der Offset der Color SizeOf(TVector4D). <br />
<br />
Ich habe hier zwar kein nächstes Vertex-Element, aber wenn ich eines hätte, dann wäre dessen Offset COL_OFFSET+SizeOf(TVector4D) oder auch in Pseudoschreibweise: Offset(Color)+Size(Color).<br />
<br />
Nach dem Binden des Indexpuffers muss man den VBO Client-seitig aktivieren, und zwar für jeden Attribut-Typ extra. Wenn Ihr also eine Texturkoordinate ergänzen wollt - dazu muss man natürlich die Vertex-Definition ändern -, dann vergeßt bloß nicht das "glEnableClientState(GL_TEXTURE_COORD_ARRAY)" nachzutragen.<br />
<br />
So, jetzt kann man endlich zeichnen. Die Typangabe im glDrawElements beschreibt den Index und der letzte Parameter muss "NIL" sein, denn in unserem Fall ist dieser Parameter überflüssig (er wird in einem anderen Zusammenhang zum Nachladen der Daten benutzt).<br />
<br />
<br />
<br />
===4. Nachher reinen Tisch machen===<br />
<source lang="pascal"><br />
Finalize(IndexBuffer);<br />
Finalize(VBOBuffer);<br />
glDeleteBuffers(1,@IDVbo);<br />
glDeleteBuffers(1,@IDIndex);<br />
</source><br />
<br />
<br />
Und, naja, wenn man etwas auf eine solche Art zeichnet, sollte es natürlich nicht grade ein Dreieck sein. Das wäre nämlich so, als ob man um die Ecke in den Supermarkt gehen wollte und dazu einen Jumbojet benutzt. :) <br />
<br />
Insgesamt fand ich am Ende, dass ich Euch vielleicht ein wenig Zeit und Frust ersparen kann, wenn ich das Ganze ins DGL-Wiki stelle. <br />
<br />
Ich hoffe, es hilft.<br><br />
Viele Grüße,<br><br />
[[Benutzer:Traude|Traude]]<br />
<br />
<br />
''Fragen und Verbesserungsvorschläge wie immer ins Feedback-Forum bei DelphiGL.com.''</div>Traudehttps://wiki.delphigl.com/index.php?title=VBO_ohne_glInterleavedArrays&diff=24795VBO ohne glInterleavedArrays2010-03-20T11:28:40Z<p>Traude: Noch ein Tippfehler *Seufz*</p>
<hr />
<div>(Voraussetzung: mindestens OpenGL 1.5)<br />
<br />
"VBO" ist die Abkürzung von "Vertex Buffer Object" und ist eine Möglichkeit der Darstellung von Objekten mit OpenGL. In den OpenGL-Versionen ab Nummer 3 ist es die '''einzige''' Möglichkeit.<br />
<br />
Es gibt aber mehrere Möglichkeiten, einen VBO zu verwenden. Die Variante, die ich unten erkläre, ist also nicht die einzige.<br />
<br />
<br />
VBO mit frei definierter Datenstruktur, ohne glInterleavedArrays <br />
<br />
Der untenstehende Pascal-Code zeichnet das Opengl-Dreieck mit einem VBO. Ich hatte beim Erzeugen dieses Code-Stücks eine steile Lernkurve und jede Menge Frust, denn beim Ändern einzelner Teile sind dann natürlich auch korrespondierende Teile anderswo zu ändern, aber da kann man leicht etwas übersehen, speziell wenn es gegen vier Uhr morgens geht. :)<br />
<br />
<br />
<br />
'''1. Zunächst die globalen Deklarationen'''<br />
<br />
Typen<br />
<source lang="pascal"><br />
TVector4D = Packed Record X,Y,Z,W: Single; End; <br />
<br />
TVBOVertex = Packed Record <br />
Position,<br />
Color,<br />
Empty: TVector4D;<br />
End;<br />
<br />
TVBOBuffer = Array Of TVBOVertex;<br />
TIndexBuffer = Array Of Word;<br />
</source><br />
<br />
Konstanten<br />
<source lang="pascal"><br />
POS_OFFSET = 0;<br />
COL_OFFSET = SizeOf(TVector4D);<br />
STRIDE = SizeOf(TVBOVertex);<br />
</source><br />
<br />
Variablen<br />
<source lang="pascal"><br />
VBOBuffer: TVBOBuffer; // VBO-Daten<br />
IndexBuffer: TIndexBuffer; // VBO-Indices<br />
VertexBufSize, // VBO-Daten: Puffergröße<br />
IndexBufSize, // VBO-Indices: Puffergröße <br />
IndexCount, // Anzahl der Indices<br />
IDVbo,IDIndex: Cardinal; // Opengl-"Handles" für VBO- und Indexpuffer<br />
</source><br />
<br />
Bei dieser Variante des VBO kann man sein eigenes Vertex definieren und ist nicht auf vorgegebene Datenstrukturen beschränkt wie bei den glInterleavedArrays. Der "Empty"-Vektor im TVBOVertex soll darauf hinweisen, dass man vorgegebene Vertexattribute mit benutzerdefinierten mischen kann. Das wird hier aber nicht behandelt. <br />
<br />
Ihr könnt die Typen definieren, wie Ihr wollt, aber es ergeben sich daraus Konsequenzen. Die Datendeklaration hat unmittelbaren Einfluss auf den untenstehenden Initialisierungs- und Rendercode. Wenn also der Datentyp geändert wird, muss man den ganzen untenstehenden Code auf notwendige Anpassungen untersuchen. Wie sich gezeigt hat, habe ich dabei immer wieder das eine oder andere vergessen. :(<br />
<br />
<br />
<br />
<br />
'''2. Dann das Hochladen der Daten aus dem Hauptspeicher in den Grafikkartenspeicher'''<br />
<source lang="pascal"><br />
IndexCount:= 3;<br />
<br />
VertexBufSize:= IndexCount*SizeOf(TVBOVertex);<br />
IndexBufSize:= IndexCount*SizeOf(Word);<br />
</source><br />
<br />
Vertexpuffer erzeugen,initialisieren und mit Daten bestücken<br />
<source lang="pascal"><br />
SetLength(VBOBuffer,IndexCount);<br />
FillChar(VBOBuffer[0],Length(VBOBuffer)*SizeOf(TVBOVertex),#0);<br />
<br />
With VBOBuffer[0] Do<br />
Begin<br />
With Position Do Begin X:=-1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+1.0; Y:=+0.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[1] Do<br />
Begin<br />
With Position Do Begin X:=+1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[2] Do<br />
Begin<br />
With Position Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+0.0; Z:=+1.0; W:=+1.0; End;<br />
End;<br />
</source><br />
<br />
Vertexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDVbo);<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
glBufferData(GL_ARRAY_BUFFER,VertexBufSize,@VBOBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Dasselbe mit dem Indexpuffer<br />
<source lang="pascal"><br />
SetLength(IndexBuffer,IndexCount);<br />
<br />
IndexBuffer[0]:= 0;<br />
IndexBuffer[1]:= 1;<br />
IndexBuffer[2]:= 2;<br />
</source><br />
<br />
Indexdaten hochladen<br />
<source lang="pascal"><br />
glGenBuffers(1,@IDIndex);<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
glBufferData(GL_ELEMENT_ARRAY_BUFFER,IndexBufSize,@IndexBuffer[0],GL_STATIC_DRAW);<br />
</source><br />
<br />
Ich habe hier für den VBO einen Record genommen, weil bei den Demos im Netz normalerweise immer Arrays benutzt werden. Der Recordtyp ist zusätzlich viel selbsterklärender als ein Array und man kann ihn auch noch durch treffende Namensgebung verbessern. <br />
<br />
Abgesehen von der Entscheidung, welchen Datentyp man nehmen soll, ist das der einfachere Teil des Ganzen. Und damit es nicht ganz trivial wird, habe ich noch einen winzigen Indexbuffer definiert, damit ich zum Zeichnen glDrawElements verwenden kann. <br />
<br />
In den Beispielen, die man im Web finden kann, gibt es außerdem noch die Variante, wo glBufferdata nur zur Definition der Puffer-Parameter benutzt wird, aber für das Hochladen der Daten auf die Grafikkarte wird glBufferSubdata verwendet. Damit kann man entweder den ganzen Puffer oder auch nur Teile davon neu beschicken. <br />
<br />
<br />
<br />
'''3. Der Rendercode'''<br />
<br />
Vertexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
</source><br />
<br />
Nötige Zeiger setzen<br />
<source lang="pascal"><br />
glVertexPointer(4, GL_FLOAT, STRIDE, POS_OFFSET);<br />
glColorPointer(4, GL_FLOAT, STRIDE, COL_OFFSET);<br />
</source><br />
<br />
Indexpuffer binden<br />
<source lang="pascal"><br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
</source><br />
<br />
Zeichnen<br />
<source lang="pascal"><br />
glEnableClientState(GL_VERTEX_ARRAY);<br />
glEnableClientState(GL_COLOR_ARRAY);<br />
<br />
glDrawElements(GL_TRIANGLES,IndexCount,GL_UNSIGNED_SHORT,NIL);<br />
<br />
glDisableClientState(GL_COLOR_ARRAY);<br />
glDisableClientState(GL_VERTEX_ARRAY);<br />
</source><br />
<br />
Über das Binden der Puffer gibt es eigentlich nicht viel zu sagen. Die OpenGL-Pufferobjekte sind alle ziemlich ähnlich.<br />
<br />
Aber bei den Zeigern kann man eine Menge falsch machen. Etliche Leute im Netz haben z.B. nachgeforscht, wie man den Parameter "Stride" zu interpretieren hat. Ich habe Stride ganz oben im Defnitionsteil als Konstante definiert: STRIDE = SizeOf(TVBOVertex); damit ist klar, dass hier die gesamte Blockgröße des Vertex gemeint ist. Die "Offset"-Parameter habe ich als Konstanten definiert weil sie von der Struktur des Vertex abhängen und daher vermutlich nicht dauernd geändert werden. "Offset" ist hier genau das richtige Wort. Zwischen dem Beginn des Vertex und der Color liegt eine Position mit dem Typ "TVector4D", daher ist der Offset der Color SizeOf(TVector4D). <br />
<br />
Ich habe hier zwar kein nächstes Vertex-Element, aber wenn ich eines hätte, dann wäre dessen Offset COL_OFFSET+SizeOf(TVector4D) oder auch in Pseudoschreibweise: Offset(Color)+Size(Color).<br />
<br />
Nach dem Binden des Indexpuffers muss man den VBO Client-seitig aktivieren, und zwar für jeden Attribut-Typ extra. Wenn Ihr also eine Texturkoordinate ergänzen wollt - dazu muss man natürlich die Vertex-Definition ändern -, dann vergeßt bloß nicht das "glEnableClientState(GL_TEXTURE_COORD_ARRAY)" nachzutragen.<br />
<br />
So, jetzt kann man endlich zeichnen. Die Typangabe im glDrawElements beschreibt den Index und der letzte Parameter muss "NIL" sein, denn in unserem Fall ist dieser Parameter überflüssig (er wird in einem anderen Zusammenhang zum Nachladen der Daten benutzt).<br />
<br />
<br />
<br />
'''4. Nacher reinen Tisch machen'''<br />
<source lang="pascal"><br />
Finalize(IndexBuffer);<br />
Finalize(VBOBuffer);<br />
glDeleteBuffers(1,@IDVbo);<br />
glDeleteBuffers(1,@IDIndex);<br />
</source><br />
<br />
<br />
Und, naja, wenn man etwas auf eine solche Art zeichnet, sollte es natürlich nicht grade ein Dreieck sein. Das wäre nämlich so, als ob man um die Ecke in den Supermarkt gehen wollte und dazu einen Jumbojet benutzt. :) Allerdings lässt uns OpenGL keine Wahl, denn ab OpenGL 3 gibt es keine anderen Möglichkeiten mehr. Also müssen wir uns mit dem Jumbojet anfreunden.<br />
<br />
Insgesamt fand ich am Ende, dass ich Euch vielleicht ein wenig Zeit und Frust ersparen kann, wenn ich das Ganze ins WIKI stelle. <br />
<br />
Ich hoffe, es hilft.<br />
Viele Grüße,<br />
Traude</div>Traudehttps://wiki.delphigl.com/index.php?title=VBO_ohne_glInterleavedArrays&diff=24793VBO ohne glInterleavedArrays2010-03-20T09:38:26Z<p>Traude: Tippfehler eliminiert</p>
<hr />
<div>(Voraussetzung: mindestens OpenGL 1.5)<br />
<br />
"VBO" ist die Abkürzung von "Vertex Buffer Object" und ist eine Möglichkeit der Darstellung von Objekten mit OpenGL. In den OpenGL-Versionen ab Nummer 3 ist es die '''einzige''' Möglichkeit.<br />
<br />
Es gibt aber mehrere Möglichkeiten, einen VBO zu verwenden. Die Variante, die ich unten erkläre, ist also nicht die einzige.<br />
<br />
<br />
VBO mit frei definierter Datenstruktur, ohne glInterleavedArrays <br />
<br />
Der untenstehende Pascal-Code zeichnet das Opengl-Dreieck mit einem VBO. Ich hatte beim Erzeugen dieses Code-Stücks eine steile Lernkurve und jede Menge Frust, denn beim Ändern einzelner Teile sind dann natürlich auch korrespondierende Teile anderswo zu ändern, aber da kann man leicht etwas übersehen, speziell wenn es gegen vier Uhr morgens geht. :)<br />
<br />
<br />
<br />
'''1. Zunächst die globalen Deklarationen'''<br />
<br />
Typen<br />
TVector4D = Packed Record X,Y,Z,W: Single; End; <br />
<br />
TVBOVertex = Packed Record <br />
Position,<br />
Color,<br />
Empty: TVector4D;<br />
End;<br />
<br />
TVBOBuffer = Array Of TVBOVertex;<br />
TIndexBuffer = Array Of Word;<br />
<br />
Konstanten<br />
POS_OFFSET = 0;<br />
COL_OFFSET = SizeOf(TVector4D);<br />
STRIDE = SizeOf(TVBOVertex);<br />
<br />
Variablen<br />
VBOBuffer: TVBOBuffer; // VBO-Daten<br />
IndexBuffer: TIndexBuffer; // VBO-Indices<br />
VertexBufSize, // VBO-Daten: Puffergröße<br />
IndexBufSize, // VBO-Indices: Puffergröße <br />
IndexCount, // Anzahl der Indices<br />
IDVbo,IDIndex: Cardinal; // Opengl-"Handles" für VBO- und Indexpuffer<br />
<br />
Bei dieser Variante des VBO kann man sein eigenes Vertex definieren und ist nicht auf vorgegebene Datenstrukturen beschränkt wie bei den glInterleavedArrays. Der "Empty"-Vektor im TVBOVertex soll darauf hinweisen, dass man vorgegebene Vertexattribute mit benutzerdefierten mischen kann. Das wird hier aber nicht behandelt. <br />
<br />
Ihr könnt die Typen definieren, wie Ihr wollt, aber es ergeben sich daraus Konsequenzen. Die Datendeklaration hat unmittelbaren Einfluss auf den untenstehenden Initialisierungs- und Rendercode. Wenn also der Datentyp geändert wird, muss man den ganzen untenstehenden Code auf notwendige Anpassungen untersuchen. Wie sich gezeigt hat, habe ich dabei immer wieder das eine oder andere vergessen. :(<br />
<br />
<br />
<br />
<br />
'''2. Dann das Hochladen der Daten aus dem Hauptspeicher in den Grafikkartenspeicher<br />
'''<br />
IndexCount:= 3;<br />
<br />
VertexBufSize:= IndexCount*SizeOf(TVBOVertex);<br />
IndexBufSize:= IndexCount*SizeOf(Word);<br />
<br />
Vertexpuffer erzeugen,initialisieren und mit Daten bestücken<br />
SetLength(VBOBuffer,IndexCount);<br />
FillChar(VBOBuffer[0],Length(VBOBuffer)*SizeOf(TVBOVertex),#0);<br />
<br />
With VBOBuffer[0] Do<br />
Begin<br />
With Position Do Begin X:=-1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+1.0; Y:=+0.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[1] Do<br />
Begin<br />
With Position Do Begin X:=+1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[2] Do<br />
Begin<br />
With Position Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+0.0; Z:=+1.0; W:=+1.0; End;<br />
End;<br />
<br />
Vertexdaten hochladen<br />
glGenBuffers(1,@IDVbo);<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
glBufferData(GL_ARRAY_BUFFER,VertexBufSize,@VBOBuffer[0],GL_STATIC_DRAW);<br />
<br />
Dasselbe mit dem Indexpuffer<br />
SetLength(IndexBuffer,IndexCount);<br />
<br />
IndexBuffer[0]:= 0;<br />
IndexBuffer[1]:= 1;<br />
IndexBuffer[2]:= 2;<br />
<br />
Indexdaten hochladen<br />
glGenBuffers(1,@IDIndex);<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
glBufferData(GL_ELEMENT_ARRAY_BUFFER,IndexBufSize,@IndexBuffer[0],GL_STATIC_DRAW);<br />
<br />
Ich habe hier für den VBO einen Record genommen, weil bei den Demos im Netz normalerweise immer Arrays benutzt werden. Der Recordtyp ist zusätzlich viel selbsterklärender als ein Array und man kann ihn auch noch durch treffende Namensgebung verbessern. <br />
<br />
Abgesehen von der Entscheidung, welchen Datentyp man nehmen soll, ist das der einfachere Teil des Ganzen. Und damit es nicht ganz trivial wird, habe ich noch einen winzigen Indexbuffer definiert, damit ich zum Zeichnen glDrawElements verwenden kann. <br />
<br />
In den Beispielen, die man im Web finden kann, gibt es außerdem noch die Variante, wo glBufferdata nur zur Definition der Puffer-Parameter benutzt wird, aber für das Hochladen der Daten auf die Grafikkarte wird glBufferSubdata verwendet. Damit kann man entweder den ganzen Puffer oder auch nur Teile davon neu beschicken. <br />
<br />
<br />
<br />
'''3. Der Rendercode'''<br />
<br />
Vertexpuffer binden<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
<br />
Nötige Zeiger setzen<br />
glVertexPointer(4, GL_FLOAT, STRIDE, POS_OFFSET);<br />
glColorPointer(4, GL_FLOAT, STRIDE, COL_OFFSET);<br />
<br />
Indexpuffer binden<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
<br />
Zeichnen<br />
glEnableClientState(GL_VERTEX_ARRAY);<br />
glEnableClientState(GL_COLOR_ARRAY);<br />
<br />
glDrawElements(GL_TRIANGLES,IndexCount,GL_UNSIGNED_SHORT,NIL);<br />
<br />
glDisableClientState(GL_COLOR_ARRAY);<br />
glDisableClientState(GL_VERTEX_ARRAY);<br />
<br />
Über das Binden der Puffer gibt es eigentlich nicht viel zu sagen. Die OpenGL-Pufferobjekte sind alle ziemlich ähnlich.<br />
<br />
Aber bei den Zeigern kann man eine Menge falsch machen. Etliche Leute im Netz haben z.B. nachgeforscht, wie man den Parameter "Stride" zu interpretieren hat. Ich habe Stride ganz oben im Defnitionsteil als Konstante definiert: STRIDE = SizeOf(TVBOVertex); damit ist klar, dass hier die gesamte Blockgröße des Vertex gemeint ist. Die "Offset"-Parameter habe ich als Konstanten definiert weil sie von der Struktur des Vertex abhängen und daher vermutlich nicht dauernd geändert werden. "Offset" ist hier genau das richtige Wort. Zwischen dem Beginn des Vertex und der Color liegt eine Position mit dem Typ "TVector4D", daher ist der Offset der Color SizeOf(TVector4D). <br />
<br />
Ich habe hier zwar kein nächstes Vertex-Element, aber wenn ich eines hätte, dann wäre dessen Offset COL_OFFSET+SizeOf(TVector4D) oder auch in Pseudoschreibweise: Offset(Color)+Size(Color).<br />
<br />
Nach dem Binden des Indexpuffers muss man den VBO Client-seitig aktivieren, und zwar für jeden Attribut-Typ extra. Wenn Ihr also eine Texturkoordinate ergänzen wollt - dazu muss man natürlich die Vertex-Definition ändern -, dann vergeßt bloß nicht das "glEnableClientState(GL_TEXTURE_COORD_ARRAY)" nachzutragen.<br />
<br />
So, jetzt kann man endlich zeichnen. Die Typangabe im glDrawElements beschreibt den Index und der letzte Parameter muss "NIL" sein, denn in unserem Fall ist dieser Parameter überflüssig (er wird in einem anderen Zusammenhang zum Nachladen der Daten benutzt).<br />
<br />
<br />
<br />
'''4. Nacher reinen Tisch machen'''<br />
Finalize(IndexBuffer);<br />
Finalize(VBOBuffer);<br />
glDeleteBuffers(1,@IDVbo);<br />
glDeleteBuffers(1,@IDIndex);<br />
<br />
<br />
Und, naja, wenn man etwas auf eine solche Art zeichnet, sollte es natürlich nicht grade ein Dreieck sein. Das wäre nämlich so, als ob man um die Ecke in den Supermarkt gehen wollte und dazu einen Jumbojet benutzt. :) Allerdings lässt uns OpenGL keine Wahl, denn ab OpenGL 3 gibt es keine anderen Möglichkeiten mehr. Also müssen wir uns mit dem Jumbojet anfreunden.<br />
<br />
Insgesamt fand ich am Ende, dass ich Euch vielleicht ein wenig Zeit und Frust ersparen kann, wenn ich das Ganze ins WIKI stelle. <br />
<br />
Ich hoffe, es hilft.<br />
Viele Grüße,<br />
Traude</div>Traudehttps://wiki.delphigl.com/index.php?title=VBO_ohne_glInterleavedArrays&diff=24792VBO ohne glInterleavedArrays2010-03-20T09:24:21Z<p>Traude: Doppelte Überschift eliminiert</p>
<hr />
<div>(Voraussetzung: mindestens OpenGL 1.5)<br />
<br />
"VBO" ist die Abkürzung von "Vertex Buffer Object" und ist eine Möglichkeit der Darstellung von Objekten mit OpenGL. In den OpenGL-Versionen ab Nummer 3 ist es die '''einzige''' Möglichkeit.<br />
<br />
Es gibt aber mehrere Möglichkeiten, einen VBO zu verwenden. Die Variante, die ich unten erkläre, ist also nicht die einzige.<br />
<br />
<br />
VBO mit frei definierter Datenstruktur, ohne glInterleavedArrays <br />
<br />
Der untenstehende Pascal-Code zeichnet das Opengl-Dreieck mit einem VBO. Ich hatte beim Erzeugen dieses Code-Stücks eine steile Lernkurve und jede Menge Frust, denn beim Ändern einzelner Teile sind dann natürlich auch korrespondierende Teile anderswo zu ändern, aber da kann man leicht etwas übersehen, speziell wenn es gegen vier Uhr morgens geht. :)<br />
<br />
<br />
<br />
'''1. Zunächst die globalen Deklarationen'''<br />
<br />
Typen<br />
TVector4D = Packed Record X,Y,Z,W: Single; End; <br />
<br />
TVBOVertex = Packed Record <br />
Position,<br />
Color,<br />
Empty: TVector4D;<br />
End;<br />
<br />
TVBOBuffer = Array Of TVBOVertex;<br />
TIndexBuffer = Array Of Word;<br />
<br />
Konstanten<br />
POS_OFFSET = 0;<br />
COL_OFFSET = SizeOf(TVector4D);<br />
STRIDE = SizeOf(TVBOVertex);<br />
<br />
Variablen<br />
VBOBuffer: TVBOBuffer; // VBO-Daten<br />
IndexBuffer: TIndexBuffer; // VBO-Indices<br />
VertexBufSize, // VBO-Daten: Puffergröße<br />
IndexBufSize, // VBO-Indices: Puffergröße <br />
IndexCount, // Anzahl der Indices<br />
IDVbo,IDIndex: Cardinal; // Opengl-"Handles" für VBO- und Indexpuffer<br />
<br />
Bei dieser Variante des VBO kann man sein eigenes Vertex definieren und ist nicht auf vorgegebene Datenstrukturen beschränkt wie bei den glInterleavedArrays. Der "Empty"-Vektor im TVBOVertex soll darauf hinweisen, dass man vorgegebene Vertexattribute mit benutzerdefierten mischen kann. Das wird hier aber nicht behandelt. <br />
<br />
Ihr könnt die Typen definieren, wie Ihr wollt, aber es ergeben sich daraus Konsequenzen. Die Datendeklaration hat unmittelbaren Einfluss auf den untenstehenden Initialisierungs- und Rendercode. Wenn also der Datentyp geändert wird, muss man den ganzen untenstehenden Code auf notwendige Anpassungen untersuchen. Wie sich gezeigt hat, habe ich dabei immer wieder das eine oder andere vergessen. :(<br />
<br />
<br />
<br />
<br />
'''2. Dann das Hochladen der Daten aus dem Hauptspeicher in den Grafikkartenspeicher<br />
'''<br />
IndexCount:= 3;<br />
<br />
VertexBufSize:= IndexCount*SizeOf(TVBOVertex);<br />
IndexBufSize:= IndexCount*SizeOf(Word);<br />
<br />
Vertexpuffer erzeugen,initialisieren und mit Daten bestücken<br />
SetLength(VBOBuffer,IndexCount);<br />
FillChar(VBOBuffer[0],Length(VBOBuffer)*SizeOf(TVBOVertex),#0);<br />
<br />
With VBOBuffer[0] Do<br />
Begin<br />
With Position Do Begin X:=-1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+1.0; Y:=+0.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[1] Do<br />
Begin<br />
With Position Do Begin X:=+1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[2] Do<br />
Begin<br />
With Position Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+0.0; Z:=+1.0; W:=+1.0; End;<br />
End;<br />
<br />
Vertexdaten hochladen<br />
glGenBuffers(1,@IDVbo);<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
glBufferData(GL_ARRAY_BUFFER,VertexBufSize,@VBOBuffer[0],GL_STATIC_DRAW);<br />
<br />
Dasselbe mit dem Indexpuffer<br />
SetLength(IndexBuffer,IndexCount);<br />
<br />
IndexBuffer[0]:= 0;<br />
IndexBuffer[1]:= 1;<br />
IndexBuffer[2]:= 2;<br />
<br />
Indexdaten hochladen<br />
glGenBuffers(1,@IDIndex);<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
glBufferData(GL_ELEMENT_ARRAY_BUFFER,IndexBufSize,@IndexBuffer[0],GL_STATIC_DRAW);<br />
<br />
Ich habe hier für den VBO einen Record genommen, weil bei den Demos im Netz normalerweise immer Arrays benutzt werden. Der Recordtyp ist zusätzlich viel selbsterklärender als ein Array und man kann ihn auch noch noch durch treffende Namensgebung verbessern. <br />
<br />
Abgesehen von der Entscheidung, welchen Datentyp man nehmen soll, ist das der einfachere Teil des Ganzen. Und damit es nicht ganz trivial wird, habe ich noch einen winzigen Indexbuffer definiert, damit ich zum Zeichnen glDrawElements verwenden kann. <br />
<br />
In den Beispielen, die man im Web finden kann, gibt es außerdem noch die Variante, wo glBufferdata nur zur Definition der Puffer-Parameter benutzt wird, aber für das Hochladen der Daten auf die Grafikkarte wird glBufferSubdata verwendet. Damit kann man entweder den ganzen Puffer oder auch nur Teile davon neu beschicken. <br />
<br />
<br />
<br />
'''3. Der Rendercode'''<br />
<br />
Vertexpuffer binden<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
<br />
Nötige Zeiger setzen<br />
glVertexPointer(4, GL_FLOAT, STRIDE, POS_OFFSET);<br />
glColorPointer(4, GL_FLOAT, STRIDE, COL_OFFSET);<br />
<br />
Indexpuffer binden<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
<br />
Zeichnen<br />
glEnableClientState(GL_VERTEX_ARRAY);<br />
glEnableClientState(GL_COLOR_ARRAY);<br />
<br />
glDrawElements(GL_TRIANGLES,IndexCount,GL_UNSIGNED_SHORT,NIL);<br />
<br />
glDisableClientState(GL_COLOR_ARRAY);<br />
glDisableClientState(GL_VERTEX_ARRAY);<br />
<br />
Über das Binden der Puffer gibt es eigentlich nicht viel zu sagen. Die OpenGL-Pufferobjekte sind alle ziemlich ähnlich.<br />
<br />
Aber bei den Zeigern kann man eine Menge falsch machen. Etliche Leute im Netz haben z.B. nachgeforscht, wie man den Parameter "Stride" zu interpretieren hat. Ich habe Stride ganz oben im Defnitionsteil als Konstante definiert: STRIDE = SizeOf(TVBOVertex); damit ist klar, dass hier die gesamte Blockgröße des Vertex gemeint ist. Die "Offset"-Parameter habe ich als Konstanten definiert weil sie von der Struktur des Vertex abhängen und daher vermutlich nicht dauernd geändert werden. "Offset" ist hier genau das richtige Wort. Zwischen dem Beginn des Vertex und der Color liegt eine Position mit dem Typ "TVector4D", daher ist der Offset der Color SizeOf(TVector4D). <br />
<br />
Ich habe hier zwar kein nächstes Vertex-Element, aber wenn ich eines hätte, dann wäre dessen Offset COL_OFFSET+SizeOf(TVector4D) oder auch in Pseudoschreibweise: Offset(Color)+Size(Color).<br />
<br />
Nach dem Binden des Indexpuffers muss man den VBO Client-seitig aktivieren, und zwar für jeden Attribut-Typ extra. Wenn Ihr also eine Texturkoordinate ergänzen wollt - dazu muss man natürlich die Vertex-Definition ändern -, dann vergeßt bloß nicht das "glEnableClientState(GL_TEXTURE_COORD_ARRAY)" nachzutragen.<br />
<br />
So, jetzt kann man endlich zeichnen. Die Typangabe im glDrawElements beschreibt den Index und der letzte Parameter muss "NIL" sein, denn in unserem Fall ist dieser Parameter überflüssig (er wird in einem anderen Zusammenhang zum Nachladen der Daten benutzt).<br />
<br />
<br />
<br />
'''4. Nacher reinen Tisch machen'''<br />
Finalize(IndexBuffer);<br />
Finalize(VBOBuffer);<br />
glDeleteBuffers(1,@IDVbo);<br />
glDeleteBuffers(1,@IDIndex);<br />
<br />
<br />
Und, naja, wenn man etwas auf eine solche Art zeichnet, sollte es natürlich nicht grade ein Dreieck sein. Das wäre nämlich so, als ob man um die Ecke in den Supermarkt gehen wollte und dazu einen Jumbojet benutzt. :) Allerdings lässt uns OpenGL keine Wahl, denn ab OpenGL 3 gibt es keine anderen Möglichkeiten mehr. Also müssen wir uns mit dem Jumbojet anfreunden.<br />
<br />
Insgesamt fand ich am Ende, dass ich Euch vielleicht ein wenig Zeit und Frust ersparen kann, wenn ich das Ganze ins WIKI stelle. <br />
<br />
Ich hoffe, es hilft.<br />
Viele Grüße,<br />
Traude</div>Traudehttps://wiki.delphigl.com/index.php?title=VBO_ohne_glInterleavedArrays&diff=24791VBO ohne glInterleavedArrays2010-03-20T09:18:17Z<p>Traude: Text geladen und ein wenig formatiert</p>
<hr />
<div>= VBO ohne glInterleavedArrays =<br />
(Voraussetzung: mindestens OpenGL 1.5)<br />
<br />
"VBO" ist die Abkürzung von "Vertex Buffer Object" und ist eine Möglichkeit der Darstellung von Objekten mit OpenGL. In den OpenGL-Versionen ab Nummer 3 ist es die '''einzige''' Möglichkeit.<br />
<br />
Es gibt aber mehrere Möglichkeiten, einen VBO zu verwenden. Die Variante, die ich unten erkläre, ist also nicht die einzige.<br />
<br />
<br />
VBO mit frei definierter Datenstruktur, ohne glInterleavedArrays <br />
<br />
Der untenstehende Pascal-Code zeichnet das Opengl-Dreieck mit einem VBO. Ich hatte beim Erzeugen dieses Code-Stücks eine steile Lernkurve und jede Menge Frust, denn beim Ändern einzelner Teile sind dann natürlich auch korrespondierende Teile anderswo zu ändern, aber da kann man leicht etwas übersehen, speziell wenn es gegen vier Uhr morgens geht. :)<br />
<br />
<br />
<br />
'''1. Zunächst die globalen Deklarationen'''<br />
<br />
Typen<br />
TVector4D = Packed Record X,Y,Z,W: Single; End; <br />
<br />
TVBOVertex = Packed Record <br />
Position,<br />
Color,<br />
Empty: TVector4D;<br />
End;<br />
<br />
TVBOBuffer = Array Of TVBOVertex;<br />
TIndexBuffer = Array Of Word;<br />
<br />
Konstanten<br />
POS_OFFSET = 0;<br />
COL_OFFSET = SizeOf(TVector4D);<br />
STRIDE = SizeOf(TVBOVertex);<br />
<br />
Variablen<br />
VBOBuffer: TVBOBuffer; // VBO-Daten<br />
IndexBuffer: TIndexBuffer; // VBO-Indices<br />
VertexBufSize, // VBO-Daten: Puffergröße<br />
IndexBufSize, // VBO-Indices: Puffergröße <br />
IndexCount, // Anzahl der Indices<br />
IDVbo,IDIndex: Cardinal; // Opengl-"Handles" für VBO- und Indexpuffer<br />
<br />
Bei dieser Variante des VBO kann man sein eigenes Vertex definieren und ist nicht auf vorgegebene Datenstrukturen beschränkt wie bei den glInterleavedArrays. Der "Empty"-Vektor im TVBOVertex soll darauf hinweisen, dass man vorgegebene Vertexattribute mit benutzerdefierten mischen kann. Das wird hier aber nicht behandelt. <br />
<br />
Ihr könnt die Typen definieren, wie Ihr wollt, aber es ergeben sich daraus Konsequenzen. Die Datendeklaration hat unmittelbaren Einfluss auf den untenstehenden Initialisierungs- und Rendercode. Wenn also der Datentyp geändert wird, muss man den ganzen untenstehenden Code auf notwendige Anpassungen untersuchen. Wie sich gezeigt hat, habe ich dabei immer wieder das eine oder andere vergessen. :(<br />
<br />
<br />
<br />
<br />
'''2. Dann das Hochladen der Daten aus dem Hauptspeicher in den Grafikkartenspeicher<br />
'''<br />
IndexCount:= 3;<br />
<br />
VertexBufSize:= IndexCount*SizeOf(TVBOVertex);<br />
IndexBufSize:= IndexCount*SizeOf(Word);<br />
<br />
Vertexpuffer erzeugen,initialisieren und mit Daten bestücken<br />
SetLength(VBOBuffer,IndexCount);<br />
FillChar(VBOBuffer[0],Length(VBOBuffer)*SizeOf(TVBOVertex),#0);<br />
<br />
With VBOBuffer[0] Do<br />
Begin<br />
With Position Do Begin X:=-1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+1.0; Y:=+0.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[1] Do<br />
Begin<br />
With Position Do Begin X:=+1.0; Y:=-1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
End;<br />
With VBOBuffer[2] Do<br />
Begin<br />
With Position Do Begin X:=+0.0; Y:=+1.0; Z:=+0.0; W:=+1.0; End;<br />
With Color Do Begin X:=+0.0; Y:=+0.0; Z:=+1.0; W:=+1.0; End;<br />
End;<br />
<br />
Vertexdaten hochladen<br />
glGenBuffers(1,@IDVbo);<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
glBufferData(GL_ARRAY_BUFFER,VertexBufSize,@VBOBuffer[0],GL_STATIC_DRAW);<br />
<br />
Dasselbe mit dem Indexpuffer<br />
SetLength(IndexBuffer,IndexCount);<br />
<br />
IndexBuffer[0]:= 0;<br />
IndexBuffer[1]:= 1;<br />
IndexBuffer[2]:= 2;<br />
<br />
Indexdaten hochladen<br />
glGenBuffers(1,@IDIndex);<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
glBufferData(GL_ELEMENT_ARRAY_BUFFER,IndexBufSize,@IndexBuffer[0],GL_STATIC_DRAW);<br />
<br />
Ich habe hier für den VBO einen Record genommen, weil bei den Demos im Netz normalerweise immer Arrays benutzt werden. Der Recordtyp ist zusätzlich viel selbsterklärender als ein Array und man kann ihn auch noch noch durch treffende Namensgebung verbessern. <br />
<br />
Abgesehen von der Entscheidung, welchen Datentyp man nehmen soll, ist das der einfachere Teil des Ganzen. Und damit es nicht ganz trivial wird, habe ich noch einen winzigen Indexbuffer definiert, damit ich zum Zeichnen glDrawElements verwenden kann. <br />
<br />
In den Beispielen, die man im Web finden kann, gibt es außerdem noch die Variante, wo glBufferdata nur zur Definition der Puffer-Parameter benutzt wird, aber für das Hochladen der Daten auf die Grafikkarte wird glBufferSubdata verwendet. Damit kann man entweder den ganzen Puffer oder auch nur Teile davon neu beschicken. <br />
<br />
<br />
<br />
'''3. Der Rendercode'''<br />
<br />
Vertexpuffer binden<br />
glBindBuffer(GL_ARRAY_BUFFER, IDVbo);<br />
<br />
Nötige Zeiger setzen<br />
glVertexPointer(4, GL_FLOAT, STRIDE, POS_OFFSET);<br />
glColorPointer(4, GL_FLOAT, STRIDE, COL_OFFSET);<br />
<br />
Indexpuffer binden<br />
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IDIndex);<br />
<br />
Zeichnen<br />
glEnableClientState(GL_VERTEX_ARRAY);<br />
glEnableClientState(GL_COLOR_ARRAY);<br />
<br />
glDrawElements(GL_TRIANGLES,IndexCount,GL_UNSIGNED_SHORT,NIL);<br />
<br />
glDisableClientState(GL_COLOR_ARRAY);<br />
glDisableClientState(GL_VERTEX_ARRAY);<br />
<br />
Über das Binden der Puffer gibt es eigentlich nicht viel zu sagen. Die OpenGL-Pufferobjekte sind alle ziemlich ähnlich.<br />
<br />
Aber bei den Zeigern kann man eine Menge falsch machen. Etliche Leute im Netz haben z.B. nachgeforscht, wie man den Parameter "Stride" zu interpretieren hat. Ich habe Stride ganz oben im Defnitionsteil als Konstante definiert: STRIDE = SizeOf(TVBOVertex); damit ist klar, dass hier die gesamte Blockgröße des Vertex gemeint ist. Die "Offset"-Parameter habe ich als Konstanten definiert weil sie von der Struktur des Vertex abhängen und daher vermutlich nicht dauernd geändert werden. "Offset" ist hier genau das richtige Wort. Zwischen dem Beginn des Vertex und der Color liegt eine Position mit dem Typ "TVector4D", daher ist der Offset der Color SizeOf(TVector4D). <br />
<br />
Ich habe hier zwar kein nächstes Vertex-Element, aber wenn ich eines hätte, dann wäre dessen Offset COL_OFFSET+SizeOf(TVector4D) oder auch in Pseudoschreibweise: Offset(Color)+Size(Color).<br />
<br />
Nach dem Binden des Indexpuffers muss man den VBO Client-seitig aktivieren, und zwar für jeden Attribut-Typ extra. Wenn Ihr also eine Texturkoordinate ergänzen wollt - dazu muss man natürlich die Vertex-Definition ändern -, dann vergeßt bloß nicht das "glEnableClientState(GL_TEXTURE_COORD_ARRAY)" nachzutragen.<br />
<br />
So, jetzt kann man endlich zeichnen. Die Typangabe im glDrawElements beschreibt den Index und der letzte Parameter muss "NIL" sein, denn in unserem Fall ist dieser Parameter überflüssig (er wird in einem anderen Zusammenhang zum Nachladen der Daten benutzt).<br />
<br />
<br />
<br />
'''4. Nacher reinen Tisch machen'''<br />
Finalize(IndexBuffer);<br />
Finalize(VBOBuffer);<br />
glDeleteBuffers(1,@IDVbo);<br />
glDeleteBuffers(1,@IDIndex);<br />
<br />
<br />
Und, naja, wenn man etwas auf eine solche Art zeichnet, sollte es natürlich nicht grade ein Dreieck sein. Das wäre nämlich so, als ob man um die Ecke in den Supermarkt gehen wollte und dazu einen Jumbojet benutzt. :) Allerdings lässt uns OpenGL keine Wahl, denn ab OpenGL 3 gibt es keine anderen Möglichkeiten mehr. Also müssen wir uns mit dem Jumbojet anfreunden.<br />
<br />
Insgesamt fand ich am Ende, dass ich Euch vielleicht ein wenig Zeit und Frust ersparen kann, wenn ich das Ganze ins WIKI stelle. <br />
<br />
Ich hoffe, es hilft.<br />
Viele Grüße,<br />
Traude</div>Traudehttps://wiki.delphigl.com/index.php?title=Hintergrundwissen&diff=24790Hintergrundwissen2010-03-20T08:34:02Z<p>Traude: Eintrag "VBO ohne glInterleavedArrays" hinzugefügt</p>
<hr />
<div>== Was hier hinein gehört ==<br />
<br />
In diese Kategorie kommt alles rein was zum Verständnis im Bereich OpenGL/3D-Programmierung nützlich sein könnte. Also u.a. welche Puffer es unter OpenGL gibt, und für was die gut sind.<br />
<br />
Auch hier sollte man möglichst aufspalten und dann eine Überschrift setzen. So macht man das Auffinden bestimmter Dinge leichter und auch die Verlinkung darauf ist oft etwas das man in anderen Dokumenten benötigt.<br />
<br />
P.S. : Ob hier Deutsche Begriffe oder Anglizismen genutzt werden ist jedem selbst überlassen. Ich persönlich bevorzuge ersteres.<br />
<br />
<br />
== Begriffserklärungen ==<br />
In diesem Teil findet ihr Erklärungen zu begriffen, die ihr ständig im Zusammenhang mit OpenGL höhrt. Wenn ihr etwas nicht kennt, könnt ihr hier nachsehen, ob der Begriff bereits erklärt wurde.<br />
<br />
=== Grundlagen ===<br />
: [[Alpha-Clipping|&alpha;-Clipping]] <br />
: [[Funktions Anhang|Aufbau von OpenGL Funktionen]] <br />
: [[Bounding Volume]] ([[Bounding Box]])<br />
: [[Bresenham-Algorithmus|Bresenham Algorithmus (Linien / Kurven zeichnen)]]<br />
: [[Clipping Plane]] {{excIcon}} (Schnittebenen)<br />
: [[Frustum]]<br />
: [[OpenGL Name|Namen in OpenGL]]<br />
: [[Projektions-Transformationen]]<br />
: [[Scanline-Rasterization|Scanline Algorithmus (Polygone zeichen)]]<br />
: [[Normalen]]<br />
: [[Primitive]]<br />
: [[Texel]] {{icpIcon}}<br />
<br />
=== Mathematische Grundlagen ===<br />
: [[Matrix|Matrix / Matrizen]]<br />
: [[Quaternion|Quaternion / Hamiltonsche Quaternionen]]<br />
: [[Standard Skalarprodukt|Skalarprodukt / Punktprodukt / Dotproduct / Dot]]<br />
: [[Vektorprodukt|Vektorprodukt / Vektorkreuzprodukt / Kreuzprodukt]]<br />
<br />
=== Bildentstehung ===<br />
: [[Dithering]] {{icpIcon}}<br />
: [[Fragment| Fragmente]]<br />
: [[Pixel]]<br />
: [[Rasterisierung]]<br />
: [[Tiefentest]]<br />
<br />
=== Puffer ===<br />
: [[Akkumulationspuffer]] (Accumulationbuffer)<br />
: [[Doppelpufferung]] (Doublebuffering)<br />
: [[Farbpuffer]] (Colorbuffer)<br />
: [[Feedbackpuffer]]<br />
: [[Framebuffer]]<br />
: [[Logischer Puffer]]<br />
: [[Schablonenpuffer]] (Stencilbuffer)<br />
: [[Selektionspuffer]]<br />
: [[Tiefenpuffer]] (Depthbuffer)<br />
<br />
=== Texturen ===<br />
''Wer Informationen zum Erstellen von Texturen benötigt, sollte sich die [[Link]]-Sektion und den Artikel zum Thema [[Farbraum|Farbräume]]{{excIcon}} ansehen.''<br />
: [[Anisotropes Filtern]]<br />
: [[Decals]]<br />
: [[MipMaps]]<br />
: [[Register Combiner]]<br />
: [[Texel Berechnung]]<br />
: [[Texturen]]<br />
: [[Texturesynthesis]] ''automatisiertes Erzeugen von (u.A. kachelbaren) Texturen ohne Wiederholung''<br />
<br />
=== Textureneffekte ===<br />
: [[Animierte Textur]]en<br />
: [[Bumpmapping]] (Simulation rauher Oberflächen)<br />
: [[Displacementmapping]] (Änderung der Oberflächengeometrie)<br />
: [[Detailmapping]] (Erhöhung des Texturdetailgrades)<br />
: [[Environment Mapping]] (Umgebungsspiegelung)<br />
:: [[Cubemap]]ping {{icpIcon}}<br />
:: [[Spheremap]]ping {{icpIcon}}<br />
: [[Multitexturing]]<br />
: [[Texture Stage]]<br />
<br />
=== Effekte ===<br />
: [[Antialiasing]] (Kantenglättung)<br />
: [[Blenden]] (Blending)<br />
: [[Jittering]] (Verwischen)<br />
: [[Nebel]] (Fogging)<br />
: [[Reflexion]] (Spiegelungen)<br />
: [[Transparenz]] (durchsichtige Objekte)<br />
<br />
=== Optimierungen ===<br />
: [[Backfaceculling]]<br />
: [[Displaylisten]]<br />
: [[Frustum Culling]] <br />
: [[Triangulation]]<br />
: [[VBO]] (Vertex Buffer Objects)<br />
: [[VBO ohne glInterleavedArrays]]<br />
: [[Occlusion Query|Occlusion Queries]]<br />
: [[Performance]] (Allgemeine Performance-Tipps)<br />
: [[Instancing]]<br />
: [[Deferred Shading]]<br />
: [[Inferred Lighting]]<br />
<br />
=== Weiterführendes ===<br />
: [[Beleuchtung]]<br />
: [[Billboard]]s <br />
:: [[sphärisches Billboard]] {{icpIcon}}<br />
:: [[zylindrisches Billboard]] {{icpIcon}}<br />
: [[Convolution]]<br />
: [[NURBS]]<br />
: [[Picking]]<br />
: [[Point Sprite]]<br />
: [[Quadrik]]en<br />
: [[Selektion]]<br />
: [[Sprite]]s<br />
: [[Tesselierung]]<br />
<br />
=== Fehler/ Nebeneffekte ===<br />
: [[Aliasing]] (Treppenbildung und Ähnliches)<br />
: [[Popping]] (Plötzliches Auftauchen von Elementen. Z.B. bekannt bei [[LOD]])<br />
: [[ZFighting]] (Flimmernde Polygone und Kanten)<br />
<br />
=== Render-Pipeline ===<br />
: [[Feste Funktionspipeline]] {{icpIcon}}<br />
: [[GLSlang]] <br />
: [[GLSL]]<br />
: [[Cg]]<br />
: [[Shader]] (allgemein)<br />
:: [[Vertexshader]]<br />
:: [[Geometryshader]]<br />
:: [[Fragmentshader]] (auch ''Pixelshader'')<br />
: [[Transform-Feedback]] (auch ''Stream-Out'')<br />
<br />
=== Bibliotheken ===<br />
: [[DGLSDK]]<br />
: [[OpenAL]]<br />
: [[SDL]]<br />
<br />
=== Grafikkarten ===<br />
: [[Bandbreitenlimitiert]]<br />
: [[Shaderlimitiert]]<br />
: [[Vertex Cache]]<br />
: [[Vertexlimitiert]]<br />
<br />
<br />
<br />
=== Sonstiges ===<br />
: [[Benchmark]]<br />
: [[Callback]]<br />
: [[Farbraum]]<br />
: [[Füllrate]]<br />
: [[hexfeld | Hexfeld rendern]]<br />
: [[Raytracing]]<br />
: [[Renderkontext]]<br />
: [[Scanlinerenderer]]<br />
: [[Timebased Movement]]<br />
<br />
=== Bücher zum Thema ... ===<br />
: ... OpenGL: [[RedBook]]<br />
: ... OpenGL: [[BlueBook]]<br />
: ... OpenGL: [[PurpleBook]]<br />
: ... OpenGL: [[OrangeBook]]<br />
: ... OpenGL: [http://www.starstonesoftware.com/OpenGL/ OpenGL Superbible]<br />
<br />
== Checklisten ==<br />
In diesem Teil findet ihr Checklisten die ihr durcharbeiten solltet, wenn ihr Fehler im Code habt, bzw. wenn eure Ausgabe nicht so aussieht wie sie es söllte.<br />
<br />
:[[Checkliste Blending]]<br />
:[[Checkliste Positionierung]]<br />
:[[Checkliste Selektion]]<br />
:[[Checkliste Shader]]<br />
:[[Checkliste Texturierung]]</div>Traudehttps://wiki.delphigl.com/index.php?title=Techniken_zur_Matrixinversion&diff=23840Techniken zur Matrixinversion2009-07-08T08:25:56Z<p>Traude: Artikel Offline gesetzt, denn der Artikel bedarf einer Überarbeitung</p>
<hr />
<div>{{Offline}}<br />
== Techniken zur Matrixinversion ==<br />
=== Übersicht ===<br />
Das Invertieren von [[Matrix|Matrizen]] kommt bei der [[OpenGL]]-Programmierung gelegentlich vor. Speichert man z.B. seine Kamera in Matrixform ab, weil die Rotation und Translation der Objekte generell in Matrixform gespeichert wird, so muss man, um die [[Tutorial_Kamera1|Kameraanalogie]] zu wahren, die Matrix invertieren. Da man dabei jedoch sehr häufig sehr spezielle Matrizen im Einsatz hat, gibt es hier verschiedene Techniken, um diese Matrizen zu invertieren. <br />
<br />
=== Reine Rotationsmatrizen ===<br />
Am einfachsten sind reine Rotationsmatrizen zu invertieren. Diese dürfen aus beliebigen Rotationen für den 3-Dimensionalen Raum bestehen. Dann ist eine Inversion unproblematisch, denn es genügt, die [[Matrix Transposition|Matrix M zu transponieren]], d.h. die Zeilen der Matrix als Spalten in die Invertierte Matrix M<sup>-1</sup> zu schreiben. Diese Translationsoperation wird häufig auch durch M<sup>T</sup> bezeichnet.<br />
<br />
=== Translations- und Rotationsmatrizen ===<br />
Hat man eine OpenGL-Matrix, die aus Rotationen und Translationen besteht, so zerfällt diese in einen seperaten Rotations- und Translationsanteil. Eine Translation um einen Vektor b können wir leicht invertieren, indem wir um -b translieren. Reine Rotationsmatrizen können wir wie bekannt durch Translation invertieren. Betrachtet man OpenGL-Matrizen, so zerfallen sie wie folgt:<br />
{|<br />
|- align="center"<br />
| r || r || r || b<sub>1</sub> || |<br />
|- align="center"<br />
| r || r || r || b<sub>2</sub> || |<br />
|- align="center"<br />
| r || r || r || b<sub>3</sub> || |<br />
|- align="center"<br />
| 0 || 0 || 0 || 1 || |<br />
|}<br />
Die Felder mit r wollen bilden den Rotationsteil und wollen wir als eine 3x3 Matrix R zusammenfassen. Zusätzlich definieren wir den Verschiebungsvektor b := (b<sub>1</sub>;b<sub>2</sub>b<sub>3</sub>).<br />
<br />
Statt einer Multiplikation mit unserer Ausgangsmatrix M mit einem Vektor x könnten wir also auch rechnen:<br />
y = Mx = Rx + b ( Achtung: Mathematisch geht das eigentlich nicht, <br />
aber x ist ja 3-Dimensional und nicht 4-D . Damit<br />
hier niemand schreit, daß das alles nur Mist ist )<br />
R und b können wir leicht invertieren, also versuchen wir unser Glück und Rechnen auf y mit R<sup>T</sup> und -b:<br />
R<sup>T</sup>y - b = R<sup>T</sup>(Rx + b) - b = R<sup>T</sup>Rx + R<sup>T</sup>b - b = x + R<sup>T</sup>b -b<br />
Wir stellen fest: Die Inversion der Rotation hat wunderbar geklappt, aber die Translation ist schiefgegangen. Rechnen wir aber statt -b mit -R<sup>T</sup>b, so fällt auch der hintere Teil weg:<br />
R<sup>T</sup>y - R<sup>T</sup>b = R<sup>T</sup>(Rx + b) - R<sup>T</sup>b = x + R<sup>T</sup>b -R<sup>T</sup>b = x<br />
Wir kennen jetzt also die Abbildung, die unsere Matrix invertiert. Es handelt sich wieder um eine Rotations + Translation (Wer hätte das gedacht? Verschieben und Rotieren kann man tatsächlich mit Verschieben und Rotieren rückgängig machen ;-) ). Definieren wir noch schnell v := -R<sup>T</sup>b. Dann stellen wir unsere Inversionsmatrix auf:<br />
{|<br />
|- align="center"<br />
| r<sup>T</sup> || r<sup>T</sup> || r<sup>T</sup> || v<sub>1</sub> || |<br />
|- align="center"<br />
| r<sup>T</sup> || r<sup>T</sup> || r<sup>T</sup> || v<sub>2</sub> || |<br />
|- align="center"<br />
| r<sup>T</sup> || r<sup>T</sup> || r<sup>T</sup> || v<sub>3</sub> || |<br />
|- align="center"<br />
| 0 || 0 || 0 || 1 || |<br />
|}<br />
Wobei nun r<sup>T</sup> die Komponenten von R<sup>T</sup> darstellen soll. Diese Matrix invertiert unsere Ausgangsmatrix ohne übderdimensionierte Rechnung, denn wir brauchen ja nur eine Teilmatrix zu transponieren (also eine Vertauschoperation), diese Matrix auf ein Vertex anwenden und in dessen Komponenten die Vorzeichen zu ändern. <br />
<br />
=== Beliebige Matrizen ===<br />
Beliebige nxn-Matrizen, deren Determinante ungleich 0 ist, lassen sich auch invertieren. Weis man gar nichts über diese Matrix, so empfiehlt es sich mithilfe von [http://de.wikipedia.org/wiki/LR-Zerlegung LR-Zerlegung] und anschließender Vorwärts- und Rückwärtssubstitution die inverse Matrix zu berechnen. <br />
<br />
=== Siehe Auch ===<br />
[[Matrix|Matrizen]], [[glLoadMatrix]], [[glMultMatrix]], [[Quaternion|Quaternionen]], [[Tutorial_Nachsitzen|Tutorial: Nachsitzen]]</div>Traudehttps://wiki.delphigl.com/index.php?title=TBN_Matrix&diff=23712TBN Matrix2009-06-18T15:16:24Z<p>Traude: /* Bitangent/Binormal */ Schreibfehler eliminiert</p>
<hr />
<div>{{Offline}}<br />
<br />
<br />
Warnung: Alles noch nicht überprüft<br />
<br />
==Was ist die TBN Matrix==<br />
<br />
Die TBN Matrix ist nach ihren Komponenten benannt, den Vektoren Normal, Bitangent (auch Binormal) und Tangent. Sie ist in der Lage Vektoren aus dem Worldspace in den Texturspace zu transformieren.<br />
Sie wird für alle Formen des Bumpmapping im Pixelshader benötigt um die Normal- und Höhenmaps vom Texturespace in den Worldspace zu transformieren. In den meisten Fällen tritt sie in normalisierter Form auf und entspricht einer reinen Drehmatrix.<br />
<br />
==Wie kann die TBN Matrix berechnet werden==<br />
<br />
Da die einzigen Erklärungen, die mir bis jetzt bekannt sind auch Englisch sind und dazu mit sehr unverständlichen Formeln gewürzt sind, die auch noch unaussprechliche Zeichen enthalten, versuche ich das ganze mal so zu beschreiben, dass es auch von normalen Programmierern verstanden wird. <br />
<br />
[[Bild:triangle_im_texturspace.png]]<br />
<br />
Bekannt sind zum Berechnen der TBN Matrix nur die Textur und Weltkoordinaten des Dreiecks ABC, welches oben abgebildet ist. Die beiden blauen Vektoren, die auf das graue Kreuz gezeichnet sind, spannen zusammen mit der grauen gestrichelten Linie die Textur auf. Der horizontale Vektor repräsentiert zugleich die U Achse der Textur, als auch den Tangentvektor. der vertikale entspricht der V Achse und Bitangent.<br />
Im Texturespace sieht es jetzt sehr leicht aus, das Problem ist jedoch, dass wir die TBN Matrix aus der Sicht des Worldspaces beschreiben müssen. Die einzigen Punkte, die wir aus dem Worldspace kennen sind jedoch nur A,B und C.<br />
<br />
Die Berechnung von Tangent und Bitangent ist fast gleich da nur andere Komponenten eingesetzt werden müssen. Erst einmal nur Tangent:<br />
<br />
Da unsere Vektoren 5 Komponenten haben: xyzuv, werden einzelne Komponenten durch u oder v markiert. Für die TBN Matrix an sich brauchen nur xyz berechnet zu werden.<br />
<br />
Der Tangent entspricht dem Vektor (F-A), Da wir ihn nicht direkt kennen, müssen wir erst (E-A) berechnen. Um den Punkt E zu bekommen muss der Vektor (C-B) so weit verlängert werden, dass er (E-B) ergibt. Um diesen Verlängerungsfaktor zu berechnen nehmen wir die V Komponenten der Texturkoordinaten zu Hilfe:<br />
<br />
Da Av = Dv ist, muss (D-C)*(Cv-Bv) = (B-C)*(Cv-Av) sein. Das lösen wir nach D auf:<br />
<br />
D = C + (B-C)*((Cv-Av)/(Cv-Bv))<br />
<br />
Da der Vektor (D-A) kleiner als 1.0 (im Texturspace!!!) ist, müssen wir ihn noch durch Teilen von (Du-Au) auf die richtige Länge bringen:<br />
<br />
D = C + (B-C)*((Cv-Av)/(Cv-Bv))<br />
<br />
Tangent = (D-A)/(Du-Au)<br />
<br />
Bitantent lässt sich berechnen, indem B;C, D;E, F;G und u;v getauscht werden:<br />
<br />
E = B + (C-B)*((Bu-Au)/(Bu-Cu))<br />
<br />
Bitangent = (E-A)/(Ev-Av) <br />
<br />
Alternativ lässt sich für normalisierte TBN Matrizen Folgendes schreiben:<br />
<br />
Tangent = normalize(C - A + (B-C)*((Cv-Av)/(Cv-Bv)))<br />
<br />
Bitangent = normalize(B - A + (C-B)*((Bu-Au)/Bu-Cu)))<br />
<br />
Dabei sollte beachtet werden, dass die Längenberechnung nicht so schnell ist wie die alternative Subtraktion.<br />
<br />
Es könnte sein, dass (C-B) parallel zu Tangent oder Bitangent ausgerichtet ist, die Division durch 0 sollte man unbedingt abfangen.<br />
<br />
Die am einfachsten zu berechnende Komponente ist der Normalvektor, er ist quasi unabhängig von den Texturkoordinaten. Es gibt zwei Möglichkeiten ihn zu berechnen. Entweder das Kreuzprodukt der Vektoren (C-A)x(B-A) oder das Kreuzprodukt von Tangent x Bitangent.<br />
<br />
==Interpolation==<br />
<br />
Wie Normalvektoren können auch die TBN Matrizen nur pro Triangle berechnet werden. Um runde Oberflächen zu erhalten, kann es sinnvoll sein, die TBN Matrizen am gemittelten Normalvektor auszurichten. Die die Ausrichtung von Tangent und Bitangent von den Texturkoordinaten abhängt, ist es nicht möglich, sie wie den Normalvektor zu interpolieren.<br />
<br />
Um die TBN Matrizen zu drehen, sollte die Drehachse mit dem Kreuzprodukt des nicht interpolierten Normalvektors und des interpolierten Normalvektors gebildet werden. Den Winkel kann man über das Skalarprodukt berechnen. Abschließend müssen Tangent und Bitangent nur noch um die Drehachse mit dem errechneten Winkel rotiert werden. Für Solid (nicht oth) gekennzeichnete Flächen kann dieser Schritt komplett entfallen.<br />
<br />
==Bitangent/Binormal==<br />
<br />
Es genügt Tangent oder Bitangent im Model zu speichern. Bitangent lässt sich auch nach durchgeführten Transformationen per Kreuzprodukt wiederherstellen. Im Vertexshader sollten zunächst Normal und Tangent mit der Normalmatrix rotiert werden (je 3 Skalarprodukte) und erst dann mit einem Kreuzprodukt ein passender Bitangentvektor berechnet werden. Das Kreuzprodukt sollte sich schneller berechnen lassen als die 3 Skalarprodukte einer Vektor/Matrixmultiplikation. Zusätzlich wird eine Komponente bei den Attributen gespart.</div>Traudehttps://wiki.delphigl.com/index.php?title=TBN_Matrix&diff=23711TBN Matrix2009-06-18T15:12:30Z<p>Traude: /* Interpolation */ Schreibfehler eliminiert</p>
<hr />
<div>{{Offline}}<br />
<br />
<br />
Warnung: Alles noch nicht überprüft<br />
<br />
==Was ist die TBN Matrix==<br />
<br />
Die TBN Matrix ist nach ihren Komponenten benannt, den Vektoren Normal, Bitangent (auch Binormal) und Tangent. Sie ist in der Lage Vektoren aus dem Worldspace in den Texturspace zu transformieren.<br />
Sie wird für alle Formen des Bumpmapping im Pixelshader benötigt um die Normal- und Höhenmaps vom Texturespace in den Worldspace zu transformieren. In den meisten Fällen tritt sie in normalisierter Form auf und entspricht einer reinen Drehmatrix.<br />
<br />
==Wie kann die TBN Matrix berechnet werden==<br />
<br />
Da die einzigen Erklärungen, die mir bis jetzt bekannt sind auch Englisch sind und dazu mit sehr unverständlichen Formeln gewürzt sind, die auch noch unaussprechliche Zeichen enthalten, versuche ich das ganze mal so zu beschreiben, dass es auch von normalen Programmierern verstanden wird. <br />
<br />
[[Bild:triangle_im_texturspace.png]]<br />
<br />
Bekannt sind zum Berechnen der TBN Matrix nur die Textur und Weltkoordinaten des Dreiecks ABC, welches oben abgebildet ist. Die beiden blauen Vektoren, die auf das graue Kreuz gezeichnet sind, spannen zusammen mit der grauen gestrichelten Linie die Textur auf. Der horizontale Vektor repräsentiert zugleich die U Achse der Textur, als auch den Tangentvektor. der vertikale entspricht der V Achse und Bitangent.<br />
Im Texturespace sieht es jetzt sehr leicht aus, das Problem ist jedoch, dass wir die TBN Matrix aus der Sicht des Worldspaces beschreiben müssen. Die einzigen Punkte, die wir aus dem Worldspace kennen sind jedoch nur A,B und C.<br />
<br />
Die Berechnung von Tangent und Bitangent ist fast gleich da nur andere Komponenten eingesetzt werden müssen. Erst einmal nur Tangent:<br />
<br />
Da unsere Vektoren 5 Komponenten haben: xyzuv, werden einzelne Komponenten durch u oder v markiert. Für die TBN Matrix an sich brauchen nur xyz berechnet zu werden.<br />
<br />
Der Tangent entspricht dem Vektor (F-A), Da wir ihn nicht direkt kennen, müssen wir erst (E-A) berechnen. Um den Punkt E zu bekommen muss der Vektor (C-B) so weit verlängert werden, dass er (E-B) ergibt. Um diesen Verlängerungsfaktor zu berechnen nehmen wir die V Komponenten der Texturkoordinaten zu Hilfe:<br />
<br />
Da Av = Dv ist, muss (D-C)*(Cv-Bv) = (B-C)*(Cv-Av) sein. Das lösen wir nach D auf:<br />
<br />
D = C + (B-C)*((Cv-Av)/(Cv-Bv))<br />
<br />
Da der Vektor (D-A) kleiner als 1.0 (im Texturspace!!!) ist, müssen wir ihn noch durch Teilen von (Du-Au) auf die richtige Länge bringen:<br />
<br />
D = C + (B-C)*((Cv-Av)/(Cv-Bv))<br />
<br />
Tangent = (D-A)/(Du-Au)<br />
<br />
Bitantent lässt sich berechnen, indem B;C, D;E, F;G und u;v getauscht werden:<br />
<br />
E = B + (C-B)*((Bu-Au)/(Bu-Cu))<br />
<br />
Bitangent = (E-A)/(Ev-Av) <br />
<br />
Alternativ lässt sich für normalisierte TBN Matrizen Folgendes schreiben:<br />
<br />
Tangent = normalize(C - A + (B-C)*((Cv-Av)/(Cv-Bv)))<br />
<br />
Bitangent = normalize(B - A + (C-B)*((Bu-Au)/Bu-Cu)))<br />
<br />
Dabei sollte beachtet werden, dass die Längenberechnung nicht so schnell ist wie die alternative Subtraktion.<br />
<br />
Es könnte sein, dass (C-B) parallel zu Tangent oder Bitangent ausgerichtet ist, die Division durch 0 sollte man unbedingt abfangen.<br />
<br />
Die am einfachsten zu berechnende Komponente ist der Normalvektor, er ist quasi unabhängig von den Texturkoordinaten. Es gibt zwei Möglichkeiten ihn zu berechnen. Entweder das Kreuzprodukt der Vektoren (C-A)x(B-A) oder das Kreuzprodukt von Tangent x Bitangent.<br />
<br />
==Interpolation==<br />
<br />
Wie Normalvektoren können auch die TBN Matrizen nur pro Triangle berechnet werden. Um runde Oberflächen zu erhalten, kann es sinnvoll sein, die TBN Matrizen am gemittelten Normalvektor auszurichten. Die die Ausrichtung von Tangent und Bitangent von den Texturkoordinaten abhängt, ist es nicht möglich, sie wie den Normalvektor zu interpolieren.<br />
<br />
Um die TBN Matrizen zu drehen, sollte die Drehachse mit dem Kreuzprodukt des nicht interpolierten Normalvektors und des interpolierten Normalvektors gebildet werden. Den Winkel kann man über das Skalarprodukt berechnen. Abschließend müssen Tangent und Bitangent nur noch um die Drehachse mit dem errechneten Winkel rotiert werden. Für Solid (nicht oth) gekennzeichnete Flächen kann dieser Schritt komplett entfallen.<br />
<br />
==Bitangent/Binormal==<br />
<br />
Es genügt Tangent oder Bitangent im Model zu speichern. Bitangent lässt sich auch nach durchgeführten Transformationen per Kreutzprodukt wiederherstellen. Im Vertexshader sollten zunächst Normal und Tangent mit der Normalmatrix rotiert werden (je 3 Skalarprodukte) und erst dann mit einem Kreutzprodukt ein passender Bitangentvektor berechnet werden. Das Kreutprodukt sollte sich schneller berechenen lassen als die 3 Skalarprodukte einer Vektor/Matrixmultiplikation. Zusätzlich wird eine Komponente bei den Atributen gespart.</div>Traudehttps://wiki.delphigl.com/index.php?title=TBN_Matrix&diff=23710TBN Matrix2009-06-18T15:07:03Z<p>Traude: /* Wie kann die TBN Matrix berechnet werden */ Schreibfehler eliminiert</p>
<hr />
<div>{{Offline}}<br />
<br />
<br />
Warnung: Alles noch nicht überprüft<br />
<br />
==Was ist die TBN Matrix==<br />
<br />
Die TBN Matrix ist nach ihren Komponenten benannt, den Vektoren Normal, Bitangent (auch Binormal) und Tangent. Sie ist in der Lage Vektoren aus dem Worldspace in den Texturspace zu transformieren.<br />
Sie wird für alle Formen des Bumpmapping im Pixelshader benötigt um die Normal- und Höhenmaps vom Texturespace in den Worldspace zu transformieren. In den meisten Fällen tritt sie in normalisierter Form auf und entspricht einer reinen Drehmatrix.<br />
<br />
==Wie kann die TBN Matrix berechnet werden==<br />
<br />
Da die einzigen Erklärungen, die mir bis jetzt bekannt sind auch Englisch sind und dazu mit sehr unverständlichen Formeln gewürzt sind, die auch noch unaussprechliche Zeichen enthalten, versuche ich das ganze mal so zu beschreiben, dass es auch von normalen Programmierern verstanden wird. <br />
<br />
[[Bild:triangle_im_texturspace.png]]<br />
<br />
Bekannt sind zum Berechnen der TBN Matrix nur die Textur und Weltkoordinaten des Dreiecks ABC, welches oben abgebildet ist. Die beiden blauen Vektoren, die auf das graue Kreuz gezeichnet sind, spannen zusammen mit der grauen gestrichelten Linie die Textur auf. Der horizontale Vektor repräsentiert zugleich die U Achse der Textur, als auch den Tangentvektor. der vertikale entspricht der V Achse und Bitangent.<br />
Im Texturespace sieht es jetzt sehr leicht aus, das Problem ist jedoch, dass wir die TBN Matrix aus der Sicht des Worldspaces beschreiben müssen. Die einzigen Punkte, die wir aus dem Worldspace kennen sind jedoch nur A,B und C.<br />
<br />
Die Berechnung von Tangent und Bitangent ist fast gleich da nur andere Komponenten eingesetzt werden müssen. Erst einmal nur Tangent:<br />
<br />
Da unsere Vektoren 5 Komponenten haben: xyzuv, werden einzelne Komponenten durch u oder v markiert. Für die TBN Matrix an sich brauchen nur xyz berechnet zu werden.<br />
<br />
Der Tangent entspricht dem Vektor (F-A), Da wir ihn nicht direkt kennen, müssen wir erst (E-A) berechnen. Um den Punkt E zu bekommen muss der Vektor (C-B) so weit verlängert werden, dass er (E-B) ergibt. Um diesen Verlängerungsfaktor zu berechnen nehmen wir die V Komponenten der Texturkoordinaten zu Hilfe:<br />
<br />
Da Av = Dv ist, muss (D-C)*(Cv-Bv) = (B-C)*(Cv-Av) sein. Das lösen wir nach D auf:<br />
<br />
D = C + (B-C)*((Cv-Av)/(Cv-Bv))<br />
<br />
Da der Vektor (D-A) kleiner als 1.0 (im Texturspace!!!) ist, müssen wir ihn noch durch Teilen von (Du-Au) auf die richtige Länge bringen:<br />
<br />
D = C + (B-C)*((Cv-Av)/(Cv-Bv))<br />
<br />
Tangent = (D-A)/(Du-Au)<br />
<br />
Bitantent lässt sich berechnen, indem B;C, D;E, F;G und u;v getauscht werden:<br />
<br />
E = B + (C-B)*((Bu-Au)/(Bu-Cu))<br />
<br />
Bitangent = (E-A)/(Ev-Av) <br />
<br />
Alternativ lässt sich für normalisierte TBN Matrizen Folgendes schreiben:<br />
<br />
Tangent = normalize(C - A + (B-C)*((Cv-Av)/(Cv-Bv)))<br />
<br />
Bitangent = normalize(B - A + (C-B)*((Bu-Au)/Bu-Cu)))<br />
<br />
Dabei sollte beachtet werden, dass die Längenberechnung nicht so schnell ist wie die alternative Subtraktion.<br />
<br />
Es könnte sein, dass (C-B) parallel zu Tangent oder Bitangent ausgerichtet ist, die Division durch 0 sollte man unbedingt abfangen.<br />
<br />
Die am einfachsten zu berechnende Komponente ist der Normalvektor, er ist quasi unabhängig von den Texturkoordinaten. Es gibt zwei Möglichkeiten ihn zu berechnen. Entweder das Kreuzprodukt der Vektoren (C-A)x(B-A) oder das Kreuzprodukt von Tangent x Bitangent.<br />
<br />
==Interpolation==<br />
<br />
Wie auch Normalverktoren, können auch die TBN Matrizen nur pro Triangle berechnet werden. Um runde Oberflächen zu erhalten, kann es sinvoll sein, die TBN Matrizen am gemitteltem Normalvektor auszurichten. Die die Ausrichtung von Tangent und Bitangent von den Texturkoordinaten abhängt, ist es nicht möglich, sie wie den Normalvektor zu interpolieren.<br />
<br />
Um die TBN Matrizen zu drehen, sollte die Drehachse mit des Kreutzproduktes des nicht Interpoliertem Normalvektors und des Interpolierten Normalvektors gebildet werden. Den Winkel kann man über das Skalarprodukt berechnen. Abschließend müssen Tangent und Bitangent nur noch um die Drehachse mit dem erechnetem Winkel rotiert werden. Für Solid (nicht oth) gekennzeichnete Flächen kann dieser Schritt komplett entfallen.<br />
<br />
==Bitangent/Binormal==<br />
<br />
Es genügt Tangent oder Bitangent im Model zu speichern. Bitangent lässt sich auch nach durchgeführten Transformationen per Kreutzprodukt wiederherstellen. Im Vertexshader sollten zunächst Normal und Tangent mit der Normalmatrix rotiert werden (je 3 Skalarprodukte) und erst dann mit einem Kreutzprodukt ein passender Bitangentvektor berechnet werden. Das Kreutprodukt sollte sich schneller berechenen lassen als die 3 Skalarprodukte einer Vektor/Matrixmultiplikation. Zusätzlich wird eine Komponente bei den Atributen gespart.</div>Traudehttps://wiki.delphigl.com/index.php?title=TBN_Matrix&diff=23709TBN Matrix2009-06-18T14:53:04Z<p>Traude: /* Was ist die TBN Matrix */ Schreibfehler eliminiert</p>
<hr />
<div>{{Offline}}<br />
<br />
<br />
Warnung: Alles noch nicht überprüft<br />
<br />
==Was ist die TBN Matrix==<br />
<br />
Die TBN Matrix ist nach ihren Komponenten benannt, den Vektoren Normal, Bitangent (auch Binormal) und Tangent. Sie ist in der Lage Vektoren aus dem Worldspace in den Texturspace zu transformieren.<br />
Sie wird für alle Formen des Bumpmapping im Pixelshader benötigt um die Normal- und Höhenmaps vom Texturespace in den Worldspace zu transformieren. In den meisten Fällen tritt sie in normalisierter Form auf und entspricht einer reinen Drehmatrix.<br />
<br />
==Wie kann die TBN Matrix berechnet werden==<br />
<br />
Da die einzigsten Erklärungen, die mir bis jetzt bekannt sind auch Englisch sind und dazu mit sehr unverständlichen Formeln gewürzt sind, die auch noch unausprechliche Zeichen enthalten, versuch ich das ganze mal so zu beschreiben, dass es auch von normalen Programieren verstanden wird. <br />
<br />
[[Bild:triangle_im_texturspace.png]]<br />
<br />
Bekannt sind zum Berechnen der TBN Matrix nur die Textur und Weltkoordinaten des Dreiecks ABC, welches oben abgebildet ist. Die beiden blauen Vektoren, die auf das graue Kreutz gezeichnet sind spannen zusammen mit der grauen gestrichelten Linie die Textur auf. Der Horizontale Vektor repäsentiert Zugleich die U Achse der Textur, als auch den Tangentvektor. Der Vertikale entspricht der V Achse und Bitangent.<br />
Im Texturspace sieht es jetzt sehr leicht aus, das Problem ist jedoch, dass wir die TBN Matrix aus der Sicht des Worldspaces beschreiben müssen. Die einzigen Punkte, die wir aus dem Worldspace kennen sind jedoch nur AB und C.<br />
<br />
Die Berechnung von Tangent und Bitangent ist fast gleich da nur andere Komponeten eingesetz werden müssen. Erst einmal nur Tangent:<br />
<br />
Da unsere Vektoren 5 Komponenten haben xyzuv, werden einzelne komponenten durch u oder v makiert. Für die TBN Matrix an sich brauchen nur xyz berechnet werden.<br />
<br />
Der Tangend entspricht dem Vektor (F-A), Da wir ih nicht direkt kennen müssen wir erst (E-A) berechnen. Um den Punkt E zu bekommen muss der Vektor (C-B) so weit verlänger werden, das er (E-B) ergibt. Um diesen Verlängerungsfakor zu Berechnen müssen wir die V Komonenten der Texturkoordinaten zu hilfe nehmen:<br />
<br />
Da Av = Dv ist, muss (D-C)*(Cv-Bv) = (B-C)*(Cv-Av) sein. Das lösen wir Nach D auf:<br />
<br />
D = C + (B-C)*((Cv-Av)/(Cv-Bv))<br />
<br />
Da der Vektor (D-A) kleiner als 1.0 (im Texturspace!!!) ist. Müssen wir ihn noch durch Teilen von (Du-Au) auf die Richtige Länge bringen:<br />
<br />
D = C + (B-C)*((Cv-Av)/(Cv-Bv))<br />
<br />
Tangent = (D-A)/(Du-Au)<br />
<br />
Bitantent lässt sich berechnen, in dem B;C, D;E, F;G und u;v getauscht werden:<br />
<br />
E = B + (C-B)*((Bu-Au)/(Bu-Cu))<br />
<br />
Bitangent = (E-A)/(Ev-Av) <br />
<br />
Alternativ lässt sich für normalisierte TBN Matrizen folgendes schreiben:<br />
<br />
Tangent = normalize(C - A + (B-C)*((Cv-Av)/(Cv-Bv)))<br />
<br />
Bitangent = normalize(B - A + (C-B)*((Bu-Au)/Bu-Cu)))<br />
<br />
Dabei sollte beachtet werden, das die Längenberechnung nicht so schnell ist wie die alternative Subtraktion.<br />
<br />
Es könnte sein, dass (C-B) Parallel zu Tangent oder Bitangent ausgerichtet ist, die Division durch 0 sollte man umbedingt abfangen.<br />
<br />
Die am einfachsten zu berechnende Komponente ist der Normalvektor, er ist quasi unabhängig von den Texturkoordinaten. Es gibt zwei Möglichkeiten ihn zu berechnen. Entweder das Kreutzprodukt der Verktoren (C-A)x(B-A) oder das Kreutzprodukt von Tangent x Bitangent.<br />
<br />
==Interpolation==<br />
<br />
Wie auch Normalverktoren, können auch die TBN Matrizen nur pro Triangle berechnet werden. Um runde Oberflächen zu erhalten, kann es sinvoll sein, die TBN Matrizen am gemitteltem Normalvektor auszurichten. Die die Ausrichtung von Tangent und Bitangent von den Texturkoordinaten abhängt, ist es nicht möglich, sie wie den Normalvektor zu interpolieren.<br />
<br />
Um die TBN Matrizen zu drehen, sollte die Drehachse mit des Kreutzproduktes des nicht Interpoliertem Normalvektors und des Interpolierten Normalvektors gebildet werden. Den Winkel kann man über das Skalarprodukt berechnen. Abschließend müssen Tangent und Bitangent nur noch um die Drehachse mit dem erechnetem Winkel rotiert werden. Für Solid (nicht oth) gekennzeichnete Flächen kann dieser Schritt komplett entfallen.<br />
<br />
==Bitangent/Binormal==<br />
<br />
Es genügt Tangent oder Bitangent im Model zu speichern. Bitangent lässt sich auch nach durchgeführten Transformationen per Kreutzprodukt wiederherstellen. Im Vertexshader sollten zunächst Normal und Tangent mit der Normalmatrix rotiert werden (je 3 Skalarprodukte) und erst dann mit einem Kreutzprodukt ein passender Bitangentvektor berechnet werden. Das Kreutprodukt sollte sich schneller berechenen lassen als die 3 Skalarprodukte einer Vektor/Matrixmultiplikation. Zusätzlich wird eine Komponente bei den Atributen gespart.</div>Traudehttps://wiki.delphigl.com/index.php?title=Physik_und_3D&diff=22513Physik und 3D2009-01-29T09:48:53Z<p>Traude: Die Seite wurde neu angelegt: Wir nehmen an, dass uns ein hübsches Mesh (eine Ansammlung von Dreiecken) zur Verfügung steht, sagen wir mal: ein Kämpfer-Modell. Wir laden diese Daten mal in den Ha...</p>
<hr />
<div>Wir nehmen an, dass uns ein hübsches Mesh (eine Ansammlung von Dreiecken) zur Verfügung steht, sagen wir mal: ein Kämpfer-Modell. Wir laden diese Daten mal in den Hauptspeicher. Anhand dieses Mesh kann man jetzt auf automatisierte Weise ein vereinfachtes grobes Mesh herstellen, oder auch nur eine Bounding Box des Mesh berechnen oder vielleicht sind solche Daten sogar in der Meshdatei vorhanden. Die Mesh-Daten, die zum Zeichnen bestimmt sind, schicken wir an die Grafikkarte weiter, damit sie schnell gezeichnet werden können. Diese Daten sehen den Hauptspeicher normalerweise nie wieder. Man könnte die Vertex-Daten schon wieder zurücklesen, aber es ist gar nicht nötig und auch kontraproduktiv, denn es wäre viel zu langsam. <br />
<br />
Das vereinfachte Mesh (oder die Bounding Box) behalten wir im Hauptspeicher zurück. Das ist eine „dünne“ Repräsentation unseres Modells. Je „dünner“ (also je weniger Daten es hat), desto besser (nämlich schneller), aber auch nicht zu dünn, sonst werden unsere Berechnungen zu ungenau. Hier muss man sich zwischen Geschwindigkeit und Genauigkeit entscheiden. Das Schnellste, was man hier nehmen kann, ist eine Kugel („Bounding Sphere“), aber unser Kämpfer wird durch eine simple Kugel ziemlich schlecht repräsentiert.<br />
<br />
Auf dieses Pseudomesh und einige andere Physik-Daten (Masse, Geschwindigkeit, augenblickliche Position und Orientierung etc.) werden jetzt die Physikberechnungen angewendet (Anwenden von Kräften, Kollisionsberechnungen). Wenn man eine externe Physik-Engine verwendet, wäre die Struktur der Daten zwar von der Physik-Engine bestimmt, aber in welchem Umfeld sie gespeichert werden, ist unsere Sache. Das Pseudomesh und seine zugehörigen Physik-Daten könnte man z.B. in ein Objekt kapseln, denn sie gehören eindeutig zusammen. <br />
<br />
Wichtiger ist aber, dass das Ergebnis der Physik-Berechnungen Verschiebungen und Drehungen sind. Diese verändern die aktuelle Position und Orientierung und ergeben eine NEUE Position und Orientierung. Im nächsten Renderpass fließt diese neue Position/Orientierung aus der Physikberechnung daher in die Renderpipline mit ein, z.B. einfach als glTranslate/glRotate. Ja, es wird normalerweise glMultMatrix benutzt, aber ein einfaches glTranslate/glRotate tut genau dasselbe. <br />
<br />
Wenn wir allerdings für unser Kämpfer-Modell wirklich nur eine Bounding Box haben, sehen wir ganz schön alt aus. Besser wäre hier z.B. eine Ansammlung von Bounding Boxen: eine für die Brust, je eine für die Oberarme, Unterarme, usw. <br />
<br />
Kollisionskörper werden „Bounding Volumes“ genannt. Für ein Mesh, dass sich per Skelett bewegt („skeletale Animation“) gibt es nicht nur ein Bounding Volume, sondern gleich eine ganze Hierarchie davon, für jedes Bone eines.<br />
<br />
Bei der Demonstration von Physik-Engines sieht man manchmal solche Bounding Volumes, die hier ausnahmsweise auch gezeichnet werden.</div>Traudehttps://wiki.delphigl.com/index.php?title=Datei:Tutorial_lektion8_RoteRinge.jpg&diff=22491Datei:Tutorial lektion8 RoteRinge.jpg2009-01-23T21:28:22Z<p>Traude: </p>
<hr />
<div></div>Traudehttps://wiki.delphigl.com/index.php?title=glCopyTexSubImage3D&diff=22218glCopyTexSubImage3D2008-11-17T13:34:38Z<p>Traude: /* Parameter x,y*/ Richtigstellung gemäß Originalspezifikation</p>
<hr />
<div>= glCopyTexSubImage3D =<br />
<br />
<br />
<br />
== Name ==<br />
'''glCopyTexSubImage3D''' - kopiert ein dreidimensionales Teilbild.<br />
<br />
<br />
<br />
== Delphi-Spezifikation ==<br />
<br />
procedure '''glCopyTexSubImage3D'''(''target'' : GLenum; <br />
''level'' : GLint; <br />
''xoffset'' : GLint; ''yoffset'' : GLint; ''zoffset'' : GLint;<br />
''x'' : GLint; ''y'' : GLint;<br />
''width'' : GLsizei; ''height'' : GLsizei; ''depth'' : GLsizei)<br />
<br />
<br />
<br />
== Parameter ==<br />
<br />
{| border="1" rules="all"<br />
! ''target''<br />
| Gibt die Zieltextur an. Muss '''GL_TEXTURE_3D''' sein.<br />
|-<br />
! ''level''<br />
| Gibt die [[LOD]]-Nummer an. Level 0 entspricht dem Standard-Bildlevel. Level ''n'' ist die ''n''-te Mipmap-Textur.<br />
|-<br />
! ''xoffset''<br />
| Gibt den Texel-Offset-Wert in x-Richtung innerhalb des Texturarrays an.<br />
|-<br />
! ''yoffset''<br />
| Gibt den Texel-Offset-Wert in y-Richtung innerhalb des Texturarrays an.<br />
|-<br />
! ''zoffset''<br />
| Gibt den Texel-Offset-Wert in z-Richtung innerhalb des Texturarrays an.<br />
|-<br />
! ''x'', ''y''<br />
| Gibt die Fenster-Koordinaten der unteren linken Ecke der zu kopierenden rechteckigen Region von Pixeln an.<br />
|-<br />
! ''width''<br />
| Gibt die Breite des Teilbildes an.<br />
|-<br />
! ''height''<br />
| Gibt die Höhe des Teilbildes an.<br />
|-<br />
! ''depth''<br />
| Gibt die Tiefe des Teilbildes an.<br />
|}<br />
<br />
== Beschreibung ==<br />
'''glCopyTexSubImage3D''' ersetzt einen rechteckigen Teil einer zweidimensionalen Textur mit Pixeln aus dem aktuellen '''GL_READ_BUFFER''' (statt aus dem Hauptspeicher, wie das bei [[glTexSubImage3D]] der Fall ist).<br />
<br />
Das Pixelrechteck mit der linken, unteren Ecke bei [x,y], mit der Länge ''width'' und der Höhe ''height'' ersetzt die Pixel des Texturarrays mit den x-Indices von ''xoffset'' bis ''xoffset + width - 1'', y-Indices von ''yoffset'' bis ''yoffset + height - 1'' und z-Indices von ''zoffset'' bis ''zoffset + depth - 1'' . Dieser Bereich muss nicht alle Texel enthalten, die im ursprünglichen Texturarray lagen. Dabei wird das Texturarray verändert, welches dem Mipmaplevel entspricht, der über ''level'' angegeben wurde.<br />
<br />
Die Pixel werden genauso bearbeitet, wie wenn [[glCopyPixels]] aufgerufen worden wäre, nur dass der Prozess vor der finalen Umwandlung stoppt. An diesem Punkt angelangt, werden alle Pixelwerte an den [0,1]-Bereich angepasst und dann in das texturinterne Format konvertiert, um im Texelarray gespeichert zu werden.<br />
<br />
Es ist nicht falsch wenn man eine Sub-Textur mit einer Breite oder Höhe von 0 festlegt, aber das hat keinen Effekt. Wenn irgendwelche der Pixel innerhalb der angegebenen Reihe im '''GL_READ_BUFFER''' außerhalb des Fenster sind, dann sind die für diese Werte erhaltenen Werte undefiniert.<br />
<br />
Es werden keine Änderungen am internen Format, der Breite, der Höhe, der Tiefe oder Randparametern des angegebenen Texturarrays vorgenommen. <br />
<br />
<br />
<br />
== Hinweise ==<br />
'''glCopyTexSubImage3D''' ist nur verfügbar, wenn die OpenGL-Version 1.1 oder höher ist.<br />
<br />
Texturierung hat keinen Effekt, wenn man sich im Color-Index-Modus befindet.<br />
<br />
[[glPixelStore]]-und [[glPixelTransfer]]-Modi beeinflussen Texturen auf gleiche Weise, wie sie [[glDrawPixels]] beeinflussen.<br />
<br />
Wenn die [[GL_ARB_imaging]]-Extension unterstützt wird, werden die kopierten RGBA-Komponenten möglicherweise durch die Imaging-Pipeline verarbeitet. Siehe [[glTexImage3D]] für mehr Informationen.<br />
<br />
<br />
<br />
== Fehlermeldungen ==<br />
'''GL_INVALID_ENUM''' wird generiert, wenn ''target'' nicht der Wert '''GL_TEXTURE_3D''' zugewiesen wurde.<br />
<br />
'''GL_INVALID_OPERATION''' wird generiert, wenn das Texturarrays nicht durch eine vorhergehende [[glTexImage3D]]- oder [[glCopyTexImage3D]]-Operation definiert wurde.<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn ''level'' kleiner als 0 ist.<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn ''level'' größer als log2(max) (max = '''GL_MAX_TEXTURE_SIZE''') ist.<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn '''b''' größer ist als ''y'', ''x'', ''width'', ''depth'' oder ''height'' ('''b''' ist die Randbreite des Texturarrays).<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn xoffset oder yoffset kleiner als b ist oder wenn (xoffset + width), (yoffset + width) bzw. (zoffset + depth) kleiner ist als (w - b) (w = GL_TEXTURE_WIDTH, b = GL_TEXTURE_BORDER). Man beachte, dass w mindestens zweimal so groß ist wie b.<br />
<br />
'''GL_INVALID_OPERATION''' wird generiert, wenn '''glCopyTexSubImage3D''' innerhalb eines [[glBegin]]-[[glEnd]]-Blocks aufgerufen wird. <br />
<br />
<br />
<br />
== Zugehörige Wertrückgaben ==<br />
[[glGetTexImage]]<br />
<br />
[[glIsEnabled]] mit Token [[glIsEnabled#GL_TEXTURE_3D|GL_TEXTURE_3D]]<br />
<br />
<br />
<br />
== Siehe auch ==<br />
[[glCopyPixels]], [[glCopyTexImage]], [[glCopyTexImage2D]], [[glCopyTexSubImage1D]], [[glCopyTexSubImage2D]], [[glPixelStore]], [[glPixelTransfer]], [[glReadBuffer]], [[glTexEnv]], [[glTexGen]], [[glTexImage1D]], [[glTexImage2D]], [[glTexImage3D]], [[glTexParameter]], [[glTexSubImage1D]], [[glTexSubImage2D]], [[glTexSubImage3D]]<br />
<br />
[[Kategorie:GL|CopyTexSubImage3D]]<br />
[[Kategorie:GL1.2|CopyTexSubImage3D]]</div>Traudehttps://wiki.delphigl.com/index.php?title=glCopyTexSubImage2D&diff=22217glCopyTexSubImage2D2008-11-17T13:26:39Z<p>Traude: /* Parameter x,y */ Richtigstellung gemäß Originalspezifikation</p>
<hr />
<div>= glCopyTexSubImage2D =<br />
<br />
<br />
<br />
== Name ==<br />
'''glCopyTexSubImage2D''' - kopiert ein zweidimensionales Teilbild.<br />
<br />
<br />
<br />
== Delphi-Spezifikation ==<br />
<br />
procedure '''glCopyTexSubImage2D'''(''target'' : GLenum; <br />
''level'' : GLint; <br />
''xoffset'' : GLint; ''yoffset'' : GLint;<br />
''x'' : GLint; ''y'' : GLint; <br />
''width'' : GLsizei; ''height'' : GLsizei)<br />
<br />
<br />
<br />
== Parameter ==<br />
<br />
{| border="1" rules="all"<br />
! ''target''<br />
| Gibt die Zieltextur an. Muss '''GL_TEXTURE_2D''' sein.<br />
|-<br />
! ''level''<br />
| Gibt die [[LOD]]-Nummer an. Level 0 entspricht dem Standard-Bildlevel. Level ''n'' ist die ''n''-te Mipmap-Textur.<br />
|-<br />
! ''xoffset''<br />
| Gibt den Texel-Offset-Wert in x-Richtung innerhalb des Texturarrays an.<br />
|-<br />
! ''yoffset''<br />
| Gibt den Texel-Offset-Wert in y-Richtung innerhalb des Texturarrays an.<br />
|-<br />
! ''x'', ''y''<br />
| Gibt die Fenster-Koordinaten der unteren linken Ecke der zu kopierenden rechteckigen Region von Pixeln an.<br />
|-<br />
! ''width''<br />
| Gibt die Breite des Teilbildes an.<br />
|-<br />
! ''height''<br />
| Gibt die Höhe des Teilbildes an.<br />
|}<br />
<br />
== Beschreibung == <br />
'''glCopyTexSubImage2D''' ersetzt einen rechteckigen Teil einer zweidimensionalen Textur mit Pixeln aus dem aktuellen '''GL_READ_BUFFER''' (statt aus dem Hauptspeicher, wie das bei [[glTexSubImage2D]] der Fall ist).<br />
<br />
Das Pixelrechteck mit der linken, unteren Ecke bei [x,y], mit der Länge ''width'' und der Höhe ''height'' ersetzt die Pixel des Texturarrays mit den x-Indices von ''xoffset'' bis ''xoffset + width - 1'' und y-Indices von ''yoffset'' bis ''yoffset + height - 1''. Dieser Bereich muss nicht alle Texel enthalten, die im ursprünglichen Texturarray lagen. Dabei wird das Texturarray verändert, welches dem Mipmaplevel entspricht, der über ''level'' angegeben wurde.<br />
<br />
Die Pixel werden genauso bearbeitet, wie wenn [[glCopyPixels]] aufgerufen worden wäre, nur dass der Prozess vor der finalen Umwandlung stoppt. An diesem Punkt angelangt, werden alle Pixelwerte an den [0,1]-Bereich angepasst und dann in das texturinterne Format konvertiert, um im Texelarray gespeichert zu werden.<br />
<br />
Es ist nicht falsch wenn man eine Sub-Textur mit einer Breite oder Höhe von 0 festlegt, aber das hat keinen Effekt. Wenn irgendwelche der Pixel innerhalb der angegebenen Reihe im '''GL_READ_BUFFER''' außerhalb des Fenster sind, dann sind die für diese Werte erhaltenen Werte undefiniert.<br />
<br />
Es werden keine Änderungen am internen Format, der Breite oder Randparametern des angegebenen Texturarrays vorgenommen. <br />
<br />
<br />
<br />
== Hinweise ==<br />
'''glCopyTexSubImage2D''' ist nur verfügbar, wenn die OpenGL-Version 1.1 oder höher ist.<br />
<br />
Texturierung hat keinen Effekt, wenn man sich im Color-Index-Modus befindet.<br />
<br />
[[glPixelStore]]-und [[glPixelTransfer]]-Modi beeinflussen Texturen auf gleiche Weise, wie sie [[glDrawPixels]] beeinflussen.<br />
<br />
Wenn die [[GL_ARB_imaging]]-Extension unterstützt wird, werden die kopierten RGBA-Komponenten möglicherweise durch die Imaging-Pipeline verarbeitet. Siehe [[glTexImage1D]] für mehr Informationen.<br />
<br />
<br />
<br />
== Fehlermeldungen ==<br />
'''GL_INVALID_ENUM''' wird generiert, wenn ''target'' nicht der Wert '''GL_TEXTURE_2D''' zugewiesen wurde.<br />
<br />
'''GL_INVALID_OPERATION''' wird generiert, wenn das Texturarrays nicht durch eine vorhergehende [[glTexImage2D]]- oder [[glCopyTexImage2D]]-Operation definiert wurde.<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn ''level'' kleiner als 0 ist.<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn ''level'' größer als log2(max) (max = '''GL_MAX_TEXTURE_SIZE''') ist.<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn '''b''' größer ist als ''y'', ''x'', ''width'' oder ''height'' ('''b''' ist die Randbreite des Texturarrays).<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn xoffset oder yoffset kleiner als b ist oder wenn (xoffset + width) bzw (yoffset + width) kleiner ist als (w - b) (w = GL_TEXTURE_WIDTH, b = GL_TEXTURE_BORDER). Man beachte, dass w mindestens zweimal so groß ist wie b.<br />
<br />
'''GL_INVALID_OPERATION''' wird generiert, wenn '''glCopyTexSubImage2D''' innerhalb eines [[glBegin]]-[[glEnd]]-Blocks aufgerufen wird. <br />
<br />
<br />
<br />
== Zugehörige Wertrückgaben ==<br />
[[glGetTexImage]]<br />
<br />
[[glIsEnabled]] mit Token [[glIsEnabled#GL_TEXTURE_2D|GL_TEXTURE_2D]]<br />
<br />
<br />
<br />
== Siehe auch ==<br />
[[glCopyPixels]], [[glCopyTexImage]], [[glCopyTexImage2D]], [[glCopyTexSubImage1D]], [[glCopyTexSubImage3D]], [[glPixelStore]], [[glPixelTransfer]], [[glReadBuffer]], [[glTexEnv]], [[glTexGen]], [[glTexImage1D]], [[glTexImage2D]], [[glTexImage3D]], [[glTexParameter]], [[glTexSubImage1D]], [[glTexSubImage2D]], [[glTexSubImage3D]]<br />
<br />
[[Kategorie:GL|CopyTexSubImage2D]]<br />
[[Kategorie:GL1.1]]</div>Traudehttps://wiki.delphigl.com/index.php?title=glCopyTexImage2D&diff=22216glCopyTexImage2D2008-11-17T13:24:14Z<p>Traude: /* Parameter x,y */ Richtigstellung gemäß Originalspezifikation</p>
<hr />
<div>= glCopyTexImage2D =<br />
<br />
<br />
<br />
== Name ==<br />
'''glCopyTexImage2D''' - Kopiert Pixel in eine 2-dimensionale Textur.<br />
<br />
<br />
<br />
== Delphi-Spezifikation ==<br />
<br />
procedure '''glCopyTexImage2D'''(''target'' : GLenum; ''level'' : GLint; ''internalformat'' : GLenum;<br />
''x'' : GLint; ''y'' : GLint; ''width'' : GLsizei; ''height'' : GLsizei; ''border'' : GLint)<br />
<br />
<br />
<br />
== Parameter ==<br />
<br />
{| border="1" rules="all"<br />
! ''target'' <br />
| Gibt die zu bearbeitende Textur an. Die Textur muss vom Typ '''GL_TEXTURE_2D''' sein.<br />
|-<br />
! ''level'' <br />
| Gibt den level-of-detail-Grad an. Level 0 ist das normale Bild. Level ''n'' ist der n-te Mipmap-Level<br />
|-<br />
! ''internalformat''<br />
| Gibt das interne Format der Textur an. Muss eine der folgenden Konstanten sein: <br>'''GL_ALPHA''', '''GL_ALPHA4''', '''GL_ALPHA8''', '''GL_ALPHA12''', '''GL_ALPHA16''', '''GL_LUMINANCE''', '''GL_LUMINANCE4''', '''GL_LUMINANCE8''', '''GL_LUMINANCE12''', '''GL_LUMINANCE16''', '''GL_LUMINANCE_ALPHA''', '''GL_LUMINANCE4_ALPHA4''', '''GL_LUMINANCE6_ALPHA2''', '''GL_LUMINANCE8_ALPHA8''', '''GL_LUMINANCE12_ALPHA4''', '''GL_LUMINANCE12_ALPHA12''', '''GL_LUMINANCE16_ALPHA16''', '''GL_INTENSITY''', '''GL_INTENSITY4''', '''GL_INTENSITY8''', '''GL_INTENSITY12''', '''GL_INTENSITY16''', '''GL_RGB''', '''GL_R3_G3_B2''', '''GL_RGB4''', '''GL_RGB5''', '''GL_RGB8''', '''GL_RGB10''', '''GL_RGB12''', '''GL_RGB16''', '''GL_RGBA''', '''GL_RGBA2''', '''GL_RGBA4''', '''GL_RGB5_A1''', '''GL_RGBA8''', '''GL_RGB10_A2''', '''GL_RGBA12''', oder '''GL_RGBA16'''.<br />
|-<br />
! ''x, y''<br />
| Gibt die Fenster-Koordinaten der unteren linken Ecke der zu kopierenden rechteckigen Region von Pixeln an.<br />
|-<br />
! ''width''<br />
| Gibt die Breite der Textur an. Muss entweder 0 oder 2^n + 2 * border (für Ganzahlige n) sein.<br />
|-<br />
! ''height''<br />
| Gibt die Höhe der Textur an. Muss 2^m + 2 * border (für Ganzahlige m) sein. Wenn '''GL_INTERLACE_EXT''' aktiviert ist, muss die Höhe 2^m + border sein, da die Höhe dann verdoppelt wird. Alle Implementationen unterstützen Texturen, die mindestens 64 Texel hoch sind. <br />
|-<br />
! ''border''<br />
| Gibt die Breite des Rands an. Muss 0 oder 1 sein.<br />
|-<br />
|}<br />
<br />
== Beschreibung ==<br />
'''glCopyTexImage2D''' definiert eine 2-dimensionale Textur mit Pixeln aus dem aktuellen '''GL_READ_BUFFER'''. <br />
<br />
Das Bildschirm-bezogene Pixelrechteck mit der unteren linken Ecke bei (x, y) und mit einer Länge von ''width'' + 2 * ''border'' und einer Höhe von ''height'' + 2 * ''border'' definiert den Texturbereich. Als [[Mipmap]]-Level wird ''level'' benutzt.<br />
<br />
<br />
''internalformat'' gibt das interne Format des Textur-Arrays an.<br />
<br />
<br />
Die Pixel in dem Rechteck werden genau so bearbeitet wie wenn [[glCopyPixels]] aufgerufen worden wäre, nur dass der Vorgang vor der finalen Konvertierung gestoppt wird. An diesem Punkt werden alle Pixel-Werte an den [0, 1]-Bereich angepasst und dann in das interne Texturformat konvertiert, um im Texel-Array gespeichert zu werden.<br />
<br />
<br />
Das Bildschirm-bezogene Pixelrechteck mit der unteren linken Ecke bei (x, y), der Breite ''width'' und der Höhe ''height'' wird benutzt, um die Textur zu definieren. Ist '''GL_INTERLACE_READ_I3D''' aktiviert, werden gewisse Zeilen ignoriert, so dass das Pixelrechteck mit der linken unteren Ecke bei (x, y), der Breite ''width'' und der Höhe 2 * ''height'' - 1 verwendet wird, um die Textur zu definieren. Wenn Pixel die innerhalb dieses Bereich liegen sich außerhalb des Fensters des GL-Kontextes befinden, bleiben die Werte für diese Pixel undefiniert.<br />
<br />
<br />
Die Pixel werden so geordnet, dass kleinere x- und y-Werte am Bildschirm kleineren s- und t-Texturkoordinaten entsprechen.<br />
<br />
<br />
Wenn sich einige der Pixel, die in der Zeile des aktuellen '''GL_READ_BUFFER''' angegeben werden, außerhalb des Bildschirms befinden, sind die Werte für diese Pixel undefiniert.<br />
<br />
<br />
Ist '''GL_INTERLACE_EXT''' aktiviert, sind nur die Zeilen (0,2,4,...) der Textur - bei der der Rand als Teil der Textur zählt - definiert. Die restlichen Zeilen (1,3,5,...) bleiben undefiniert und können nur per [[glTexSubImage2D]] oder [[glCopyTexSubImage2D]] definiert werden.<br />
<br />
<br />
<br />
== Hinweise ==<br />
'''glCopyTexImage2D''' ist ab OpenGL Version 1.1 verfügbar.<br />
<br />
Texturierung hat keinen Effekt im Farbindex-Modus.<br />
<br />
1, 2, 3 oder 4 werden nicht als ''internalformat'' akzeptiert.<br />
<br />
Ein Bild mit der Breite 0 entspricht einer '''nil'''-Textur.<br />
<br />
<br />
<br />
== Änderungen ==<br />
Folgende Erweiterungen hat die Funktion erfahren:<br />
=== Ab OpenGL-Version 1.3 ===<br />
:[[GL_ARB_texture_cube_map]] definiert weitere 6 2D-Texture-Typen welche als target angegeben werden können. <br />
<br />
<br />
<br />
== Extensions ==<br />
Einige der Anweisungen und Konstanten dieser Funktion sind Teil einer Extension, also in der Standard-OpenGL-Implementation nicht enthalten. Die folgenden Extension-Bezeichnungen müssen in dem String, den [[glGetString]] liefert, enthalten sein, wenn die Funktion mit dem Argument '''GL_EXTENSIONS''' aufgerufen wird, um diese Anweisungen und Konstanten zu verwenden.<br />
<br />
<br />
'''EXT_interlace<br />
:GL_INTERLACE_EXT''' ist Teil der [[EXT_interlace]] - Extension.<br />
<br />
'''EXT_interlace_read<br />
:GL_INTERLACE_READ_I3D''' ist Teil der [[EXT_interlace_read]] - Extension.<br />
<br />
<br />
== Fehlermeldungen ==<br />
'''GL_INVALID_ENUM''' wird generiert, wenn ''target'' nicht '''GL_TEXTURE_2D''' ist.<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn ''level'' kleiner als 0 ist.<br />
<br />
'''GL_INVALID_VALUE''' könnte generiert werden, wenn ''level'' größer als log2(max) ist. (max ist der Wert, der beim Aufruf von glGet mit Token '''GL_MAX_TEXTURE_SIZE''' geliefert wird)<br />
<br />
'''GL_INVALID_VALUE''' wird genereirt, wenn ''internalformat'' keinen zulässigen Wert hat.<br />
<br />
'''GL_INVALID_VALUE''' wird generiert, wenn <br />
*''width'' oder ''height'' kleiner als 0 oder <br />
*''width'' größer als 2 + '''GL_MAX_TEXTURE_SIZE''' ist oder nicht als 2^n + 2 * border (n ganzzahlig) dargestellt werden kann oder <br />
*''height'' nicht als 2^k + I * ''border'' dargestellt werden kann. (k ganzzahlig, I ist 1, wenn '''GL_INTERLACE_EXT''' aktiviert ist oder andernfalls 2)<br />
<br />
'''GL_INVALID_VALUE''' wird erzeugt, wenn ''border'' nicht 1 oder 0 ist.<br />
<br />
'''GL_INVALID_OPERATION''' wird generiert, wenn '''glCopyTexImage2D''' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird. <br />
<br />
<br />
<br />
== Zugehörige Wertrückgaben ==<br />
[[glGetTexImage]]<br />
<br />
[[glIsEnabled]] mit dem Parameter '''GL_TEXTURE_2D'''<br />
<br />
<br />
<br />
<br />
== Siehe auch ==<br />
[[glCopyPixels]], [[glCopyTexImage1D]], [[glCopyTexSubImage1D]], [[glCopyTexSubImage2D]], [[glCopyTexSubImage3D]], [[glPixelStore]], [[glPixelTransfer]], [[glTexEnv]], [[glTexGen]], [[glTexImage1D]], [[glTexImage2D]], [[glTexImage3D]], [[glTexSubImage1D]], [[glTexSubImage2D]], [[glTexSubImage3D]], [[glTexParameter]]<br />
<br />
[[Kategorie:GL|CopyTexImage2D]]<br />
[[Kategorie:GL1.1]]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21956GL ARB multisample2008-07-13T14:51:40Z<p>Traude: /* Neue Prozeduren */ Prozedur verlinkt</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
<br />
== Abhängigkeiten ==<br />
GL_ARB_multisample ist abhängig von folgenden Extensions: <br><br />
'''[[WGL_ARB_extensions_string]]''' <br><br />
'''[[WGL_ARB_pixel_format]]''' <br><br />
<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''[[glSampleCoverageARB]]''' (value: TGLclampf; invert: TGLboolean); <br><br />
<br />
<br />
Die Prozedur SampleCoverageARB setzt die beiden Werte SAMPLE_COVERAGE_VALUE_ARB und SAMPLE_COVERAGE_INVERT_ARB.<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von wglChoosePixelFormatARB:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
== Anwendung ==<br />
<br />
HINWEIS: Die folgenden Erläuterungen gelten nur für Windows: <br><br />
Das Multisampling wird mithilfe der Prozedur [[wglChoosePixelFormatARB]] ausgewählt, mit der Windows API Prozedur SetPixelFormat gesetzt und anschließend kann ein Rendering Context mit [[wglCreateContext]] erstellt werden. <br />
<br />
Das erfordert aber eine besondere Vorgangsweise, denn die Prozedur wglChoosePixelFormatARB ist ebenfalls Bestandteil einer Extension, und Extensions stehen nur zur Verfügung, wenn bereits ein Rendering Context aktiviert ist. Da für einen Rendering Context anläßlich der Erstellung nur einmal ein Pixelformat vergeben werden darf, kann man das Multisampling-Pixelformat auf diese Weise zwar in Erfahrung bringen, aber nicht mehr setzen.<br />
<br />
Daher ist die korrekte Vorgangsweise die Folgende: <br><br />
1. Einen temporären Rendering Context mit einem gültigen Pixelformat erstellen <br><br />
2. Prüfen, ob ein Pixelformat mit Multisampling zur Verfügung steht und das Ergebnis speichern <br><br />
3. Den temporären Context wieder löschen <br><br />
4. Einen neuen Rendering Context aufgrund des Ergebnisses gemäß Pkt.2 erstellen. <br><br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=glSampleCoverage&diff=21947glSampleCoverage2008-07-12T17:39:58Z<p>Traude: /* glSampleCoverage */ glSampleCoverageARB hinzugefügt</p>
<hr />
<div>= glSampleCoverage (glSampleCoverageARB) =<br />
<br />
<br />
<br />
== Name ==<br />
'''glSampleCoverage''' - setzt einen temporären Überdeckungswert fürs [[Multisampling]].<br />
<br />
<br />
<br />
== Delphi-Spezifikation ==<br />
procedure '''glSampleCoverage'''(''value'': TGLclampf; ''invert'': TGLboolean)<br />
<br />
procedure '''glSampleCoverageARB'''(''value'': TGLclampf; ''invert'': TGLboolean)<br />
<br />
<br />
<br />
== Parameter ==<br />
<br />
{| border="1" rules="all"<br />
! ''value'' <br />
| Temporärer Überdeckungswert.<br />
|-<br />
! ''invert'' <br />
| Flag, ob temporärer Überdeckungswert bitweise invertiert werden soll.<br />
|}<br />
<br />
<br />
<br />
<br />
== Beschreibung == <br />
Der Befehl '''glSampleCoverage''' legt mit ''value'' fest, welcher Wert beim [[Multisampling]] mit dem [[glSampleCoverage#Überdeckungswert|Überdeckungswert des Fragments]] bitweise geUNDet wird, falls [[glEnable]]('''GL_SAMPLE_COVERAGE''') aktiviert ist.<br />
<br />
Ist ''invert'' auf '''GL_TRUE''' gesetzt, wird der Wert ''value'' vor der VerUNDung nocheinmal bitweise invertiert.<br />
<br />
=== Überdeckungswert ===<br />
Normalerweise wird beim Multisampling, welches mit [[glEnable]]('''GL_MULTISAMPLE''') aktiviert wird, ein Überdeckungswert für jedes Fragment bestimmt, welcher zwischen 0.0 und 1.0 liegt.<br />
Dieser Wert gibt an, wie groß der Anteil von einem Pixel ist, der von einem Fragment überdeckt wird. Liegt der Wert bei 1.0, so wird der Pixel komplett vom Fragment überdeckt, ansonsten nur teilweise, bei 0.0 garnicht.<br />
<br />
<br />
<br />
== Hinweise ==<br />
'''glSampleCoverage''' ist erst ab OpenGL Version 1.3 oder höher nutzbar.<br />
<br />
Der Parameter ''value'' wird vor der Anwendung auf den Bereich [0, 1] gemapped.<br />
<br />
<br />
<br />
== Fehlermeldungen ==<br />
'''GL_INVALID_OPERATION''' wird generiert wenn '''glSampleCoverage''' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird.<br><br />
<br />
<br />
<br />
== Zugehörige Wertrückgaben ==<br />
[[glGet]] mit Token [[glGet#GL_SAMPLE_COVERAGE_VALUE|GL_SAMPLE_COVERAGE_VALUE]]<br><br />
[[glGet]] mit Token [[glGet#GL_SAMPLE_COVERAGE_INVERT|GL_SAMPLE_COVERAGE_INVERT]]<br><br />
<br><br />
<br />
== Siehe auch ==<br />
[[glEnable]]<br />
<br />
<br />
[[Kategorie:GL|SampleCoverage]]<br />
[[Kategorie:GL1.3]]</div>Traudehttps://wiki.delphigl.com/index.php?title=OpenGL-Funktions%C3%BCbersicht&diff=21946OpenGL-Funktionsübersicht2008-07-12T17:31:20Z<p>Traude: /* S */ glSampleCoverageARB hinzugefügt</p>
<hr />
<div>[[Bild:Opengl_logo.png|right|200px]]<br />
== Hinweise für Helfer ==<br />
<br />
=== Was hier hinein gehört ===<br />
<br />
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]]). <br />
<br />
Allerdings sind hier auch glu-/wgl- und glx-Funktionen erlaubt. Konstanten bitte nicht hier im Inhaltsverzeichnis einfügen, genausowenig wie [[OpenGL-Extensions]].<br />
<br />
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).<br />
<br />
<br />
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. <br />
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.<br />
<br />
'''Zu aller erst sollte die Orginalspezifikation übersetzt werden''' und erst dann eigene Hinweise untergebracht werden (z.B. Erfahrungen, typische Fehler etc.)<br />
<br />
===Artikel-Vorlage===<br />
'''Wichtiger Hinweis ''' : Bei der Funktionsübersicht ist v.a. eine einheitliche Gliederung der Artikel wichtig. Deshalb haltet euch bitte an '''[[Funktionsvorlage|folgende Vorlage]]'''!<br />
<br />
===Kategorisieren von Artikeln===<br />
Das Wiki ermöglicht es einen Artikel einer Kategorie zuzuordnen. Diese Möglichkeit sollte von Artikelschreibern genutzt werden.<br />
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:<br />
<br />
{| border="1" cellspacing="0"<br />
|+Beispiel<br />
|<br />
{| border="0" cellspacing="4"<br />
|<nowiki>[[Kategorie:GL|Name ohne "gl"]]</nowiki><br />
|}<br />
|}<br />
<br />
Das sind die neuen Kategorien:<br />
*[[:Kategorie:GL]]<br />
*[[:Kategorie:GLU]]<br />
*[[:Kategorie:GLX]]<br />
*[[:Kategorie:WGL]]<br />
<br />
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.<br />
<br />
== [[:Kategorie:GL|GL]] ==<br />
Abkürzung für '''G'''raphics '''L'''ibrary, hierunter fallen alle Funktionen die direkter Bestandteil (entweder als Kernfunktion oder über Extensions) der OpenGL sind.<br />
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.<br />
<br />
=== A ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glAccum]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glActiveTexture]]''' || {{Version_1_3}} || [[glActiveTextureARB]] || - || -<br />
|-<br />
|'''[[glAddSwapHintRectWIN]]''' || - || - || - || [[glAddSwapHintRectWIN]]<br />
|-<br />
|'''[[glAlphaFunc]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glAreTexturesResident]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glArrayElement]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glAttachShader]]''' || {{Version_2_0}} || [[glAttachObjectARB]]{{altIcon}} || - || -<br />
|-<br />
|}<br />
<br />
=== B ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glBegin]]'''{{excIcon}} || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glBeginQuery]]''' || {{Version_1_5}} || [[glBeginQueryARB]] || - || -<br />
|-<br />
|'''[[glBindAttribLocation]]''' || {{Version_2_0}} || [[glBindAttribLocationARB]] || - || -<br />
|-<br />
|'''[[glBindBuffer]]''' || {{Version_1_5}} || [[glBindBufferARB]] || - || -<br />
|-<br />
|'''[[glBindProgrammARB]]''' || - || [[glBindProgrammARB]] || - || -<br />
|-<br />
|'''[[glBindTexture]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glBitmap]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glBlendColor]]''' || {{Version_1_2}} || - || [[glBlendColorEXT]] || -<br />
|-<br />
|'''[[glBlendEquation]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glBlendEquationSeparate]]''' || {{Version_2_0}} || - || - || -<br />
|-<br />
|'''[[glBlendFunc]]'''{{excIcon}} || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glBlendFuncSeparate]]''' || {{Version_1_4}} || - || [[GL_EXT_blend_func_separate]]|| -<br />
|-<br />
|'''[[glBufferData]]''' || {{Version_1_5}} || [[glBufferDataARB]] || - || -<br />
|-<br />
|'''[[glBufferSubData]]''' || {{Version_1_5}} || [[glBufferSubDataARB]] || - || -<br />
|-<br />
|}<br />
<br />
=== C ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glCallList]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glCallLists]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glClear]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glClearAccum]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glClearColor]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glClearDepth]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glClearIndex]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glClearStencil]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glClientActiveTexture]]''' || {{Version_1_3}} || [[ClientActiveTextureARB]] || - || -<br />
|-<br />
|'''[[glClipPlane]]'''{{excIcon}} || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glColor]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glColorMask]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glColorMaterial]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glColorPointer]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glColorSubTable]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glColorTable]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glColorTableParameter]]''' || {{Version_1_2}}|| - || - <br />
|-<br />
|'''[[glCompileShader]]''' || {{Version_2_0}} || [[glCompileShaderARB]] || - || -<br />
|-<br />
|'''[[glCompressedTexSubImage]]''' || {{Version_1_3}} || - || - || -<br />
|-<br />
|'''[[glCompressedTexImage]]''' || {{Version_1_3}} || - || - || -<br />
|-<br />
|'''[[glConvolutionFilter1D]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glConvolutionFilter2D]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glConvolutionParameter]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glCopyColorSubTable]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glCopyColorTable]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glCopyConvolutionFilter]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glCopyPixels]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glCopyTexImage1D]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glCopyTexImage2D]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glCopyTexSubImage1D]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glCopyTexSubImage2D]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glCopyTexSubImage3D]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glCreateProgram]]''' || {{Version_2_0}} || [[glCreateProgramObjectARB]] || - || -<br />
|-<br />
|'''[[glCreateShader]]''' || {{Version_2_0}} || [[glCreateShaderObjectARB]] || - || -<br />
|-<br />
|'''[[glCullFace]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glCurrentPaletteMatrixARB]]''' || - || [[glCurrentPaletteMatrixARB]] || - || -<br />
|-<br />
|}<br />
<br />
=== D ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glDeleteBuffers]]''' || {{Version_1_5}} || [[glDeleteBuffersARB]] || - || -<br />
|-<br />
|'''[[glDeleteLists]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glDeleteProgram]]''' || {{Version_2_0}} || [[glDeleteObjectARB]] {{altIcon}} || - || -<br />
|-<br />
|'''[[glDeleteQueries]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glDeleteShader]]''' || {{Version_2_0}} || [[glDeleteObjectARB]] {{altIcon}} || - || -<br />
|-<br />
|'''[[glDeleteTextures]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glDepthFunc]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glDepthMask]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glDepthRange]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glDetachShader]]''' || {{Version_2_0}} || [[glDetachObjectARB]] || - || -<br />
|-<br />
|'''[[glDisable]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glDisableClientState]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glDisableVertexAttribArray]]''' || {{Version_2_0}} || [[glDisableVertexAttribArrayARB]] || - || -<br />
|-<br />
|'''[[glDrawArrays]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glDrawBuffer]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glDrawBuffers]]''' || {{Version_2_0}} || [[glDrawBufferARB]] || - || -<br />
|-<br />
|'''[[glDrawElements]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glDrawPixels]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glDrawRangeElements]]''' || {{Version_1_2}} || - || - || -<br />
|}<br />
<br />
=== E ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glEdgeFlag]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glEdgeFlagPointer]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glEnable]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glEnableClientState]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glEnableVertexAttribArray]]''' || {{Version_2_0}} || [[glEnableVertexAttribArrayARB]] || - || -<br />
|-<br />
|'''[[glEnd]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glEndList]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glEndQuery]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glEvalCoord]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glEvalMesh]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glEvalPoint]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== F ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glFeedbackBuffer]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glFinish]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glFlush]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glFog]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glFogCoord]]''' || {{Version_1_4}} || - || - || -<br />
|-<br />
|'''[[glFogCoordPointer]]''' || {{Version_1_4}} || - || - || -<br />
|-<br />
|'''[[glFrontFace]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glFrustum]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== G ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glGenBuffers]]''' || {{Version_1_5}} || [[glGenBuffersARB]] || - || -<br />
|-<br />
|'''[[glGenLists]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGenTextures]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glGenProgramsARB]]''' || - || [[glGenProgramsARB]] || - || -<br />
|-<br />
|'''[[glGenQueries]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glGet]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetActiveAttrib]]''' || {{Version_2_0}} || [[glGetActiveAttribARB]] || - || -<br />
|-<br />
|'''[[glGetActiveUniform]]''' || {{Version_2_0}} || [[glGetActiveUniformARB]] || - || -<br />
|-<br />
|'''[[glGetAttachedShaders]]''' || {{Version_2_0}} || [[glGetAttachedObjectsARB]] || - || -<br />
|-<br />
|'''[[glGetAttribLocation]]''' || {{Version_2_0}} || [[glGetAttribLocationARB]] || - || -<br />
|-<br />
|'''[[glGetBooleanv]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetBufferParameter]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glGetBufferPointerv]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glGetBufferSubData]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glGetClipPlane]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetColorTable]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glGetColorTableParameter]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glGetCompressedTexImage]]''' || {{Version_1_3}} || - || - || -<br />
|-<br />
|'''[[glGetConvolutionFilter]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glGetConvolutionParameter]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glGetDoublev]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetError]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetFloatv]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|''als Parameter von [[glGet#GL_CURRENT_PROGRAM|glGet]]'' || {{Version_2_0}} || [[glGetHandleARB]]{{altIcon}} || - || -<br />
|-<br />
|'''[[glGetHistogram]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glGetHistogramParameter]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glGetIntegerv]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetLight]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetMap]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetMaterial]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetMinmax]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glGetMinmaxParameter]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glGetPixelMap]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetPointerv]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetPolygonStipple]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetProgram]]''' || {{Version_2_0}} || [[glGetObjectParameterARB]]{{altIcon}} || - || -<br />
|-<br />
|'''[[glGetProgramEnvParameterARB]]''' || - || [[glGetProgramEnvParameterARB]] || - || -<br />
|-<br />
|'''[[glGetProgramInfoLog]]''' || {{Version_2_0}} || [[glGetInfoLogARB]]{{altIcon}} || - || -<br />
|-<br />
|'''[[glGetProgramLocalParameterARB]]''' || - || [[glGetProgramLocalParameterARB]] || - || -<br />
|-<br />
|'''[[glGetProgramStringARB]]''' || - || [[glGetProgramStringARB]] || - || -<br />
|-<br />
|'''[[glGetQueryiv]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glGetQueryObject]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glGetSeparableFilter]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glGetShader]]''' || {{Version_2_0}} || [[glGetObjectParameterARB]]{{altIcon}} || - || -<br />
|-<br />
|'''[[glGetShaderInfoLog]]''' || {{Version_2_0}} || [[glGetInfoLogARB]]{{altIcon}} || - || -<br />
|-<br />
|'''[[glGetShaderSource]]''' || {{Version_2_0}} || [[glGetShaderSourceARB]] || - || -<br />
|-<br />
|'''[[glGetString]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetTexEnv]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetTexGen]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetTexImage]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetTexLevelParameter]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetTexParameter]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glGetUniform]]''' || {{Version_2_0}} || [[glGetUniformARB]] || - || -<br />
|-<br />
|'''[[glGetUniformLocation]]''' || {{Version_2_0}} || [[glGetUniformLocationARB]]{{altIcon}} || - || -<br />
|-<br />
|'''[[glGetVertexAttrib]]''' || {{Version_2_0}} || [[glGetVertexAttribARB]] || - || -<br />
|-<br />
|'''[[glGetVertexAttribPointer]]''' || {{Version_2_0}} || [[glGetVertexAttribPointerARB]] || - || -<br />
|}<br />
<br />
=== H ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glHint]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glHistogram]]''' || {{Version_1_2}} || - || - || -<br />
|}<br />
<br />
=== I ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glIndex]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glIndexMask]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glIndexPointer]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glInitNames]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glInterleavedArrays]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glIsBuffer]]''' || {{Version_1_5}} || [[glIsBufferARB]] || - || -<br />
|-<br />
|'''[[glIsEnabled]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glIsList]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glIsProgram]]''' || {{Version_2_0}} || - || - || - <br />
|-<br />
|'''[[glIsQuery]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glIsShader]]''' || {{Version_2_0}} || - || - || -<br />
|-<br />
|'''[[glIsTexture]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== L ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glLight]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glLightModel]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glLineStipple]]'''{{excIcon}} || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glLineWidth]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glLinkProgram]]''' || {{Version_2_0}} || [[glLinkProgramARB]]{{altIcon}} || - || -<br />
|-<br />
|'''[[glListBase]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glLoadIdentity]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glLoadMatrix]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glLoadName]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glLoadTransposeMatrix]]''' || {{Version_1_3}} || - || - || -<br />
|-<br />
|'''[[glLogicOp]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== M ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glMap1]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glMap2]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glMapBuffer]]''' || {{Version_1_5}} || - || - || -<br />
|-<br />
|'''[[glMapGrid]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glMaterial]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glMatrixIndexARB]]''' || - || [[glMatrixIndexARB]] || - || -<br />
|-<br />
|'''[[glMatrixIndexPointerARB]]''' || - || [[glMatrixIndexPointerARB]] || - || -<br />
|-<br />
|'''[[glMatrixMode]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glMinmax]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glMultiDrawArrays]]''' || {{Version_1_4}} || - || - || -<br />
|-<br />
|'''[[glMultiDrawElements]]''' || {{Version_1_4}} || - || - || -<br />
|-<br />
|'''[[glMultiTexCoord]]''' || {{Version_1_3}} || - || - || -<br />
|-<br />
|'''[[glMultMatrix]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glMultTransposeMatrix]]''' || {{Version_1_3}} || - || - || -<br />
|}<br />
<br />
=== N ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glNewList]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glNormal]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glNormalPointer]]''' || {{Version_1_1}} || - || - || -<br />
|}<br />
<br />
=== 0 ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glOrtho]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== P ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glPassThrough]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPixelMap]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPixelStore]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPixelTransfer]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPixelZoom]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPointParameter]]''' || {{Version_1_4}} || [[glPointParameterARB]] || [[glPointParameterEXT]] || -<br />
|-<br />
|'''[[glPointSize]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPolygonMode]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPolygonOffset]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPolygonStipple]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPopAttrib]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPopClientAttrib]]''' || {{Version_1_0}} || - || - || - <br />
|-<br />
|'''[[glPopMatrix]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPopName]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPrioritizeTextures]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glProgramEnvParameterARB]]''' || - || [[glProgramEnvParameterARB]] || - || -<br />
|-<br />
|'''[[glProgramLocalParameterARB]]''' || - || [[glProgramLocalParameterARB]] || - || -<br />
|-<br />
|'''[[glProgramStringARB]]''' || - || [[glGetProgramStringARB]] || - || -<br />
|-<br />
|'''[[glPushAttrib]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPushClientAttrib]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPushMatrix]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glPushName]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== R ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glRasterPos]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glReadBuffer]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glReadPixels]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glRect]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glRenderMode]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glResetHistogram]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glResetMinmax]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glRotate]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== S ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glSampleCoverage]]''' || {{Version_1_3}} || [[glSampleCoverageARB]] || - || -<br />
|-<br />
|'''[[glScale]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glScissor]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glSecondaryColor]]''' || {{Version_1_4}} || - || - || -<br />
|-<br />
|'''[[glSecondaryColorPointer]]''' || {{Version_1_4}} || - || - || -<br />
|-<br />
|'''[[glSelectBuffer]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glSeparableFilter2D]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glShadeModel]]'''{{excIcon}} || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glShaderSource]]''' || {{Version_2_0}} || [[glShaderSourceARB]] || - || -<br />
|-<br />
|'''[[glStencilFunc]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glStencilMask]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glStencilOp]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== T ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glTexCoord]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glTexCoordPointer]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glTexEnv]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glTexGen]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glTexImage|glTexImage1D]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glTexImage|glTexImage2D]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glTexImage|glTexImage3D]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glTexParameter]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glTexSubImage1D]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glTexSubImage2D]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glTexSubImage3D]]''' || {{Version_1_2}} || - || - || -<br />
|-<br />
|'''[[glTranslate]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== U ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glUniform]]''' || {{Version_2_0}} || [[glUniformARB]] || - || -<br />
|-<br />
|'''[[glUniformMatrix]]''' || {{Version_2_0}} || [[glUniformMatrixARB]] || - || -<br />
|-<br />
|'''[[glUseProgram]]''' || {{Version_2_0}} || [[glUseProgramObjectARB]] ||- || -<br />
|-<br />
|'''[[glUnmapBuffer]]''' || {{Version_1_5}} || - || - || -<br />
|}<br />
<br />
=== V ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glValidateProgram]]''' || {{Version_2_0}} || [[glValidateProgramARB]] || - || -<br />
|-<br />
|'''[[glVertex]]''' || {{Version_1_0}} || - || - || -<br />
|-<br />
|'''[[glVertexAttrib]]''' || {{Version_2_0}} || [[glVertexAttribARB]] || - || -<br />
|-<br />
|'''[[glVertexAttribPointer]]''' || {{Version_2_0}} || [[glVertexAttrixPointerARB]] || - || -<br />
|-<br />
|'''[[glVertexBlendARB]]''' || - || [[glVertexBlendARB]] || - || -<br />
|-<br />
|'''[[glVertexPointer]]''' || {{Version_1_1}} || - || - || -<br />
|-<br />
|'''[[glViewport]]''' || {{Version_1_0}} || - || - || -<br />
|}<br />
<br />
=== W ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glWeightARB]]''' || - || [[glWeightARB]] || - || -<br />
|-<br />
|'''[[glWeightPointerARB]]''' || - || [[glWeightPointerARB]] || - || -<br />
|-<br />
|'''[[glWindowPos]]''' || {{Version_1_4}} || - || - || -<br />
|}<br />
<br />
== [[:Kategorie:GLU|GLU]] ==<br />
(Was ist die [[GLU]]?)<br />
<br />
=== B ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluBeginCurve]]''' || - || - || - || -<br />
|-<br />
|'''[[gluBeginPolygon]]''' || - || - || - || -<br />
|-<br />
|'''[[gluBeginSurface]]''' || - || - || - || -<br />
|-<br />
|'''[[gluBeginTrim]]''' || - || - || - || -<br />
|-<br />
|'''[[gluBuild1DMipmaps]]''' || - || - || - || -<br />
|-<br />
|'''[[gluBuild2DMipmaps]]''' || - || - || - || -<br />
|-<br />
|'''[[gluBuild3DMipmaps]]''' || - || - || - || -<br />
|}<br />
<br />
=== C ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluCylinder]]''' || - || - || - || -<br />
|}<br />
<br />
=== D ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluDeleteNurbsRenderer]]''' || - || - || - || -<br />
|-<br />
|'''[[gluDeleteQuadric]]''' || - || - || - || -<br />
|-<br />
|'''[[gluDeleteTess]]''' || - || - || - || -<br />
|-<br />
|'''[[gluDisk]]''' || - || - || - || -<br />
|}<br />
<br />
=== E ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluEndCurve]]''' || - || - || - || -<br />
|-<br />
|'''[[gluEndPolygon]]''' || - || - || - || -<br />
|-<br />
|'''[[gluEndSurface]]''' || - || - || - || -<br />
|-<br />
|'''[[gluEndTrim]]''' || - || - || - || -<br />
|-<br />
|'''[[gluErrorString]]''' || - || - || - || -<br />
|}<br />
<br />
=== G ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluGetNurbsProperty]]''' || - || - || - || -<br />
|-<br />
|'''[[gluGetString]]''' || - || - || - || -<br />
|-<br />
|'''[[gluGetTessProperty]]''' || - || - || - || -<br />
|}<br />
<br />
=== L ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluLoadSamplingMatrices]]''' || - || - || - || -<br />
|-<br />
|'''[[gluLookAt]]''' || - || - || - || -<br />
|}<br />
<br />
=== N ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluNewNurbsRenderer]]''' || - || - || - || -<br />
|-<br />
|'''[[gluNewQuadric]]''' || - || - || - || -<br />
|-<br />
|'''[[gluNewTess]]''' || - || - || - || -<br />
|-<br />
|'''[[gluNextContour]]''' || - || - || - || -<br />
|-<br />
|'''[[gluNurbsCallback]]''' || - || - || - || -<br />
|-<br />
|'''[[gluNurbsCurve]]''' || - || - || - || -<br />
|-<br />
|'''[[gluNurbsProperty]]''' || - || - || - || -<br />
|-<br />
|'''[[gluNurbsSurface]]''' || - || - || - || -<br />
|}<br />
<br />
=== O ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluOrtho2D]]''' || - || - || - || -<br />
|}<br />
<br />
=== P ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluPartialDisk]]'''{{excIcon}} || - || - || - || -<br />
|-<br />
|'''[[gluPerspective]]''' || - || - || - || -<br />
|-<br />
|'''[[gluPickMatrix]]''' || - || - || - || -<br />
|-<br />
|'''[[gluProject]]''' || - || - || - || -<br />
|-<br />
|'''[[gluPwlCurve]]''' || - || - || - || -<br />
|}<br />
<br />
=== Q ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluQuadricCallback]]''' || - || - || - || -<br />
|-<br />
|'''[[gluQuadricDrawStyle]]'''{{excIcon}} || - || - || - || -<br />
|-<br />
|'''[[gluQuadricNormals]]''' || - || - || - || -<br />
|-<br />
|'''[[gluQuadricOrientation]]''' || - || - || - || -<br />
|-<br />
|'''[[gluQuadricTexture]]''' || - || - || - || -<br />
|}<br />
<br />
=== S ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluScaleImage]]''' || - || - || - || -<br />
|-<br />
|'''[[gluSphere]]'''{{excIcon}} || - || - || - || -<br />
|}<br />
<br />
=== T ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluTessBeginContour]]''' || - || - || - || -<br />
|-<br />
|'''[[gluTessBeginPolygon]]''' || - || - || - || -<br />
|-<br />
|'''[[gluTessCallback]]''' || - || - || - || -<br />
|-<br />
|'''[[gluTessEndContour]]''' || - || - || - || -<br />
|-<br />
|'''[[gluTessEndPolygon]]''' || - || - || - || -<br />
|-<br />
|'''[[gluTessNormal]]''' || - || - || - || -<br />
|-<br />
|'''[[gluTessProperty]]''' {{icpIcon}} || - || - || - || -<br />
|-<br />
|'''[[gluTessVertex]]''' || - || - || - || -<br />
|}<br />
<br />
=== U ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[gluUnProject]]''' || - || - || - || -<br />
|}<br />
<br />
== [[:Kategorie:GLX|GLX]] ==<br />
(Was ist die [[GLX]]?)<br />
<br />
=== C ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXChooseVisual]]''' || - || - || - || -<br />
|-<br />
|'''[[glXCopyContext]]''' || - || - || - || -<br />
|-<br />
|'''[[glXCreateContext]]''' || - || - || - || -<br />
|-<br />
|'''[[glXCreateGLXPixmap]]''' || - || - || - || -<br />
|}<br />
<br />
=== D ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXDestroyContext]]''' || - || - || - || -<br />
|-<br />
|'''[[glXDestroyGLXPixmap]]''' || - || - || - || -<br />
|}<br />
<br />
=== F ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXFreeContextEXT]]''' || - || - || - || -<br />
|}<br />
<br />
=== G ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXGetClientString]]''' || - || - || - || -<br />
|-<br />
|'''[[glXGetConfig]]''' || - || - || - || -<br />
|-<br />
|'''[[glXGetCurrentContextIDEXT]]''' || - || - || - || -<br />
|-<br />
|'''[[glXGetCurrentContext]]''' || - || - || - || -<br />
|-<br />
|'''[[glXGetCurrentDisplay]]''' || - || - || - || -<br />
|-<br />
|'''[[glXGetCurrentDrawable]]''' || - || - || - || -<br />
|}<br />
<br />
=== I ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXImportContextEXT]]''' || - || - || - || -<br />
|-<br />
|'''[[glXIntro]]''' || - || - || - || -<br />
|-<br />
|'''[[glXIsDirect]]''' || - || - || - || -<br />
|}<br />
<br />
=== M ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXMakeCurrent]]''' || - || - || - || -<br />
|} <br />
<br />
=== Q ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXQueryContext]]''' || - || - || - || -<br />
|-<br />
|'''[[glXQueryContextInfoEXT]]''' || - || - || [[glXQueryContextInfoExt]] || -<br />
|-<br />
|'''[[glXQueryDrawable]]''' || - || - || - || -<br />
|-<br />
|'''[[glXQueryExtension]]''' || - || - || - || -<br />
|-<br />
|'''[[glXQueryExtensionsString]]''' || - || - || - || -<br />
|-<br />
|'''[[glXQueryServerString]]''' || - || - || - || -<br />
|-<br />
|'''[[glXQueryVersion]]''' || - || - || - || -<br />
|}<br />
<br />
=== S ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXSwapBuffers]]''' || - || - || - || -<br />
|}<br />
<br />
=== U ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXUseXFont]]''' || - || - || - || -<br />
|}<br />
<br />
=== W ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[glXWaitGL]]''' || - || - || - || -<br />
|-<br />
|'''[[glXWaitX]]''' || - || - || - || -<br />
|}<br />
<br />
== [[:Kategorie:WGL|WGL]] ==<br />
(Was ist die [[WGL]]?)<br />
<br />
=== C ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[wglChoosePixelFormatARB]]''' || - || [[wglChoosePixelFormatARB]] || - || - <br />
|-<br />
|'''[[wglCopyContext]]''' || - || - || - || - <br />
|-<br />
|'''[[wglCreateContext]]''' || - || - || - || - <br />
|-<br />
|'''[[wglCreateBufferRegionEXT]]''' || - || - || [[wglCreateBufferRegionEXT]] || - <br />
|-<br />
|'''[[wglCreateLayerContext]]''' || - || - || - || - <br />
|-<br />
|'''[[wglCreatePbufferARB]]''' || - || [[wglCreatePbufferARB]] || - || - <br />
|}<br />
<br />
=== D ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[wglDeleteBufferRegionEXT]]''' || - || - || [[wglDeleteBufferRegionEXT]] || - <br />
|-<br />
|'''[[wglDeleteContext]]''' || - || - || - || - <br />
|-<br />
|'''[[wglDestroyPbufferARB]]''' || - || [[wglDestroyPbufferARB]] || - || - <br />
|-<br />
|'''[[wglDescribeLayerPlane]]''' || - || - || - || - <br />
|}<br />
<br />
=== G ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[wglGetCurrentContext]]''' || - || - || - || - <br />
|-<br />
|'''[[wglGetCurrentDC]]''' || - || - || - || - <br />
|-<br />
|'''[[wglGetCurrentReadDC]]''' || - || - || - || - <br />
|-<br />
|'''[[wglGetExtensionsStringARB]]''' || - || [[wglGetExtensionsStringARB]] || - || - <br />
|-<br />
|'''[[wglGetLayerPaletteEntries]]''' || - || - || - || - <br />
|-<br />
|'''[[wglGetPbufferDCARB]]''' || - || [[wglGetPbufferDVARB]] || - || - <br />
|-<br />
|'''[[wglGetPixelFormatAttribARB]]''' || - || [[wglGetPixelFormatAttribARB]] || - || - <br />
|-<br />
|'''[[wglGetPixelFormatAttribEXT]]''' || - || - || [[wglGetPixelFormatAttrixExt]] || - <br />
|-<br />
|'''[[wglGetProcAddress]]''' || - || - || - || - <br />
|}<br />
<br />
=== M ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[wglMakeCurrent]]''' || - || - || - || - <br />
|-<br />
|'''[[wglMakeCurrentContextEXT]]''' || - || - || [[wglMakeCurrentContextEXT]] || -<br />
|}<br />
<br />
=== Q ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[wglQueryPbufferARB]]''' || - || [[wglQueryPbufferARB]] || - || -<br />
|}<br />
<br />
=== R ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[wglRealizeLayerPalette]]''' || - || - || - || - <br />
|-<br />
|'''[[wglReleasePbufferDCARB]]''' || - || [[wglReleasePbufferDCARB]] || - || - <br />
|-<br />
|'''[[wglRestoreBufferRegionEXT]]''' || - || - || [[wglRestoreBufferRegionEXT]] || - <br />
|}<br />
<br />
=== S ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[wglSaveBufferRegionEXT]]''' || - || - || [[wglSaveBufferRegionExt]] || - <br />
|-<br />
|'''[[wglSetLayerPaletteEntries]]''' || - || - || - || - <br />
|-<br />
|'''[[wglShareLists]]''' || - || - || - || - <br />
|-<br />
|'''[[wglSwapIntervalEXT]]''' || - || - || [[wglSwapIntervalEXT]] || - <br />
|-<br />
|'''[[wglSwapLayerBuffers]]''' || - || - || - || - <br />
|}<br />
<br />
=== U ===<br />
{|{{Prettytable_B1}} style="width:100%"<br />
!width="25%"|Aktuelle Version <br />
!width="15%"|Kernfunktion (seit)<br />
!width="20%"|ARB Entsprechung<br />
!width="20%"|EXT Entsprechung<br />
!width="20%"|Herstellerspezifisch<br />
|-<br />
|'''[[wglUseFontBitmaps]]''' || - || - || - || -<br />
|-<br />
|'''[[wglUseFontOutlines]]''' || - || - || - || -<br />
|}<br />
<br />
== Externe Funktionen ==<br />
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.<br />
<br />
=== Win32 Funktionen ===<br />
{|{{Prettytable_B1}}<br />
|-<br />
|'''[[ChoosePixelFormat]]'''<br />
|-<br />
|'''[[DescribePixelFormat]]'''<br />
|-<br />
|'''[[GetPixelFormat]]'''<br />
|-<br />
|'''[[SetPixelFormat]]'''<br />
|-<br />
|'''[[SwapBuffers]]'''<br />
|-<br />
|'''[[GetLastError]]'''<br />
|}<br />
<br />
=== Linux / Unix Funktionen ===<br />
{|{{Prettytable_B1}}<br />
|-<br />
|'''[[XCloseDisplay]]'''<br />
|-<br />
|'''[[XDefaultScreen]]'''<br />
|-<br />
|'''[[XOpenDisplay]]'''<br />
|}<br />
<br />
===Siehe auch===<br />
[[OpenAL-Funktionsübersicht]], [[SDL-Funktionsübersicht]]<br />
<br />
== OpenGL Parameter-Tabellen ==<br />
Hier gehören alle Parameter-Tabellen hin. Dies sind Listen von Parametern, die bei vielen OpenGL-Funktionen immer wieder auftauchen.<br />
<br />
[[internes Pixelformat|interne Pixelformate]]<br><br />
[[Pixelformat|Pixelformate]]<br><br />
[[Pixeldatentyp|Datentypen für Pixel]]<br></div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21945GL ARB multisample2008-07-12T16:55:57Z<p>Traude: /* Anwendung */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
<br />
== Abhängigkeiten ==<br />
GL_ARB_multisample ist abhängig von folgenden Extensions: <br><br />
'''[[WGL_ARB_extensions_string]]''' <br><br />
'''[[WGL_ARB_pixel_format]]''' <br><br />
<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean); <br><br />
<br />
<br />
Die Prozedur SampleCoverageARB setzt die beiden Werte SAMPLE_COVERAGE_VALUE_ARB und SAMPLE_COVERAGE_INVERT_ARB. <br><br />
<br><br />
Wenn SAMPLE_COVERAGE_ARB aktiviert ist, wird die ermittelte Fragmentüberdeckung mit einem temporären Überdeckungswert einer bitweisen "And"-Operation unterzogen. Dieser temporäre Überdeckungswert wird mit einer Funktion erzeugt, deren Input der Wert von SAMPLE_COVERAGE_VALUE_ARB ist (die Funktion wurde nicht näher spezifiziert). Wenn SAMPLE_COVERAGE_INVERT auf "TRUE" gesetzt ist, wird der temporäre Überdeckungswert invertiert (alle Bitwerte werden invertiert), bevor der And-Operator angewendet wird.<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von wglChoosePixelFormatARB:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
== Anwendung ==<br />
<br />
HINWEIS: Die folgenden Erläuterungen gelten nur für Windows: <br><br />
Das Multisampling wird mithilfe der Prozedur [[wglChoosePixelFormatARB]] ausgewählt, mit der Windows API Prozedur SetPixelFormat gesetzt und anschließend kann ein Rendering Context mit [[wglCreateContext]] erstellt werden. <br />
<br />
Das erfordert aber eine besondere Vorgangsweise, denn die Prozedur wglChoosePixelFormatARB ist ebenfalls Bestandteil einer Extension, und Extensions stehen nur zur Verfügung, wenn bereits ein Rendering Context aktiviert ist. Da für einen Rendering Context anläßlich der Erstellung nur einmal ein Pixelformat vergeben werden darf, kann man das Multisampling-Pixelformat auf diese Weise zwar in Erfahrung bringen, aber nicht mehr setzen.<br />
<br />
Daher ist die korrekte Vorgangsweise die Folgende: <br><br />
1. Einen temporären Rendering Context mit einem gültigen Pixelformat erstellen <br><br />
2. Prüfen, ob ein Pixelformat mit Multisampling zur Verfügung steht und das Ergebnis speichern <br><br />
3. Den temporären Context wieder löschen <br><br />
4. Einen neuen Rendering Context aufgrund des Ergebnisses gemäß Pkt.2 erstellen. <br><br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21944GL ARB multisample2008-07-12T16:32:50Z<p>Traude: /* Neue Tokens */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
<br />
== Abhängigkeiten ==<br />
GL_ARB_multisample ist abhängig von folgenden Extensions: <br><br />
'''[[WGL_ARB_extensions_string]]''' <br><br />
'''[[WGL_ARB_pixel_format]]''' <br><br />
<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean); <br><br />
<br />
<br />
Die Prozedur SampleCoverageARB setzt die beiden Werte SAMPLE_COVERAGE_VALUE_ARB und SAMPLE_COVERAGE_INVERT_ARB. <br><br />
<br><br />
Wenn SAMPLE_COVERAGE_ARB aktiviert ist, wird die ermittelte Fragmentüberdeckung mit einem temporären Überdeckungswert einer bitweisen "And"-Operation unterzogen. Dieser temporäre Überdeckungswert wird mit einer Funktion erzeugt, deren Input der Wert von SAMPLE_COVERAGE_VALUE_ARB ist (die Funktion wurde nicht näher spezifiziert). Wenn SAMPLE_COVERAGE_INVERT auf "TRUE" gesetzt ist, wird der temporäre Überdeckungswert invertiert (alle Bitwerte werden invertiert), bevor der And-Operator angewendet wird.<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von wglChoosePixelFormatARB:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
== Anwendung ==<br />
<br />
HINWEIS: Die folgenden Erläuterungen gelten nur für Windows: <br><br />
Das Multisampling wird mithilfe der Prozedur wglChoosePixelFormatARB ausgewählt, mit der Prozedur SetPixelFormat gesetzt und anschließend kann ein Rendering Context erstellt werden. <br />
<br />
Das ist problematisch, wenn nicht bekannt ist, ob auf dem gegebenen System die Extension GL_ARB_multisample zur Verfügung steht. Denn die Prozedur wglChoosePixelFormatARB ist ebenfalls Bestandteil einer Extension, und Extensions stehen nur zur Verfügung, wenn bereits ein Rendering Context aktiviert ist. Da für einen Rendering Context anläßlich der Erstellung nur einmal ein Pixelformat vergeben wird, kann man das Multisampling-Pixelformat auf diese Weise zwar in Erfahrung bringen, aber nicht mehr setzen.<br />
<br />
Daher ist die korrekte Vorgangsweise auf einem unbekannten System die Folgende: <br><br />
1. Einen temporären Rendering Context mit einem gültigen Pixelformat erstellen <br><br />
2. Prüfen, ob ein Pixelformat mit Multisampling zur Verfügung steht und das Ergebnis speichern <br><br />
3. Den temporären Context wieder löschen <br><br />
4. Einen neuen Rendering Context aufgrund des Ergebnisses gemäß Pkt.2 erstellen. <br><br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21943GL ARB multisample2008-07-12T16:25:29Z<p>Traude: /* Neue Prozeduren */ Beschreibung der Funktion SampleCoverageARB hinzugefügt</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
<br />
== Abhängigkeiten ==<br />
GL_ARB_multisample ist abhängig von folgenden Extensions: <br><br />
'''[[WGL_ARB_extensions_string]]''' <br><br />
'''[[WGL_ARB_pixel_format]]''' <br><br />
<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean); <br><br />
<br />
<br />
Die Prozedur SampleCoverageARB setzt die beiden Werte SAMPLE_COVERAGE_VALUE_ARB und SAMPLE_COVERAGE_INVERT_ARB. <br><br />
<br><br />
Wenn SAMPLE_COVERAGE_ARB aktiviert ist, wird die ermittelte Fragmentüberdeckung mit einem temporären Überdeckungswert einer bitweisen "And"-Operation unterzogen. Dieser temporäre Überdeckungswert wird mit einer Funktion erzeugt, deren Input der Wert von SAMPLE_COVERAGE_VALUE_ARB ist (die Funktion wurde nicht näher spezifiziert). Wenn SAMPLE_COVERAGE_INVERT auf "TRUE" gesetzt ist, wird der temporäre Überdeckungswert invertiert (alle Bitwerte werden invertiert), bevor der And-Operator angewendet wird.<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von [[wglChoosePixelFormatARB]]:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
<br />
== Anwendung ==<br />
<br />
HINWEIS: Die folgenden Erläuterungen gelten nur für Windows: <br><br />
Das Multisampling wird mithilfe der Prozedur wglChoosePixelFormatARB ausgewählt, mit der Prozedur SetPixelFormat gesetzt und anschließend kann ein Rendering Context erstellt werden. <br />
<br />
Das ist problematisch, wenn nicht bekannt ist, ob auf dem gegebenen System die Extension GL_ARB_multisample zur Verfügung steht. Denn die Prozedur wglChoosePixelFormatARB ist ebenfalls Bestandteil einer Extension, und Extensions stehen nur zur Verfügung, wenn bereits ein Rendering Context aktiviert ist. Da für einen Rendering Context anläßlich der Erstellung nur einmal ein Pixelformat vergeben wird, kann man das Multisampling-Pixelformat auf diese Weise zwar in Erfahrung bringen, aber nicht mehr setzen.<br />
<br />
Daher ist die korrekte Vorgangsweise auf einem unbekannten System die Folgende: <br><br />
1. Einen temporären Rendering Context mit einem gültigen Pixelformat erstellen <br><br />
2. Prüfen, ob ein Pixelformat mit Multisampling zur Verfügung steht und das Ergebnis speichern <br><br />
3. Den temporären Context wieder löschen <br><br />
4. Einen neuen Rendering Context aufgrund des Ergebnisses gemäß Pkt.2 erstellen. <br><br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=WGL_ARB_pixel_format&diff=21941WGL ARB pixel format2008-07-12T09:35:13Z<p>Traude: /* Ressourcen */ Spezifikations-Link berichtigt</p>
<hr />
<div>{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
<br />
== Abfragestring ==<br />
WGL_ARB_pixel_format<br />
<br />
== Beschreibung ==<br />
Diese Extension ersetzt die Funktionen [[GetPixelFormat]] und [[ChoosePixelFormat]] durch flexieblere Funktionen welche eine Parameterliste variabler Länge erhalten können.<br />
<br />
== Verwendung ==<br />
Nachdem man mit [[wglChoosePixelFormatARB]] im Array piFormats die (Integer-) ID eines Pixel Formates erhalten hat, und mit [[wglGetPixelFormatAttribARB]] geprüft hat ob die nicht spezifiezierten Anforderungen ebenfalls passen, setzt man mittels [[SetPixelFormat]]( hdc, Pixel-Format-ID, NIL ); das gewünschte Format.<br />
<br />
== Neue Funktionen ==<br />
* [[wglChoosePixelFormatARB]]<br />
* [[wglGetPixelFormatAttribARB]]<br />
<br />
== Neue Tokens ==<br />
Folgende Attribute können bei [[wglChoosePixelFormatARB]] in der ''piAttribIList'' und der ''pfAttribFList'' Liste angegeben werden. Der in dieser Liste darauffolgende Wert muss einem Wert eines bestimmten Datentyps entsprechen und wird teils als exaktes und teils als minimum - Kriterium bei der Suche nach Pixel Formaten verwendet.<br />
Die selben Attribute werden auch für ''piAttributes'' von [[wglGetPixelFormatAttribARB]] verwendet.<br />
{| border=1 rules=all<br />
|'''Attribut'''<br />
|'''Hex-Code'''<br />
|'''Datentyp'''<br />
|'''Kriterientyp'''<br />
|'''Beschreibung'''<br />
|-<br />
|'''WGL_NUMBER_PIXEL_FORMATS_ARB'''<br />
|0x2000<br />
|integer<br />
|ignoriert<br />
|Die Anzahl der Pixel Formate für diesen Device Context. Der iLayerPlane- und iPixelFormat-Parameter wird ignoriert wenn dieses Attribut angegeben wird.<br />
|-<br />
|'''WGL_DRAW_TO_WINDOW_ARB'''<br />
|0x2001<br />
|boolean<br />
|exakt<br />
|True wenn das Pixel Format für ein Fenster verwendet werden kann. Der iLayerPlane Parameter wird ignoriert wenn dieses Attribut angegeben wird.<br />
|-<br />
|'''WGL_DRAW_TO_BITMAP_ARB'''<br />
|0x2002<br />
|boolean<br />
|exakt<br />
|True wenn dieses Pixel Format für ein Bitmap verwendet werden kann. Der iLayerPlane Parameter wird ignoriert wenn dieses Attribut angegeben wird.<br />
|-<br />
|'''WGL_ACCELERATION_ARB'''<br />
|0x2003<br />
|enum<br />
|exakt<br />
|Gibt an wie dieses Pixel Format vom Treiber unterstützt wird. '''WGL_NO_ACCELERATION_ARB''' untestützt nur software rendering. Bei '''WGL_GENERIC_ACCELERATION_ARB''' wird dieses Pixel Format von einem MCD Treiber unterstützt. Mit '''WGL_FULL_ACCELERATION_ARB''' wird dieses Pixel Format von einem ICD Treiber unterstütz.<br />
|-<br />
|'''WGL_NEED_PALETTE_ARB'''<br />
|0x2004<br />
|boolean<br />
|exakt<br />
|Eine logische Palette ist erforderlich um die besten Resultate mit diesem Pixel Format zu erzielen. Der iLayerPlane Parameter wird ignoeriert wenn dieses Attribut angegeben wird.<br />
|-<br />
|'''WGL_NEED_SYSTEM_PALETTE_ARB'''<br />
|0x2005<br />
|boolean<br />
|exakt<br />
|Die Hardware unterstützung nur eine Hardware Palette in 256-Farben Modus. Der iLayerPlane Parameter wird ignoriert wenn dieses Attribut angegeben wird.<br />
|-<br />
|'''WGL_SWAP_LAYER_BUFFERS_ARB'''<br />
|0x2006<br />
|boolean<br />
|exakt<br />
|True wenn das Pixel Format das swappen von Layer Ebenen unabhängig von der haupt-Ebene unterstützt. Wenn das Pixel Format keine Back-Puffer unterstützt, so ist dieser Wert False. Der iLayerPlane Parameter wird ignoriert wenn dieses Attribut angegeben wird.<br />
|-<br />
|'''WGL_SWAP_METHOD_ARB'''<br />
|0x2007<br />
|enum<br />
|exakt<br />
|Wenn das Pixel Format einen Back-Buffer unterstützt, so gibt dieser Wert an wie geswapped wird. Wenn das Attribut auf '''WGL_SWAP_EXCHANGE_ARB''' gesetzt ist, so wird der Front- und der Back-Puffer ausgetauscht. Wenn er auf '''WGL_SWAP_COPY_ARB''' gesetzt ist, so wird beim swapping der Inhalt des Back-Puffers in den Front-Puffer kopiert. Wenn er auf '''WGL_SWAP_UNDEFINED_ARB''' gesetzt ist, so wird der Inhalt des Back-Puffers in den Front-Puffer kopiert, jedoch ist der Inhalt des Back-Puffers nach dieser Operation undefiniert. Wenn dieses Pixel Format keinen Back-Puffer untestützt, so ist dieser Wert WGL_SWAP_UNDEFINED_ARB. Der iLayerPlane Parameter wird ignoriert wenn dieses Attribut angegeben wird.<br />
|-<br />
|'''WGL_NUMBER_OVERLAYS_ARB'''<br />
|0x2008<br />
|integer<br />
|minimum<br />
|Die Anzahl der darüber liegenden Ebenen. Der iLayerPlane-Parameter wird ignoriert wenn dieses Attribut angegeben wird.<br />
|-<br />
|'''WGL_NUMBER_UNDERLAYS_ARB'''<br />
|0x2009<br />
|integer<br />
|minimum<br />
|Die Anzahl der darunter liegenden Ebenen. Der iLayerPlane-Parameter wird ignoriert wenn dieses Attribut angegeben wird.<br />
|-<br />
|'''WGL_TRANSPARENT_ARB'''<br />
|0x200A<br />
|boolean<br />
|ignoriert<br />
|True wenn Transparenz unterstützt wird.<br />
|-<br />
|'''WGL_TRANSPARENT_RED_VALUE_ARB'''<br />
|0x2037<br />
|integer<br />
|ignoriert<br />
|Gibt den Transparenten Rotwert an. Typischer weise ist dieser Wert für alle Layer-Ebenen gleich. Dieser Wert ist undefiniert wenn keine Transparenz unterstützt wird.<br />
|-<br />
|'''WGL_TRANSPARENT_GREEN_VALUE_ARB'''<br />
|0x2038<br />
|integer<br />
|ignoriert<br />
|Gibt den Transparenten Grünwert an. Typischer weise ist dieser Wert für alle Layer-Ebenen gleich. Dieser Wert ist undefiniert wenn keine Transparenz unterstützt wird.<br />
|-<br />
|'''WGL_TRANSPARENT_BLUE_VALUE_ARB'''<br />
|0x2039<br />
|integer<br />
|ignoriert<br />
|Gibt den Transparenten Blauwert an. Typischer weise ist dieser Wert für alle Layer-Ebenen gleich. Dieser Wert ist undefiniert wenn keine Transparenz unterstützt wird.<br />
|-<br />
|'''WGL_TRANSPARENT_ALPHA_VALUE_ARB'''<br />
|0x203A<br />
|integer<br />
|ignoriert<br />
|Gibt den Transparenten Alpha Wert an. Reserviert für zukünftige Erweiterungen!<br />
|-<br />
|'''WGL_TRANSPARENT_INDEX_VALUE_ARB'''<br />
|0x203B<br />
|integer<br />
|ignoriert<br />
|Gibt den Transparenten Color-Index Wert an. Typischer weise ist dieser Wert für alle Layer-Ebenen gleich. Dieser Wert ist undefiniert wenn keine Transparenz unterstützt wird.<br />
|-<br />
|'''WGL_SHARE_DEPTH_ARB'''<br />
|0x200C<br />
|boolean<br />
|exakt<br />
|True wenn die Layer-ebenen den Tiefenpuffer mit der haupt-Ebene teilen. Wenn iLayerPlane 0 ist, so ist dieser Wert immer True.<br />
|-<br />
|'''WGL_SHARE_STENCIL_ARB'''<br />
|0x200D<br />
|boolean<br />
|exakt<br />
|True wenn die Layer-Ebenen den Stencil-Puffer mit der haupt-Ebene teilen. Wenn iLayerPlane 0 ist, so ist dieser Wert immer True.<br />
|-<br />
|'''WGL_SHARE_ACCUM_ARB'''<br />
|0x200E<br />
|boolean<br />
|exakt<br />
|True wenn die Layer-Ebenen den Accumulations-Puffer mit der haupt-Ebene teilen. Wenn iLayerPlane 0 ist, so ist dieser Wert immer True.<br />
|-<br />
|'''WGL_SUPPORT_GDI_ARB'''<br />
|0x200F<br />
|boolean<br />
|exakt<br />
|True wenn GDI rendering untestützt wird.<br />
|-<br />
|'''WGL_SUPPORT_OPENGL_ARB'''<br />
|0x2010<br />
|boolean<br />
|exakt<br />
|True wenn [[OpenGL]] unterstützt wird.<br />
|-<br />
|'''WGL_DOUBLE_BUFFER_ARB'''<br />
|0x2011<br />
|boolean<br />
|exakt<br />
|True wenn der Farb-Puffer ein vorne/hinten Paar hat.<br />
|-<br />
|'''WGL_STEREO_ARB'''<br />
|0x2012<br />
|boolean<br />
|exakt<br />
|True wenn der Farb-Puffer ein links/rechts Paar hat.<br />
|-<br />
|'''WGL_PIXEL_TYPE_ARB'''<br />
|0x2013<br />
|enum<br />
|exakt<br />
|Der Typ der Pixel Daten. Kann WGL_TYPE_RGBA_ARB oder WGL_TYPE_COLORINDEX_ARB sein.<br />
|-<br />
|'''WGL_COLOR_BITS_ARB'''<br />
|0x2014<br />
|integer<br />
|minimum<br />
|Die Anzahl der Bits für jeden Farb-Puffer. Für RGBA-Pixel ist es die Bittiefe des Farb-Puffers ohne die Alpha-Bits. Für Farb-Index Pixel ist es die Anzahl der Bits für den Farb-Index-Puffer.<br />
|-<br />
|'''WGL_RED_BITS_ARB'''<br />
|0x2015<br />
|integer<br />
|minimum<br />
|Die Anzahl der Bits für den Rotwert im Farb-Puffer.<br />
|-<br />
|'''WGL_RED_SHIFT_ARB'''<br />
|0x2016<br />
|integer<br />
|ignoriert<br />
|Der Shift-Wert für die Rotwert-Bits im Farb-Puffer.<br />
|-<br />
|'''WGL_GREEN_BITS_ARB'''<br />
|0x2017<br />
|integer<br />
|minimum<br />
|Die Anzahl der Bits für den Grünwert im Farb-Puffer.<br />
|-<br />
|'''WGL_GREEN_SHIFT_ARB'''<br />
|0x2018<br />
|integer<br />
|ignoriert<br />
|Der Shift-Wert für die Grünwert-Bits im Farb-Puffer.<br />
|-<br />
|'''WGL_BLUE_BITS_ARB'''<br />
|0x2019<br />
|integer<br />
|minimum<br />
|Die Anzahl der Bits für den Blauwert im Farb-Puffer.<br />
|-<br />
|'''WGL_BLUE_SHIFT_ARB'''<br />
|0x201A<br />
|integer<br />
|ignoriert<br />
|Der Shift-Wert für die Blauwert-Bits im Farb-Puffer.<br />
|-<br />
|'''WGL_ALPHA_BITS_ARB'''<br />
|0x201B<br />
|integer<br />
|minimum<br />
|Die Anzahl der Bits für den Alphawert im Farb-Puffer.<br />
|-<br />
|'''WGL_ALPHA_SHIFT_ARB'''<br />
|0x201C<br />
|integer<br />
|minimum<br />
|Der Shift-Wert für die Alphawert-Bits im Farb-Puffer.<br />
|-<br />
|'''WGL_ACCUM_BITS_ARB'''<br />
|0x201D<br />
|integer<br />
|minimum<br />
|Die gesamt Bittiefe des Accumulations Buffers.<br />
|-<br />
|'''WGL_ACCUM_RED_BITS_ARB'''<br />
|0x201E<br />
|integer<br />
|minimum<br />
|Die Anzahl der Bits für den Rotwert im Accumulations Puffer.<br />
|-<br />
|'''WGL_ACCUM_GREEN_BITS_ARB'''<br />
|0x201F<br />
|integer<br />
|minimum<br />
|Die Anzahl der Bits für den Grünwert im Accumulations Puffer.<br />
|-<br />
|'''WGL_ACCUM_BLUE_BITS_ARB'''<br />
|0x2020<br />
|integer<br />
|minimum<br />
|Die Anzahl der Bits für den Blauwert im Accumulations Puffer.<br />
|-<br />
|'''WGL_ACCUM_ALPHA_BITS_ARB'''<br />
|0x2021<br />
|integer<br />
|minimum<br />
|Die Anzahl der Bits für den Alphawert im Accumulations Puffer.<br />
|-<br />
|'''WGL_DEPTH_BITS_ARB'''<br />
|0x2022<br />
|integer<br />
|minimum<br />
|Die Bittiefe des Tiefenpuffers.<br />
|-<br />
|'''WGL_STENCIL_BITS_ARB'''<br />
|0x2023<br />
|integer<br />
|minimum<br />
|Die Bittiefe des Stencil Puffers.<br />
|-<br />
|'''WGL_AUX_BUFFERS_ARB'''<br />
|0x2024<br />
|integer<br />
|minimum<br />
|Die Anzahl der auxiliary Puffer.<br />
|}<br />
<br />
Akzeptiert als Wert im ''piAttribIList'' und ''pfAttribFList'' Parameter von [[wglChoosePixelFormatARB]], und zurückgegeben im ''piValues'' Array von [[wglGetPixelFormatAttribARB|wglGetPixelFormatAttribivARB]] und im ''pfValues'' Array von [[wglGetPixelFormatAttribARB|wglGetPixelFormatAttribfvARB]].<br />
Für eine gülte Verwendung und Beschreibung siehe die entsprechenden Einträge der obigen Attrib-Liste.<br />
{| border=1 rules=all<br />
|'''Bezeichnung'''<br />
|'''Hex-Code'''<br />
|'''Verwendung bei'''<br />
|-<br />
|'''WGL_NO_ACCELERATION_ARB'''<br />
|0x2025<br />
|WGL_ACCELERATION_ARB<br />
|-<br />
|'''WGL_GENERIC_ACCELERATION_ARB'''<br />
|0x2026<br />
|WGL_ACCELERATION_ARB<br />
|-<br />
|'''WGL_FULL_ACCELERATION_ARB'''<br />
|0x2027<br />
|WGL_ACCELERATION_ARB<br />
|-<br />
|'''WGL_SWAP_EXCHANGE_ARB'''<br />
|0x2028<br />
|WGL_SWAP_METHOD_ARB<br />
|-<br />
|'''WGL_SWAP_COPY_ARB'''<br />
|0x2029<br />
|WGL_SWAP_METHOD_ARB<br />
|-<br />
|'''WGL_SWAP_UNDEFINED_ARB'''<br />
|0x202A<br />
|WGL_SWAP_METHOD_ARB<br />
|-<br />
|'''WGL_TYPE_RGBA_ARB'''<br />
|0x202B<br />
|WGL_PIXEL_TYPE_ARB<br />
|-<br />
|'''WGL_TYPE_COLORINDEX_ARB'''<br />
|0x202C<br />
|WGL_PIXEL_TYPE_ARB<br />
|}<br />
<br />
== Abhängigkeiten ==<br />
*[[WGL_ARB_extensions_string]] wird für die Abfrage ob die Extension vorhanden ist verwendet<br />
<br />
== Ressourcen ==<br />
[http://www.delphi3d.net/hardware/extsupport.php?extension=WGL_ARB_pixel_format Hardware Unterstützung]<br><br />
[http://www.opengl.org/registry/specs/ARB/wgl_pixel_format.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=WGL_ARB_extensions_string&diff=21940WGL ARB extensions string2008-07-12T09:32:35Z<p>Traude: /* Ressourcen */ Spezifikations-Linkt berichtigt</p>
<hr />
<div>{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
<br />
== Abfragestring ==<br />
WGL_ARB_extensions_string<br />
<br />
<br />
== Beschreibung ==<br />
Diese Extension erlaubt es einer Applikation abzufragen welche WGL-Extensions unterstützt werden. Sie bildet die Grundlage für alle anderen WGL-Extensions. Dazu wird die neue Funktion '''wglGetExtensionStringARB''' eingeführt welche einen String mit den Bezeichnern aller unterstützten WGL Extensions zurückliefert.<br />
<br />
=== Verwendung ===<br />
Rufen Sie [[wglGetExtensionsStringARB]] auf um zu überprüfen welche WGL Versionen unterstützt werden.<br />
<br />
=== Hinweise ===<br />
Der Extension String (WGL_ARB_extensions_string) ist nicht in [[glGetString]]( GL_EXTENSIONS ) enthalten! Es sollte mittels [[wglGetProcAddress]] abgefragt werden ob [[wglGetExtensionsStringARB]] vorhanden ist. Wenn ja, wird die Extension unterstützt.<br />
<br />
<br />
== Neue Funktionen ==<br />
*[[wglGetExtensionsStringARB]]<br />
<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[http://www.delphi3d.net/hardware/extsupport.php?extension=WGL_ARB_extensions_string Hardware Unterstützung]<br><br />
[http://www.opengl.org/registry/specs/ARB/wgl_extensions_string.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_texture_cube_map&diff=21939GL ARB texture cube map2008-07-12T09:00:42Z<p>Traude: /* Ressourcen */ Spezifikations-Link berichtigt</p>
<hr />
<div>= GL_ARB_texture_cube_map =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_texture_cube_map<br />
<br />
<br />
<br />
== Beschreibung ==<br />
Wie der Name zumindest ansatzweise vermuten lässt, handelt es sich hier um ein neues Texturenziel (neben 1D-, 2D- und 3D-Texturen), dass aus insgesamt 6 2D-Texturen besteht die einen Würfel (=Cube) beschreiben. Beim Rendern werden dann die s,t und r-Texturkoordinaten als Richtungsvektoren genutzt, um den passenden Texel der passenden Würfelseite zu ermitteln. Um diese Cubemaps auch sinnvoll nutzen zu können, wurden zwei neue Modi für die automatische Generierung von Texturkoordinaten eingeführt :<br />
<br />
=== '''GL_NORMAL_MAP_ARB''' ===<br />
In diesem Modus werden die (s,t,r)-Texturkoordinaten anhand der transformierten Vertexnormale (im Betrachterraum(EyeSpace)) ermittelt. Mittels dieser Methode kann man Cubemaps für erweiterte (und Per-Pixel!) Beleuchtungsmodelle nutzen, die sonst nur unter Verwendung von [[Shader|Shadern]] möglich wären.<br />
<br />
=== '''GL_REFLECTION_MAP_ARB''' ===<br />
Hier werden die (s,t,r)-Texturkoordinaten entsprechend des Reflektionsvektors des Vertex (im Betrachterraum) generiert. So kann man Cubemaps (das ist auch ihr primärer Verwendungszweck) nutzen um wirklich realistische Reflektionen zu generieren, die nicht so fehlerhaft sind wie die vorgekaugelten Reflektionen die durch Spheremapping oder Environmentmapping generiert werden.<br />
<br />
<br />
<br />
== Neue Tokens ==<br />
'''Für [[glTexGen]]'''<br />
<ul><br />
Wenn ''pname'' '''TEXTURE_GEN_MODE''' ist, dann sind für ''param'' folgende neuen Werte gültig :<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_NORMAL_MAP_ARB'''</td><br />
<td>Texturkoordinaten werden entsprechend dieses [[#GL_GL_NORMAL_MAP_ARB|Kapitels]] generiert.</td><br />
</tr><br />
<tr><br />
<td>'''GL_REFLECTION_MAP_ARB'''</td><br />
<td>Texturkoordinaten werden entsprechend dieses [[#GL_REFLECTION_MAP_ARB|Kapitels]] generiert.</td><br />
</tr><br />
</table><br />
</ul><br />
<br><br />
<br />
'''Für [[glEnable]], [[glDisable]], [[glIsEnabled]], [[glGet]], [[glBindTexture]], [[glGetTexParameter]], [[glTexParameter]]'''<br />
<ul><br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_TEXTURE_CUBE_MAP_ARB'''</td><br />
<td>Gültig als Parameter ''cap'' für [[glEnable]], [[glDisable]], [[glIsEnabled]], und ''pname'' für [[glGet]], um den Zustand des Cubemappings zu sezten, bzw. abzufragen. Bei [[glBindTexture]], [[glGetTexParameter]], [[glTexParameter]] gültig als Parameter ''target'' um das Texturenziel als Cubemap zu kennzeichnen.<br />
</td><br />
</tr><br />
</table><br />
</ul><br />
<br><br />
<br />
'''Für [[glGet]]'''<br />
<ul><br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_TEXTURE_BINDING_CUBE_MAP_ARB'''</td><br />
<td>Gültig als Parameter ''pname'' für [[glGet]], um zu ermitteln welcher Cubemapseite eine Textur zugewiesen ist.<br />
</td><br />
</tr><br />
</table><br />
</ul><br />
<br><br />
<br />
'''Für [[glGetTexImage]], [[glGetTexLevelParameter]], [[glTexImage2D]], [[glCopyTexImage2D]], [[glCopySubTexImage2D]], [[glTexSubImage2D]] '''<br />
<ul><br />
<table border=1 rules=all><br />
<tr><br />
<td>'''TEXTURE_CUBE_MAP_POSITIVE_X_ARB'''<br><br />
'''TEXTURE_CUBE_MAP_NEGATIVE_X_ARB'''<br><br />
'''TEXTURE_CUBE_MAP_POSITIVE_Y_ARB'''<br><br />
'''TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB'''<br><br />
'''TEXTURE_CUBE_MAP_POSITIVE_Z_ARB'''<br><br />
'''TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB'''</td><br />
<td>Gültig als Parameter ''target'', und gibt dann an welche Seite der Cubemap ausgelesen, bzw. in welche die Textur kopiert werden soll.<br />
</td><br />
</tr><br />
</table><br />
</ul><br />
<br><br />
<br />
'''Für [[glGetTexLevelParameter]], [[glTexImage2D]]'''<br />
<ul><br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_PROXY_TEXTURE_CUBE_MAP_ARB'''</td><br />
<td>Gültig als Parameter ''target''.<br />
</td><br />
</tr><br />
</table><br />
</ul><br />
<br><br />
<br />
'''Für [[glGet]]'''<br />
<ul><br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB'''</td><br />
<td>Gültig als Parameter ''pname'', und gibt die maximale Texturengröße pro Cubemapseite an.<br />
</td><br />
</tr><br />
</table><br />
</ul><br />
<br><br />
<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[[Tutorial_Cubemap]]<br />
<br />
[http://opengl.org/registry/specs/ARB/texture_cube_map.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_texture_env_combine&diff=21938GL ARB texture env combine2008-07-12T08:58:38Z<p>Traude: /* Ressourcen */ Spezifikations-Link berichtigt</p>
<hr />
<div>= GL_ARB_texture_env_combine =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_texture_env_combine<br />
<br />
== Abhängigkeiten ==<br />
Diese Extension baut auf OpenGL 1.1 auf und ist abhängig von der OpenGL 1.2.1 Extension [[GL_ARB_multitexture]].<br />
<br />
== Beschreibung ==<br />
Diese Extension ist eine wichtige Erweiterung für [[Multitexturing]]. Sie erlaubt es zu bestimmen wie die Farbwerte und Alphawerte von 2 oder mehreren Texturen kombiniert werden soll.<br />
<br />
Für jede [[Texture stage]] können hierbei die Berechnung die durchgeführt werden sollen angegeben werden. Zuerst wird die Berechnung für die 0. [[Texture stage]] durchgeführt, dann die Berechnungen für die 1. und so weiter, bis die letzte [[Texture stage]] das Ergebnis an die nächste Stufe der [[Rendering Pipeline]] weiter gibt.<br />
<br />
<br />
=== '''Verwendung''' ===<br />
Man muss OpenGL für jede [[Texture stage]] mitteilen, dass diese Extension verwendet werden soll. Dies wird mittels<br />
<br />
[[glTexEnv|glTexEnvi]]( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);<br />
<br />
gemacht. Nun muss sowohl für den Alphawert, als auch für den Farbwert festgelegt werden, welcher Art die Kombinierung sein soll.<br />
<br />
=== '''Kombinierungsarten''' ===<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''Art'''</td><br />
<td>'''Formel'''</td><br />
</tr><br />
<tr><br />
<td>'''GL_REPLACE'''</td><br />
<td>Arg0</td><br />
</tr><br />
<tr><br />
<td>'''GL_MODULATE'''</td><br />
<td>Arg0 * Arg1</td><br />
</tr><br />
<tr><br />
<td>'''GL_ADD'''</td><br />
<td>Arg0 + Arg1</td><br />
</tr><br />
<tr><br />
<td>'''GL_ADD_SIGNED_ARB'''</td><br />
<td>Arg0 + Arg1 - 0.5</td><br />
</tr><br />
<tr><br />
<td>'''GL_SUBTRACT_ARB'''</td><br />
<td>Arg0 - Arg1</td><br />
</tr><br />
<tr><br />
<td>'''GL_INTERPOLATE_ARB'''</td><br />
<td>Arg0 * (Arg2) + Arg1 * (1-Arg2)</td><br />
</tr><br />
</table><br />
<br />
gesetzt wird die Kombinierungsart mittels: <br />
<br />
[[glTexEnv|glTexEnvi]]( GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, KOMBINIERUNGSART);<br />
<br />
für die Farbwerte bzw. mit<br />
<br />
[[glTexEnv|glTexEnvi]]( GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, KOMBINIERUNGSART);<br />
<br />
für die Alphawerte. Nun müssen noch die Operanden Arg0, Arg1 und Arg2 für die Kombinierung gesetzt werden.<br />
<br />
<br />
=== '''Operanden''' ===<br />
Für das setzen eines Operanden werden 2 Informationen benötigt. Zum einen die Quelle (Source) der Information, wofür es folgende Möglichkeiten gibt:<br />
<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''Quelle'''</td><br />
<td>'''Beschreibung'''</td><br />
</tr><br />
<tr><br />
<td>'''GL_PRIMARY_COLOR_ARB'''</td><br />
<td>Farbwert der mit [[glColor]] oder vergleichbarem gesetzt wurde.</td><br />
</tr><br />
<tr><br />
<td>'''GL_TEXTURE'''</td><br />
<td>Wert der aktuellen [[Textur]] (in der aktuellen [[Texture stage]])</td><br />
</tr><br />
<tr><br />
<td>'''GL_CONSTANT_ARB'''</td><br />
<td>Wert der mit [[glTexEnv]]fv] für die aktuelle [[Textur]] gesetzt wurde.</td><br />
</tr><br />
<tr><br />
<td>'''GL_PREVIOUS_ARB'''</td><br />
<td>Ergebnis der Berechnungen aus der vorherigen [[Texture stage]], oder gleich wie GL_PRIMARY_COLOR_ARB, wenn es sich um die aller erste [[Texture stage]] handelt.</td><br />
</tr><br />
</table><br />
<br />
nun erfolgt noch die Unterscheidung für welchen Operanden (Arg0, Arg1 oder Arg2) der Wert gesetzt werden soll, und ob dieser Operand für die RGB- oder Alphawert Berechnung verwendet werden soll. Hier gibt es folgende Möglichkeiten:<br />
<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''Art der Quelle'''</td><br />
<td>'''Beschreibung'''</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE0_RGB_ARB'''</td><br />
<td>Wert für Arg0 in der RGB Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE1_RGB_ARB'''</td><br />
<td>Wert für Arg1 in der RGB Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE2_RGB_ARB'''</td><br />
<td>Wert für Arg2 in der RGB Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE0_ALPHA_ARB'''</td><br />
<td>Wert für Arg0 in der Alpha Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE1_ALPHA_ARB'''</td><br />
<td>Wert für Arg1 in der Alpha Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE2_ALPHA_ARB'''</td><br />
<td>Wert für Arg2 in der Alpha Berechnung setzen</td><br />
</tr><br />
</table><br />
<br />
gesetzt werden diese Werte nun mit<br />
<br />
[[glTexEnv|glTexEnvi]]( GL_TEXTURE_ENV, Art der Quelle, Quelle );<br />
<br />
Nun weiß OpenGL welchen Wert er für die Berechnung nehmen soll, jedoch muss man auch noch angeben Welcher Teil des Wertes verwendet werden soll. Für die RGB Berechnung hat man hier folgende Möglichkeiten:<br />
<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''Operand RGB-Berechnung'''</td><br />
<td>'''Beschreibung'''</td><br />
</tr><br />
<tr><br />
<td>'''GL_SRC_COLOR'''</td><br />
<td>Verwende RGB Teil des Wertes</td><br />
</tr><br />
<tr><br />
<td>'''GL_ONE_MINUS_SRC_COLOR'''</td><br />
<td>Verwende 1-RGB Teil des Wertes</td><br />
</tr><br />
<tr><br />
<td>'''GL_SRC_ALPHA'''</td><br />
<td>Verwende Alpha Teil des Wertes</td><br />
</tr><br />
<tr><br />
<td>'''GL_ONE_MINUS_SRC_ALPHA'''</td><br />
<td>Verwende 1-Alpha Teil des Wertes</td><br />
</tr><br />
</table><br />
<br />
Da RGB 3 Werte sind und Alpha nur 1 Wert gibt es für die Alphaberechnung nur 2 Arten von Operanden:<br />
<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''Operand Alphaberechnung'''</td><br />
<td>'''Beschreibung'''</td><br />
</tr><br />
<tr><br />
<td>'''GL_SRC_ALPHA'''</td><br />
<td>Verwende Alpha Teil des Wertes</td><br />
</tr><br />
<tr><br />
<td>'''GL_ONE_MINUS_SRC_ALPHA'''</td><br />
<td>Verwende 1-Alpha Teil des Wertes</td><br />
</tr><br />
</table><br />
<br />
Um anzugeben wofür der Operand eingesetzt werden soll muss man noch wählen zwischen:<br />
<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''Art des Operanden'''</td><br />
<td>'''Beschreibung'''</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND0_RGB_ARB'''</td><br />
<td>Operand für Arg0 in der RGB Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND1_RGB_ARB'''</td><br />
<td>Operand für Arg1 in der RGB Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND2_RGB_ARB'''</td><br />
<td>Operand für Arg2 in der RGB Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND0_ALPHA_ARB'''</td><br />
<td>Operand für Arg0 in der Alpha Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND1_ALPHA_ARB'''</td><br />
<td>Operand für Arg1 in der Alpha Berechnung setzen</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND2_ALPHA_ARB'''</td><br />
<td>Operand für Arg2 in der Alpha Berechnung setzen</td><br />
</tr><br />
</table><br />
<br />
gesetzt werden diese Werte nun mit<br>[[glTexEnv]]i]( GL_TEXTURE_ENV, Art des Operanden, Operand Alphaberechnung bzw. Operand RGB-Berechnung );<br />
<br />
<br />
=== '''Scalen''' ===<br />
Am Ende der Berechnung einer [[Texture stage]] kann der errechnete Wert noch mit einem Scale Faktor multipliziert werden, und zwar mittels<br />
<br />
[[glTexEnv|glTexEnvf]]( GL_TEXTURE_ENV, RGB_SCALE_ARB, Faktor );<br />
<br />
Gültige Werte für Faktor sind hier jedoch nur 1.0, 2.0 oder 4.0. Am Ende Wird das Ergebnis noch auf den Wertebereich [0|1] gebracht. Zu hohe oder zu niedrige Werte werden mit 1.0 bzw. mit 0.0 ersetzt.<br />
<br />
<br />
== Neue Tokens ==<br />
<br />
=== Neue Parameterwerte ===<br />
'''Für [[glTexEnv]]'''<br />
wenn ''pname'' '''GL_TEXTURE_ENV_MODE''' ist, dann ist für ''param'' folgender zustäzlicher Wert gültig:<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_COMBINE_ARB'''</td><br />
<td>0x8570</td><br />
<td>Diese Extension wird für diese [[Texture stage]] aktiviert</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
'''Für [[glTexEnv]]'''<br />
wenn ''target'' '''TEXTURE_ENV''' ist, dann sind für ''pname'' folgende zustäzliche Werte gültig:<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_COMBINE_RGB_ARB'''</td><br />
<td>0x8571</td><br />
<td>Berechnungsart für RGB angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_COMBINE_ALPHA_ARB'''</td><br />
<td>0x8572</td><br />
<td>Berechnungsart für Alpha angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE0_RGB_ARB'''</td><br />
<td>0x8580</td><br />
<td>Quelle für Arg0 der RGB Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE1_RGB_ARB'''</td><br />
<td>0x8581</td><br />
<td>Quelle für Arg1 der RGB Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE2_RGB_ARB'''</td><br />
<td>0x8582</td><br />
<td>Quelle für Arg2 der RGB Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE0_ALPHA_ARB'''</td><br />
<td>0x8588</td><br />
<td>Quelle für Arg0 der Alpha Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE1_ALPHA_ARB'''</td><br />
<td>0x8589</td><br />
<td>Quelle für Arg1 der Alpha Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE2_ALPHA_ARB'''</td><br />
<td>0x858A</td><br />
<td>Quelle für Arg2 der Alpha Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND0_RGB_ARB'''</td><br />
<td>0x8590</td><br />
<td>Teil der Quelle für Arg0 der RGB Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND1_RGB_ARB'''</td><br />
<td>0x8591</td><br />
<td>Teil der Quelle für Arg1 der RGB Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND2_RGB_ARB'''</td><br />
<td>0x8592</td><br />
<td>Teil der Quelle für Arg2 der RGB Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND0_ALPHA_ARB'''</td><br />
<td>0x8598</td><br />
<td>Teil der Quelle für Arg0 der Alpha Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND1_ALPHA_ARB'''</td><br />
<td>0x8599</td><br />
<td>Teil der Quelle für Arg1 der Alpha Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND2_ALPHA_ARB'''</td><br />
<td>0x859A</td><br />
<td>Teil der Quelle für Arg2 der Alpha Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_RGB_SCALE_ARB'''</td><br />
<td>0x8573</td><br />
<td>Scale Faktor für RGB Berechnung angeben</td><br />
</tr><br />
<tr><br />
<td>'''GL_ALPHA_SCALE'''</td><br />
<td></td><br />
<td>Scale Faktor für Alpha Berechnung angeben</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
'''Für [[glTexEnv]]'''<br />
wenn ''pname'' '''GL_COMBINE_RGB_ARB''' oder '''GL_COMBINE_ALPHA_ARB''' ist, dann sind für ''param'' folgende Werte gültig:<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_REPLACE'''</td><br />
<td></td><br />
<td>Arg0</td><br />
</tr><br />
<tr><br />
<td>'''GL_MODULATE'''</td><br />
<td></td><br />
<td>Arg0 * Arg1</td><br />
</tr><br />
<tr><br />
<td>'''GL_ADD'''</td><br />
<td></td><br />
<td>Arg0 + Arg1</td><br />
</tr><br />
<tr><br />
<td>'''GL_ADD_SIGNED_ARB'''</td><br />
<td>0x8574</td><br />
<td>Arg0 + Arg1 - 0.5</td><br />
</tr><br />
<tr><br />
<td>'''GL_INTERPOLATE_ARB'''</td><br />
<td>0x8575</td><br />
<td>Arg0 * (Arg2) + Arg1 * (1-Arg2)</td><br />
</tr><br />
<tr><br />
<td>'''GL_SUBTRACT_ARB'''</td><br />
<td>0x84E7</td><br />
<td>Arg0 - Arg1</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
'''Für [[glTexEnv]]'''<br />
wenn ''pname'' '''GL_SOURCE0_RGB_ARB''', '''GL_SOURCE1_RGB_ARB''', '''GL_SOURCE2_RGB_ARB''', '''GL_SOURCE0_ALPHA_ARB''', '''GL_SOURCE1_ALPHA_ARB''', oder '''GL_SOURCE2_ALPHA_ARB''' ist, dann sind für ''param'' folgende Werte gültig:<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_TEXTURE'''</td><br />
<td></td><br />
<td>Aktuelle Textur als Quelle verwenden</td><br />
</tr><br />
<tr><br />
<td>'''GL_CONSTANT_ARB'''</td><br />
<td>0x8576</td><br />
<td>Mit [[glTexEnv]] für diese Textur gesetzte Farbe als Quelle verwenden</td><br />
</tr><br />
<tr><br />
<td>'''GL_PRIMARY_COLOR_ARB'''</td><br />
<td>0x8577</td><br />
<td>Mit [[glColor]] oder vergleichbarem gesetzte Farbe als Quelle verwenden</td><br />
</tr><br />
<tr><br />
<td>'''GL_PREVIOUS_ARB'''</td><br />
<td>0x8578</td><br />
<td>Ergebnis der vorigen [[Texture Stage]] als Quelle verwenden oder gleich wie GL_PRIMARY_COLOR_ARB wenn es die erste [[Texture stage]] ist.</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
'''Für [[glTexEnv]]'''<br />
wenn ''pname'' '''GL_OPERAND0_RGB_ARB''', '''GL_OPERAND1_RGB_ARB''' oder '''GL_OPERAND2_RGB_ARB''' ist, dann sind für ''param'' folgende Werte gültig:<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''SRC_COLOR'''</td><br />
<td></td><br />
<td>RGB Teil der Quelle als Operand verwenden</td><br />
</tr><br />
<tr><br />
<td>'''GL_ONE_MINUS_SRC_COLOR'''</td><br />
<td></td><br />
<td>1-RGB Teil der Quelle als Operand verwenden</td><br />
</tr><br />
<tr><br />
<td>'''GL_SRC_ALPHA'''</td><br />
<td></td><br />
<td>Alpha Teil der Quelle als Operand verwenden</td><br />
</tr><br />
<tr><br />
<td>'''GL_ONE_MINUS_SRC_ALPHA'''</td><br />
<td></td><br />
<td>1-Alpha Teil der Quelle als Operand verwenden</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
'''Für [[glTexEnv]]'''<br />
wenn ''pname'' '''GL_OPERAND0_ALPHA_ARB''', '''GL_OPERAND1_ALPHA_ARB''' oder '''GL_OPERAND2_ALPHA_ARB''' ist, dann sind für ''param'' folgende Werte gültig:<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''GL_SRC_ALPHA'''</td><br />
<td></td><br />
<td>Alpha Teil der Quelle als Operand verwenden</td><br />
</tr><br />
<tr><br />
<td>'''GL_ONE_MINUS_SRC_ALPHA'''</td><br />
<td></td><br />
<td>1-Alpha Teil der Quelle als Operand verwenden</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
'''Für [[glTexEnv]]'''<br />
wenn ''pname'' '''GL_RGB_SCALE_ARB''' oder '''GL_ALPHA_SCALE''' ist, dann sind für ''param'' folgende Werte gültig:<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''1.0'''</td><br />
</tr><br />
<tr><br />
<td>'''2.0'''</td><br />
</tr><br />
<tr><br />
<td>'''4.0'''</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
<br />
=== '''Neue States''' ===<br />
<table border=1 rules=all><br />
<tr><br />
<td>'''Name'''</td><br />
<td>'''Abfrage mit'''</td><br />
<td>'''Initialwert'''</td><br />
</tr><br />
<tr><br />
<td>'''GL_COMBINE_RGB_ARB '''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_MODULATE</td><br />
</tr><br />
<tr><br />
<td>'''GL_COMBINE_ALPHA_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_MODULATE</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE0_RGB_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_TEXTURE</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE1_RGB_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_PREVIOUS_ARB</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE2_RGB_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_CONSTANT_ARB</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE0_ALPHA_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_TEXTURE</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE1_ALPHA_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_PREVIOUS_ARB</td><br />
</tr><br />
<tr><br />
<td>'''GL_SOURCE2_ALPHA_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_CONSTANT_ARB</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND0_RGB_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_COLOR</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND1_RGB_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_COLOR</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND2_RGB_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_ALPHA</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND0_ALPHA_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_ALPHA</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND1_ALPHA_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_ALPHA</td><br />
</tr><br />
<tr><br />
<td>'''GL_OPERAND2_ALPHA_ARB'''</td><br />
<td>GetTexEnviv</td><br />
<td>GL_ALPHA</td><br />
</tr><br />
<tr><br />
<td>'''GL_RGB_SCALE_ARB'''</td><br />
<td>GetTexEnvfv</td><br />
<td>1.0</td><br />
</tr><br />
<tr><br />
<td>'''GL_ALPHA_SCALE'''</td><br />
<td>GetTexEnvfv</td><br />
<td>1.0</td><br />
</tr><br />
</table><br />
<br />
<br />
== Abhängigkeiten ==<br />
[[GL_ARB_multitexture]]<br />
<br />
== Verwendungsbeispiel ==<br />
Folgendender Code benutzt Multitexturing und texture_env_combine um über die erste Textur eine Zweite zu blenden. Die zweite Textur wird dabei mit einem Alphawert verrechnet. Das Ganze entspricht vom Ergebniss dem was man erreicht, wenn man die Fläche mehrfach zeichnet (multi pass) und dabei als [[Blending|Blendfunktion]] GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA benutzt.<br />
<br />
<pascal>var<br />
Color: array [0..3] of single;<br />
begin<br />
glActiveTexture(GL_TEXTURE0);<br />
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);<br />
fTex.Bind;</pascal><br />
Die erste Textur kann ganz normal an die TMU0 gebunden werden.<br />
<br />
<pascal> glActiveTexture(GL_TEXTURE1);<br />
fCube.Bind;</pascal><br />
Die Zweite Textur wird auch normal gebunden.<br />
<br />
<pascal> Color[0] := 0;<br />
Color[1] := 0;<br />
Color[2] := 0;<br />
Color[3] := 0.125;<br />
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, @Color);</pascal><br />
Damit wird die Farbe gesetzt. Aus dieser Farbe wird im aktuellen Beispiel aber lediglich der Alphakanal benutzt.<br />
<br />
<pascal> glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);</pascal><br />
texture_env_combine aktivieren.<br />
<br />
<pascal> glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);</pascal><br />
Die Kombinierungsart festlegen. Nähere informationen dazu wurden bereits oben beschrieben.<br />
<br />
<pascal> glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);<br />
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);<br />
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);</pascal><br />
Die einzelnen Operanden festlegen. Dieses richten sich nach der Kombinierungsart.<br />
<br />
<pascal> glBegin(GL_QUADS);<br />
glTexCoord2f(0, 1);<br />
glVertex3f(- 2, - 2, 0);<br />
<br />
...<br />
glEnd;</pascal><br />
Objekte zeichnen. In diesem Fall nur eine simple Fläche.<br />
<br />
<pascal> glActiveTexture(GL_TEXTURE1);<br />
fCube.Unbind;<br />
<br />
glActiveTexture(GL_TEXTURE0);<br />
fTex.Unbind;<br />
end;</pascal><br />
Die Texturen wieder aus dem TMUs entbinden.<br />
<br />
Mit diesem Code lässt sich auch auf Objekten eine leichte Spiegelung der Umgebung erzeugen. Dazu muss für die zweite Textur lediglich eine CubeMap oder SphereMap benutzt werden.<br />
<br />
== Ressourcen ==<br />
[http://www.delphi3d.net/hardware/extsupport.php?extension=GL_ARB_texture_env_combine Hardware Unterstützung]<br><br />
[http://opengl.org/registry/specs/ARB/texture_env_combine.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_occlusion_query&diff=21937GL ARB occlusion query2008-07-12T08:56:35Z<p>Traude: /* Ressourcen */ Spezifikations-Link berichtigt</p>
<hr />
<div>= GL_ARB_occlusion_query =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_occlusion_query<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_occlusion_query bietet eine Möglichkeit festzustellen, wieviele Samples (Pixel) einer [[Primitive]] gezeichnet werden.<br />
<br><br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''glGenQueriesARB'''(n : integer; ids : PGLuint);<br />
procedure '''glDeleteQueriesARB'''(n : integer; const ids : PGLuint);<br />
function '''glIsQueryARB'''(id : Cardinal) : Boolean;<br />
procedure '''glBeginQueryARB'''(target : Cardinal; id : Cardinal);<br />
procedure '''glEndQueryARB'''(target : Cardinal);<br />
procedure '''glGetQueryivARB'''(target : Cardinal; pname : Cardinal; params : PGLInt);<br />
procedure '''glGetQueryObjectivARB'''(id : Cardinal; pname : Cardinal; params : PGLInt);<br />
procedure '''glGetQueryObjectuivARB'''(id : Cardinal, pname : Cardinal; params : PGLuint);<br />
<br />
<br />
== Neue Tokens ==<br />
''Für glBeginQueryARB, glEndQueryARB oder glGetQueryivARB als <target> Parameter'' <br><br />
'''GL_SAMPLES_PASSED_ARB''' <br><br />
<br><br />
''Für glGetQueryivARB als <pname> Parameter'' <br><br />
'''GL_QUERY_COUNTER_BITS_ARB''' <br><br />
'''GL_CURRENT_QUERY_ARB''' <br><br />
<br><br />
''Für glGetQueryObjectivARB oder glGetQueryObjectuivARB als <pname> Parameter'' <br><br />
'''QUERY_RESULT_ARB''' <br><br />
'''QUERY_RESULT_AVAILABLE_ARB''' <br><br />
<br />
== Anwendung ==<br />
Bevor der Occlusion Test zur Verfügung steht, muss erst einmal eine Query mit glGenQueriesARB() erzeugt werden. Danach wird das Zählen der Samples mit glBeginQueryARB() und GL_SAMPLES_PASSED_ARB als <target> Parameter gestartet. Dann wird die Szene gerendert. Um den Test auszuwerten, muss das Zählen erst einmal mit glEndQueryARB() beendet werden. Anschließend kann man sich das Ergebnis des Test, also die gezeichneten Pixel, mittels glGetQueryObjectivARB() (QUERY_RESULT_ARB als <pname> Parameter) zurückliefern lassen.<br />
<br />
== Beispiel ==<br />
<br />
'''var''' Query : Gluint;<br />
Pixel : Integer;<br />
<br /><br />
[...]<br />
<br /><br />
<font color="#000080">''//== Query erzeugen''</font><br />
glGenQueriesARB'''('''1,@Query''')''';<br />
<font color="#000080">''//== mit dem Zählen beginnen''</font><br />
glBeginQueryARB'''('''GL_SAMPLES_PASSED_ARB,Query''')''';<br />
<br /><br />
<font color="#000080">''//== Szene/Primitive zeichnen''</font><br />
<br /><br />
<font color="#000080">''//== aufhören zu Zählen''</font><br />
glEndQueryARB'''('''GL_SAMPLES_PASSED_ARB''')''';<br />
<font color="#000080">''//== Ergebnis wird nach Pixel zurückgeliefert''</font><br />
glGetQueryObjectivARB'''('''Query,GL_QUERY_RESULT_ARB,@Pixel''')''';<br />
<font color="#000080">''//== Query wieder freigeben''</font><br />
glDeleteQueriesARB'''('''1,@Pixel''')''';<br />
<br />
== Ressourcen ==<br />
[http://delphigl.com/script/do_show.php?name=nv_occlusion_query&action=2 Occlusion Query Tutorial mit GL_OCCLUSION_QUERY_NV]<br><br />
[http://opengl.org/registry/specs/ARB/occlusion_query.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21936GL ARB multisample2008-07-11T11:21:51Z<p>Traude: /* Anwendung */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
<br />
== Abhängigkeiten ==<br />
GL_ARB_multisample ist abhängig von folgenden Extensions: <br><br />
'''[[WGL_ARB_extensions_string]]''' <br><br />
'''[[WGL_ARB_pixel_format]]''' <br><br />
<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean);<br />
<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von [[wglChoosePixelFormatARB]]:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
<br />
== Anwendung ==<br />
<br />
HINWEIS: Die folgenden Erläuterungen gelten nur für Windows: <br><br />
Das Multisampling wird mithilfe der Prozedur wglChoosePixelFormatARB ausgewählt, mit der Prozedur SetPixelFormat gesetzt und anschließend kann ein Rendering Context erstellt werden. <br />
<br />
Das ist problematisch, wenn nicht bekannt ist, ob auf dem gegebenen System die Extension GL_ARB_multisample zur Verfügung steht. Denn die Prozedur wglChoosePixelFormatARB ist ebenfalls Bestandteil einer Extension, und Extensions stehen nur zur Verfügung, wenn bereits ein Rendering Context aktiviert ist. Da für einen Rendering Context anläßlich der Erstellung nur einmal ein Pixelformat vergeben wird, kann man das Multisampling-Pixelformat auf diese Weise zwar in Erfahrung bringen, aber nicht mehr setzen.<br />
<br />
Daher ist die korrekte Vorgangsweise auf einem unbekannten System die Folgende: <br><br />
1. Einen temporären Rendering Context mit einem gültigen Pixelformat erstellen <br><br />
2. Prüfen, ob ein Pixelformat mit Multisampling zur Verfügung steht und das Ergebnis speichern <br><br />
3. Den temporären Context wieder löschen <br><br />
4. Einen neuen Rendering Context aufgrund des Ergebnisses gemäß Pkt.2 erstellen. <br><br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21935GL ARB multisample2008-07-10T21:41:10Z<p>Traude: /* GL_ARB_multisample */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
<br />
== Abhängigkeiten ==<br />
GL_ARB_multisample ist abhängig von folgenden Extensions: <br><br />
'''[[WGL_ARB_extensions_string]]''' <br><br />
'''[[WGL_ARB_pixel_format]]''' <br><br />
<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean);<br />
<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von [[wglChoosePixelFormatARB]]:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
<br />
== Anwendung ==<br />
<br />
HINWEIS: Die folgenden Erläuterungen gelten nur für Windows: <br><br />
Das Multisampling wird mithilfe der Prozedur wglChoosePixelFormatARB ausgewählt, mit der Prozedur SetPixelFormat gesetzt und anschließend kann ein Rendering Context erstellt werden. <br />
<br />
Das ist problematisch, wenn nicht bekannt ist, ob auf dem gegebenen System die Extension GL_ARB_multisample zur Verfügung steht. Denn die Prozedur wglChoosePixelFormatARB ist ebenfalls Bestandteil einer Extension, und Extensions stehen nur zur Verfügung, wenn bereits ein Rendering Context aktiviert ist. Da für einen Rendering Context anläßlich der Erstellung nur einmal ein Pixelformat vergeben wird, kann man das Multisampling-Pixelformat auf diese Weise zwar in Erfahrung bringen, aber nicht mehr setzen.<br />
<br />
Daher ist die korrekte Vorgangsweise auf einem unbekannten System die Folgende: <br><br />
1. Einen temporären Rendering Context mit einem gültigen Pixelformat erstellen <br><br />
2. Prüfen, ob ein Pixelformat mit Multisampling zur Verfügung steht und das Ergebnis speichern <br><br />
3. Den temporären Context wieder löschen <br><br />
4. Einen neuen Rendering Context mit aufgrund des Ergebnisses gemäß Pkt.2 erstellen. <br><br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21934GL ARB multisample2008-07-10T21:26:04Z<p>Traude: /* Neue Tokens */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean);<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von [[wglChoosePixelFormatARB]]:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
== Anwendung ==<br />
<br />
Die folgenden Erläuterungen gelten nur für Windows: <br><br />
Das Multisampling wird mithilfe der Prozedur wglChoosePixelFormatARB ausgewählt, mit der Prozedur SetPixelFormat gesetzt und anschließend kann ein Rendering Context erstellt werden. <br />
<br />
Das ist problematisch, wenn nicht bekannt ist, ob auf dem gegebenen System die Extension GL_ARB_multisample zur Verfügung steht. Denn die Prozedur wglChoosePixelFormatARB ist ebenfalls Bestandteil einer Extension, und Extensions stehen nur zur Verfügung, wenn bereits ein Rendering Context aktiviert ist. Da für einen Rendering Context anläßlich der Erstellung nur einmal ein Pixelformat vergeben wird, kann man das Multisampling-Pixelformat auf diese Weise zwar in Erfahrung bringen, aber nicht mehr setzen.<br />
<br />
Daher ist die korrekte Vorgangsweise auf einem unbekannten System die Folgende: <br><br />
1. Einen temporären Rendering Context mit einem gültigen Pixelformat erstellen <br><br />
2. Prüfen, ob ein Pixelformat mit Multisampling zur Verfügung steht und das Ergebnis speichern <br><br />
3. Den temporären Context wieder löschen <br><br />
4. Einen neuen Rendering Context mit aufgrund des Ergebnisses gemäß Pkt.2 erstellen. <br><br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21933GL ARB multisample2008-07-10T21:17:26Z<p>Traude: /* GL_ARB_multisample */ Hinweis auf Bearbeitung entfernt</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean);<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von wglChoosePixelFormatARB:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
== Anwendung ==<br />
<br />
Die folgenden Erläuterungen gelten nur für Windows: <br><br />
Das Multisampling wird mithilfe der Prozedur wglChoosePixelFormatARB ausgewählt, mit der Prozedur SetPixelFormat gesetzt und anschließend kann ein Rendering Context erstellt werden. <br />
<br />
Das ist problematisch, wenn nicht bekannt ist, ob auf dem gegebenen System die Extension GL_ARB_multisample zur Verfügung steht. Denn die Prozedur wglChoosePixelFormatARB ist ebenfalls Bestandteil einer Extension, und Extensions stehen nur zur Verfügung, wenn bereits ein Rendering Context aktiviert ist. Da für einen Rendering Context anläßlich der Erstellung nur einmal ein Pixelformat vergeben wird, kann man das Multisampling-Pixelformat auf diese Weise zwar in Erfahrung bringen, aber nicht mehr setzen.<br />
<br />
Daher ist die korrekte Vorgangsweise auf einem unbekannten System die Folgende: <br><br />
1. Einen temporären Rendering Context mit einem gültigen Pixelformat erstellen <br><br />
2. Prüfen, ob ein Pixelformat mit Multisampling zur Verfügung steht und das Ergebnis speichern <br><br />
3. Den temporären Context wieder löschen <br><br />
4. Einen neuen Rendering Context mit aufgrund des Ergebnisses gemäß Pkt.2 erstellen. <br><br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21932GL ARB multisample2008-07-10T21:14:14Z<p>Traude: /* Anwendung */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Leere Sektionen werden gerade bearbeitet.}}<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean);<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von wglChoosePixelFormatARB:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
== Anwendung ==<br />
<br />
Die folgenden Erläuterungen gelten nur für Windows: <br><br />
Das Multisampling wird mithilfe der Prozedur wglChoosePixelFormatARB ausgewählt, mit der Prozedur SetPixelFormat gesetzt und anschließend kann ein Rendering Context erstellt werden. <br />
<br />
Das ist problematisch, wenn nicht bekannt ist, ob auf dem gegebenen System die Extension GL_ARB_multisample zur Verfügung steht. Denn die Prozedur wglChoosePixelFormatARB ist ebenfalls Bestandteil einer Extension, und Extensions stehen nur zur Verfügung, wenn bereits ein Rendering Context aktiviert ist. Da für einen Rendering Context anläßlich der Erstellung nur einmal ein Pixelformat vergeben wird, kann man das Multisampling-Pixelformat auf diese Weise zwar in Erfahrung bringen, aber nicht mehr setzen.<br />
<br />
Daher ist die korrekte Vorgangsweise auf einem unbekannten System die Folgende: <br><br />
1. Einen temporären Rendering Context mit einem gültigen Pixelformat erstellen <br><br />
2. Prüfen, ob ein Pixelformat mit Multisampling zur Verfügung steht und das Ergebnis speichern <br><br />
3. Den temporären Context wieder löschen <br><br />
4. Einen neuen Rendering Context mit aufgrund des Ergebnisses gemäß Pkt.2 erstellen. <br><br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21931GL ARB multisample2008-07-10T20:41:55Z<p>Traude: /* Neue Tokens */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Leere Sektionen werden gerade bearbeitet.}}<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean);<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attrib> Parameter von glXGetConfig und'' <br><br />
''für den <attribList> Parameter von glXChooseVisual:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von wglChoosePixelFormatARB:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
== Anwendung ==<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21930GL ARB multisample2008-07-10T20:35:52Z<p>Traude: /* Neue Tokens */ EXT durch ARB ersetzt</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Leere Sektionen werden gerade bearbeitet.}}<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean);<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attribList> Parameter von glXChooseVisual und'' <br><br />
''für den <attrib> Parameter von glXGetConfig:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivARB, wglGetPixelFormatAttribfvARB und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von wglChoosePixelFormatARB:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
== Anwendung ==<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21929GL ARB multisample2008-07-10T20:21:10Z<p>Traude: /* Neue Tokens */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Leere Sektionen werden gerade bearbeitet.}}<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean);<br />
<br />
== Neue Tokens ==<br />
<br />
''Für den <attribList> Parameter von glXChooseVisual und'' <br><br />
''für den <attrib> Parameter von glXGetConfig:'' <br><br />
'''GLX_SAMPLE_BUFFERS_ARB''' <br><br />
'''GLX_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <piAttributes> Parameter von wglGetPixelFormatAttribivEXT, wglGetPixelFormatAttribfvEXT und '' <br><br />
''für <piAttribIList> und <pfAttribIList> von wglChoosePixelFormatEXT:'' <br><br />
'''WGL_SAMPLE_BUFFERS_ARB''' <br><br />
'''WGL_SAMPLES_ARB''' <br><br />
<br><br />
''Für den <cap> Parameter von Enable, Disable und IsEnabled und '' <br><br />
''für den <pname> Parameter von GetBooleanv, GetIntegerv, GetFloatv, und GetDoublev:'' <br><br />
'''MULTISAMPLE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_COVERAGE_ARB''' <br><br />
'''SAMPLE_ALPHA_TO_ONE_ARB''' <br><br />
'''SAMPLE_COVERAGE_ARB''' <br><br />
<br><br />
''Für den <mask> Parameter von PushAttrib:'' <br><br />
'''MULTISAMPLE_BIT_ARB''' <br><br />
<br><br />
''Für den <pname> Parameter von GetBooleanv, GetDoublev, GetIntegerv und GetFloatv:'' <br><br />
'''SAMPLE_BUFFERS_ARB''' <br><br />
'''SAMPLES_ARB''' <br><br />
'''SAMPLE_COVERAGE_VALUE_ARB''' <br><br />
'''SAMPLE_COVERAGE_INVERT_ARB''' <br><br />
<br><br />
<br />
== Anwendung ==<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21928GL ARB multisample2008-07-10T19:46:37Z<p>Traude: /* Neue Prozeduren */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Leere Sektionen werden gerade bearbeitet.}}<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
procedure '''SampleCoverageARB''' (value: TGLclampf; invert: TGLboolean);<br />
<br />
== Neue Tokens ==<br />
<br />
<br />
<br />
== Anwendung ==<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21927GL ARB multisample2008-07-10T19:29:44Z<p>Traude: /* Ressourcen */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Leere Sektionen werden gerade bearbeitet.}}<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
<br />
<br />
== Neue Tokens ==<br />
<br />
<br />
<br />
== Anwendung ==<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[http://opengl.org/registry/specs/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21908GL ARB multisample2008-07-04T16:41:25Z<p>Traude: /* GL_ARB_multisample */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Leere Sektionen werden gerade bearbeitet.}}<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
<br />
<br />
== Neue Tokens ==<br />
<br />
<br />
<br />
== Anwendung ==<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[http://oss.sgi.com/projects/ogl-sample/registry/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=OpenGL-Extensions&diff=21907OpenGL-Extensions2008-07-04T16:31:15Z<p>Traude: /* ARB */</p>
<hr />
<div>== Was hier hinein gehört ==<br />
Idealerweise landen hier Übersetzungen der Extensiondokumente aus der [http://oss.sgi.com/projects/ogl-sample/registry/ Extension-Registry von SGI]. Dabei werden die Informationen so zusammengefasst und strukturiert, wie es die [[Extensionvorlage]] vorgibt. Dadurch soll die Nutz- und Lesbarkeit der Spezifikationen erhöht werden.<br />
<br />
Die Artikel enthalten entsprechend '''nur technische Erklärungen zur Nutzung einer Extension''', also z.B. wie man VBOs lädt, was die Parameter bedeutet, etc. <br><br />
Die Artikel enthalten '''nicht''' <br />
*Ausführliche Erklärungen zu den neuen Funktionen. Diese werden in gesonderten Artikeln beschrieben.<br />
*Erklärungen zu den Techniken die eine Extension verkörpert (also darf z.B. bei GL_ARB_Vertex_Shader nicht stehen was ein Vertexshader ist). Solche Informationen kommen je nach Thematik in die Sektionen [[Techniken und Algorithmen]] oder [[Hintergrundwissen]].<br />
<br />
'''Bitte benutzt die [[Extensionvorlage]] damit alle Artikel gleich strukturiert sind.'''<br />
Wie so ein Artikel aussehen sollte kann am Beispiel [[GL_ARB_texture_env_combine]] gesehen werden.<br />
<br />
Sollte eine Extension neue Funktionen mitbringen, so gehört deren Verlinkung und Erklärung in die [[OpenGL-Funktionsübersicht]].<br />
<br />
Bittet sortiert eure neue Extension alphabetisch '''und''' in die passende Subkategorie ein!<br />
<br />
== Extensionübersicht ==<br />
<br />
=== ARB ===<br />
: (Was bedeutet [[ARB]] {{icpIcon}}?)<br />
: [[GL_ARB_fragment_program]]<br />
: [[GL_ARB_imaging]]{{icpIcon}}<br />
: [[GL_ARB_multisample]]{{icpIcon}}<br />
: [[GL_ARB_occlusion_query]]<br />
: [[GL_ARB_texture_env_combine]]<br />
: [[GL_ARB_texture_cube_map]]<br />
: [[GL_ARB_vertex_program]]<br />
<br />
=== EXT ===<br />
: (Was bedeutet [[EXT]]?)<br />
: [[GL_EXT_color_table]]<br />
: [[GL_EXT_convolution]]<br />
: [[GL_EXT_fog_offset]]<br />
: [[GL_EXT_framebuffer_object]] {{icpIcon}}<br />
: [[GL_EXT_interlace]]<br />
: [[GL_EXT_interlace_read]]<br />
: [[GL_EXT_multisample]]<br />
: [[GL_EXT_occlusion_test]]<br />
: [[GL_EXT_pixel_texture]]<br />
: [[GL_EXT_rescale_normal]]<br />
: [[GL_EXT_stencil_wrap]]<br />
: [[GL_EXT_texture3D]]<br />
: [[GL_EXT_texture_color_table]]<br />
<br />
=== WGL ===<br />
: (Was bedeutet [[WGL]]?)<br />
: [[WGL_ARB_extensions_string]]<br />
: [[WGL_ARB_pixel_format]]<br />
: [[WGL_ARB_pbuffer]]<br />
: [[WGL_ARB_multisample]]<br />
<br />
=== GLX ===<br />
: (Was bedeutet [[GLX]] {{icpIcon}}?)<br />
: [[GLX_ARB_get_proc_address]]<br />
<br />
=== Herstellerabhängig ===<br />
: [[GL_ATI_draw_buffers]] <br />
: [[GL_HP_occlusion_test]]<br />
: [[GL_NV_fence]]<br />
: [[GL_NV_texture_env_combine4]]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21906GL ARB multisample2008-07-04T16:30:32Z<p>Traude: /* Beschreibung */</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten [[Tiefenpuffer]] oder Stencilpuffer ([[Schablonenpuffer]]), sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können.<br />
<br />
== Neue Prozeduren ==<br />
<br />
<br />
<br />
== Neue Tokens ==<br />
<br />
<br />
<br />
== Anwendung ==<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[http://oss.sgi.com/projects/ogl-sample/registry/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=GL_ARB_multisample&diff=21905GL ARB multisample2008-07-04T16:27:42Z<p>Traude: Beschreibung der Extension GL_ARB_multisample hinzugefügt</p>
<hr />
<div>= GL_ARB_multisample =<br />
{{Hinweis|Die Orginalspezifikation finden Sie unter "Ressourcen" am Ende des Artikels.}}<br />
<br />
<br />
== Abfragestring ==<br />
GL_ARB_multisample<br />
<br />
<br />
<br />
== Beschreibung ==<br />
GL_ARB_multisample ermöglicht [[Antialiasing]] bezüglich aller GL Primitiven: Punkte, Linien, Polygone, Bitmaps und Bilder. Dabei werden bei jedem Pixel alle Primitive mehrere Male geprüft. Die erhaltenen einzelnen Farbwerte werden jedes Mal, wenn ein Pixel neu gezeichnet werden muss, zu einer einzigen ausgabefähigen Farbe zusammengefasst. Das geschieht automatisch, sodass für ein Programm kein zusätzlicher Aufwand anfällt.Weil jeder einzelne geprüfte Wert Tiefen- und Stencilinformation beinhaltet, werden die Tiefen- und Stencilfunktionen in ihrer Schnelligkeit nicht beeinträchtigt.<br />
<br />
Ein zusätzlicher Puffer, der Multisample buffer, wird zum [[Framebuffer]] hinzugefügt. Die einzelnen Pixelwerte, einschließlich Farbe, Tiefe- und Stencilwerte werden hier gespeichert. Wenn der Framebuffer einen Multisample buffer hat, gibt es keinen separaten Tiefen- oder Stencilpuffer, sogar auch dann nicht, wenn der Multisample buffer Tiefen- oder Stencilwerte gar nicht speichert. Farbpuffer (links/rechts/vorne/hinten/aux) koexistieren aber jedenfalls mit dem Multisample buffer.<br />
<br />
Multisample-Antialiasing ist für das Zeichnen von Polygonen von großem Vorteil, da es keine Sortierung erfordert, um versteckte Objekte zu eliminieren und angrenzende Polygone, Objektsilhouetten und sogar schneidende Polygone korrekt dargestellt werden können. Wenn nur Punkte oder Linien gezeichnet werden, erzeugt das "Smooth"-Antialiasing, das die Basis-GL erzeugt, bessere Ergebnisse. Diese Extension wurde so gestaltet, dass sowohl "Smooth" als auch Multisample Antialiasing alternierend beim Zeichnen einer Szene verwendet werden können. <br />
<br />
<br />
== Neue Prozeduren ==<br />
<br />
<br />
<br />
== Neue Tokens ==<br />
<br />
<br />
<br />
== Anwendung ==<br />
<br />
<br />
<br />
== Ressourcen ==<br />
[http://oss.sgi.com/projects/ogl-sample/registry/ARB/multisample.txt Original Extension-Spezifikation]</div>Traudehttps://wiki.delphigl.com/index.php?title=OpenGL-Extensions&diff=21904OpenGL-Extensions2008-07-04T14:50:50Z<p>Traude: /* ARB */</p>
<hr />
<div>== Was hier hinein gehört ==<br />
Idealerweise landen hier Übersetzungen der Extensiondokumente aus der [http://oss.sgi.com/projects/ogl-sample/registry/ Extension-Registry von SGI]. Dabei werden die Informationen so zusammengefasst und strukturiert, wie es die [[Extensionvorlage]] vorgibt. Dadurch soll die Nutz- und Lesbarkeit der Spezifikationen erhöht werden.<br />
<br />
Die Artikel enthalten entsprechend '''nur technische Erklärungen zur Nutzung einer Extension''', also z.B. wie man VBOs lädt, was die Parameter bedeutet, etc. <br><br />
Die Artikel enthalten '''nicht''' <br />
*Ausführliche Erklärungen zu den neuen Funktionen. Diese werden in gesonderten Artikeln beschrieben.<br />
*Erklärungen zu den Techniken die eine Extension verkörpert (also darf z.B. bei GL_ARB_Vertex_Shader nicht stehen was ein Vertexshader ist). Solche Informationen kommen je nach Thematik in die Sektionen [[Techniken und Algorithmen]] oder [[Hintergrundwissen]].<br />
<br />
'''Bitte benutzt die [[Extensionvorlage]] damit alle Artikel gleich strukturiert sind.'''<br />
Wie so ein Artikel aussehen sollte kann am Beispiel [[GL_ARB_texture_env_combine]] gesehen werden.<br />
<br />
Sollte eine Extension neue Funktionen mitbringen, so gehört deren Verlinkung und Erklärung in die [[OpenGL-Funktionsübersicht]].<br />
<br />
Bittet sortiert eure neue Extension alphabetisch '''und''' in die passende Subkategorie ein!<br />
<br />
== Extensionübersicht ==<br />
<br />
=== ARB ===<br />
: (Was bedeutet [[ARB]] {{icpIcon}}?)<br />
: [[GL_ARB_fragment_program]]<br />
: [[GL_ARB_imaging]]{{icpIcon}}<br />
: [[GL_ARB_multisample]]<br />
: [[GL_ARB_occlusion_query]]<br />
: [[GL_ARB_texture_env_combine]]<br />
: [[GL_ARB_texture_cube_map]]<br />
: [[GL_ARB_vertex_program]]<br />
<br />
=== EXT ===<br />
: (Was bedeutet [[EXT]]?)<br />
: [[GL_EXT_color_table]]<br />
: [[GL_EXT_convolution]]<br />
: [[GL_EXT_fog_offset]]<br />
: [[GL_EXT_framebuffer_object]] {{icpIcon}}<br />
: [[GL_EXT_interlace]]<br />
: [[GL_EXT_interlace_read]]<br />
: [[GL_EXT_multisample]]<br />
: [[GL_EXT_occlusion_test]]<br />
: [[GL_EXT_pixel_texture]]<br />
: [[GL_EXT_rescale_normal]]<br />
: [[GL_EXT_stencil_wrap]]<br />
: [[GL_EXT_texture3D]]<br />
: [[GL_EXT_texture_color_table]]<br />
<br />
=== WGL ===<br />
: (Was bedeutet [[WGL]]?)<br />
: [[WGL_ARB_extensions_string]]<br />
: [[WGL_ARB_pixel_format]]<br />
: [[WGL_ARB_pbuffer]]<br />
: [[WGL_ARB_multisample]]<br />
<br />
=== GLX ===<br />
: (Was bedeutet [[GLX]] {{icpIcon}}?)<br />
: [[GLX_ARB_get_proc_address]]<br />
<br />
=== Herstellerabhängig ===<br />
: [[GL_ATI_draw_buffers]] <br />
: [[GL_HP_occlusion_test]]<br />
: [[GL_NV_fence]]<br />
: [[GL_NV_texture_env_combine4]]</div>Traudehttps://wiki.delphigl.com/index.php?title=Tutorial_Matrix2&diff=21881Tutorial Matrix22008-06-23T10:44:29Z<p>Traude: /* glRotate */</p>
<hr />
<div>=Matrizen und Matrixmanipulationen= <br />
<br />
== Vorwort == <br />
Willkommen bei meinem 2. Tutorial.<br> <br />
In letzter Zeit traten im Forum verstärkt fragen wie ''"Wie positioniere ich Objekte richtig?"'' und ''"Ich komm mit den Matrizen net klar. Könnt ihr helfen?"'' auf. Dies war Anlass für mich ein weiteres Tutorial zum Thema Matrizen zu schreiben. Ich werde versuchen viel mit Bildern und Gleichnissen zu arbeiten. Wer aber das ganze Angebot zum Thema "Matrix" nutzen will sollte ruhig auch einen Blick auf Phobeus Matrixtutorial ([[Tutorial_lektion3]]) und auf den Wikiartikel zum Thema [[Matrix]] werfen. <br />
<br />
== Matrizen in OpenGL == <br />
<br />
OpenGL kennt 3 Matrizen. Wer OpenGL programmieren will sollte diese auch kennen: <br />
* '''GL_MODELVIEW''' - Die Modelviewmatrix <br />
: Die Modelviewmatrix sollte immer dann aktiviert sein, wenn ihr an die Grafikkarte [[Vertex]]daten senden wollt. Diese Matrix wird auf die Position der Vertices, die mit [[glVertex]] gesendet werden angewandt. Ebenso beeinflusst sie die Ausrichtung der [[Normalen]], die mit Hilfe von [[glNormal]] gesetzt werden. Kurz, alles was mit den Objekten eurer Welt zu tun hat, erfordert die Aktivierung dieser Matrix.<br />
* '''GL_PROJECTION''' - Die Projektionsmatrix <br />
: Diese Matrix wird selten gebraucht. Sie bestimmt, wie am Ende alles angezeigt wird. Sie bestimmt quasi die Eigenschaften der "Kamera". <br />
* '''GL_TEXTURE''' - Die Texturmatrix <br />
: Diese Matrix wird auf die Texturkoordinaten angewandt, mit der Folge, dass sich die Texturen auf den Oberflächen bewegen.<br />
<br />
Diese 3 Matrizen können per [[glMatrixMode]] aktiviert werden. Dabei kann immer nur eine Matrix aktiv sein. Wenn ihr z.B. {{INLINE_CODE|glMatrixMode(GL_MODELVIEW)}} aufgerufen habt, dann sagt man "Die Modelviewmatrix ist die '''''aktuelle Matrix'''''". Alle Matrixmanipulationen (wir kommen gleich dazu was das ist) wirken sich ''nur'' auf die ''aktuelle Matrix'' aus.<br />
<br />
== Kurze Matrixtheorie == <br />
''Was sind Matrizen?'' <br> <br />
Matrizen sind aufgebaut wie Tabellen. Das tolle daran ist - man kann damit rechnen. <br> <br />
''"Gaaaaanz toll! Jetzt rechnen die schon mit Tabellen..."''<br> <br />
So schlimm ist das gar nicht. Denn das Rechnen übernimmt OpenGL für uns. Ihr müsst nur wissen, dass wann immer ihr einen Befehl wie [[glTranslate]], [[glRotate]] oder [[glScale]] verwendet, ihr eine Matrix mit der ''aktuellen Matrix'' multipliziert. <br />
{{Hinweis|Wenn ihr wissen wollt, wie man Matrizen miteinander multipliziert, dann lest euch einmal den Artikel "[[Matrix]]" durch und auch das dort verlinkte PDF "CompGeoScript".}} <br />
<br />
== Wie sehen Matrizen aus? == <br />
In "echt" sehen Matrizen wie Tabellen voller Zahlen aus. <br> <br />
Will man sich eine Matrix grafisch vorstellen, sollte man sich ein 3 dimensionales Gitter vorstellen. Dieses Gitter ist das Koordinatensystem der Matrix. Wenn ihr mit [[glTranslate]], [[glRotate]] oder [[glScale]] die Matrix manipuliert, dann verändert ihr die Position des Koordinatenursprungs (glTranslate), die Ausrichtung der Achsen (glRotate) oder die Maße (glScale). Im dritten Teil des Tutorials gehe ich auf die Auswirkungen dieser Befehle noch einmal genauer ein. <br />
<br />
<br />
<br />
= Die drei OpenGL Matrizen = <br />
<br />
== GL_PROJECTION == <br />
Ich möchte zuerst einmal die Projektionsmatrix vorstellen. Diese Matrix wird meist nur am Rande erwähnt, macht aber einen verdammt wichtigen Job: Sie projeziert den Inhalt der Welt auf den Bildschirm. <br />
<br />
Wenn ihr der Projektionsmatrix per [[glLoadMatrix]] eine Matrix zuweist, die nur Nullen enthält, werdet ihr feststellen, dass ihr nichts seht. Ihr habt damit nämlich die Projektionsmatrix ausgeschaltet und da wir ja was sehen wollen, unterlassen wir das in Zukunft lieber ;). <br />
<br />
''Aber was kann man dann mit der Projektionsmatrix machen (,außer sie nicht auszuschalten ;-) )?'' <br> <br />
Bei der Vorstellung der einzelnen Matrizen erwähnte ich bereits die "Kamera". Um gleich mal eins festzustellen: Ein Objekt "Kamera" existiert nicht. Das einzigste was man von der "Kamera" mitbekommt ist die Ausgabe. Und wie wir gerade gelernt haben ist welcher Teil für die Ausgabe zuständig? Richtig! Die Projektionsmatrix. Sie ist unsere "Kamera". <br />
<br />
Kommt jetzt aber bitte nicht auf die Idee, eure Projektionsmatrix per '''glTranslate''' und '''glRotate''' irgendwohin zu bewegen... Das ist nämlich gar nicht die Aufgabe der Projektionsmatrix. Ihre Aufgabe ist "das Abbild für die Ausgabe zu manipulieren". <br />
<br />
Im Ausgangszustand ([[glLoadIdentity]] wurde für die Projektionsmatrix aufgerufen), gibt die Projektionsmatrix das Bild der Welt unverändert aus. Wenn man '''glTranslate''' auf die Projektionsmatrix anwendet, dann verschiebt man nicht die Welt, sondern sagt der Projektionsmatrix, dass sie das gesehene Bild verschieben soll. <br />
<br />
Befehle wie [[gluPerspective]] und [[glOrtho]] sind typische Befehle zum einstellen der Projektionsmatrix. Diese Befehle bestimmen nämlich in welcher Form die Ausgabe gemacht wird. Entweder perspektivisch verzerrt (gluPerspective) oder durch Parallelprojektion (glOrtho).<br />
<br />
Wenn man die Projektionsmatrix manipuliert, ist das vergleichbar mit dem Austauschen des Objektivs bei einer Kamera. Man könnt sogar über die Projektionsmatrix einen "Fischauge" Effekt erzeugen... (Aber fragt mich bitte nicht, wie die Matrix dazu aussieht... ;-) Falls ihrs wißt, einfach im Forum posten. Ich wäre interessiert.)<br />
<br />
== GL_MODELVIEW == <br />
Wie bereits erwähnt ist die Modelviewmatrix die wichtigste Matrix in der OpenGL Welt, denn sie wirkt sich auf Ausrichtung und Position aller Primitive und damit Objekte in der OpenGL Welt aus. Ohne Daten in der Modelviewmatrix, kann die Projektionsmatrix auch nichts ausgeben. <br />
<br />
Wenn ihr [[Vertex]]daten an die Grafikkarte übermittelt solltet ihr die Modelviewmatrix aktiviert haben. Positionsangaben wie z.B. {{INLINE_CODE|glVertex3f(1,0,1);}} beziehen sich auf das aktuelle Koordinatensystem. Das Koordinatensystem ist quasi der Teil der Matrix mit dem ihr arbeitet, und den ihr euch vorstellen könnt (/müßt.).<br><br />
Wie ihr bereits wisst kann man mit den Befehlen [[glTranslate]], [[glRotate]] und [[glScale]] das Koordinatensystem manipulieren. Dadurch seit ihr in der Lage beim "bauen" von Objekten mit "lokalen Koordinaten" zu arbeiten. <br />
<br />
=== lokale und globale Koordinaten === <br />
''Worin unterscheiden sich lokale und globale Koordinaten?'' <br> <br />
Um diese Frage zu klären bedarf es eines kleinen Beispiels: <br />
<br />
Stellt euch vor, ihr wollt zwei Würfel zeichnen. Der eine soll um den Punkt (3,4,5) mit einer Kantenlänge von 1 erstellt werden, der andere soll um den Punkt (1,2,3) mit Kantenlänge 2 und dazu 30° um die Y-Achse gedreht werden. <br />
<br />
Wenn man mit '''globalen''' Koordinaten arbeitet lässt man die Matrix so wie sie ist (verzichtet also auf die 3 genannten Befehle) und schreibt die Koordinaten der Eckpunkte per Hand hin: <br />
<pascal>glBegin(GL_QUADS); <br />
//Vorderseite erster Würfel <br />
glVertex3f(2,5,6); <br />
glVertex3f(2,3,6); <br />
glVertex3f(4,3,6); <br />
glVertex3f(4,5,6); <br />
//Nächste Seite <br />
[...] <br />
<br />
//Vorderseite zweiter Würfel <br />
glVertex3f(0,3,4); <br />
glVertex3f(0,1,4); <br />
glVertex3f(2,1,4); <br />
glVertex3f(2,3,4); <br />
[...] <br />
<br />
glEnd; <br />
</pascal> <br />
<br />
Bei '''lokalen''' Koordinaten bewegt man zuerst den Koordinatenursprung an die Stelle an die der Würfel entstehen soll, richtet dann wenn nötig die Achsen entsprechend aus, und kann dann '''lokale''' Koordinaten übergeben. Lokal bedeutet hier relativ zum aktuellen Koordinatensystem. <br />
<br />
''Aber was soll das für einen Vorteil haben?'' <br> <br />
Dem ein oder anderen ist vielleicht aufgefallen, dass wir 2x das selbe Objekt zeichnen sollen. Der einzigste Unterschied besteht in der Position, Ausrichtung und Größe/Scalierung. Um Arbeit zu sparen erstellt man deshalb ein Unterprogramm welches einen Einheitswürfel (Kantenlänge 1) rendert, und ruft vor dem zeichnen einfach die passende Kombination aus glTranslate, glRotate und glScale auf: <br />
<br />
<pascal>procedure zeichneWuerfel; <br />
begin <br />
glBegin(GL_QUADS); <br />
glVertex3f(-0.5, 0.5, 0.5); <br />
glVertex3f(-0.5,-0.5, 0.5); <br />
glVertex3f( 0.5,-0.5, 0.5); <br />
glVertex3f( 0.5, 0.5, 0.5); <br />
[...] <br />
glEnd; <br />
end; <br />
<br />
begin <br />
glPushMatrix; <br />
glTranslatef(3,4,5); <br />
zeichneWuerfel; <br />
glPopMatrix; <br />
glPushMatrix; <br />
glTranslatef(1,2,3); <br />
glRotatef(30,0,1,0); <br />
glScalef(2,2,2); <br />
zeichneWuerfel; <br />
glPopMatrix; <br />
end; <br />
</pascal> <br />
<br />
Wie ihr seht, haben lokale Koordinaten den Vorteil, dass man wiederverwendbaren Code schreiben kann. Bei globalen Koordinaten muss für jedes Objekt eigener Code geschrieben werden (und wenn sich das Objekt bewegt dann wieder...).<br />
<br />
Dreimal dürft ihr raten, welche Methode häufiger verwendet wird. ;-) <br />
{{Hinweis|Modeller wie 3D Studio Max benutzen globale Koordinaten beim exportieren der Modelle. Dies hat den Vorteil, dass beim importieren einer ganzen 3DS Szene, die Objekte gleich an der richtigen Position stehen, und nicht erst ausgerichtet werden müssen.}} <br />
<br />
== GL_TEXTURE == <br />
Dieser Matrix sollte endlich mehr Aufmerksamkeit geschenkt werden. Sie kann nämlich mit den Texturen in der Szene einiges anfangen... <br />
<br />
Aber der Reihe nach: <br />
<br />
Wie ihr vielleicht schon im [[Tutorial_lektion4|Einsteigertutorial 4 - Texturen]] gelesen habt, sind Texturkoordinaten immer so, dass {{INLINE_CODE|[[glTexCoord2f]](0,0)}} die obere linke Ecke und {{INLINE_CODE|glTexCoord2f(1,1)}} die untere Rechte Ecke der Textur betrifft. Wie die Textur außerhalb dieses Bereichs aussieht bestimmt ihr mittels [[glTexParameter]] und dem Parametern '''GL_TEXTURE_WRAP_S''' und '''GL_TEXTURE_WRAP_T'''. <br />
<br />
Nun stellt euch einmal vor, ihr habt 2 Quads die beide die selbe Textur bekommen sollen. Einziger Unterschied ist, dass bei dem einen Quad der Inhalt der Textur um 20° in Uhrzeigerrichtung gedreht ist. Blöd, oder? Das heißt ja jetzt, dass ihr in eurem Zeichenprogramm eine weitere Textur erstellen müßt, um das zweite Quad zu texturieren oder die Texturkoordinaten per Hand ändern müsst. <br> <br />
'''STOP!''' Ihr hab es sicherlich schon mitbekommen: Dieses Szenario kann leicht mit der Texturmatrix gelößt werden. Und zwar so... <br />
<br />
<pascal>procedure drawTexturedQuad; <br />
begin <br />
glBegin(GL_QUADS); <br />
glTexCoord(0,0); glVertex3f(-1, 1,0); <br />
glTexCoord(0,1); glVertex3f(-1,-1,0); <br />
glTexCoord(1,1); glVertex3f( 1,-1,0); <br />
glTexCoord(1,0); glVertex3f( 1, 1,0); <br />
glEnd; <br />
end; <br />
<br />
begin <br />
glMatrixMode(GL_MODELVIEW); <br />
glBindTexture(GL_TEXTURE_2D, texID); <br />
glTranslatef(-2,0,0); <br />
drawTexturedQuad; <br />
<br />
glMatrixMode(GL_TEXTURE); <br />
glRotatef(20,0,0,1); <br />
<br />
glMatrixMode(GL_MODELVIEW); <br />
glTranslatef(4,0,0); <br />
drawTexturedQuad; <br />
end;</pascal> <br />
''Was ist hier geschehn? ''<br><br />
Durch die vorherige Aktivierung der Texturmatrix wirkt sich das nachfolgende glRotate nicht auf die Modelle der Szene sondern auf die Texturkoordinaten aus. Auf gut deutsch: OpenGL dreht vor dem rendern des zweiten Quads die Textur um 20°. <br />
<br />
Wenn ihr beim rotieren der Texturmatrix, bei jedem Renderdurchlauf den Winkel um ein Stück erhöht passiert was?... Richtig! Eure Textur dreht sich auf eurem Quad... Das is dann quasi eure erste Animation... Und das ohne ein Objekt zu bewegen... Cool, oder?<br />
<br />
= Auswirkungen von Matrixmanipulationen - oder "Wie positioniere ich meine Objekte richtig?"= <br />
In diesem Teil des Tutorials möchte ich euch zeigen wie die 3 Befehle '''glTranslate, glRotate''' und '''glScale''' eure aktuelle Matrix verändern. Ich bleibe hierbei im 2 dimensionalen Raum, da sonst die Skizzen zu unübersichtlich werden. (Die Befehle sind dabei natürlich die selben wie für 3D Manipulationen. Ich ignoriere nur einfach immer die Y-Angaben.) <br />
<br />
Zuersteinmal zum warm werden: <br> <br />
[[Bild:Tutorial Matrix2 Ausgangsbild.png|framed|center|So stelle ich mir eine 2D-Matrix vor.]] <br />
<br />
<br />
==glTranslate== <br />
{{INLINE_CODE|[[glTranslate]](a,b,c)}} verschiebt den Koordinatenursprung des aktuellen Koordinatensystems um ''a'' Einheiten in die Richtung der X-Achse, um ''b'' Einheiten in die Richtung der Y-Achse und um ''c'' Einheiten in die Richtung der Z-Achse. <br />
<br />
[[Bild:Tutorial Matrix2 Translate.png|framed|center|Das passiert bei einer Translation um 3.5 Einheiten in X und -3 Einheiten in Z-Richtung.]] <br />
<br />
<br />
==glRotate== <br />
{{INLINE_CODE|[[glRotate]](w,x,y,z)}} rotiert das Koordinatensystem um ''w'' Grad um die Rotationsachse welche durch (0,0,0) und (''x,y,z'') verläuft. '''glRotate richtet also die Achsen neu aus.''' (Die Richtung der Achsen ist z.B. wichtig für glTranslate) <br />
<br />
[[Bild:Tutorial Matrix2 Rotate.png|framed|center|Das passiert bei einer Rotation um 45° mit der Y-Achse als Rotationsachse.]]<br />
<br />
==glScale== <br />
{{INLINE_CODE|[[glScale]](x,y,z)}} skaliert die Maße der Koordinatenachsen (Bestimmt also wie lange "eine Einheit" wirklich ist). Wenn ''x,y'' oder ''z'' größer als 1 ist, werden die Maßeinheiten der entsprechenden Achse gestreckt, wenn die Werte kleiner 1 sind gestaucht. (Wenn die Werte gleich 0 sind verschwindet die Szene auf nimmer wieder sehn(, da hilft dann nur noch glLoadIdentity um die Matrix wieder nutzbar zu machen), sind die Werte gleich 1 verändert sich nichts.) <br />
<br />
''x,y'' und ''z'' muss man sich als Prozentangaben vorstellen. Will man die Szene in X-Richtung um das doppelte (also 200%) vergrößern/strecken muss ''x'' gleich 2 sein. Will man die Y-Richtung auf ein Zehntel (also 10%) verkürzen/stauchen muss ''y'' gleich 0.1 sein. <br />
<br />
[[Bild:Tutorial Matrix2 Scale.png|framed|center|Das passiert bei einer Skalierung. Wie ihr seht, sind die Seiten unterschiedlich skaliert worden (X-Achse: 80%, Z-Achse: 60%).]] <br />
<br />
<br />
==Kombination - Translate vor Rotate== <br />
Wird Translate vor Rotate aufgerufen, bewegt sich der Koordinatenursprung zuerst an den Zielpunkt (über glTranslate angegeben). Anschließend werden die Achsen neu ausgerichtet (durch glRotate). <br />
<br />
<div align="center"> <br />
{|{{Prettytable}} <br />
|Folgender Code wird demonstriert: <br />
<pascal> <br />
glTranslatef(3.5,0,-3); <br />
glRotatef(45, 0, 1, 0); <br />
ZeichneKoordinatensystem; <br />
</pascal> <br />
|- <br />
|[[Bild:Tutorial Matrix2 Ausgangsbild.png|framed|center|Bevor glTranslate aufgerufen wurde.]] <br />
|- <br />
|[[Bild:Tutorial Matrix2 Translate.png|framed|center|Nachdem glTranslate aufgerufen wurde.]] <br />
|- <br />
|[[Bild:Tutorial Matrix2 TranslateRot.png|framed|center|Nachdem glRotate aufgerufen wurde. Man sieht, dass die jeweils vorhergehende Veränderung bestehend bleibt, und die Basis für die nachfolgende Änderung bildet.]] <br />
|}</div> <br />
<br />
<br />
Wird der Winkel von glRotate bei jedem Renderdurchlauf erhöht, dreht sich ein anschließend gezeichnetes Objekt um die durch glTranslate angegeben Position. <br />
<br />
<br />
==Kombination - Rotate vor Translate== <br />
Wird Rotate vor Translate aufgerufen, werden zuerst die Achsen neu ausgerichtet und dann der Koordinatenursprung bezüglich dieser neuen Achsen verschoben. <br />
<br />
<div align="center"> <br />
{|{{Prettytable}} <br />
|Folgender Code wird demonstriert: <br />
<pascal> <br />
glRotatef(45, 0, 1, 0); <br />
glTranslatef(3.5,0,-3); <br />
ZeichneKoordinatensystem; <br />
</pascal> <br />
|- <br />
|[[Bild:Tutorial Matrix2 Ausgangsbild.png|framed|center|Bevor glRotate aufgerufen wurde.]] <br />
|- <br />
|[[Bild:Tutorial Matrix2 Rotate.png|framed|center|Nachdem glRotate aufgerufen wurde.]] <br />
|- <br />
|[[Bild:Tutorial Matrix2 RotateTrans.png|framed|center|Nachdem glTranslate aufgerufen wurde. Man sieht, dass die vorhergehende Rotation die Verschieberichtung beeinflusst.]] <br />
|}</div> <br />
<br />
Wird der Winkel von glRotate bei jedem Renderdurchlauf erhöht, bewegt sich ein nach glTranslate gezeichnetes Objekt auf einer Kreisbahn um den Koordinatenursprung wie er beim Aufruf von glRotate aktuell war. Der Radius der Kreisbahn wird durch glTranslate bestimmt. <br />
<br />
<br />
Wenn man die beiden Ergebnisse direkt vergleicht sieht man, dass die Reihenfolge von Bedeutung für das Ergebniss ist. Das die Unterschiede so "klein" ausfallen liegt nur daran, dass bei rotate nicht mit größeren Winkeln rotiert wurde. <br />
<br />
<br />
<div align="center"> <br />
{|{{Prettytable}} <br />
|width="50%" | [[Bild:Tutorial Matrix2 RotateTrans.png|framed|center|Erst Rotiert]] <br />
|- <br />
|width="50%" | [[Bild:Tutorial Matrix2 TranslateRot.png|framed|center|Erst Verschoben]] <br />
|}</div><br />
<br />
==Kombination - Scale vor Rotate== <br />
Die Rotation wird nur von der Richung, nicht aber der Länge der Achsen beeinflusst. Der Winkel um den gedreht wird, bleibt von der Skalierung unberührt (45° bleiben 45°. Die Achsen zeigen anschließend jeweils in die gleiche Richtung) <br />
<br />
<div align="center"> <br />
{|{{Prettytable}} <br />
|Folgender Code wird demonstriert: <br />
<pascal> <br />
glScalef(0.8, 1, 0.6); <br />
glRotatef(45, 0, 1, 0); <br />
ZeichneKoordinatensystem; <br />
</pascal> <br />
|- <br />
|[[Bild:Tutorial Matrix2 Ausgangsbild.png|framed|center|Bevor glScale aufgerufen wurde.]] <br />
|- <br />
|[[Bild:Tutorial Matrix2 Scale.png|framed|center|Nachdem glScale aufgerufen wurde.]] <br />
|- <br />
|[[Bild:Tutorial Matrix2 ScaleRot.png|framed|center|Nachdem glRotate aufgerufen wurde. Man sieht, dass die Skalierung den Winkel nicht beeinflusst. Das Koordinatensystem wurde korrekt um 45° gedreht.]] <br />
|}</div> <br />
<br />
Der direkte Vergleich zeigt, dass die Skalierung keinen Effekt auf den Winkel hatte. Beide Koordinatensysteme sind gleich ausgerichtet: <br />
<div align="center"> <br />
{|{{Prettytable}} <br />
|width="50%" | [[Bild:Tutorial Matrix2 Rotate.png|framed|center|Unskaliert]] <br />
|- <br />
|width="50%" | [[Bild:Tutorial Matrix2 ScaleRot.png|framed|center|Skaliert]] <br />
|}</div> <br />
<br />
<br />
==Kombination - Scale vor Translate== <br />
Die Verschiebung ist Abhängig von der Ausrichtung der Achsen (glRotate) und der Maße der Achsen (glScale). Aus diesem Grunde beeinflusst glScale die nachfolgenden Translationen. <br />
<br />
<div align="center"> <br />
{|{{Prettytable}} <br />
|Folgender Code wird demonstriert: <br />
<pascal> <br />
glScalef(0.8, 1, 0.6); <br />
glTranslatef(3.5,0,-3); <br />
ZeichneKoordinatensystem; <br />
</pascal> <br />
|- <br />
|[[Bild:Tutorial Matrix2 Ausgangsbild.png|framed|center|Bevor glScale aufgerufen wurde.]] <br />
|- <br />
|[[Bild:Tutorial Matrix2 Scale.png|framed|center|Nachdem glScale aufgerufen wurde.]] <br />
|- <br />
|[[Bild:Tutorial Matrix2 ScaleTrans.png|framed|center|Nachdem glTranslate aufgerufen wurde.]] <br />
|}</div> <br />
<br />
Der direkte Vergleich zeigt, dass sich die Skalierung auf die Verschiebung auswirkt. Denn obwohl der Verschiebung in die gleiche Richtung und um den selben Wert erfolgt, sind die Resultate nicht identisch. Dies liegt daran, dass glScale die Maße verändert hat. Die Verschiebung in X-Richtung erreicht dadurch nur 80% und in Z-Richtung sogar nur 60% der unskalierten Transformation: <br />
<div align="center"> <br />
{|{{Prettytable}} <br />
|width="50%" | [[Bild:Tutorial Matrix2 Translate.png|framed|center|Unskaliert]] <br />
|- <br />
|width="50%" | [[Bild:Tutorial Matrix2 ScaleTrans.png|framed|center|Skaliert]] <br />
|}</div> <br />
<br />
<br />
<br />
=Nachwort= <br />
7 Stunden sind vorbei und das Tutorial ist auf eine ordentliche Länge angewachsen. Ich hoffe ich konnte euch die OpenGL Matrizen etwas näher bringen. <br />
<br />
Wer jetzt denkt ''"Bilder sind mir zu statisch!"'', dem möchte ich noch diese Programme ans Herz legen: <br />
<div align="center"><br />
{|{{Prettytable}}<br />
!Name<br />
!Hersteller<br />
!Beschreibung<br />
|-<br />
|[http://www.delphigl.com/forum/viewtopic.php?p=37378#37378 '''Matrix2 - Skizzenrenderer''']<br />
|Flash<br />
|Dieses Programm habe ich geschrieben um die Skizzen für dieses Tutorial zu erstellen. Es wurde so modifiziert, dass man beliebige Kombinationen von glTranslate, glRotate und glScale anzeigen kann. <br />
|-<br />
|[http://www.phobeus.de/hosting/shared/pixelpracht/main.php?s=opengl&t=1&p=2 '''Matrix Control''']<br />
|Lithander<br />
|Das Programm erlaubt euch zu beobachten, wie die Matrizen sich bei den einzelnen Befehlen verändern und wie die Ausgabe aussieht. Besonderheit an diesem Programm ist, dass ihr die Matrizen auch per Hand manipulieren könnt.<br />
|}</div><br />
<br />
Sollten immer noch Unklarheiten bestehen bleibt das Forum natürlich auch weiterhin die Anlaufstelle Nummer1. Dies betrifft auch euer Feedback zum Tutorial. <br />
<br />
MfG <br />
: Flash ('''Kevin Fleischer''') <br />
<br />
{{TUTORIAL_NAVIGATION|[[Tutorial_2D]]|-}} <br />
<br />
[[Kategorie:Tutorial|Matrix2]]</div>Traudehttps://wiki.delphigl.com/index.php?title=Modelformat&diff=21711Modelformat2008-05-14T08:37:40Z<p>Traude: Korrekturgelesen, kleine Grammatikfehler korrigiert</p>
<hr />
<div>Es gibt einige Arten von Modelformaten: Textbasierende, binäre, sogar grafische (siehe parametrisierte Geometry Maps).<br />
Die Formate sind auf bestimmte Ziele ausgerichtet und dementsprechend auch im Aufbau unterschiedlich.<br />
<br />
<br />
In diesem Artikel möchte ich ein für OpenGL optimiertes Format vorstellen, welches als weiteres Kriterium eine sehr geringe CPU und Ladezeit in Anspruch nimmt. Also sollten wir uns erstmal die für OpenGL benötigten Daten angucken.<br />
<br />
<cpp>typedef Vertex float x,y,z;<br />
typedef Color float r,g,b;<br />
typedef Normal float x,y,z;<br />
typedef Texcoord float u,v;<br />
typedef Index unsigned int i;</cpp><br />
<br />
<br />
OpenGL bietet mehrere Möglichkeiten diese Daten darzustellen.<br />
*[[VBO]] (vertex buffer object)<br />
*Bruteforce([[glBegin]]/glEnd)<br />
*[[Vertexarray]]<br />
*[[Displayliste]]<br />
Die effektivsten Varianten sind Displaylisten mit Vertexarray und VBO. Displaylisten haben aber den Nachteil, dass sie geringfügig langsamer und nicht so flexibel wie VBO sind. VBO bietet uns zwei Möglichkeiten, die Daten in den VRam zu speichern: als einzelne Streams oder als ein einziger Stream. Hier sollte man alle Daten als einzelne Streams behandeln, also Vertexliste, Normalliste, Colorliste,... . So können wir später einzelne Streams abschalten und anschalten, wenn wir sie beim Zeichnen benötigen.<br />
<br />
<br />
Wozu der Index? Der Index zeigt auf einen Wert in der Vertex-, Color-, Normal-, ...-Stream. Man kann also bei großen Models viel Platz sparen, wenn man Indices verwendet, da man jedes Datenelement nur einmal ablegt und durch den Index mehrfach verwenden kann.<br />
<cpp>struct Model<br />
{<br />
Vertex *Verticelist;<br />
Normal *Normallist;<br />
Color *Colorlist;<br />
Texcoord *Texcoordlist;<br />
Index *Indices;<br />
};</cpp><br />
<br />
Nun brauchen wir auch Texturen und Shader für unsere Models. Um diese zu verwenden brauchen wir Faces, also müssen wir Flächen bilden. Jede Fläche bekommt den Startindex, die Vertexcount und nun noch das Material. Das Material ist ein Name, über den wir auf eine Ressource zugreifen können, die die Texturen und Shader verwalten.<br />
<cpp>struct Face<br />
{<br />
unsigned int Start;<br />
unsigned int Count;<br />
string MaterialName;<br />
};</cpp><br />
<br><br />
Der Name ist allerdings ziemlich groß und würde in jeden Face wieder auftreten. Also speichern wir im Format eine Liste von Materialnamen und speichern im Face den Index in der Liste.<br />
<cpp>struct Face<br />
{<br />
unsigned int Start;<br />
unsigned int Count;<br />
unsigned int MaterialIndex;<br />
};<br />
<br />
struct Model<br />
{<br />
Vertex *Verticelist;<br />
Normal *Normallist;<br />
Color *Colorlist;<br />
Texcoord *Texcoordlist;<br />
Index *Indices;<br />
string *MaterialList[32]; //feste Strings sind besser zu laden<br />
Face *Facelist;<br />
};</cpp><br />
<br><br />
Für das Material File könnte z.B. ein Script oder eine XML Datei erstellt werden, die alle benötigten Texturen, Flags und Shader enthält. Wenn man Shader verwendet, dann könnte man die Tangenten mit dazu packen. <br />
<br />
Okay, nun müssen wir die Daten auch noch speichern und das möglichst in einer schnell ladbaren Form. Hier kann man Serializing aufgreifen und die Daten und den Lader entsprechend anpassen. Bei diesem Ansatz wird jede dynamische Variable (arrays/pointer) überarbeitet. Alle Daten, die gleich bleiben, werden 1 zu 1 geschrieben, für die dynamischen Daten wird ein Bereich am Ende des Formates zur Verfügung gestellt und dorthin verschoben. Die Differenz zwischen Position des Pointers/Array und der Stelle der abgelegten Daten ist der Offset und wird an der Stelle der Liste geschrieben. <br />
Ein Beispiel kann das wohl besser beschreiben:<br />
<br />
<cpp>//eigentliche Struktur<br />
struct Data<br />
{<br />
unsigned int VerticeCount;<br />
Vertex* Vertice; //Array durch verticecount korrekt nutzbar (Delphi pVertex(Vertice+i)^ oder bei c++/freepascal Vertice[i])<br />
};<br />
<br />
//gut speicherbare und ladbare Version<br />
struct SpeicherbareDaten<br />
{<br />
unsigned int VerticeCount;<br />
#if defined(64BIT)//Pointer sind 64bit groß, der Offset liegt vor relocate an der Pointerstelle<br />
Vertex* Vertice;<br />
#else<br />
#if defined(32BIT)//Pointer sind 32bit groß, der offset=pointer und die anderen 4 Byte sind toter speicher<br />
Vertex* Vertice;<br />
unsigned int unused;<br />
#else<br />
Die Bitarchitektur ist nicht vorgesehen.<br />
#endif<br />
#endif<br />
};<br />
<br />
void relocate(SpeicherbareDaten* Data)<br />
{<br />
Data->Vertice=(Vertex*)((char*)Data+(unsigned int)Data->Vertice);<br />
}</cpp><br />
Aktuell hat keine Console oder PC eine größere Speicheradressierung als 64Bit.<br />
Also werden die dynamischen Elemente mit offsets von 4byte und 4byte ungenutzt besetzt. Wir könnten die Daten nun mit einem read Aufruf laden und das relocate korrigiert den offset zu einem Pointer.<br />
<br />
<br />
Die Probleme der meisten Formate liegen im Aufbau, wenn oft noch geparsed und in mehreren Etappen geladen werden muss (braucht CPU Zeit und verschwendet Zeit beim Festplattenzugriff) und in der unpassenden Datenbeschaffenheit (eventuell konvertieren oder noch schlimmer, Speicherreservierung und konvertieren). Das oben beschriebene Speicher- und Ladesystem braucht nur einen einzigen Read Aufruf und hat danach die Daten komplett im Speicher. Dann noch ein relocate und wir haben die fertigen Daten. <br />
Der Vorteil des relocate ist, dass man lediglich für dynamische Elemente einmal eine Addition ausführt (10 Arrays = 10 Additionen).<br />
Durch die Anpassung an das von OpenGL gewollte Datenformat kann man ganz einfach die Daten in den VRam laden lassen (VBO Streams lassen grüssen) und leitet das Laden des Materials an die entsprechende Stelle weiter.<br />
<br />
<br />
Meine Umsetzung ist hier zu finden.<br />
*[https://svn.linuxprofessionals.org/filedetails.php?repname=karmarama&path=%2Ftrunk%2Finclude%2Fkar_model.hpp kar_model.hpp]<br />
*[https://svn.linuxprofessionals.org/filedetails.php?repname=karmarama&path=%2Ftrunk%2Fsrc%2Fkar_model.cpp kar_model.cpp]<br />
*[https://svn.linuxprofessionals.org/filedetails.php?repname=karmarama&path=%2Ftrunk%2Fdemos%2Fdata%2Fexporter.py exporter.py(Blender exporter Script)]<br />
Ein weiterer Vorteil ist der Codeumfang, denn dieser ist in meiner Implementierung gerademal 205 Zeilen lang.<br />
Mein Testmodel hatte ~15k Vertice, Normals, Texcoords, ~46k Indices, 15k Faces, 1Material und keine Properties.<br />
Die Dateigröße betrug 1,5MB und wurde in 7ms ungecached (erster Aufruf der Datei) und 3ms gecached(die Datei wurde seit dem Start von Windows schonmal angefasst) geladen, Pointer angepasst, VBOs für alle Daten erstellt und der Ladeprozess für die Textur angestoßen (alles in stolzen 7ms).<br />
Das Laden des ganzen Models mit der einer Textur (512x512 dxt5) hat knapp 20ms gedauert.<br />
[http://karmarama.developer-alliance.org/upload/model.PNG Ein nicht ganz aktuelles Screenshot.]<br />
<br />
<br />
Bei Fragen, Verbesserungsvorschlägen oder ähnlichem, mich([[Benutzer:TAK2004|TAK2004]) einfach per PM im Forum ansprechen.</div>Traude