Quelltext der Seite Vertex Array Object

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 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 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.

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==
===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_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);
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.

====IBO====
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>
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"===
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'' oder ''glBindBuffer'' nicht auf unser VAO auswirken.

===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>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''.

==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! :)

==Siehe auch==
[[Tutorial Vertexbufferobject]]<br>
[[VBO ohne glInterleavedArrays]]

==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)