DGL Wiki - Benutzerbeiträge [de]

Tiefentest

2010-02-20T10:50:55Z

Philip: Hinweis auf glDepthMask

Bei der Berechnung eines [[Fragment]]es, muss OpenGL feststellen können, welche Teile der Grafik im Vordergrund stehen und welche Objekte ganz oder teilweise durch andere Objekte verdeckt werden.

== Funktionsweise ==
Für den Tiefentest existiert der [[Tiefenpuffer]](ZBuffer). Dieser ist genauso gross wie der Framebuffer. Für jeden Pixel auf dem Bildschirm gibt es dann also einen weiteren Wert - den Eintrag im Tiefenpuffer.

Im ersten Schritt wird der gesamte Tiefenpuffer auf den größtmöglichen Wert initialisiert (also die maximale Distanz, siehe [[glClear]] und [[glClearDepth]]).
Sobald dann ein Objekt gerendert wird, wird für jeden Pixel überprüft, ob der Tiefenwert des Pixels dieses Objekts kleiner ist als der Wert im Tiefenpuffer. Ist dies der Fall, wird dieses Pixel in den Framebuffer gezeichnet und der Tiefenpuffer aktualisiert, ansonsten wird es verworfen. Der Test kann mittels [[glDepthFunc]] auch abgeändert werden. Zum Beispiel kann man dafür sorgen, dass auch gleich große Tiefenwerte akzeptiert werden.

