OpenGL 2.0 Vertex Arrays

Transkript

1 OpenGL 2.0 Vertex Arrays Boguslaw Sylla Interaktive 3D-Computergrafik SS 2010 Hochschule RheinMain

2 Inhalt des Vortrags 1 Ein- / Ausschalten von Arrays EnableClientState, DisableClientState 2 Spezifizieren der Daten Einzelne Arrays ColorPointer, EdgeFlagPointer, FogCoordPointer, IndexPointer, NormalPointer, SecondaryColorPointer, TextCoordPointer, VertexPointer Mehrere Arrays InterleavedArrays Elementweise (ein Objekt) ArrayElement Listenweise (ein Objekt) DrawElements, DrawRangeElements Listenweise (mehrere Objekte) MultiDrawElements Direkt (ein Objekt) DrawArrays Direkt (mehrere Objekte) MultiDrawArrays 2 von 40

3 1 Ein- / Ausschalten von Arrays 1 Ein- / Ausschalten von Arrays EnableClientState, DisableClientState 2 Spezifizieren der Daten Einzelne Arrays ColorPointer, EdgeFlagPointer, FogCoordPointer, IndexPointer, NormalPointer, SecondaryColorPointer, TextCoordPointer, VertexPointer Mehrere Arrays InterleavedArrays Elementweise (ein Objekt) ArrayElement Listenweise (ein Objekt) DrawElements, DrawRangeElements Listenweise (mehrere Objekte) MultiDrawElements Direkt (ein Objekt) DrawArrays Direkt (mehrere Objekte) MultiDrawArrays 3 von 40

4 1 Ein- / Ausschalten von Arrays 1 Ein- / Ausschalten von Arrays EnableClientState, DisableClientState void glenableclientstate(glenum array) void gldisableclientstate(glenum array) Gibt an welche Daten-Felder momentan benutzt werden sollen. array := GL_COLOR_ARRAY für Farben in RGB oder RGBA, GL_EDGE_FLAG_ARRAY zum Abschalten des Zeichnens von Punkten/Kanten bei Vertexen, GL_FOG_COORDINATE_ARRAY, GL_INDEX_ARRAY, GL_NORMAL_ARRAY für Normalvektoren, GL_SECONDARY_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY und GL_VERTEX_ARRAY für Vertexe // Einschalten glenableclientstate(gl_color_array); glenableclientstate(gl_vertex_array); // Spezifizieren der Daten... // Zeichnen der Objekte... // Ausschalten gldisableclientstate(gl_color_array); gldisableclientstate(gl_vertex_array); 4 von 40

5 2 Spezifizieren der Daten 1 Ein- / Ausschalten von Arrays EnableClientState, DisableClientState 2 Spezifizieren der Daten Einzelne Arrays ColorPointer, EdgeFlagPointer, FogCoordPointer, IndexPointer, NormalPointer, SecondaryColorPointer, TextCoordPointer, VertexPointer Mehrere Arrays InterleavedArrays Elementweise (ein Objekt) ArrayElement Listenweise (ein Objekt) DrawElements, DrawRangeElements Listenweise (mehrere Objekte) MultiDrawElements Direkt (ein Objekt) DrawArrays Direkt (mehrere Objekte) MultiDrawArrays 5 von 40

6 2 Spezifizieren der Daten 2 Spezifizieren der Daten Einzelne Arrays ColorPointer, EdgeFlagPointer, FogCoordPointer, IndexPointer, NormalPointer, SecondaryColorPointer, TextCoordPointer, VertexPointer void glcolorpointer(glint size, GLenum type, GLsizei stride, const GLvoid *pointer) void gledgeflagpointer(glsizei stride, const GLvoid *pointer) void glfogcoordpointer(glenum type, GLsizei stride, const GLvoid *pointer) void glindexpointer(glenum type, GLsizei stride, const GLvoid *pointer) void glnormalpointer(glenum type, GLsizei stride, const GLvoid *pointer) void glsecondarycolorpointer(glint size, GLenum type, GLsizei stride, const GLvoid *pointer) void gltextcoordpointer(glint size, GLenum type, GLsizei stride, const GLvoid *pointer) void glvertexpointer(glint size, GLenum type, GLsizei stride, const GLvoid *pointer) Verbindet ein Daten-Feld. In dem Feld müssen sich die Daten in einheitlichem Format befinden, deren Elemente jeweils als Datenpakete verstanden werden können, z.b. je drei Elemente nacheinander für X, Y, und Z oder je vier Elemente für R, G, B und A. size := 2, 3 oder 4 ist die Anzahl der Elemente die jeweils ein Datenpaket bilden (siehe untere Tabelle) type := Datentyp der einzelnen Elemente (siehe untere Tabelle) stride := 0 (Sonderbedeutung) wenn Datenpaket an Datenpaket ohne Pausen im Array, sonst Abstand (Offset) vom ersten Element eines Datenpaketes zum ersten Element des darauf folgenden Datenpaketes *pointer := Adresse des ersten Elementes 6 von 40

