static GLfloat intertwined[] =
{1.0, 0.2, 1.0, 100.0, 100.0, 0.0,
1.0, 0.2, 0.2, 0.0, 200.0, 0.0,
1.0, 1.0, 0.2, 100.0, 300.0, 0.0,
0.2, 1.0, 0.2, 200.0, 300.0, 0.0,
0.2, 1.0, 1.0, 300.0, 200.0, 0.0,
0.2, 0.2, 1.0, 200.0, 100.0, 0.0};
There is also a behemoth routine, glInterleavedArrays(), that can specify several vertex arrays at once. glInterleavedArrays() also enables and disables the appropriate arrays (so it combines both Steps 1 and 2). The array intertwined exactly fits one of the fourteen data interleaving configurations supported by glInterleavedArrays(). So to specify the contents of the array intertwined into the RGB color and vertex arrays and enable both arrays, call:
glInterleavedArrays (GL_C3F_V3F, 0, intertwined);
This call to glInterleavedArrays() enables the GL_COLOR_ARRAY and GL_VERTEX_ARRAY arrays. It disables the GL_INDEX_ARRAY, GL_TEXTURE_COORD_ARRAY, GL_NORMAL_ARRAY, and GL_EDGE_FLAG_ARRAY.
This call also has the same effect as calling glColorPointer() and glVertexPointer() to specify the values for six vertices into each array. Now you are ready for Step 3: Calling glArrayElement(), glDrawElements(), or glDrawArrays() to dereference array elements.
void glInterleavedArrays(GLenum format, GLsizei stride, void *pointer)Initializes all six arrays, disabling arrays that are not specified in format, and enabling the arrays that are specified. format is one of 14 symbolic constants, which represent 14 data configurations; the table displays format values. stride specifies the byte offset between consecutive vertexes. If stride is 0, the vertexes are understood to be tightly packed in the array. pointer is the memory address of the first coordinate of the first vertex in the array.
Note: glInterleavedArrays() only enables and disables vertex arrays and specifies values for the vertex-array data. It does not render anything. You must still complete Step 3 and call glArrayElement(), glDrawElements(), or glDrawArrays() to dereference the pointers and render graphics.
In the table et, ec, and en are the boolean values for the enabled or disabled texture coordinate, color, and normal arrays, and you'll see st, sc, and sv, which are the sizes (number of components) for the texture coordinate, color, and vertex arrays. tc is the data type for RGBA color, which is the only array that can have non-float interleaved values. pc, pn, and pv are the calculated strides for jumping over individual color, normal, and vertex values, and s is the stride (if one is not specified by the user) to jump from one array element to the next.
T and F are True and False. f is sizeof(GL_FLOAT). c is 4 times sizeof(GL_UNSIGNED_BYTE), rounded up to the nearest multiple of f.
Table: Variables that Direct glInterleavedArrays()
|
format |
et |
ec |
en |
st |
sc |
sv |
tc |
pc |
pn |
pv |
s |
|
GL_V2F |
F |
F |
F |
2 |
0 |
2f |
|||||
|
GL_V3F |
F |
F |
F |
3 |
0 |
3f |
|||||
|
GL_C4UB_V2F |
F |
T |
F |
4 |
2 |
GL_UNSIGNED_BYTE |
0 |
c |
c+2f |
||
|
GL_C4UB_V3F |
F |
T |
F |
4 |
3 |
GL_UNSIGNED_BYTE |
0 |
c |
c+3f |
||
|
GL_C3F_V3F |
F |
T |
F |
3 |
3 |
GL_FLOAT |
0 |
3f |
6f |
||
|
GL_N3F_V3F |
F |
F |
T |
3 |
0 |
3f |
6f |
||||
|
GL_C4F_N3F_V3F |
F |
T |
T |
4 |
3 |
GL_FLOAT |
0 |
4f |
7f |
10f |
|
|
GL_T2F_V3F |
T |
F |
F |
2 |
3 |
2f |
5f |
||||
|
GL_T4F_V4F |
T |
F |
F |
4 |
4 |
4f |
8f |
||||
|
GL_T2F_C4UB_V3F |
T |
T |
F |
2 |
4 |
3 |
GL_UNSIGNED_BYTE |
2f |
c+2f |
c+5f |
|
|
GL_T2F_C3F_V3F |
T |
T |
F |
2 |
3 |
3 |
GL_FLOAT |
2f |
5f |
8f |
|
|
GL_T2F_N3F_V3F |
T |
F |
T |
2 |
3 |
2f |
5f |
8f |
|||
|
GL_T2F_C4F_N3F_V3F |
T |
T |
T |
2 |
4 |
3 |
GL_FLOAT |
2f |
6f |
9f |
12f |
|
GL_T4F_C4F_N3F_V4F |
T |
T |
T |
4 |
4 |
4 |
GL_FLOAT |
4f |
8f |
11f |
15f |
Note that glInterleavedArrays() does not support edge flags.
For some OpenGL implementations, use of interleaved arrays may increase application performance. With an interleaved array, the exact layout of your data is known. You know your data is tightly packed and may be accessed in one chunk. If interleaved arrays are not used, the stride and size information has to be examined to detect whether data is tightly packed.
The effect of glInterleavedArrays() is the same as calling the command sequence:
int str; // set format: et, ec, en, st, sc, sv, tc, pc, pn, pv, and s
str = stride;
if (str == 0)
str = s;
glDisableClientState(GL_EDGE_FLAG_ARRAY);
glDisableClientState(GL_INDEX_ARRAY);
if (et) {
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(st, GL_FLOAT, str, pointer);
}
else
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if (ec) {
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(sc, tc, str, pointer+pc);
}
else
glDisableClientState(GL_COLOR_ARRAY);
if (en) {
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, str, pointer+pn);
}
else
glDisableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(sv, GL_FLOAT, str, pointer+pv);