Der Tiefentest findet verhältnismäßig früh in der [[Feste_Funktionspipeline#Fragment_Pipeline|Fragment-Pipeline]] statt, wodurch er sehr effizient nicht benötigte Fragmente ausschließen kann. Wenn Objekte tiefensortiert (in diesem Fall von vorne nach hinten) gezeichnet werden, ist der Tiefentest sehr gut geeignet um sehr früh nicht benötigte Fragmente zu verwerfen um so die [[Füllrate]] zu schonen.

Den Tiefentest aktiviert man mit [[glEnable#GL_DEPTH_TEST|glEnable(GL_DEPTH_TEST)]] und deaktiviert ihn entsprechend mit glDisable.

Außerdem kann man mit [[glDepthMask]] einstellen, ob beim Rendern des momentanen Objektes der Tiefenbuffer beschrieben werden soll oder nicht.

===Aufteilung des Tiefenpuffers===
Was steht im Tiefenpuffer? Im Tiefenpuffer steht nicht die Tiefe sondern die Tiefenzone. Beim erstellen der [[Renderkontext]]s wird angegeben, wie viele Bits für den ZBuffer zur Verfügung stehen. Bei 1Bit, gibt es genau 2^1=2 Tiefenzonen. Bei 4Bit 2^4=16 und bei 24Bit 2^24=16,7Mio Tiefenzonen. Der Bereich zwischen der Near- und Far-[[Clipping]]plane wird nun auf diese Zonen aufgeteilt. Fallen zwei Fragmente in die selbe Zone, entscheidet das durch [[glDepthFunc]] eingestellte Verhalten welches Fragment den Platz behalten/einnehmen darf.

'''Ein simples Beispiel''' 
{{Hinweis|Die Werte wurden in diesem Beispiel so gewählt, dass ganze Zahlen herauskommen. Das ist in der Realität sehr unwahrscheinlich.}}
ZNear liegt bei 1, ZFar liegt bei 257. Das heißt der Renderbereich ist 256 Einheiten groß.
Dem ZBuffer wurden nur 4Bit gegönnt (eine sehr niedrige Auflösung). Das heißt 16 Zonen.
Jede Tiefenzone ist (bei linearer Aufteilung) 256/16=16 OpenGL Einheiten tief.

Wird nun ein Fragment erzeugt, welches den Abstand z=17 zur Kamera hat (also Zone 2 von vorn) und ein anderes Fragment den Abstand z=35 hat (Zone 3) ist klar, welches Fragment näher ist.
Nehmen wir an es kommt ein drittes Fragment hinzu mit dem Abstand 20. Für uns ist klar, dass dieses hinter dem ersten Fragment gehört. Allerdings ist der ZBuffer nicht fein genug aufgelöst, um das genauso zu sehen. Für ihn fällt auch dieses Fragment in Zone 2 und unter Umständen entscheidet die glDepthFunc Einstellung nun sogar, dass das neue Fragment das alte überschreiben darf. D.h. das 3. Fragment ist sichtbar obwohl es verdeckt sein sollte!

Zu beachten ist, dass nicht Bitanzahl des ZBuffers allein, die Auflösung bestimmt. Auch die Distanz zwischen den beiden Clippingplanes spielt eine Rolle. Je größer diese wird, desto grober wird der ZBuffer aufgelöst.

=== Beispiel ===

[[Bild:Depthtest_nt_enabled.jpg|thumb|200px|Aktivierter Tiefentest]]
[[Bild:Depthtest_nt_disabled.jpg|thumb|200px|Deaktivierter Tiefentest]]
Dieser Rendercode wird einmal mit und einmal ohne Tiefentest verwendet.
glBegin(GL_QUADS);
glColor4f(1.0, 0.5, 0.5, 1.0);
glVertex3f(-1.0, 0.0, -1.0);
glVertex3f(-1.0, 0.0, 1.0);
glVertex3f(1.0, 0.0, 1.0);
glVertex3f(1.0, 0.0, -1.0);

glColor4f(0.5, 1.0, 0.5, 1.0);
glVertex3f(-1.0, 0.5, -1.0);
glVertex3f(-1.0, 0.5, 1.0);
glVertex3f(1.0, 0.5, 1.0);
glVertex3f(1.0, 0.5, -1.0);
glEnd;

Man kann deutlich erkennen, dass bei deaktiviertem Tiefentest das eigentlich vorne liegende rote Quad vom weiter hinten liegenden, allerdings später gerenderten, grünen Quad überdeckt wird.

== Transparenz und Tiefentest ==
Sobald Transparenz verwendet wird, kann der Tiefentest zumindest für diese Teile nicht mehr benutzt werden. Dies würde zu Fehlern führen, da das transparente Fragment ggfs. das durchscheinende, jedoch erst später an die Grafik-Pipeline gesendete und somit vom Tiefentest verworfene Fragment dahinter völlig verbirgt. Wenn man Transparente Fragmente nicht in den Tiefenbuffer schreibt, so können diese Fragmente von anderen, eigentlich weiter hinten liegenden, Fragmenten komplett überschrieben werden. 
Aus diesem Grund sollten Transparente Objekte nach allen anderen Objekten an OpenGL geschickt werden und diese möglichst von hinten nach vorne sortiert sein. Das Sortieren kann durch einen Alpha Wert im [[Framebuffer]] umgangen werden, jedoch ist dieser nur selten in Hardware vorhanden, wodurch in den weit langsameren Softwaremodus gewechselt wird.

Tiefentest

2010-02-20T10:50:28Z

Philip: /* Funktionsweise */

Bei der Berechnung eines [[Fragment]]es, muss OpenGL feststellen können, welche Teile der Grafik im Vordergrund stehen und welche Objekte ganz oder teilweise durch andere Objekte verdeckt werden.

== Funktionsweise ==
Für den Tiefentest existiert der [[Tiefenpuffer]](ZBuffer). Dieser ist genauso gross wie der Framebuffer. Für jeden Pixel auf dem Bildschirm gibt es dann also einen weiteren Wert - den Eintrag im Tiefenpuffer.

Im ersten Schritt wird der gesamte Tiefenpuffer auf den größtmöglichen Wert initialisiert (also die maximale Distanz, siehe [[glClear]] und [[glClearDepth]]).
Sobald dann ein Objekt gerendert wird, wird für jeden Pixel überprüft, ob der Tiefenwert des Pixels dieses Objekts kleiner ist als der Wert im Tiefenpuffer. Ist dies der Fall, wird dieses Pixel in den Framebuffer gezeichnet und der Tiefenpuffer aktualisiert, ansonsten wird es verworfen. Der Test kann mittels [[glDepthFunc]] auch abgeändert werden. Zum Beispiel kann man dafür sorgen, dass auch gleich große Tiefenwerte akzeptiert werden.

Der Tiefentest findet verhältnismäßig früh in der [[Feste_Funktionspipeline#Fragment_Pipeline|Fragment-Pipeline]] statt, wodurch er sehr effizient nicht benötigte Fragmente ausschließen kann. Wenn Objekte tiefensortiert (in diesem Fall von vorne nach hinten) gezeichnet werden, ist der Tiefentest sehr gut geeignet um sehr früh nicht benötigte Fragmente zu verwerfen um so die [[Füllrate]] zu schonen.

Den Tiefentest aktiviert man mit [[glEnable#GL_DEPTH_TEST|glEnable(GL_DEPTH_TEST)]] und deaktiviert ihn entsprechend mit glDisable.

Außerdem kann man mit [glDepthMask] einstellen, ob beim Rendern des momentanen Objektes der Tiefenbuffer beschrieben werden soll oder nicht.

===Aufteilung des Tiefenpuffers===
Was steht im Tiefenpuffer? Im Tiefenpuffer steht nicht die Tiefe sondern die Tiefenzone. Beim erstellen der [[Renderkontext]]s wird angegeben, wie viele Bits für den ZBuffer zur Verfügung stehen. Bei 1Bit, gibt es genau 2^1=2 Tiefenzonen. Bei 4Bit 2^4=16 und bei 24Bit 2^24=16,7Mio Tiefenzonen. Der Bereich zwischen der Near- und Far-[[Clipping]]plane wird nun auf diese Zonen aufgeteilt. Fallen zwei Fragmente in die selbe Zone, entscheidet das durch [[glDepthFunc]] eingestellte Verhalten welches Fragment den Platz behalten/einnehmen darf.

'''Ein simples Beispiel''' 
{{Hinweis|Die Werte wurden in diesem Beispiel so gewählt, dass ganze Zahlen herauskommen. Das ist in der Realität sehr unwahrscheinlich.}}
ZNear liegt bei 1, ZFar liegt bei 257. Das heißt der Renderbereich ist 256 Einheiten groß.
Dem ZBuffer wurden nur 4Bit gegönnt (eine sehr niedrige Auflösung). Das heißt 16 Zonen.
Jede Tiefenzone ist (bei linearer Aufteilung) 256/16=16 OpenGL Einheiten tief.

Wird nun ein Fragment erzeugt, welches den Abstand z=17 zur Kamera hat (also Zone 2 von vorn) und ein anderes Fragment den Abstand z=35 hat (Zone 3) ist klar, welches Fragment näher ist.
Nehmen wir an es kommt ein drittes Fragment hinzu mit dem Abstand 20. Für uns ist klar, dass dieses hinter dem ersten Fragment gehört. Allerdings ist der ZBuffer nicht fein genug aufgelöst, um das genauso zu sehen. Für ihn fällt auch dieses Fragment in Zone 2 und unter Umständen entscheidet die glDepthFunc Einstellung nun sogar, dass das neue Fragment das alte überschreiben darf. D.h. das 3. Fragment ist sichtbar obwohl es verdeckt sein sollte!

Zu beachten ist, dass nicht Bitanzahl des ZBuffers allein, die Auflösung bestimmt. Auch die Distanz zwischen den beiden Clippingplanes spielt eine Rolle. Je größer diese wird, desto grober wird der ZBuffer aufgelöst.

=== Beispiel ===

[[Bild:Depthtest_nt_enabled.jpg|thumb|200px|Aktivierter Tiefentest]]
[[Bild:Depthtest_nt_disabled.jpg|thumb|200px|Deaktivierter Tiefentest]]
Dieser Rendercode wird einmal mit und einmal ohne Tiefentest verwendet.
glBegin(GL_QUADS);
glColor4f(1.0, 0.5, 0.5, 1.0);
glVertex3f(-1.0, 0.0, -1.0);
glVertex3f(-1.0, 0.0, 1.0);
glVertex3f(1.0, 0.0, 1.0);
glVertex3f(1.0, 0.0, -1.0);

glColor4f(0.5, 1.0, 0.5, 1.0);
glVertex3f(-1.0, 0.5, -1.0);
glVertex3f(-1.0, 0.5, 1.0);
glVertex3f(1.0, 0.5, 1.0);
glVertex3f(1.0, 0.5, -1.0);
glEnd;

Man kann deutlich erkennen, dass bei deaktiviertem Tiefentest das eigentlich vorne liegende rote Quad vom weiter hinten liegenden, allerdings später gerenderten, grünen Quad überdeckt wird.

== Transparenz und Tiefentest ==
Sobald Transparenz verwendet wird, kann der Tiefentest zumindest für diese Teile nicht mehr benutzt werden. Dies würde zu Fehlern führen, da das transparente Fragment ggfs. das durchscheinende, jedoch erst später an die Grafik-Pipeline gesendete und somit vom Tiefentest verworfene Fragment dahinter völlig verbirgt. Wenn man Transparente Fragmente nicht in den Tiefenbuffer schreibt, so können diese Fragmente von anderen, eigentlich weiter hinten liegenden, Fragmenten komplett überschrieben werden. 
Aus diesem Grund sollten Transparente Objekte nach allen anderen Objekten an OpenGL geschickt werden und diese möglichst von hinten nach vorne sortiert sein. Das Sortieren kann durch einen Alpha Wert im [[Framebuffer]] umgangen werden, jedoch ist dieser nur selten in Hardware vorhanden, wodurch in den weit langsameren Softwaremodus gewechselt wird.

Vertexarray

2008-08-11T13:48:19Z

Philip: Hinweis auf VBOs

Bei einem Vertexarray werden die Vertexdaten in einem Array zur Grafikkarte geschickt.

==Was sind Vertexarrays==
Ein Vertexarray ist ein großes Array, in dem die Vertexdaten stehen. Idealerweise existiert dabei jeder Vertex nur einmal in diesem Array. Daneben wird noch ein Indexarray erstellt, dass auf die Vertices in dem Vertexarray verweist. Anhand dieses Indexarrays wird gezeichnet. Natürlich können
auf einzelne Vertices aus dem Indexarray heraus mehrfach verwiesen werden.

==Wie helfen Vertexarrays bei der Performance==
Dadurch, dass alle Daten an einem Block liegen und die GPU stumpf die Daten abarbeiten kann, sind die Vertexarrays weitaus schneller als die [[glBegin]]/[[glEnd]]-Methode. Werden die Daten dann auch noch als [[Displayliste]] an die Grafikkarte geschickt, kommt Freude auf. :)
Außerdem wird Speicher gespart, indem durch die Indirektstufe, die man durch das Indexarray hat, einen Vertex mehrfach zeichnen kann.

==Verwendung==

===Prinzip===
Wie wird nun so ein Vertexarray aufgebaut und gezeichnet? 
Beispiel, wie es intern abläuft für zwei nebeneinanderliegende 2D-Quads: 
Vertexarray vertices: {(0.0f, 0.0f), (0.0f, 1.0f), (1.0f, 0.0f), (1.0f, 1.0f), (2.0f, 0.0f), (2.0f, 1.0f)} 
Indexarray indices: {0, 2, 3, 1, 2, 4, 5, 3} 
Beim Zeichnen wird nun folgendermaßen vorgegangen:
<cpp>
int vertexCount = length(indices);
glBegin(GL_QUADS);
for (int i = 0; i < vertexCount; ++i) {
int vIndex = indices[i];
Vertex2F v = vertices[vIndex];
glVertex2f(v[0], v[1]);
}
glEnd();
</cpp>
Dieses Minimalbeispiel soll nur verdeutlichen, wie Vertexarrays prinzipiell funktionieren. Pro Vertex gibt es natürlich noch andere interessante Informationen wie dessen Normale, dessen Farbe und Texturkoordinate. Dazu später mehr.

===Umsetzung in C===
Das Beispiel von eben soll nun in wirklichen Code umgesetzt werden. Dazu sind zwei Schritte nötig: 
1. Die Initialisierung.
2. Das eigentliche Zeichnen
====Die Initialisierung====
Als erstes definieren wir einen Vertex:
<cpp>
typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;
</cpp>
Dieser Typ besteht aus zwei Teilen: Einmal 3 Floats für die Koordinate und einmal 3 Floats für die Farbe.
Das Vertexarray besteht eben aus einem Array mit diesem Typen. Bei einer Zeile sind die ersten drei Zahlen die Koordinate und die nächsten drei die Farbe
<cpp>
static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};
</cpp>
Nun müssen noch die Indices aufgebaut werden:
GLuint *indices;
<cpp>
static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static const int indexCount = 8;
</cpp>
Damit hätten wir alle Daten beisammen. Nun muss nur noch OpenGL davon wissen.
<cpp>
void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);

glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}
</cpp>
Was geschieht hier? 
Als erstes wird das Vertex-Array eingeschaltet sowie das zugehörige Farbarray.
Dann wird als erstes der Vertexpointer gesetzt. Der erste Parameter sagt, dass es 3 Komponenten pro Vertex sind (x, y, z), der zweite, dass es sich um Floats handelt, der dritte der Offset zwischen zwei Vertices im Array (Wie viele Bytes er überspringen muss um zum nächsten Vertex zu gelangen) und der Dritte ist ein Pointer auf das erste Vertex.
Genau so sieht der Colorpointer aus.

====Das eigentliche Zeichnen====
Nun, da alles initialisiert ist, sollen die Quads auch auf den Bildschirm. Dazu folgende Funktion:
<cpp>
void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /*Index-Array*/
}
</cpp>
Als erstes wird gesagt, dass die gezeichneten Elemente Quads sind. Dann kommt die Anzahl der Indices sowie deren Typ. Als letztes das eigentliche Indexarray. 
Das Ergebnis sollte nun so aussehen: 
[[Bild:Varray.png‎]]

====Die kompletten C-Dateien====
Der Übersicht halber die komplette vertexarray.h:
<cpp>
#ifndef _VERTEXARRAY_H
#define _VERTEXARRAY_H

void initVertexArray(void);

void drawVertexArray(void);

#endif
</cpp>
Und die vertexarray.c:
<cpp>
#include "vertexArray.h"

#include <GL/glut.h>

typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;

static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};

static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static int indexCount = 8;

void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}

void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /* Index-Array */
}
</cpp>

