Vertex Array Object - Versionsgeschichte

Glawesome: /* IBO */ Aussage war nicht in jedem Fall korrekt, jetzt korrigiert

2016-04-08T09:39:49Z

‎IBO: Aussage war nicht in jedem Fall korrekt, jetzt korrigiert

Glawesome: Klargestellt, dass sich ein VAO auch den ELEMENT_ARRAY_BUFFER merkt

2016-04-08T08:59:14Z

Klargestellt, dass sich ein VAO auch den ELEMENT_ARRAY_BUFFER merkt

Glawesome: Zwei Vertipper korrigiert

2013-08-20T14:03:12Z

Zwei Vertipper korrigiert

Glawesome: "Siehe auch"-Abschnitt ergänzt

2013-08-20T11:16:41Z

"Siehe auch"-Abschnitt ergänzt

Glawesome: Hinweise für Delphi-Programmierer ergänzt

2013-08-20T11:08:49Z

Hinweise für Delphi-Programmierer ergänzt

Glawesome am 20. August 2013 um 11:04 Uhr

2013-08-20T11:04:23Z

Glawesome: Die Seite wurde neu angelegt: „Willkommen zu meinem ersten Tutorial. Hier möchte ich euch erklären, was es mit Vertex Array Objects (VAOs) auf sich hat und wie man sie verwendet. ==Warum …“

2013-08-20T10:45:21Z

Die Seite wurde neu angelegt: „Willkommen zu meinem ersten Tutorial. Hier möchte ich euch erklären, was es mit Vertex Array Objects (VAOs) auf sich hat und wie man sie verwendet. ==Warum …“

Neue Seite

Willkommen zu meinem ersten Tutorial. Hier möchte ich euch erklären, was es mit Vertex Array Objects (VAOs) auf sich hat und wie man sie verwendet.

==Warum VAOs?==
Nun werdet ihr euch vermutlich fragen, warum ihr schon wieder ein neues "Object" (neben [[VBO]], [[IBO]], [[FBO]] usw.) kennenlernen sollt. Da gibt es im Wesentlichen zwei Gründe:
Erstens habt ihr keine Wahl, wenn ihr mit einem [[Tutorial_OpenGL3_Zeichenkontext|OpenGL-Kontext ab Version 3.0]] im forward-compatible Modus VBOs benutzen möchtet. Ohne VAOs geht es da nicht.
Zweitens, und das ist vermutlich der Grund für diesen Zwang in neueren OpenGL-Versionen: Es erspart euch beim Rendern einige API-Funktionsaufrufe (konkret: [[glBindBuffer]], [[glEnableVertexAttribArray]] und [[glDisableVertexAttribArray]]), was bekanntlich der [[Performance]] zuträglich ist.
<br>
==Was merkt sich ein VAO?==
In einem VAO wird gespeichert, welches Datenformat die Vertices haben, die ihr rendern möchtet. Also beispielsweise, dass ein Vertex aus 3 floats für die Position, 3 unsigned bytes für den Normalenvektor und 2 floats als Textur-Koordinaten besteht. Außerdem merkt sich das VAO, woher (aus welchem VBO) diese Daten gennomen werden sollen.

Kurz: Das VAO merkt sich alles, was ihr mit [[glVertexAttribPointer]] einstellen könnt.

Es ist wichtig, den Unterschied zwischen VBO und VAO zu verstehen. Man könnte sagen, das VBO enthält die eigentlichen Vertexdaten und das VAO enthält die Informationen, in welchem VBO sich die benötigten Daten befinden und in welchem Format sie vorliegen. Das VAO ist also eine Lesevorschrift für die Daten im VBO.

