Tutorial Vertexbufferobject - Versionsgeschichte

Mathias: /* Übergabe der Vertexdaten (Variante 1: Ohne Umweg über den Hauptspeicher) */

2018-05-22T20:40:06Z

‎Übergabe der Vertexdaten (Variante 1: Ohne Umweg über den Hauptspeicher)

Coolcat: /* Ave! */ Zeitgemäßge Überarbeitung

2011-05-04T08:30:10Z

‎Ave!: Zeitgemäßge Überarbeitung

Coolcat: /* Erstellen des Vertexbufferobjects */ ARB entfernt

2011-05-04T08:22:41Z

‎Erstellen des Vertexbufferobjects: ARB entfernt

Coolcat: /* Übergabe der Vertexdaten (Variante 1: Ohne Umweg über den Hauptspeicher) */ ARB entfernt...

2011-05-04T08:22:20Z

‎Übergabe der Vertexdaten (Variante 1: Ohne Umweg über den Hauptspeicher): ARB entfernt...

Coolcat: /* Ave! */ "vor kurzem" ist nicht mehr ganz zutreffend

2011-05-04T08:21:00Z

‎Ave!: "vor kurzem" ist nicht mehr ganz zutreffend

DGLBot: Der Ausdruck ''(.*?)'' wurde ersetzt mit ''$1''.

2009-03-10T18:15:30Z

Der Ausdruck ''<pascal>(.*?)</pascal>'' wurde ersetzt mit ''<source lang="pascal">$1</source>''.

Änderungen zeigen

Sascha Willems: /* Ave! */

2009-01-12T13:00:50Z

‎Ave!

Sascha Willems: Aktualisiert, kleine Änderungen, neue Extensions statt alter ARB-Varianten

2009-01-12T12:59:34Z

Aktualisiert, kleine Änderungen, neue Extensions statt alter ARB-Varianten

Ireyon: /* Weitere Vertexformate */

2009-01-05T17:20:07Z

‎Weitere Vertexformate

Ireyon: /* Weitere Vertexformate */

2009-01-03T18:22:03Z

‎Weitere Vertexformate

@@ Zeile 45: / Zeile 45: @@
 PVertex = ^TVertex;
 TVertex = packed record
- S,T,X,Y,Z : TGLFloat;
+  S, T, X, Y, Z: TGLFloat;
 end;
 </source>
@@ Zeile 55: / Zeile 55: @@
 <source lang="pascal">
-glBufferData(GL_ARRAY_BUFFER, VertexAnzahl*SizeOf(TVertex), nil, GL_STATIC_DRAW);
+glBufferData(GL_ARRAY_BUFFER, VertexAnzahl * SizeOf(TVertex), nil, GL_STATIC_DRAW);
 </source>
@@ Zeile 106: / Zeile 106: @@
 VertexDatenLaenge := 0;
 for i := 0 to High(MeineVertexDaten) do
- begin
+begin
- VertexPointer    := VBOPointer;
+  VertexPointer    := VBOPointer;
- VertexPointer^.X := GeneriertesVertex.X;
+  VertexPointer^.X := GeneriertesVertex.X;
- VertexPointer^.Y := GeneriertesVertex.Y;
+  VertexPointer^.Y := GeneriertesVertex.Y;
- VertexPointer^.Z := GeneriertesVertex.Z;
+  VertexPointer^.Z := GeneriertesVertex.Z;
- VertexPointer^.S := GeneriertesVertex.S;
+  VertexPointer^.S := GeneriertesVertex.S;
- VertexPointer^.T := GeneriertesVertex.T;
+  VertexPointer^.T := GeneriertesVertex.T;
- inc(Integer(VBOPointer), SizeOf(TVertex));
+  inc(Integer(VBOPointer), SizeOf(TVertex));
- inc(VertexDatenLaenge);
+  inc(VertexDatenLaenge);
- end;
+end;
 </source>

@@ Zeile 1: / Zeile 1: @@
 ==Ave!==