===Hinweis zu dem Array===
In dem Minimalbeispiel wurde für Vertices und Farben das selbe Array verwendet. Meistens ist es sinnvoller, das in verschiedenen Arrays zu halten. Die entsprechenden Aufrufe, die OpenGL die Pointer mitteilen, müssen dann natürlich entsprechend angepasst werden.

==Weiterführendes==

===Weitere Pointer===
Bisher wurden nur Vertices und Farben als Array benutzt. Nützlich sind noch Pointer auf Normale und Texturkoordinaten. Dazu müssen die entsprechenden Clientstates aktiviert werden:
<cpp>
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
</cpp>
OpenGL muss natürlich im Init entsprechende Pointer mittels [[glNormalPointer]] und [[glTexCoordPointer]] bekommen.
Die entsprechenden Werte funktionieren genau so wie bei dem Colorpointer. 
Desweiteren gibt es noch diese Pointer:
*[[glFogCoordPointer]] setzt einen Pointer auf Nebelkoordinaten.
*[[glSecondaryColorPointer]] setzt einen Pointer auf Sekundärfarben, siehe [[glSecondaryColor]].

===Weitere Zeichenfunktionen===
Neben [[glDrawElements]] gibt es noch weitere Funktionen, um ein Vertexarray zu zeichnen.
*[[glDrawRangeElements]] funktioniert wie [[glDrawElements]], jedoch kann hier ein Start- und Endindex angegeben werden.
*[[glArrayElement]] zeichnet ein einzelnes Element des Vertexarrays.
*[[glDrawArrays]] zeichnet ein komplettes Vertexarray ohne Indexarray.
*[[glMultiDrawArrays]] funktioniert ähnlich wie [[glDrawArrays]], nimmt aber Arrays für die Start- und Endwerte und arbeitet die so ab, als ob [[glDrawArrays]] entsprechend in einer Schleife aufgerufen werden würde.
*[[glMultiDrawElements]]funktioniert ähnlich wie [[glDrawElements]], nimmt aber statt eines Indexarrays ein Array von Indexarrays und arbeitet es so ab, als ob [[glDrawElements]]in einer Schleife aufgerufen werden würde.