Ebenfalls wichtig: Obwohl im VAO gespeichert wird, aus welchem VBO die Daten beim Rendern entnommen werden sollen, führt das Binden den VAOs '''nicht''' dazu, dass das zugehörige VBO auch gebunden wird. Das ist auch nicht notwendig, denn welches VBO während des Zeichnens gebunden ist, hat keinen Einfluss auf den Rendervorgang. Entscheidend ist nur, welches VBO gebunden war, als das VAO initialisiert wurde (genauer: als ''glVertexAttribPointer'' aufgerufen wurde). Zum genauen Ablauf kommen wir im nächsten Abschnitt.
<br>
==Anwendung==
===Initialisierung===
====VBO====
Es empfiehlt sich, zuerst das VBO zu initialisieren. Da möchte ich an dieser Stelle nicht zu sehr in die Details gehen, denn dazu gibt es bereits ein eigenes Tutorial. Daher nur ein kurzes Stück Beispielcode:
<cpp>GLuint VboID;
glGenBuffers(1, &VboID);
glBindBuffer(GL_ARRAY_BUFFER, VboID);
glBufferData(GL_ARRAY_BUFFER, vbo_size, data, usage);</cpp>

====VAO====
Wie fast alles in OpenGL, haben auch Vertex Array Objects einen Namen, der auch hier eigentlich nur ein Integer ist. Um einen solchen Namen zu erhalten, rufen wir die Funktion [[glGenVertexArrays]] auf:
<cpp>GLuint VaoID;
glGenVertexArrays(1, &VaoID);</cpp>
Anschließend wird das VAO das erste Mal gebunden:
<cpp>glBindVertexArray(VaoID);</cpp>
Spätestens hier sollte das VBO [[glBindBuffer|gebunden]] werden, falls noch nicht geschehen. Nun werden die Funktionen [[glEnableVertexAttribArray]] und [[glVertexAttribPointer]] aufgerufen, um das Vertexformat festzulegen. Zum Beispiel:
<cpp>glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(TVertex), 0); // 3 floats für Position
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(TVertex), 12); // 3 floats für den Normalenvektor
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TVertex), 24); // 2 floats als Textur-Koordinaten</cpp>
Der erste Parameter der beiden Funktionen ist der Index des jeweils betroffenen Vertexshader-Attributs (eine Variable, die im Vertexshader mit ''attribute'' oder ''in'' deklariert wurde). Dieser muss entweder vor dem Linken des Shaders mit [[glBindAttribLocation]] festgelegt werden, oder er wird nach dem Linken mit [[glGetAttribLocation]] abgefragt.
Nun haben wir das VAO vollständig gefüllt. Jetzt können wir, falls wir das möchten ein anderes VAO binden, oder wir entbinden das aktuelle einfach mit
<cpp>glBindVertexArray(0);</cpp>
Damit sichern wir, dass sich nachfolgende Aufrufe von ''glVertexAttribPointer'' nicht auf unser VAO auswirken.

====IBO====
An dieser Stelle besteht nun optional die Möglichkeit, auch einen Indexpuffer anzulegen (dies kann aber genau so gut ganz am Anfang geschehen). Dazu wieder ein kleines Stück Code:
<cpp>GLuint IboID;
glGenBuffers(1, &IboID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IboID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibo_size, indexdata, usage);</cpp>

===Rendern===
Jetzt kommt der schöne Part. Da das komplette Vertexformat nämlich schon im VAO gespeichert ist, reicht ein einziger Aufruf von
<cpp>glBindVertexArray(VaoID);</cpp>
und schon stellt OpenGL alles so ein, wie wir es bei der Initialisierung festgelegt haben. Es ist jetzt nicht einmal mehr notwendig, ein VBO zu binden. Wir können einfach drauflos zeichnen:
<cpp>glDrawArrays(GL_TRIANGLES, 0, vertices_count);</cpp>
Wer nicht nur ein VBO, sondern auch einen Indexbuffer angelegt hat, der schreibt statt der letzten Zeile nun:
<cpp>glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IboID);
glDrawElements(GL_TRIANGLES, indices_count, GL_UNSIGNED_SHORT, 0);</cpp>

===Aufräumen===
Wenn wir das VAO nicht mehr benötigen, sollten wir es der Sauberkeit halber freigeben:
<cpp>glDeleteVertexArrays(1, &VaoID);</cpp>
[[glDeleteVertexArrays]] ist sozusagen das genaue Gegenstück zu ''glGenVertexArrays''.

@@ Zeile 45: / Zeile 45: @@
 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IboID);
 glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibo_size, indexdata, usage);</cpp>