-Und willkommen zu meinem zweiten GL_ARB-Extension Tutorial. Diesmal beschäftigen wir uns mit der recht neuen '''GL_ARB_Vertex_Buffer_Object'''-Extension, die vom ARB am 12.Februar 2003 fertiggestellt und später im Jahr 2003 auch als Corefeature in OpenGL 1.5 promoted wurde.
+Und willkommen zu meinem zweiten Tutorial. Diesmal beschäftigen wir uns mit den sogenannten ''Vertex Buffer Objects''. Die Extension '''GL_ARB_vertex_buffer_object''' wurde vom ARB am 12.Februar 2003 fertiggestellt. Später im Jahr 2003 wurde sie in den Core von OpenGL 1.5 aufgenommen. In diesem Tutorial werden diese Core-Funktionen verwendet. Das Verhalten der Extension sollte aber identisch sein.
-VBOs (Vertex Buffer Objects) sind quasi eine Erweiterung der recht weit verbreiteten Vertexarrays, die jedoch den großen Vorteil besitzen, dass ihre Vertexdaten serverseitig, also im schnellen VRAM der Grafikkarte, statt wie bei den VAs im Hauptspeicher, abgelegt werden. Das ist bei einer Displayliste zwar (fast) genauso der Fall, allerdings können die Daten nicht so einfach dynamisch geändert werden, was bei einem VBO aber bei Bedarf sehr einfach ist.
+VBOs (Vertex Buffer Objects) sind quasi eine Erweiterung der Vertexarrays, die jedoch den großen Vorteil besitzen, dass ihre Vertexdaten serverseitig, also im schnellen VRAM der Grafikkarte, statt wie bei den VAs im Hauptspeicher, abgelegt werden. Das ist bei einer Displayliste zwar (fast) genauso der Fall, allerdings können die Daten nicht so einfach dynamisch geändert werden, was bei einem VBO aber bei Bedarf sehr einfach ist.
 Kurz gesagt vereint das VBO also die Flexibilität eines Vertexarrays mit der Geschwindigkeit einer Displayliste und eignet sich daher besonders für das Rendern aufwändiger Geometrie, egal ob statisch oder dynamisch.

@@ Zeile 29: / Zeile 29: @@
 <source lang="pascal">
-glBindBufferARB(GL_ARRAY_BUFFER, VBO);
+glBindBuffer(GL_ARRAY_BUFFER, VBO);
 glEnableClientState(GL_VERTEX_ARRAY);
 </source>

@@ Zeile 56: / Zeile 56: @@
 <source lang="pascal">
-glBufferDataARB(GL_ARRAY_BUFFER, VertexAnzahl*SizeOf(TVertex), nil, GL_STATIC_DRAW);
+glBufferData(GL_ARRAY_BUFFER, VertexAnzahl*SizeOf(TVertex), nil, GL_STATIC_DRAW);
 </source>

@@ Zeile 2: / Zeile 2: @@
 ==Ave!==
-Und willkommen zu meinem zweiten GL_ARB-Extension Tutorial. Diesmal beschäftigen wir uns mit der recht neuen '''GL_ARB_Vertex_Buffer_Object'''-Extension, die vom ARB am 12.Februar 2003 fertiggestellt und vor kurzem auch als Corefeature in OpenGL 1.5 promoted wurde.
+Und willkommen zu meinem zweiten GL_ARB-Extension Tutorial. Diesmal beschäftigen wir uns mit der recht neuen '''GL_ARB_Vertex_Buffer_Object'''-Extension, die vom ARB am 12.Februar 2003 fertiggestellt und später im Jahr 2003 auch als Corefeature in OpenGL 1.5 promoted wurde.
 VBOs (Vertex Buffer Objects) sind quasi eine Erweiterung der recht weit verbreiteten Vertexarrays, die jedoch den großen Vorteil besitzen, dass ihre Vertexdaten serverseitig, also im schnellen VRAM der Grafikkarte, statt wie bei den VAs im Hauptspeicher, abgelegt werden. Das ist bei einer Displayliste zwar (fast) genauso der Fall, allerdings können die Daten nicht so einfach dynamisch geändert werden, was bei einem VBO aber bei Bedarf sehr einfach ist.

@@ Zeile 10: / Zeile 10: @@
 Eine weitere tolle Neuerung der VBO-API ist die Tatsache, dass man sich von OpenGL einen Pointer übergeben lassen kann, mit dessen Hilfe man Vertexdaten direkt in den VRAM schreiben kann. Dadurch spart man sich natürlich den Umweg über den Hauptspeicher und somit auch den erhöhten Speicherbedarf des Programmes beim Laden von Modellen o.&nbsp;Ä.