===Anwendungshinweise===
Vertex-Arrays sind zwar weitaus besser als der Immediate-Mode mit [[glBegin]]/[[glEnd]], aber noch nicht das Wahre. Weitaus performanter sind Vertexbufferobjekte. Sie arbeiten ähnlich wie Vertexarrays, bloß dass die Daten nicht im Hauptspeicher liegen, sondern direkt im Grafikkartenspeicher. Es gibt im Wiki hier ein Tutorial dazu: [[Tutorial_Vertexbufferobject]]

Vertexarray

2008-08-11T01:16:33Z

Philip: Weitere Zeichenfunktionen und Pointer angerissen.

Vertexarray

2008-08-11T00:19:54Z

Philip: Layout bischen geändert.

Bei einem Vertexarray werden die Vertexdaten in einem Array zur Grafikkarte geschickt.

==Was sind Vertexarrays==
Ein Vertexarray ist ein großes Array, in dem die Vertexdaten stehen. Idealerweise existiert dabei jeder Vertex nur einmal in diesem Array. Daneben wird noch ein Indexarray erstellt, dass auf die Vertices in dem Vertexarray verweist. Anhand dieses Indexarrays wird gezeichnet. Natürlich können
auf einzelne Vertices aus dem Indexarray heraus mehrfach verwiesen werden.

==Wie helfen Vertexarrays bei der Performance==
Dadurch, dass alle Daten an einem Block liegen und die GPU stumpf die Daten abarbeiten kann, sind die Vertexarrays weitaus schneller als die [[glBegin]]/[[glEnd]]-Methode. Werden die Daten dann auch noch als [[Displayliste]] an die Grafikkarte geschickt, kommt Freude auf. :)
Außerdem wird Speicher gespart, indem durch die Indirektstufe, die man durch das Indexarray hat, einen Vertex mehrfach zeichnen kann.

==Verwendung==

===Prinzip===
Wie wird nun so ein Vertexarray aufgebaut und gezeichnet? 
Beispiel, wie es intern abläuft für zwei nebeneinanderliegende 2D-Quads: 
Vertexarray vertices: {(0.0f, 0.0f), (0.0f, 1.0f), (1.0f, 0.0f), (1.0f, 1.0f), (2.0f, 0.0f), (2.0f, 1.0f)} 
Indexarray indices: {0, 2, 3, 1, 2, 4, 5, 3} 
Beim Zeichnen wird nun folgendermaßen vorgegangen:
<cpp>
int vertexCount = length(indices);
glBegin(GL_QUADS);
for (int i = 0; i < vertexCount; ++i) {
int vIndex = indices[i];
Vertex2F v = vertices[vIndex];
glVertex2f(v[0], v[1]);
}
glEnd();
</cpp>
Dieses Minimalbeispiel soll nur verdeutlichen, wie Vertexarrays prinzipiell funktionieren. Pro Vertex gibt es natürlich noch andere interessante Informationen wie dessen Normale, dessen Farbe und Texturkoordinate. Dazu später mehr.

===Umsetzung in C===
Das Beispiel von eben soll nun in wirklichen Code umgesetzt werden. Dazu sind zwei Schritte nötig: 
1. Die Initialisierung.
2. Das eigentliche Zeichnen
====Die Initialisierung====
Als erstes definieren wir einen Vertex:
<cpp>
typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;
</cpp>
Dieser Typ besteht aus zwei Teilen: Einmal 3 Floats für die Koordinate und einmal 3 Floats für die Farbe.
Das Vertexarray besteht eben aus einem Array mit diesem Typen. Bei einer Zeile sind die ersten drei Zahlen die Koordinate und die nächsten drei die Farbe
<cpp>
static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};
</cpp>
Nun müssen noch die Indices aufgebaut werden:
GLuint *indices;
<cpp>
static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static const int indexCount = 8;
</cpp>
Damit hätten wir alle Daten beisammen. Nun muss nur noch OpenGL davon wissen.
<cpp>
void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);

glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}
</cpp>
Was geschieht hier? 
Als erstes wird das Vertex-Array eingeschaltet sowie das zugehörige Farbarray.
Dann wird als erstes der Vertexpointer gesetzt. Der erste Parameter sagt, dass es 3 Komponenten pro Vertex sind (x, y, z), der zweite, dass es sich um Floats handelt, der dritte der Offset zwischen zwei Vertices im Array (Wie viele Bytes er überspringen muss um zum nächsten Vertex zu gelangen) und der Dritte ist ein Pointer auf das erste Vertex.
Genau so sieht der Colorpointer aus.