-Man kann den Indexbuffer auch ganz am Anfang (vor dem VBO) anlegen. Jedoch muss ''glBindBuffer'' nach ''glBindVertexArray'' aufgerufen werden, damit sich das VAO den Indexbuffer merkt.
+Wichtig ist hierbei, dass ''glBindBuffer'' mit GL_ELEMENT_ARRAY_BUFFER nach ''glBindVertexArray'' aufgerufen werden muss. Sonst merkt sich das zuvor gebundene VAO den Indexbuffer (falls vorher ein anderes VAO gebunden war).
 ===VAO vor Veränderung "schützen"===

@@ Zeile 18: / Zeile 18: @@
 ===Initialisierung===
 ====VBO====
-Es empfiehlt sich, zuerst das VBO zu initialisieren. Da möchte ich an dieser Stelle nicht zu sehr in die Details gehen, denn dazu gibt es bereits ein eigenes Tutorial. Daher nur ein kurzes Stück Beispielcode:
+Es empfiehlt sich, zuerst das VBO zu initialisieren. Da möchte ich an dieser Stelle nicht zu sehr in die Details gehen, denn dazu gibt es bereits ein eigenes [[Tutorial_Vertexbufferobject|Tutorial]]. Daher nur ein kurzes Stück Beispielcode:
 <cpp>GLuint VboID;              // für Delphi-Programmierer: var VboID : GLuint;
 glGenBuffers(1, &VboID);   // in Pascal: glGenBuffers(1, @VboID);
@@ Zeile 65: / Zeile 65: @@
 ==Schlusswort==
 Das war schon alles! War doch gar nicht so schwer, oder? Falls dennoch Fragen offen geblieben sind, oder ihr etwas nicht versteht, dürft, nein sollt, ihr im [http://www.delphigl.com/forum/index.php Forum] gerne eure Fragen stellen. Ebenfalls freuen würde ich mich über Feedback zu diesem Tutorial oder zum Wiki allgemein. Dazu einfach einen Beitrag ins Unterforum [http://www.delphigl.com/forum/viewforum.php?f=8 "Feedback"] schreiben. In diesem Sinne: Vielen Dank fürs Lesen und Füße zurück! :)
 ==Links==
 http://www.opengl.org/wiki/Vertex_Specification#Vertex_Array_Object <br>
 [http://www.opengl.org/registry/specs/ARB/vertex_array_object.txt ARB_vertex_array_object] (Extension, um VAOs bereits in OpenGL 2.1 zu nutzen)

@@ Zeile 7: / Zeile 7: @@
 <br>
 ==Was merkt sich ein VAO?==
-In einem VAO wird gespeichert, welches Datenformat die Vertices haben, die ihr rendern möchtet. Also beispielsweise, dass ein Vertex aus 3 floats für die Position, 3 unsigned bytes für den Normalenvektor und 2 floats als Textur-Koordinaten besteht. Außerdem merkt sich das VAO, woher (aus welchem VBO) diese Daten genomen werden sollen.
+In einem VAO wird gespeichert, welches Datenformat die Vertices haben, die ihr rendern möchtet. Also beispielsweise, dass ein Vertex aus 3 floats für die Position, 3 unsigned bytes für den Normalenvektor und 2 floats als Textur-Koordinaten besteht. Außerdem merkt sich das VAO, woher (aus welchem VBO) diese Daten genomen werden sollen. Wenn ihr einen Indexbuffer bindet, merkt sich das VAO auch dies.
-Kurz: Das VAO merkt sich alles, was ihr mit [[glVertexAttribPointer]] einstellen könnt.
+Kurz: Das VAO merkt sich alles, was ihr mit [[glVertexAttribPointer]] einstellen könnt plus den GL_ELEMENT_ARRAY_BUFFER, falls ihr einen gebunden habt.
 Es ist wichtig, den Unterschied zwischen VBO und VAO zu verstehen. Man könnte sagen, das VBO enthält die eigentlichen Vertexdaten und das VAO enthält die Informationen, in welchem VBO sich die benötigten Daten befinden und in welchem Format sie vorliegen. Das VAO ist also eine Lesevorschrift für die Daten im VBO.
@@ Zeile 38: / Zeile 38: @@
 glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TVertex), 24); // 2 floats als Textur-Koordinaten</cpp>
 Der erste Parameter der beiden Funktionen ist der Index des jeweils betroffenen Vertexshader-Attributs (eine Variable, die im Vertexshader mit ''attribute'' oder ''in'' deklariert wurde). Dieser muss entweder vor dem Linken des Shaders mit [[glBindAttribLocation]] festgelegt werden, oder er wird nach dem Linken mit [[glGetAttribLocation]] abgefragt.
 ====IBO====