7 2 Spezifizieren der Daten 2 Spezifizieren der Daten Einzelne Arrays ColorPointer, EdgeFlagPointer, FogCoordPointer, IndexPointer, NormalPointer, SecondaryColorPointer, TextCoordPointer, VertexPointer Befehle für Daten-Felder size type glcolorpointer() 3, 4 GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, GL_DOUBLE gledgeflagpointer() 1 GLboolean glfogcoordpointer() 1 GL_FLOAT, GL_DOUBLE glindexpointer() 1 GL_UNSIGNED_BYTE, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE glnormalpointer() 3 GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE glsecondarycolorpointer() 3 GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, G_INT, GL_UNSIGNED_INT, GL_FLOAT, GL_DOUBLE gltextcoordpointer() 1, 2, 3, 4 GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE glvertexpointer() 2, 3, 4 GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE 7 von 40

8 2 Spezifizieren der Daten 2 Spezifizieren der Daten Einzelne Arrays ColorPointer, EdgeFlagPointer, FogCoordPointer, IndexPointer, NormalPointer, SecondaryColorPointer, TextCoordPointer, VertexPointer /******************************************************************************* * erste Möglichkeit mit separaten Daten-Feldern ******************************************************************************/ glenableclientstate(gl_color_array); glenableclientstate(gl_vertex_array); static GLfloat color_array[] = { 1.0, 0.0, 0.0, // Rot 0.0, 1.0, 0.0, // Grün 1.0, 1.0, 0.0, // Gelb 0.0, 0.0, 1.0 }; // Blau static GLfloat vertex_array[] = { 0.0, 0.0, 0.0, 25.0, 0.0, 0.0, 25.0, 25.0, 0.0, 0.0, 25.0, 0.0 }; // z.b. für GL_QUADS glcolorpointer(3, GL_FLOAT, 0, color_array); glvertexpointer(3, GL_FLOAT, 0, vertex_array); // mach was das erste mal... 8 von 40

9 2 Spezifizieren der Daten 2 Spezifizieren der Daten Einzelne Arrays ColorPointer, EdgeFlagPointer, FogCoordPointer, IndexPointer, NormalPointer, SecondaryColorPointer, TextCoordPointer, VertexPointer /******************************************************************************* * zweite Möglichkeit mit einem Daten-Feld ******************************************************************************/ glenableclientstate(gl_color_array); glenableclientstate(gl_vertex_array); static GLfloat color_and_vertex_array[] = { 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 25.0, 0.0, 0.0, 1.0, 1.0, 0.0, 25.0, 25.0, 0.0, 0.0, 0.0, 1.0, 0.0, 25.0, 0.0 }; glcolorpointer(3, GL_FLOAT, 6*sizeof(GLfloat), &color_and_vertex_array[0]); glvertexpointer(3, GL_FLOAT, 6*sizeof(GLfloat), &color_and_vertex_array[3]); // mach was das zweite mal... 9 von 40

10 2 Spezifizieren der Daten 1 Ein- / Ausschalten von Arrays EnableClientState, DisableClientState 2 Spezifizieren der Daten Einzelne Arrays ColorPointer, EdgeFlagPointer, FogCoordPointer, IndexPointer, NormalPointer, SecondaryColorPointer, TextCoordPointer, VertexPointer Mehrere Arrays InterleavedArrays Elementweise (ein Objekt) ArrayElement Listenweise (ein Objekt) DrawElements, DrawRangeElements Listenweise (mehrere Objekte) MultiDrawElements Direkt (ein Objekt) DrawArrays Direkt (mehrere Objekte) MultiDrawArrays 10 von 40

11 2 Spezifizieren der Daten 2 Spezifizieren der Daten Mehrere Arrays InterleavedArrays void glinterleavedarrays(glenum format, GLsizei stride, void *pointer) Wird bei gemischten Daten-Feldern eingesetzt. Schaltet alle in Format angegebenen Daten-Felder-Typen ein und alle übrigen aus. Erspart des Weiteren alle gl*pointer(). Bei eingeschaltetem Multitexturing, betrifft das Kommando nur die aktive Textur. format := einer von 14 Konfigurationswerten (siehe untere Tabelle) stride := 0 (Sonderbedeutung) wenn Datenpaket an Datenpaket ohne Pausen im Array, sonst Abstand (Offset) vom ersten Element eines Datenpacketes zum ersten Element des darauf folgenden Datenpaketes *pointer := Adresse des ersten Elementes 11 von 40

12 2 Spezifizieren der Daten 2 Spezifizieren der Daten Mehrere Arrays InterleavedArrays format EF, FC, I, SC T C N V stride=0 ist wie nachfolgender Wert GL_V2F F F F F T 2*sizeof(GLfloat) GL_V3F F F F F T 3*sizeof(GLfloat) GL_C4UB_V2F F F T F T 4*sizeof(GLubyte) + 2*sizeof(GLfloat) GL_C4UB_V3F F F T F T 4*sizeof(GLubyte) + 3*sizeof(GLfloat) GL_C3F_V3F F F T F T 6*sizeof(GLfloat) GL_N3F_V3F F F F T T 6*sizeof(GLfloat) GL_C4F_N3F_V3F F F T T T 10*sizeof(GLfloat) GL_T2F_V3F F T F F T 5*sizeof(GLfloat) GL_T4F_V4F F T F F T 8*sizeof(GLfloat) GL_T2F_C4UB_V3F F T T F T 4*sizeof(GLubyte) + 5*sizeof(GLfloat) GL_T2F_C3F_V3F F T T F T 8*sizeof(GLfloat) GL_T2F_N3F_V3F F T F T T 8*sizeof(GLfloat) GL_T2F_C4F_N3F_V3F F T T T T 12*sizeof(GLfloat) GL_T4F_C4F_N3F_V4F F T T T T 15*sizeof(GLfloat) 12 von 40

13 2 Spezifizieren der Daten 2 Spezifizieren der Daten Mehrere Arrays InterleavedArrays /******************************************************************************* * dritte Möglichkeit mit einem Daten-Feld und glinterleavedarrays() ******************************************************************************/ // glenableclientstate(gl_color_array); // unnötig // glenableclientstate(gl_vertex_array); // unnötig static GLfloat color_and_vertex_array[] = { 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 25.0, 0.0, 0.0, 1.0, 1.0, 0.0, 25.0, 25.0, 0.0, 0.0, 0.0, 1.0, 0.0, 25.0, 0.0 }; glinterleavedarrays(gl_c3f_v3f, 0, color_and_vertex_array); // mach was das dritte mal von 40

14 1 Ein- / Ausschalten von Arrays EnableClientState, DisableClientState 2 Spezifizieren der Daten Einzelne Arrays ColorPointer, EdgeFlagPointer, FogCoordPointer, IndexPointer, NormalPointer, SecondaryColorPointer, TextCoordPointer, VertexPointer Mehrere Arrays InterleavedArrays Elementweise (ein Objekt) ArrayElement Listenweise (ein Objekt) DrawElements, DrawRangeElements Listenweise (mehrere Objekte) MultiDrawElements Direkt (ein Objekt) DrawArrays Direkt (mehrere Objekte) MultiDrawArrays 14 von 40

15 Elementweise (ein Objekt) ArrayElement 15 von 40

16 Elementweise (ein Objekt) ArrayElement // mach was das erste mal... // erste Möglichkeit der elementweisen Dereferenzierung mit C-Mitteln glbegin(gl_triangles); glcolor3fv(color_array + 0*3); glvertex3fv(vertex_array + 0*3); glcolor3fv(color_array + 1*3); glvertex3fv(vertex_array + 1*3); glcolor3fv(color_array + 3*3); glvertex3fv(vertex_array + 3*3); // Zeichne buntes Dreieck // 3 weil size=3 bei glcolorpointer() // 3 weil size=3 bei glvertexpointer() // 3 weil size=3 bei glcolorpointer() // 3 weil size=3 bei glvertexpointer() // 3 weil size=3 bei glcolorpointer() // 3 weil size=3 bei glvertexpointer() glend(); 16 von 40

17 Elementweise (ein Objekt) ArrayElement void glarrayelement(glint ith) Dereferenziert die Daten vom i-ten Element aus allen zur Verfügung gestellten Daten-Feldern auf einmal. Dieses Kommando sollte nur zwischen glbegin() und glend() verwendet werden, weil sonst der Status-Zeiger (ith) für alle zur Verfügung gestellten Daten-Felder gesetzt wird. Das Kommando ruft je nachdem welche Daten-Felder zur verfügung gestellt wurden (in unspezifizierter Reihenfolge) glcolor[size][type]v(), gledgeflagv(), glfogcoord[type]v(), glindex[type]v(), glnormal3[type]v(), glsecondarycolor3[type]v(), gltextcoord[size][type]v() und auf jeden Fall glvertex[size][type]v() zuletzt. Dabei gilt für size und type jeweils das was dafür bei den jeweiligen gl*pointer() angegeben wurde. ith := Nummer des Elements (in C mit 0 beginnend, Element #1=0, #2=1, #3=2 etc.) 17 von 40

18 Elementweise (ein Objekt) ArrayElement // mach was das erste mal... // zweite Möglichkeit der elementweisen Dereferenzierung mit OpenGL-Mitteln glbegin(gl_triangles); // Zeichne buntes Dreieck glarrayelement(0); glarrayelement(1); glarrayelement(3); glend(); 18 von 40

20 Listenweise (ein Objekt) DrawElements, DrawRangeElements 20 von 40

21 Listenweise (ein Objekt) DrawElements, DrawRangeElements // nur vordere Flächen zeichnen glenable(gl_cull_face);glcullface(gl_back); glenableclientstate(gl_color_array); glenableclientstate(gl_vertex_array); static GLfloat color_array[] = {1.0, 0.0, 1.0, // Magenta 1.0, 0.0, 0.0, // Rot 1.0, 1.0, 0.0, // Gelb 1.0, 1.0, 1.0, // Weiss 0.0, 0.0, 1.0, // Blau 0.0, 0.0, 0.0, // Schwarz 0.0, 1.0, 0.0, // Grün 0.0, 1.0, 1.0 }; // Cyan static GLfloat vertex_array[] = {-25.0, -25.0, 25.0, 25.0, -25.0, 25.0, 25.0, 25.0, 25.0, -25.0, 25.0, 25.0, -25.0, -25.0, -25.0, 25.0, -25.0, -25.0, 25.0, 25.0, -25.0, -25.0, 25.0, -25.0}; // Würfel glcolorpointer(3, GL_FLOAT, 0, color_array); glvertexpointer(3, GL_FLOAT, 0, vertex_array); 21 von 40

22 Listenweise (ein Objekt) DrawElements, DrawRangeElements void gldrawelements(glenum mode, GLsizei count, GLenum type, void *indices) void gldrawrangeelements(glenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, void *indices) Fasst mehrere glarrayelement() in sich zusammen, um ein Objekt zu zeichnen. Das Kommando darf nicht zwischen glbegin() und glend() stehen, das verursacht einen error. Bei gldrawrangeelements() dürfen keine Indices außerhalb von [start, end] referenziert werden, was dabei passiert ist implementationsabhängig. mode := Angabe was gezeichnet werden soll wie bei glbegin(); GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP oder GL_POLYGON start: = minimal vorkommendes Indice end := maximal vorkommendes Indice count := Anzahl der glarrayelement() die ausgeführt werden sollen type := Datentyp der Elemente in Daten-Feld *indices; GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT oder GL_UNSIGNED_INT *indices := Daten-Feld mit Indices die z.b. ein Polygon beschrieben int i; glbegin(mode); for(i=0; i<count; i++) glarrayelement(indices[i]); glend(); 22 von 40

23 Listenweise (ein Objekt) DrawElements, DrawRangeElements /******************************************************************************* * erste Möglichkeit mit separaten Indice-Feldern und mehreren gldrawelements() ******************************************************************************/ // mehrere Listen für Flächen (Polygone) erstellen static GLubyte vorne[] = {0, 1, 2, 3}; static GLubyte hinten[] = {5, 4, 7, 6}; static GLubyte links[] = {4, 0, 3, 7}; static GLubyte rechts[] = {1, 5, 6, 2}; static GLubyte oben[] = {3, 2, 6, 7}; static GLubyte unten[] = {4, 5, 1, 0}; // Flächen zeichnen gldrawelements(gl_quads, 4, GL_UNSIGNED_BYTE, vorne); gldrawelements(gl_quads, 4, GL_UNSIGNED_BYTE, hinten); gldrawelements(gl_quads, 4, GL_UNSIGNED_BYTE, links); gldrawelements(gl_quads, 4, GL_UNSIGNED_BYTE, rechts); gldrawelements(gl_quads, 4, GL_UNSIGNED_BYTE, oben); gldrawelements(gl_quads, 4, GL_UNSIGNED_BYTE, unten); 23 von 40

24 Listenweise (ein Objekt) DrawElements, DrawRangeElements /******************************************************************************* * zweite Möglichkeit mit einem Indice-Feld und einem gldrawelements() ******************************************************************************/ // eine Liste für Flächen (Polygone) erstellen static GLubyte alles[] = {0, 1, 2, 3, 5, 4, 7, 6, 4, 0, 3, 7, 1, 5, 6, 2, 3, 2, 6, 7, 4, 5, 1, 0}; // Flächen zeichnen gldrawelements(gl_quads, 24, GL_UNSIGNED_BYTE, alles); 24 von 40

26 Listenweise (mehrere Objekte) MultiDrawElements 26 von 40

27 Listenweise (mehrere Objekte) MultiDrawElements // Farbe setzen GlColor3f(1.0, 0.0, 0.0); // Rot glenableclientstate(gl_vertex_array); static GLfloat vertex_array[] = {-25.0, -25.0, 25.0, 25.0, -25.0, 25.0, 25.0, 25.0, 25.0, -25.0, 25.0, 25.0, -25.0, -25.0, -25.0, 25.0, -25.0, -25.0, 25.0, 25.0, -25.0, -25.0, 25.0, -25.0}; // Würfel glvertexpointer(3, GL_FLOAT, 0, vertex_array); 27 von 40

28 Listenweise (mehrere Objekte) MultiDrawElements /******************************************************************************* * erste Möglichkeit mit separaten Indice-Feldern und mehreren gldrawelements() ******************************************************************************/ // mehrere Listen für Flächen (Polygone) erstellen static GLubyte erstes_linestrip[] = {0, 1, 2, 3}; static GLubyte zweites_linestrip[] = {5, 4, 7}; // zwei Linestrips zeichnen gldrawelements(gl_line_strip, 4, GL_UNSIGNED_BYTE, erstes_linestrip); gldrawelements(gl_line_strip, 3, GL_UNSIGNED_BYTE, zweites_linestrip); /******************************************************************************* * zweite Möglichkeit mit einem Indice-Feld und einem gldrawelements() ******************************************************************************/ // Bei diesem Beispiel mit GL_LINE_STRIP nicht möglich, da einmal 4 und einmal 3 // Indices verwendet werden und somit ein Zusammenfassen für ein // gldrawelements() nicht möglich ist. Ausserdem würden die Linestrips verbunden // werden 28 von 40

29 Listenweise (mehrere Objekte) MultiDrawElements void glmultidrawelements(glenum mode, GLsizei *count, GLenum type, void **indices, GLsizei primcount) Fasst mehrere gldrawelements() in sich zusammen, um mehrere Objekt zu zeichnen. Das Kommando darf nicht zwischen glbegin() und glend() stehen, das verursacht einen error. mode := Angabe was gezeichnet werden soll wie bei gldrawelements(); GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP oder GL_POLYGON *count := Array dessen Elemente jeweils angeben, wie viel Indices jedes gldrawelements() bearbeiten soll type := Datentyp der Elemente in Daten-Feld *indices von gldrawelements(); GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT oder GL_UNSIGNED_INT **indices := Array von Pointern auf mehrere Indice-Felder, die pro gldrawelements() verwendet hätten sollen primcount := Anzahl der gldrawelements() die zusammengefasst werden sollen int i; for(i=0; i<primcount; i++) { if(count[i]>0) gldrawelements(mode, count[i], type, indices[i]); } 29 von 40

30 Listenweise (mehrere Objekte) MultiDrawElements /******************************************************************************* * dritte Möglichkeit mit separaten Indice-Feldern ******************************************************************************/ // mehrere Listen für Flächen (Polygone) erstellen static GLubyte erstes_linestrip[] = {0, 1, 2, 3}; static GLubyte zweites_linestrip[] = {5, 4, 7}; // weitere benötigte Angaben für glmultidrawelements() static count[] = {4, 3}; // Anzahl Elemente in jedem Indice-Feld static GLvoid *indices[2] = {erstes_linestrip, zweites_linestrip}; // zwei Linestrips zeichnen glmultidrawelements(gl_line_strip, count, GL_UNSIGNED_BYTE, indices, 2); 30 von 40

31 Listenweise (mehrere Objekte) MultiDrawElements /******************************************************************************* * vierte Möglichkeit mit einem Indice-Feld ******************************************************************************/ // eine List für Flächen (Polygone) erstellen static GLubyte alle_linestrips[] = {0, 1, 2, 3 5, 4, 7}; // weitere benötigte Angaben für glmultidrawelements() static count[] = {4, 3}; // Anzahl Elemente in jedem Indice-Feld static GLvoid *indices[2] = {alle_linestrips, alle_linestrips[4]}; // zwei Linestrips zeichnen glmultidrawelements(gl_line_strip, count, GL_UNSIGNED_BYTE, indices, 2); 31 von 40

33 Direkt (ein Objekt) DrawArrays 33 von 40

34 Direkt (ein Objekt) DrawArrays glenableclientstate(gl_color_array); glenableclientstate(gl_vertex_array); static GLfloat color_array[] = { 1.0, 0.0, 0.0, // Rot 0.0, 1.0, 0.0, // Grün 1.0, 1.0, 0.0, // Gelb 0.0, 0.0, 1.0 }; // Blau static GLfloat vertex_array[] = { 0.0, 0.0, 0.0, 25.0, 0.0, 0.0, 25.0, 25.0, 0.0, 0.0, 25.0, 0.0 }; // z.b. für GL_QUADS glcolorpointer(3, GL_FLOAT, 0, color_array); glvertexpointer(3, GL_FLOAT, 0, vertex_array); 34 von 40

35 Direkt (ein Objekt) DrawArrays void gldrawarrays(glenum mode, GLint first, GLsizei count) Zeichnet direkt aus den Daten-Feldern ohne Indice-Listen. Das Kommando darf nicht zwischen glbegin() und glend() stehen, das verursacht einen error. mode := Angabe was gezeichnet werden soll wie bei glbegin(); GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP oder GL_POLYGON first := erstes Element (Datenpaket) count := Anzahl der Elemente (Datenpakete) die abgearbeitet werden sollen int i; glbegin(mode); for(i=0; i<count; i++) glarrayelements(first + i); glend(); 35 von 40

36 Direkt (ein Objekt) DrawArrays /******************************************************************************* * erste Möglichkeit zwei Objekte mit zwei gldrawarrays() zu zeichnen ******************************************************************************/ // zwei Dreiecke zeichnen gldrawarrays(gl_triangles, 0, 3); gldrawarrays(gl_triangles, 1, 3); 36 von 40

38 Direkt (mehrere Objekte) MultiDrawArrays void glmultidrawarrays(glenum mode, GLint *first, GLsizei *count, GLsizei primcount) Fasst mehrere gldrawarrays() in sich zusammen, um mehrere Objekt zu zeichnen. Das Kommando darf nicht zwischen glbegin() und glend() stehen, das verursacht einen error. mode := Angabe was gezeichnet werden soll wie bei glbegin(); GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP oder GL_POLYGON *first := Array dessen Elemente jeweils angeben, wo sich jeweils das erste Element (Datenpaket) pro gldrawarrays() befindet *count() := Array dessen Elemente jeweils angeben, wieviele Elemente (Datenpakete) pro gldrawarrays() bearbeitet werden sollen primcount := Anzahl der gldrawarrays() die zusammengefasst werden sollen int i; for(i=0; i<primcount; i++) { if(count[i]>0) gldrawarrays(mode, first[i], count[i]); } 38 von 40

39 Direkt (mehrere Objekte) MultiDrawArrays /******************************************************************************* * zweite Möglichkeit zwei Objekte mit einem glmultidrawarrays() zu zeichnen ******************************************************************************/ // weitere benötigte Angaben für glmultidrawelements() static GLint *first[2] = {0, 1}; static GLint *count[2] = {3, 3}; // zwei Dreiecke zeichnen glmultidrawarrays(gl_triangles, first, count, 2}; 39 von 40

40 Quellen Funktionen OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 2, 5th Edition - Aug Codes Selbst erstellt Bilder Selbst erstellt 40 von 40