====Das eigentliche Zeichnen====
Nun, da alles initialisiert ist, sollen die Quads auch auf den Bildschirm. Dazu folgende Funktion:
<cpp>
void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /*Index-Array*/
}
</cpp>
Als erstes wird gesagt, dass die gezeichneten Elemente Quads sind. Dann kommt die Anzahl der Indices sowie deren Typ. Als letztes das eigentliche Indexarray. 
Das Ergebnis sollte nun so aussehen: 
[[Bild:Varray.png‎]]

====Die kompletten C-Dateien====
Der Übersicht halber die komplette vertexarray.h:
<cpp>
#ifndef _VERTEXARRAY_H
#define _VERTEXARRAY_H

void initVertexArray(void);

void drawVertexArray(void);

#endif
</cpp>
Und die vertexarray.c:
<cpp>
#include "vertexArray.h"

#include <GL/glut.h>

typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;

static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};

static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static int indexCount = 8;

void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}

void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /* Index-Array */
}
</cpp>
===Wie geht es weiter?===
Bisher wurden nur Vertices und Farben als Array benutzt. Nützlich sind noch Pointer auf Normale und Texturkoordinaten. Dazu müssen die entsprechenden Clientstates aktiviert werden:
<cpp>
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
</cpp>
OpenGL muss natürlich im Init entsprechende Pointer mittels [[glNormalPointer]] und [[glTexCoordPointer]] bekommen.
Die entsprechenden Werte funktionieren genau so wie bei dem Colorpointer.

In dem Minimalbeispiel wurde für Vertices und Farben das selbe Array verwendet. Meistens ist es sinnvoller, das in verschiedenen Arrays zu halten. Die entsprechenden Aufrufe, die OpenGL die Pointer mitteilen, müssen dann natürlich entsprechend angepasst werden.

Vertexarray

2008-08-11T00:08:35Z

Philip: /* Die Initialisierung */

===Vertexarray===

Bei einem Vertexarray werden die Vertexdaten in einem Array zur Grafikkarte geschickt.

==Was sind Vertexarrays==
Ein Vertexarray ist ein großes Array, in dem die Vertexdaten stehen. Idealerweise existiert dabei jeder Vertex nur einmal in diesem Array. Daneben wird noch ein Indexarray erstellt, dass auf die Vertices in dem Vertexarray verweist. Anhand dieses Indexarrays wird gezeichnet. Natürlich können
auf einzelne Vertices aus dem Indexarray heraus mehrfach verwiesen werden.

==Wie helfen Vertexarrays bei der Performance==
Dadurch, dass alle Daten an einem Block liegen und die GPU stumpf die Daten abarbeiten kann, sind die Vertexarrays weitaus schneller als die [[glBegin]]/[[glEnd]]-Methode. Werden die Daten dann auch noch als [[Displayliste]] an die Grafikkarte geschickt, kommt Freude auf. :)
Außerdem wird Speicher gespart, indem durch die Indirektstufe, die man durch das Indexarray hat, einen Vertex mehrfach zeichnen kann.

==Verwendung==

===Prinzip===
Wie wird nun so ein Vertexarray aufgebaut und gezeichnet? 
Beispiel, wie es intern abläuft für zwei nebeneinanderliegende 2D-Quads: 
Vertexarray vertices: {(0.0f, 0.0f), (0.0f, 1.0f), (1.0f, 0.0f), (1.0f, 1.0f), (2.0f, 0.0f), (2.0f, 1.0f)} 
Indexarray indices: {0, 2, 3, 1, 2, 4, 5, 3} 
Beim Zeichnen wird nun folgendermaßen vorgegangen:
<cpp>
int vertexCount = length(indices);
glBegin(GL_QUADS);
for (int i = 0; i < vertexCount; ++i) {
int vIndex = indices[i];
Vertex2F v = vertices[vIndex];
glVertex2f(v[0], v[1]);
}
glEnd();
</cpp>
Dieses Minimalbeispiel soll nur verdeutlichen, wie Vertexarrays prinzipiell funktionieren. Pro Vertex gibt es natürlich noch andere interessante Informationen wie dessen Normale, dessen Farbe und Texturkoordinate. Dazu später mehr.

===Umsetzung in C===
Das Beispiel von eben soll nun in wirklichen Code umgesetzt werden. Dazu sind zwei Schritte nötig: 
1. Die Initialisierung.
2. Das eigentliche Zeichnen
====Die Initialisierung====
Als erstes definieren wir einen Vertex:
<cpp>
typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;
</cpp>
Dieser Typ besteht aus zwei Teilen: Einmal 3 Floats für die Koordinate und einmal 3 Floats für die Farbe.
Das Vertexarray besteht eben aus einem Array mit diesem Typen. Bei einer Zeile sind die ersten drei Zahlen die Koordinate und die nächsten drei die Farbe
<cpp>
static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};
</cpp>
Nun müssen noch die Indices aufgebaut werden:
GLuint *indices;
<cpp>
static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static const int indexCount = 8;
</cpp>
Damit hätten wir alle Daten beisammen. Nun muss nur noch OpenGL davon wissen.
<cpp>
void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);

glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}
</cpp>
Was geschieht hier? 
Als erstes wird das Vertex-Array eingeschaltet sowie das zugehörige Farbarray.
Dann wird als erstes der Vertexpointer gesetzt. Der erste Parameter sagt, dass es 3 Komponenten pro Vertex sind (x, y, z), der zweite, dass es sich um Floats handelt, der dritte der Offset zwischen zwei Vertices im Array (Wie viele Bytes er überspringen muss um zum nächsten Vertex zu gelangen) und der Dritte ist ein Pointer auf das erste Vertex.
Genau so sieht der Colorpointer aus.

====Das eigentliche Zeichnen====
Nun, da alles initialisiert ist, sollen die Quads auch auf den Bildschirm. Dazu folgende Funktion:
<cpp>
void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /*Index-Array*/
}
</cpp>
Als erstes wird gesagt, dass die gezeichneten Elemente Quads sind. Dann kommt die Anzahl der Indices sowie deren Typ. Als letztes das eigentliche Indexarray. 
Das Ergebnis sollte nun so aussehen: 
[[Bild:Varray.png‎]]

====Die kompletten C-Dateien====
Der Übersicht halber die komplette vertexarray.h:
<cpp>
#ifndef _VERTEXARRAY_H
#define _VERTEXARRAY_H

void initVertexArray(void);

void drawVertexArray(void);

#endif
</cpp>
Und die vertexarray.c:
<cpp>
#include "vertexArray.h"

#include <GL/glut.h>

typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;

static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};