-VBOs bieten übrigens auch die Möglichkeit, sie je nach Anwendungsfall vom Grafikkartentreiber "optimieren" zu lassen. So legt man Vertexdaten, die im Nachhinein nicht mehr verändert werden sollenm am besten mit dem Schlüsselwort ''STATIC_DRAW_ARB'' ab, während dynamische Vertexdaten über ''DYNAMIC_DRAW_ARB'' abgelegt werden sollten. Doch dazu gibts später nähere Informationen.
+VBOs bieten übrigens auch die Möglichkeit, sie je nach Anwendungsfall vom Grafikkartentreiber "optimieren" zu lassen. So legt man Vertexdaten, die im Nachhinein nicht mehr verändert werden sollenm am besten mit dem Schlüsselwort ''STATIC_DRAW'' ab, während dynamische Vertexdaten über ''DYNAMIC_DRAW'' abgelegt werden sollten. Doch dazu gibts später nähere Informationen.
 ==Hardwareunterstützung==

@@ Zeile 4: / Zeile 4: @@
 Und willkommen zu meinem zweiten GL_ARB-Extension Tutorial. Diesmal beschäftigen wir uns mit der recht neuen '''GL_ARB_Vertex_Buffer_Object'''-Extension, die vom ARB am 12.Februar 2003 fertiggestellt und vor kurzem auch als Corefeature in OpenGL 1.5 promoted wurde.
-VBOs (Vertex Buffer Object) sind quasi eine Erweiterung der recht weit verbreiteten Vertexarrays, die jedoch den großen Vorteil besitzen, dass ihre Vertexdaten serverseitig, also im schnellen VRAM der Grafikkarte, statt wie bei den VAs im Hauptspeicher, abgelegt werden. Das ist bei einer Displayliste zwar (fast) genauso der Fall, allerdings können die Daten nicht so einfach dynamisch geändert werden, was bei einem VBO aber bei Bedarf sehr einfach ist.
+VBOs (Vertex Buffer Objects) sind quasi eine Erweiterung der recht weit verbreiteten Vertexarrays, die jedoch den großen Vorteil besitzen, dass ihre Vertexdaten serverseitig, also im schnellen VRAM der Grafikkarte, statt wie bei den VAs im Hauptspeicher, abgelegt werden. Das ist bei einer Displayliste zwar (fast) genauso der Fall, allerdings können die Daten nicht so einfach dynamisch geändert werden, was bei einem VBO aber bei Bedarf sehr einfach ist.
 Kurz gesagt vereint das VBO also die Flexibilität eines Vertexarrays mit der Geschwindigkeit einer Displayliste und eignet sich daher besonders für das Rendern aufwändiger Geometrie, egal ob statisch oder dynamisch.
@@ Zeile 14: / Zeile 14: @@
 ==Hardwareunterstützung==