-An dieser Stelle besteht nun optional die Möglichkeit, auch einen Indexpuffer anzulegen (dies kann aber genau so gut ganz am Anfang geschehen). Dazu wieder ein kleines Stück Code:
+An dieser Stelle besteht nun optional die Möglichkeit, auch einen Indexpuffer anzulegen. Dazu wieder ein kleines Stück Code:
 <cpp>GLuint IboID;
 glGenBuffers(1, &IboID);
 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IboID);
 glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibo_size, indexdata, usage);</cpp>
 ===Rendern===
@@ Zeile 55: / Zeile 58: @@
 <cpp>glDrawArrays(GL_TRIANGLES, 0, vertices_count);</cpp>
 Wer nicht nur ein VBO, sondern auch einen Indexbuffer angelegt hat, der schreibt statt der letzten Zeile nun:
-<cpp>glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IboID);
+<cpp>glDrawElements(GL_TRIANGLES, indices_count, GL_UNSIGNED_SHORT, 0);</cpp>
 ===Aufräumen===

@@ Zeile 13: / Zeile 13: @@
 Es ist wichtig, den Unterschied zwischen VBO und VAO zu verstehen. Man könnte sagen, das VBO enthält die eigentlichen Vertexdaten und das VAO enthält die Informationen, in welchem VBO sich die benötigten Daten befinden und in welchem Format sie vorliegen. Das VAO ist also eine Lesevorschrift für die Daten im VBO.
-Ebenfalls wichtig: Obwohl im VAO gespeichert wird, aus welchem VBO die Daten beim Rendern entnommen werden sollen, führt das Binden den VAOs '''nicht''' dazu, dass das zugehörige VBO auch gebunden wird. Das ist auch nicht notwendig, denn welches VBO während des Zeichnens gebunden ist, hat keinen Einfluss auf den Rendervorgang. Entscheidend ist nur, welches VBO gebunden war, als das VAO initialisiert wurde (genauer: als ''glVertexAttribPointer'' aufgerufen wurde). Zum genauen Ablauf kommen wir im nächsten Abschnitt.
+Ebenfalls wichtig: Obwohl im VAO gespeichert wird, aus welchem VBO die Daten beim Rendern entnommen werden sollen, führt das Binden des VAOs '''nicht''' dazu, dass das zugehörige VBO auch gebunden wird. Das ist auch nicht notwendig, denn welches VBO während des Zeichnens gebunden ist, hat keinen Einfluss auf den Rendervorgang. Entscheidend ist nur, welches VBO gebunden war, als das VAO initialisiert wurde (genauer: als ''glVertexAttribPointer'' aufgerufen wurde). Zum genauen Ablauf kommen wir im nächsten Abschnitt.
 <br>
 ==Anwendung==
@@ Zeile 38: / Zeile 38: @@
 glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TVertex), 24); // 2 floats als Textur-Koordinaten</cpp>
 Der erste Parameter der beiden Funktionen ist der Index des jeweils betroffenen Vertexshader-Attributs (eine Variable, die im Vertexshader mit ''attribute'' oder ''in'' deklariert wurde). Dieser muss entweder vor dem Linken des Shaders mit [[glBindAttribLocation]] festgelegt werden, oder er wird nach dem Linken mit [[glGetAttribLocation]] abgefragt.
-Nun haben wir das VAO vollständig gefüllt. Jetzt können wir, falls wir das möchten ein anderes VAO binden, oder wir entbinden das aktuelle einfach mit
+Nun haben wir das VAO vollständig gefüllt. Jetzt können wir, falls wir das möchten, ein anderes VAO binden, oder wir entbinden das aktuelle einfach mit
 <cpp>glBindVertexArray(0);</cpp>
 Damit sichern wir, dass sich nachfolgende Aufrufe von ''glVertexAttribPointer'' nicht auf unser VAO auswirken.