static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static int indexCount = 8;

void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}

void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /* Index-Array */
}
</cpp>
===Wie geht es weiter?===
Bisher wurden nur Vertices und Farben als Array benutzt. Nützlich sind noch Pointer auf Normale und Texturkoordinaten. Dazu müssen die entsprechenden Clientstates aktiviert werden:
<cpp>
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
</cpp>
OpenGL muss natürlich im Init entsprechende Pointer mittels [[glNormalPointer]] und [[glTexCoordPointer]] bekommen.
Die entsprechenden Werte funktionieren genau so wie bei dem Colorpointer.

In dem Minimalbeispiel wurde für Vertices und Farben das selbe Array verwendet. Meistens ist es sinnvoller, das in verschiedenen Arrays zu halten. Die entsprechenden Aufrufe, die OpenGL die Pointer mitteilen, müssen dann natürlich entsprechend angepasst werden.

Vertexarray

2008-08-11T00:00:43Z

Philip: /* Wie geht es weiter? */

===Vertexarray===

Bei einem Vertexarray werden die Vertexdaten in einem Array zur Grafikkarte geschickt.

==Was sind Vertexarrays==
Ein Vertexarray ist ein großes Array, in dem die Vertexdaten stehen. Idealerweise existiert dabei jeder Vertex nur einmal in diesem Array. Daneben wird noch ein Indexarray erstellt, dass auf die Vertices in dem Vertexarray verweist. Anhand dieses Indexarrays wird gezeichnet. Natürlich können
auf einzelne Vertices aus dem Indexarray heraus mehrfach verwiesen werden.

==Wie helfen Vertexarrays bei der Performance==
Dadurch, dass alle Daten an einem Block liegen und die GPU stumpf die Daten abarbeiten kann, sind die Vertexarrays weitaus schneller als die [[glBegin]]/[[glEnd]]-Methode. Werden die Daten dann auch noch als [[Displayliste]] an die Grafikkarte geschickt, kommt Freude auf. :)
Außerdem wird Speicher gespart, indem durch die Indirektstufe, die man durch das Indexarray hat, einen Vertex mehrfach zeichnen kann.

==Verwendung==

===Prinzip===
Wie wird nun so ein Vertexarray aufgebaut und gezeichnet? 
Beispiel, wie es intern abläuft für zwei nebeneinanderliegende 2D-Quads: 
Vertexarray vertices: {(0.0f, 0.0f), (0.0f, 1.0f), (1.0f, 0.0f), (1.0f, 1.0f), (2.0f, 0.0f), (2.0f, 1.0f)} 
Indexarray indices: {0, 2, 3, 1, 2, 4, 5, 3} 
Beim Zeichnen wird nun folgendermaßen vorgegangen:
<cpp>
int vertexCount = length(indices);
glBegin(GL_QUADS);
for (int i = 0; i < vertexCount; ++i) {
int vIndex = indices[i];
Vertex2F v = vertices[vIndex];
glVertex2f(v[0], v[1]);
}
glEnd();
</cpp>
Dieses Minimalbeispiel soll nur verdeutlichen, wie Vertexarrays prinzipiell funktionieren. Pro Vertex gibt es natürlich noch andere interessante Informationen wie dessen Normale, dessen Farbe und Texturkoordinate. Dazu später mehr.

===Umsetzung in C===
Das Beispiel von eben soll nun in wirklichen Code umgesetzt werden. Dazu sind zwei Schritte nötig: 
1. Die Initialisierung.
2. Das eigentliche Zeichnen
====Die Initialisierung====
Als erstes definieren wir einen Vertex:
<cpp>
typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;
</cpp>
Dieser Typ besteht aus zwei Teilen: Einmal 3 Floats für die Koordinate und einmal 3 Floats für die Farbe.
Das Vertexarray besteht eben aus einem Array mit diesem Typen. Bei einer Zeile sind die ersten drei Zahlen die Koordinate und die nächsten drei die Farbe
<cpp>
static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};
</cpp>
Nun müssen noch die Indices aufgebaut werden:
GLuint *indices;
<cpp>
static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static int indexCount = 8;
</cpp>
Damit hätten wir alle Daten beisammen. Nun muss nur noch OpenGL davon wissen.
<cpp>
void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);

glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}
</cpp>
Was geschieht hier? 
Als erstes wird das Vertex-Array eingeschaltet sowie das zugehörige Farbarray.
Dann wird als erstes der Vertexpointer gesetzt. Der erste Parameter sagt, dass es 3 Komponenten pro Vertex sind (x, y, z), der zweite, dass es sich um Floats handelt, der dritte der Offset zwischen zwei Vertices im Array (Wie viele Bytes er überspringen muss um zum nächsten Vertex zu gelangen) und der Dritte ist ein Pointer auf das erste Vertex.
Genau so sieht der Colorpointer aus.

====Das eigentliche Zeichnen====
Nun, da alles initialisiert ist, sollen die Quads auch auf den Bildschirm. Dazu folgende Funktion:
<cpp>
void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /*Index-Array*/
}
</cpp>
Als erstes wird gesagt, dass die gezeichneten Elemente Quads sind. Dann kommt die Anzahl der Indices sowie deren Typ. Als letztes das eigentliche Indexarray. 
Das Ergebnis sollte nun so aussehen: 
[[Bild:Varray.png‎]]

====Die kompletten C-Dateien====
Der Übersicht halber die komplette vertexarray.h:
<cpp>
#ifndef _VERTEXARRAY_H
#define _VERTEXARRAY_H

void initVertexArray(void);

void drawVertexArray(void);

#endif
</cpp>
Und die vertexarray.c:
<cpp>
#include "vertexArray.h"

#include <GL/glut.h>

typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;

static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};

static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static int indexCount = 8;

void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}

void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /* Index-Array */
}
</cpp>
===Wie geht es weiter?===
Bisher wurden nur Vertices und Farben als Array benutzt. Nützlich sind noch Pointer auf Normale und Texturkoordinaten. Dazu müssen die entsprechenden Clientstates aktiviert werden:
<cpp>
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
</cpp>
OpenGL muss natürlich im Init entsprechende Pointer mittels [[glNormalPointer]] und [[glTexCoordPointer]] bekommen.
Die entsprechenden Werte funktionieren genau so wie bei dem Colorpointer.