-Da '''GL_ARB_Vertex_Buffer_Object''' eine noch recht junge Extension ist, siehts mit der Hardwareunterstützung besonders auf älteren 3D-Beschleunigern nicht so toll aus. Allerdings haben sowohl ATI als auch NVidia in ihre aktuellsten Treiber für ältere Beschleuniger Softwareemulationen dieser Extension eingebaut, hinter der wohl im Endeffekt ein simples Vertexarray seinen Dienst verrichtet. Von daher wirds auf älteren Karten keine Geschwindigkeitszuwächse ggü. Vertexarrays geben, aber man erspart sich das umständliche Schreiben mehrerer Renderpfade für verschiedene Grafikkartengenerationen. (Infos zur Unterstützung von '''GL_ARB_VBO''' gibts [http://www.delphi3d.net/hardware/extsupport.php?extension=GL_ARB_vertex_buffer_object hier]).
+Inzwischen sollten alle gängigen Grafikkarten diese Extension problemlos unterstützen, ältere Modelle tun dies aber evtl. nur emuliert über den Treiber. Will man sein Programm auch für sehr alte Hardware (Karten älter als ATIs Radeon 9x00 bzw. NVidias GeForce 4-Serie) lauffähig machen, sollte man noch einen alternativen Renderpfad auf Basis von Displaylisten einbauen.
 ==Erstellen des Vertexbufferobjects==
@@ Zeile 21: / Zeile 21: @@
 <pascal>
-glGenBuffersARB(1, @VBO);
+glGenBuffers(1, @VBO);
 </pascal>
@@ Zeile 29: / Zeile 29: @@
 <pascal>
-glBindBufferARB(GL_ARRAY_BUFFER_ARB, VBO);
+glBindBufferARB(GL_ARRAY_BUFFER, VBO);
 glEnableClientState(GL_VERTEX_ARRAY);
 </pascal>
@@ Zeile 56: / Zeile 56: @@
 <pascal>
-glBufferDataARB(GL_ARRAY_BUFFER_ARB, VertexAnzahl*SizeOf(TVertex), nil, GL_STATIC_DRAW_ARB);
+glBufferDataARB(GL_ARRAY_BUFFER, VertexAnzahl*SizeOf(TVertex), nil, GL_STATIC_DRAW);
 </pascal>
-Schauen wir uns also mal die Parameter von [[glBufferDataARB]] an. Zuerst müssen wir OpenGL mitteilen, was für einen Puffer wir erstellen wollen (in zukünftigen Versionen werden wohl noch andere folgen, z.&nbsp;B. Überbuffer). In unserem Falle also einen Arraypuffer. Parameter zwei übergibt dann den Speicherplatz, den wir reservieren wollen und ist recht selbsterklärend. Der dritte Parameter würde normalerweise einen Pointer auf unsere Vertexdaten enthalten. Da wir diese aber nicht im Hauptspeicher abgelegt haben, sondern über einen Pointer dort noch ablegen wollen, übergeben wir hier '''nil'''. OpenGL nimmt dies zur Kenntnis und spuckt dementsprechend auch keinen Fehler aus.
+Schauen wir uns also mal die Parameter von [[glBufferData]] an. Zuerst müssen wir OpenGL mitteilen, was für einen Puffer wir erstellen wollen (in zukünftigen Versionen werden wohl noch andere folgen, z.&nbsp;B. Überbuffer). In unserem Falle also einen Arraypuffer. Parameter zwei übergibt dann den Speicherplatz, den wir reservieren wollen und ist recht selbsterklärend. Der dritte Parameter würde normalerweise einen Pointer auf unsere Vertexdaten enthalten. Da wir diese aber nicht im Hauptspeicher abgelegt haben, sondern über einen Pointer dort noch ablegen wollen, übergeben wir hier '''nil'''. OpenGL nimmt dies zur Kenntnis und spuckt dementsprechend auch keinen Fehler aus.
 Den letzten Parameter hab ich auch schon kurz in der Einführung angesprochen. Er teilt OpenGL mit, auf welchen Anwendungsfall unser VBO optimiert werden soll. Dabei gibt es folgende Anwendungsfälle,die ihr euch dann entsprechend eurer VBO-Verwendung aussuchen könnt:
 {|rules="all" border = "1"
-! STREAM_DRAW_ARB
+! STREAM_DRAW
 | Die Vertexdaten werden einmal übergeben und dann eher selten als Quelle für OpenGL-Befehle genutzt.
 |-
-! STREAM_READ_ARB
+! STREAM_READ
 | Die Vertexdaten werden einmal übergeben und dann selten von der Anwendung angefordert.
 |-
-! STREAM_COPY_ARB
+! STREAM_COPY
 | Die Vertexdaten werden einmal durch Kopieren von der GL übergeben und dann eher selten als Quelle für OpenGL-Befehle genutzt.
 |-
-! STATIC_DRAW_ARB
+! STATIC_DRAW
 | Die Vertexdaten werden einmal übergeben und dann recht oft von der Anwendung zum Rendern genutzt.
 |-
-! STATIC_READ_ARB
+! STATIC_READ
 | Die Vertexdaten werden einmal übergeben und dann recht oft von der Anwendung angefordert.
 |-
-! STATIC_COPY_ARB
+! STATIC_COPY
 | Die Vertexdaten werden einmal durch Kopieren von der GL übergeben und dann recht oft von der Anwendung zum Rendern genutzt.
 |-
-! DYNAMIC_DRAW_ARB
+! DYNAMIC_DRAW
 | Die Vertexdaten werden wiederholt angegeben (verändert) und recht oft von der Anwendung zum Rendern genutzt.
 |-
-! DYNAMIC_READ_ARB
+! DYNAMIC_READ
 | Die Vertexdaten werden wiederholt durch das Auslesen von Daten durch OpenGL angegeben (verändert) und oft von der Anwendung angefordert.
 |-
-! DYNAMIC_COPY_ARB
+! DYNAMIC_COPY
 | Die Vertexdaten werden wiederholt durch das Auslesen von Daten durch OpenGL angegeben (verändert) und recht oft zum Rendern genutzt.
 |}
@@ Zeile 97: / Zeile 97: @@
 <pascal>
-VBOPointer := glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
+VBOPointer := glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
 </pascal>
-Die Funktion [[glMapBufferARB]] liefert uns einen Pointer zurück, der den Speicherplatz des VBOs in den Adressraum des Clients "ummappt", also in den Hauptspeicher. Dadurch wird es dann möglich, über eine Adresse im Hauptspeicher des Rechners direkt in den Grafikkartenspeicher zu schreiben. Der zweite Parameter gibt übrigens an, das wir in das VBO schreiben wollen. Der einzige weitere zulässige Parameter ist hier '''GL_READ_ONLY_ARB''', welcher zum Auslesen des VBOs dient.
+Die Funktion [[glMapBuffer]] liefert uns einen Pointer zurück, der den Speicherplatz des VBOs in den Adressraum des Clients "ummappt", also in den Hauptspeicher. Dadurch wird es dann möglich, über eine Adresse im Hauptspeicher des Rechners direkt in den Grafikkartenspeicher zu schreiben. Der zweite Parameter gibt übrigens an, das wir in das VBO schreiben wollen. Der einzige weitere zulässige Parameter ist hier '''GL_READ_ONLY''', welcher zum Auslesen des VBOs dient.
 Endlich haben wir einen Pointer auf unser inzwischen auch im VRAM der Grafikkarte richtig dimensioniertes Vertexbufferobject, und sind nun in der Lage dort unsere Vertexdaten abzulegen. Was jetzt folgt ist ein wenig Pseudo-Code der diesen Vorgang darstellt. Pseudo-Code deshalb, weil die Vertexdaten die ins VBO kommen ja in jeder Anwendung unterschiedlich sind, und man so auch selbst ein wenig denken muss:
@@ Zeile 129: / Zeile 129: @@
 <pascal>
-glUnMapBufferARB(GL_ARRAY_BUFFER_ARB);
+glUnMapBuffer(GL_ARRAY_BUFFER);
 </pascal>
@@ Zeile 141: / Zeile 141: @@
 <pascal>
-glBufferDataARB(GL_ARRAY_BUFFER_ARB, SizeOf(VertexDaten), @VertexDaten, GL_STATIC_DRAW_ARB);
+glBufferData(GL_ARRAY_BUFFER, SizeOf(VertexDaten), @VertexDaten, GL_STATIC_DRAW);
 </pascal>
@@ Zeile 164: / Zeile 164: @@
 <pascal>
-glDeleteBuffersARB(1, @VBO);
+glDeleteBuffers(1, @VBO);
 </pascal>
@@ Zeile 191: / Zeile 191: @@
 Es ist sinnvoll, sich für jedes der Vertexformate, die man verwendet, einen Typen anzulegen, um später einfacher mit den VBOs arbeiten zu können.
 ==Nachwort==

@@ Zeile 171: / Zeile 171: @@
 Als Angabe gibt es '''V'''ertex, '''T'''exturkoordinaten, '''N'''ormalen und '''C'''olor-Werte, also Farben.
 Anzahl ist die Anzahl der Komponenten pro Angabe (V3 wären zum Bespiel die X, Y und Z-Koordinaten eines dreidimensionalen Vertex).
-Typ ist entweder '''F'''loat oder '''U'''nsigned '''Byte'''. Die Vertexdaten müssen in der richtigen Reihenfolge mit den richtigen Typen an das VBO übergeben werden.
+Typ ist entweder '''F'''loat oder '''U'''nsigned '''B'''yte. Die Vertexdaten müssen in der richtigen Reihenfolge mit den richtigen Typen an das VBO übergeben werden.
 <pascal>

@@ Zeile 185: / Zeile 185: @@
    GL_T2F_C4UB_V3F
    GL_T2F_C3F_V3F
-   GL_T2F_N3F_V3F      // Wohl eine der sinnvollsten Vertexformate. 2 Floats für Texturkoordinaten, 3 Floats für den Normalenvektor und 3 Floats für den eigentlichen Vertex.
+   GL_T2F_N3F_V3F      // Wohl eines der sinnvollsten Vertexformate. 2 Floats für Texturkoordinaten, 3 Floats für den Normalenvektor und 3 Floats für den eigentlichen Vertex.
    GL_T2F_C4F_N3F_V3F
    GL_T4F_C4F_N3F_V4F