In dem Minimalbeispiel wurde für Vertices und Farben das selbe Array verwendet. Meistens ist es sinnvoller, das in verschiedenen Arrays zu halten. Die entsprechenden Aufrufe, die OpenGL die Pointer mitteilen, müssen dann natürlich entsprechend angepasst werden.

Vertexarray

2008-08-10T23:54:46Z

Philip: V1 fertig.

===Vertexarray===

Bei einem Vertexarray werden die Vertexdaten in einem Array zur Grafikkarte geschickt.

==Was sind Vertexarrays==
Ein Vertexarray ist ein großes Array, in dem die Vertexdaten stehen. Idealerweise existiert dabei jeder Vertex nur einmal in diesem Array. Daneben wird noch ein Indexarray erstellt, dass auf die Vertices in dem Vertexarray verweist. Anhand dieses Indexarrays wird gezeichnet. Natürlich können
auf einzelne Vertices aus dem Indexarray heraus mehrfach verwiesen werden.

==Wie helfen Vertexarrays bei der Performance==
Dadurch, dass alle Daten an einem Block liegen und die GPU stumpf die Daten abarbeiten kann, sind die Vertexarrays weitaus schneller als die [[glBegin]]/[[glEnd]]-Methode. Werden die Daten dann auch noch als [[Displayliste]] an die Grafikkarte geschickt, kommt Freude auf. :)
Außerdem wird Speicher gespart, indem durch die Indirektstufe, die man durch das Indexarray hat, einen Vertex mehrfach zeichnen kann.

==Verwendung==

===Prinzip===
Wie wird nun so ein Vertexarray aufgebaut und gezeichnet? 
Beispiel, wie es intern abläuft für zwei nebeneinanderliegende 2D-Quads: 
Vertexarray vertices: {(0.0f, 0.0f), (0.0f, 1.0f), (1.0f, 0.0f), (1.0f, 1.0f), (2.0f, 0.0f), (2.0f, 1.0f)} 
Indexarray indices: {0, 2, 3, 1, 2, 4, 5, 3} 
Beim Zeichnen wird nun folgendermaßen vorgegangen:
<cpp>
int vertexCount = length(indices);
glBegin(GL_QUADS);
for (int i = 0; i < vertexCount; ++i) {
int vIndex = indices[i];
Vertex2F v = vertices[vIndex];
glVertex2f(v[0], v[1]);
}
glEnd();
</cpp>
Dieses Minimalbeispiel soll nur verdeutlichen, wie Vertexarrays prinzipiell funktionieren. Pro Vertex gibt es natürlich noch andere interessante Informationen wie dessen Normale, dessen Farbe und Texturkoordinate. Dazu später mehr.

===Umsetzung in C===
Das Beispiel von eben soll nun in wirklichen Code umgesetzt werden. Dazu sind zwei Schritte nötig: 
1. Die Initialisierung.
2. Das eigentliche Zeichnen
====Die Initialisierung====
Als erstes definieren wir einen Vertex:
<cpp>
typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;
</cpp>
Dieser Typ besteht aus zwei Teilen: Einmal 3 Floats für die Koordinate und einmal 3 Floats für die Farbe.
Das Vertexarray besteht eben aus einem Array mit diesem Typen. Bei einer Zeile sind die ersten drei Zahlen die Koordinate und die nächsten drei die Farbe
<cpp>
static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};
</cpp>
Nun müssen noch die Indices aufgebaut werden:
GLuint *indices;
<cpp>
static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static int indexCount = 8;
</cpp>
Damit hätten wir alle Daten beisammen. Nun muss nur noch OpenGL davon wissen.
<cpp>
void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);

glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}
</cpp>
Was geschieht hier? 
Als erstes wird das Vertex-Array eingeschaltet sowie das zugehörige Farbarray.
Dann wird als erstes der Vertexpointer gesetzt. Der erste Parameter sagt, dass es 3 Komponenten pro Vertex sind (x, y, z), der zweite, dass es sich um Floats handelt, der dritte der Offset zwischen zwei Vertices im Array (Wie viele Bytes er überspringen muss um zum nächsten Vertex zu gelangen) und der Dritte ist ein Pointer auf das erste Vertex.
Genau so sieht der Colorpointer aus.

====Das eigentliche Zeichnen====
Nun, da alles initialisiert ist, sollen die Quads auch auf den Bildschirm. Dazu folgende Funktion:
<cpp>
void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /*Index-Array*/
}
</cpp>
Als erstes wird gesagt, dass die gezeichneten Elemente Quads sind. Dann kommt die Anzahl der Indices sowie deren Typ. Als letztes das eigentliche Indexarray. 
Das Ergebnis sollte nun so aussehen: 
[[Bild:Varray.png‎]]

====Die kompletten C-Dateien====
Der Übersicht halber die komplette vertexarray.h:
<cpp>
#ifndef _VERTEXARRAY_H
#define _VERTEXARRAY_H

void initVertexArray(void);

void drawVertexArray(void);

#endif
</cpp>
Und die vertexarray.c:
<cpp>
#include "vertexArray.h"

#include <GL/glut.h>

typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;

static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};

static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static int indexCount = 8;

void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}

void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /* Index-Array */
}
</cpp>
===Wie geht es weiter?===
Bisher wurden nur Vertices und Farben als Array benutzt. Nützlich sind noch Pointer auf Normale und Texturkoordinaten. Dazu müssen die entsprechenden Clientstates aktiviert werden:
<cpp>
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
</cpp>
OpenGL muss natürlich im Init entsprechende Pointer mittels [[glNormalPointer]] und [[glTexCoordPointer]] bekommen.

Vertexarray

2008-08-10T23:54:25Z

Philip:

{{Offline}}

===Vertexarray===

Bei einem Vertexarray werden die Vertexdaten in einem Array zur Grafikkarte geschickt.

==Was sind Vertexarrays==
Ein Vertexarray ist ein großes Array, in dem die Vertexdaten stehen. Idealerweise existiert dabei jeder Vertex nur einmal in diesem Array. Daneben wird noch ein Indexarray erstellt, dass auf die Vertices in dem Vertexarray verweist. Anhand dieses Indexarrays wird gezeichnet. Natürlich können
auf einzelne Vertices aus dem Indexarray heraus mehrfach verwiesen werden.

==Wie helfen Vertexarrays bei der Performance==
Dadurch, dass alle Daten an einem Block liegen und die GPU stumpf die Daten abarbeiten kann, sind die Vertexarrays weitaus schneller als die [[glBegin]]/[[glEnd]]-Methode. Werden die Daten dann auch noch als [[Displayliste]] an die Grafikkarte geschickt, kommt Freude auf. :)
Außerdem wird Speicher gespart, indem durch die Indirektstufe, die man durch das Indexarray hat, einen Vertex mehrfach zeichnen kann.

==Verwendung==

===Prinzip===
Wie wird nun so ein Vertexarray aufgebaut und gezeichnet? 
Beispiel, wie es intern abläuft für zwei nebeneinanderliegende 2D-Quads: 
Vertexarray vertices: {(0.0f, 0.0f), (0.0f, 1.0f), (1.0f, 0.0f), (1.0f, 1.0f), (2.0f, 0.0f), (2.0f, 1.0f)} 
Indexarray indices: {0, 2, 3, 1, 2, 4, 5, 3} 
Beim Zeichnen wird nun folgendermaßen vorgegangen:
<cpp>
int vertexCount = length(indices);
glBegin(GL_QUADS);
for (int i = 0; i < vertexCount; ++i) {
int vIndex = indices[i];
Vertex2F v = vertices[vIndex];
glVertex2f(v[0], v[1]);
}
glEnd();
</cpp>
Dieses Minimalbeispiel soll nur verdeutlichen, wie Vertexarrays prinzipiell funktionieren. Pro Vertex gibt es natürlich noch andere interessante Informationen wie dessen Normale, dessen Farbe und Texturkoordinate. Dazu später mehr.

===Umsetzung in C===
Das Beispiel von eben soll nun in wirklichen Code umgesetzt werden. Dazu sind zwei Schritte nötig: 
1. Die Initialisierung.
2. Das eigentliche Zeichnen
====Die Initialisierung====
Als erstes definieren wir einen Vertex:
<cpp>
typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;
</cpp>
Dieser Typ besteht aus zwei Teilen: Einmal 3 Floats für die Koordinate und einmal 3 Floats für die Farbe.
Das Vertexarray besteht eben aus einem Array mit diesem Typen. Bei einer Zeile sind die ersten drei Zahlen die Koordinate und die nächsten drei die Farbe
<cpp>
static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};
</cpp>
Nun müssen noch die Indices aufgebaut werden:
GLuint *indices;
<cpp>
static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static int indexCount = 8;
</cpp>
Damit hätten wir alle Daten beisammen. Nun muss nur noch OpenGL davon wissen.
<cpp>
void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);

glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}
</cpp>
Was geschieht hier? 
Als erstes wird das Vertex-Array eingeschaltet sowie das zugehörige Farbarray.
Dann wird als erstes der Vertexpointer gesetzt. Der erste Parameter sagt, dass es 3 Komponenten pro Vertex sind (x, y, z), der zweite, dass es sich um Floats handelt, der dritte der Offset zwischen zwei Vertices im Array (Wie viele Bytes er überspringen muss um zum nächsten Vertex zu gelangen) und der Dritte ist ein Pointer auf das erste Vertex.
Genau so sieht der Colorpointer aus.

====Das eigentliche Zeichnen====
Nun, da alles initialisiert ist, sollen die Quads auch auf den Bildschirm. Dazu folgende Funktion:
<cpp>
void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /*Index-Array*/
}
</cpp>
Als erstes wird gesagt, dass die gezeichneten Elemente Quads sind. Dann kommt die Anzahl der Indices sowie deren Typ. Als letztes das eigentliche Indexarray. 
Das Ergebnis sollte nun so aussehen: 
[[Bild:Varray.png‎]]

====Die kompletten C-Dateien====
Der Übersicht halber die komplette vertexarray.h:
<cpp>
#ifndef _VERTEXARRAY_H
#define _VERTEXARRAY_H

void initVertexArray(void);

void drawVertexArray(void);

#endif
</cpp>
Und die vertexarray.c:
<cpp>
#include "vertexArray.h"

#include <GL/glut.h>

typedef struct {
GLfloat x, y, z;
GLfloat r, g, b;
} Vertex;

static const Vertex vertices[18] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
2.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
2.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f
};

static const GLuint indices[8] = {
0, 2, 3, 1, 2, 4, 5, 3
};

static int indexCount = 8;

void initVertexArray(void) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, /* Komponenten pro Vertex (x,y,z) */
GL_FLOAT, /* Typ der Komponenten */
sizeof(Vertex), /* Offset zwischen 2 Vertizes im Array */
&(vertices[0].x)); /* Zeiger auf die 1. Komponente */

glColorPointer (3, GL_FLOAT, sizeof(Vertex), &(vertices[0].r));
}

void drawVertexArray(void) {
glDrawElements(GL_QUADS, /* Primitivtyp */
indexCount, /* Anzahl Indizes */
GL_UNSIGNED_INT, /* Typ der Indizes */
indices); /* Index-Array */
}
</cpp>
===Wie geht es weiter?===
Bisher wurden nur Vertices und Farben als Array benutzt. Nützlich sind noch Pointer auf Normale und Texturkoordinaten. Dazu müssen die entsprechenden Clientstates aktiviert werden:
<cpp>
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
</cpp>
OpenGL muss natürlich im Init entsprechende Pointer mittels [[glNormalPointer]] und [[glTexCoordPointer]] bekommen.

Datei:Varray.png

2008-08-10T23:45:26Z

Philip:

Vertexarray

2008-08-10T23:39:16Z

Philip: Meilenstein 1

Vertexarray

2008-08-10T22:54:53Z

Philip: angefangen

Vertexarray

2008-08-10T22:38:29Z

Philip:

{{Offline}}

===Vertexarray===

==Was sind Vertexarrays==

==Wie helfen Vertexarrays bei der Performance==

==Verwendung==

Vertexarray

2008-08-10T22:37:55Z

Philip:

{{Offline}}

==Was sind Vertexarrays==

==Wie helfen Vertexarrays bei der Performance==

==Verwendung==

Vertexarray

2008-08-10T22:35:05Z

Philip:

{{Offline}}

Hallo Welt... Here we go, Vertexarrays...

Vertexarray

2008-08-10T22:34:46Z

Philip: Die Seite wurde neu angelegt: {{offline}} Hallo Welt... Here we go, Vertexarrays...

{{offline}}

Hallo Welt... Here we go, Vertexarrays...