Google Git Google Git
Sign in
skia/external/github.com/KhronosGroup/OpenGL-Registry/refs/heads/add-contributing-file/./extensions/EXT/EXT_vertex_array.txt
blob: f5992358a87c564d7eda505abe0d7b6cafa7117a [file] [edit]
Name
EXT_vertex_array
Name Strings
GL_EXT_vertex_array
Version
$Date: 1995/10/03 05:39:58 $ $Revision: 1.16 $ FINAL
Number
30
Dependencies
None
Overview
This extension adds the ability to specify multiple geometric primitives
with very few subroutine calls. Instead of calling an OpenGL procedure
to pass each individual vertex, normal, or color, separate arrays
of vertexes, normals, and colors are prespecified, and are used to
define a sequence of primitives (all of the same type) when a single
call is made to DrawArraysEXT. A stride mechanism is provided so that
an application can choose to keep all vertex data staggered in a
single array, or sparsely in separate arrays. Single-array storage
may optimize performance on some implementations.
This extension also supports the rendering of individual array elements,
each specified as an index into the enabled arrays.
Issues
* Should arrays for material parameters be provided? If so, how?
A: No. Let's leave this to a separate extension, and keep this
extension lean.
* Should a FORTRAN interface be specified in this document?
* It may not be possible to implement GetPointervEXT in FORTRAN. If
not, should we eliminate it from this proposal?
A: Leave it in.
* Should a stride be specified by DrawArraysEXT which, if non-zero,
would override the strides specified for the individual arrays?
This might improve the efficiency of single-array transfers.
A: No, it's not worth the effort and complexity.
* Should entry points for byte vertexes, byte indexes, and byte
texture coordinates be added in this extension?
A: No, do this in a separate extension, which defines byte support
for arrays and for the current procedural interface.
* Should support for meshes (not strips) of rectangles be provided?
A: No. If this is necessary, define a separate quad_mesh extension
that supports both immediate mode and arrays. (Add QUAD_MESH_EXT
as a token accepted by Begin and DrawArraysEXT. Add
QuadMeshLengthEXT to specify the length of the mesh.)
Reasoning
* DrawArraysEXT requires that VERTEX_ARRAY_EXT be enabled so that
future extensions can support evaluation as well as direct
specification of vertex coordinates.
* This extension does not support evaluation. It could be extended
to provide such support by adding arrays of points to be evaluated,
and by adding enables to indicate that the arrays are to be
evaluated. I think we may choose to add an array version of
EvalMesh, rather than extending the operation of DrawArraysEXT,
so I'd rather wait on this one.
* <size> is specified before <type> to match the order of the
information in immediate mode commands, such as Vertex3f.
(first 3, then f)
* It seems reasonable to allow attribute values to be undefined after
DrawArraysEXT executes. This avoids implementation overhead in
the case where an incomplete primitive is specified, and will allow
optimization on multiprocessor systems. I don't expect this to be
a burden to programmers.
* It is not an error to call VertexPointerEXT, NormalPointerEXT,
ColorPointerEXT, IndexPointerEXT, TexCoordPointerEXT,
or EdgeFlagPointerEXT between the execution of Begin and the
corresponding execution of End. Because these commands will
typically be implemented on the client side with no protocol,
testing for between-Begin-End status requires that the client
track this state, or that a round trip be made. Neither is
desirable.
* Arrays are enabled and disabled individually, rather than with a
single mask parameter, for two reasons. First, we have had trouble
allocating bits in masks, so eliminating a mask eliminates potential
trouble down the road. We may eventually require a larger number of
array types than there are bits in a mask. Second, making the
enables into state eliminates a parameter in ArrayElementEXT, and
may allow it to execute more efficiently. Of course this state
model may result in programming errors, but OpenGL is full of such
hazards anyway!
* ArrayElementEXT is provided to support applications that construct
primitives by indexing vertex data, rather than by streaming through
arrays of data in first-to-last order. Because each call specifies
only a single vertex, it is possible for an application to explicitly
specify per-primitive attributes, such as a single normal per
individual triangle.
* The <count> parameters are added to the *PointerEXT commands to
allow implementations to cache array data, and in particular to
cache the transformed results of array data that are rendered
repeatedly by ArrayElementEXT. Implementations that do not wish
to perform such caching can ignore the <count> parameter.
* The <first> parameter of DrawArraysEXT allows a single set of
arrays to be used repeatedly, possibly improving performance.
New Procedures and Functions
void ArrayElementEXT(int i);
void DrawArraysEXT(enum mode,
int first,
sizei count);
void VertexPointerEXT(int size,
enum type,
sizei stride,
sizei count,
const void* pointer);
void NormalPointerEXT(enum type,
sizei stride,
sizei count,
const void* pointer);
void ColorPointerEXT(int size,
enum type,
sizei stride,
sizei count,
const void* pointer);
void IndexPointerEXT(enum type,
sizei stride,
sizei count,
const void* pointer);
void TexCoordPointerEXT(int size,
enum type,
sizei stride,
sizei count,
const void* pointer);
void EdgeFlagPointerEXT(sizei stride,
sizei count,
const Boolean* pointer);
void GetPointervEXT(enum pname,
void** params);
New Tokens
Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, and
by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and
GetDoublev:
VERTEX_ARRAY_EXT 0x8074
NORMAL_ARRAY_EXT 0x8075
COLOR_ARRAY_EXT 0x8076
INDEX_ARRAY_EXT 0x8077
TEXTURE_COORD_ARRAY_EXT 0x8078
EDGE_FLAG_ARRAY_EXT 0x8079
Accepted by the <type> parameter of VertexPointerEXT, NormalPointerEXT,
ColorPointerEXT, IndexPointerEXT, and TexCoordPointerEXT:
DOUBLE_EXT 0x140A
Accepted by the <pname> parameter of GetBooleanv, GetIntegerv,
GetFloatv, and GetDoublev:
VERTEX_ARRAY_SIZE_EXT 0x807A
VERTEX_ARRAY_TYPE_EXT 0x807B
VERTEX_ARRAY_STRIDE_EXT 0x807C
VERTEX_ARRAY_COUNT_EXT 0x807D
NORMAL_ARRAY_TYPE_EXT 0x807E
NORMAL_ARRAY_STRIDE_EXT 0x807F
NORMAL_ARRAY_COUNT_EXT 0x8080
COLOR_ARRAY_SIZE_EXT 0x8081
COLOR_ARRAY_TYPE_EXT 0x8082
COLOR_ARRAY_STRIDE_EXT 0x8083
COLOR_ARRAY_COUNT_EXT 0x8084
INDEX_ARRAY_TYPE_EXT 0x8085
INDEX_ARRAY_STRIDE_EXT 0x8086
INDEX_ARRAY_COUNT_EXT 0x8087
TEXTURE_COORD_ARRAY_SIZE_EXT 0x8088
TEXTURE_COORD_ARRAY_TYPE_EXT 0x8089
TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
TEXTURE_COORD_ARRAY_COUNT_EXT 0x808B
EDGE_FLAG_ARRAY_STRIDE_EXT 0x808C
EDGE_FLAG_ARRAY_COUNT_EXT 0x808D
Accepted by the <pname> parameter of GetPointervEXT:
VERTEX_ARRAY_POINTER_EXT 0x808E
NORMAL_ARRAY_POINTER_EXT 0x808F
COLOR_ARRAY_POINTER_EXT 0x8090
INDEX_ARRAY_POINTER_EXT 0x8091
TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
EDGE_FLAG_ARRAY_POINTER_EXT 0x8093
Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation)
Array Specification
-------------------
Individual array pointers and associated data are maintained for an
array of vertexes, an array of normals, an array of colors, an array
of color indexes, an array of texture coordinates, and an array of edge
flags. The data associated with each array specify the data type of
the values in the array, the number of values per element in the array
(e.g. vertexes of 2, 3, or 4 coordinates), the byte stride from one
array element to the next, and the number of elements (counting from
the first) that are static. Static elements may be modified by the
application, but once they are modified, the application must explicitly
respecify the array before using it for any rendering. When an array is
specified, the pointer and associated data are saved as client-side
state, and static elements may be cached by the implementation. Non-
static (dynamic) elements are never accessed until ArrayElementEXT or
DrawArraysEXT is issued.
VertexPointerEXT specifies the location and data format of an array
of vertex coordinates. <pointer> specifies a pointer to the first
coordinate of the first vertex in the array. <type> specifies the data
type of each coordinate in the array, and must be one of SHORT, INT,
FLOAT, or DOUBLE_EXT, implying GL data types short, int, float, and
double respectively. <size> specifies the number of coordinates per
vertex, and must be 2, 3, or 4. <stride> specifies the byte offset
between pointers to consecutive vertexes. If <stride> is zero, the
vertex data are understood to be tightly packed in the array. <count>
specifies the number of vertexes, counting from the first, that are
static.
NormalPointerEXT specifies the location and data format of an array
of normals. <pointer> specifies a pointer to the first coordinate
of the first normal in the array. <type> specifies the data type
of each coordinate in the array, and must be one of BYTE, SHORT, INT,
FLOAT, or DOUBLE_EXT, implying GL data types byte, short, int, float,
and double respectively. It is understood that each normal comprises
three coordinates. <stride> specifies the byte offset between
pointers to consecutive normals. If <stride> is zero, the normal
data are understood to be tightly packed in the array. <count>
specifies the number of normals, counting from the first, that are
static.
ColorPointerEXT specifies the location and data format of an array
of color components. <pointer> specifies a pointer to the first
component of the first color element in the array. <type> specifies the
data type of each component in the array, and must be one of BYTE,
UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, FLOAT, or
DOUBLE_EXT, implying GL data types byte, ubyte, short, ushort, int,
uint, float, and double respectively. <size> specifies the number of
components per color, and must be 3 or 4. <stride> specifies the byte
offset between pointers to consecutive colors. If <stride> is zero,
the color data are understood to be tightly packed in the array.
<count> specifies the number of colors, counting from the first, that
are static.
IndexPointerEXT specifies the location and data format of an array
of color indexes. <pointer> specifies a pointer to the first index in
the array. <type> specifies the data type of each index in the
array, and must be one of SHORT, INT, FLOAT, or DOUBLE_EXT, implying
GL data types short, int, float, and double respectively. <stride>
specifies the byte offset between pointers to consecutive indexes. If
<stride> is zero, the index data are understood to be tightly packed
in the array. <count> specifies the number of indexes, counting from
the first, that are static.
TexCoordPointerEXT specifies the location and data format of an array
of texture coordinates. <pointer> specifies a pointer to the first
coordinate of the first element in the array. <type> specifies the data
type of each coordinate in the array, and must be one of SHORT, INT,
FLOAT, or DOUBLE_EXT, implying GL data types short, int, float, and
double respectively. <size> specifies the number of coordinates per
element, and must be 1, 2, 3, or 4. <stride> specifies the byte offset
between pointers to consecutive elements of coordinates. If <stride> is
zero, the coordinate data are understood to be tightly packed in the
array. <count> specifies the number of texture coordinate elements,
counting from the first, that are static.
EdgeFlagPointerEXT specifies the location and data format of an array
of boolean edge flags. <pointer> specifies a pointer to the first flag
in the array. <stride> specifies the byte offset between pointers to
consecutive edge flags. If <stride> is zero, the edge flag data are
understood to be tightly packed in the array. <count> specifies the
number of edge flags, counting from the first, that are static.
The table below summarizes the sizes and data types accepted (or
understood implicitly) by each of the six pointer-specification commands.
Command Sizes Types
------- ----- -----
VertexPointerEXT 2,3,4 short, int, float, double
NormalPointerEXT 3 byte, short, int, float, double
ColorPointerEXT 3,4 byte, short, int, float, double,
ubyte, ushort, uint
IndexPointerEXT 1 short, int, float, double
TexCoordPointerEXT 1,2,3,4 short, int, float, double
EdgeFlagPointerEXT 1 boolean
Rendering the Arrays
--------------------
By default all the arrays are disabled, meaning that they will not
be accessed when either ArrayElementEXT or DrawArraysEXT is called.
An individual array is enabled or disabled by calling Enable or
Disable with <cap> set to appropriate value, as specified in the
table below:
Array Specification Command Enable Token
--------------------------- ------------
VertexPointerEXT VERTEX_ARRAY_EXT
NormalPointerEXT NORMAL_ARRAY_EXT
ColorPointerEXT COLOR_ARRAY_EXT
IndexPointerEXT INDEX_ARRAY_EXT
TexCoordPointerEXT TEXTURE_COORD_ARRAY_EXT
EdgeFlagPointerEXT EDGE_FLAG_ARRAY_EXT
When ArrayElementEXT is called, a single vertex is drawn, using vertex
and attribute data taken from location <i> of the enabled arrays. The
semantics of ArrayElementEXT are defined in the C-code below:
void ArrayElementEXT (int i) {
byte* p;
if (NORMAL_ARRAY_EXT) {
if (normal_stride == 0)
p = (byte*)normal_pointer + i * 3 * sizeof(normal_type);
else
p = (byte*)normal_pointer + i * normal_stride;
Normal3<normal_type>v ((normal_type*)p);
}
if (COLOR_ARRAY_EXT) {
if (color_stride == 0)
p = (byte*)color_pointer +
i * color_size * sizeof(color_type);
else
p = (byte*)color_pointer + i * color_stride;
Color<color_size><color_type>v ((color_type*)p);
}
if (INDEX_ARRAY_EXT) {
if (index_stride == 0)
p = (byte*)index_pointer + i * sizeof(index_type);
else
p = (byte*)index_pointer + i * index_stride;
Index<index_type>v ((index_type*)p);
}
if (TEXTURE_COORD_ARRAY_EXT) {
if (texcoord_stride == 0)
p = (byte*)texcoord_pointer +
i * texcoord_size * sizeof(texcoord_type);
else
p = (byte*)texcoord_pointer + i * texcoord_stride;
TexCoord<texcoord_size><texcoord_type>v ((texcoord_type*)p);
}
if (EDGE_FLAG_ARRAY_EXT) {
if (edgeflag_stride == 0)
p = (byte*)edgeflag_pointer + i * sizeof(boolean);
else
p = (byte*)edgeflag_pointer + i * edgeflag_stride;
EdgeFlagv ((boolean*)p);
}
if (VERTEX_ARRAY_EXT) {
if (vertex_stride == 0)
p = (byte*)vertex_pointer +
i * vertex_size * sizeof(vertex_type);
else
p = (byte*)vertex_pointer + i * vertex_stride;
Vertex<vertex_size><vertex_type>v ((vertex_type*)p);
}
}
ArrayElementEXT executes even if VERTEX_ARRAY_EXT is not enabled. No
drawing occurs in this case, but the attributes corresponding to
enabled arrays are modified.
When DrawArraysEXT is called, <count> sequential elements from each
enabled array are used to construct a sequence of geometric primitives,
beginning with element <first>. <mode> specifies what kind of
primitives are constructed, and how the array elements are used to
construct these primitives. Accepted values for <mode> are POINTS,
LINE_STRIP, LINE_LOOP, LINES, TRIANGLE_STRIP, TRIANGLE_FAN, TRIANGLES,
QUAD_STRIP, QUADS, and POLYGON. If VERTEX_ARRAY_EXT is not enabled, no
geometric primitives are generated.
The semantics of DrawArraysEXT are defined in the C-code below:
void DrawArraysEXT(enum mode, int first, sizei count) {
int i;
if (count < 0)
/* generate INVALID_VALUE error and abort */
else {
Begin (mode);
for (i=0; i < count; i++)
ArrayElementEXT(first + i);
End ();
}
}
The ways in which the execution of DrawArraysEXT differs from the
semantics indicated in the pseudo-code above are:
1. Vertex attributes that are modified by DrawArraysEXT have an
unspecified value after DrawArraysEXT returns. For example, if
COLOR_ARRAY_EXT is enabled, the value of the current color is
undefined after DrawArraysEXT executes. Attributes that aren't
modified remain well defined.
2. Operation of DrawArraysEXT is atomic with respect to error
generation. If an error is generated, no other operations take
place.
Although it is not an error to respecify an array between the execution
of Begin and the corresponding execution of End, the result of such
respecification is undefined. Static array data may be read and cached
by the implementation at any time. If static array data are modified by
the application, the results of any subsequently issued ArrayElementEXT
or DrawArraysEXT commands are undefined.
Additions to Chapter 3 of the 1.0 Specification (Rasterization)
None
Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations
and the Frame buffer)
None
Additions to Chapter 5 of the 1.0 Specification (Special Functions)
ArrayElementEXT and DrawArraysEXT are included in display lists.
When either command is entered into a display list, the necessary
array data (determined by the array pointers and enables) is also
entered into the display list. Because the array pointers and
enables are client side state, their values affect display lists
when the lists are created, not when the lists are executed.
Array specification commands VertexPointerEXT, NormalPointerEXT,
ColorPointerEXT, IndexPointerEXT, TexCoordPointerEXT, and
EdgeFlagPointerEXT specify client side state, and are therefore
not included in display lists. Likewise Enable and Disable, when
called with <cap> set to VERTEX_ARRAY_EXT, NORMAL_ARRAY_EXT,
COLOR_ARRAY_EXT, INDEX_ARRAY_EXT, TEXTURE_COORD_ARRAY_EXT, or
EDGE_FLAG_ARRAY_EXT, are not included in display lists.
GetPointervEXT returns state information, and so is not included
in display lists.
Additions to Chapter 6 of the 1.0 Specification (State and State Requests)
GetPointervEXT returns in <param> the array pointer value specified
by <pname>. Accepted values for <pname> are VERTEX_ARRAY_POINTER_EXT,
NORMAL_ARRAY_POINTER_EXT, COLOR_ARRAY_POINTER_EXT,
INDEX_ARRAY_POINTER_EXT, TEXTURE_COORD_ARRAY_POINTER_EXT,
and EDGE_FLAG_ARRAY_POINTER_EXT.
All array data are client side state, and are not saved or restored
by PushAttrib and PopAttrib.
Additions to the GLX Specification
None
GLX Protocol
A new rendering command is added; it can be sent to the server as part of a
glXRender request or as part of a glXRenderLarge request:
The DrawArraysEXT command consists of three sections, in the following order:
(1) header information, (2) a list of array information, containing the type
and size of the array values for each enabled array and (3) a list of vertex
data. Each element in the list of vertex data contains information for a single
vertex taken from the enabled arrays.
DrawArraysEXT
2 16+(12*m)+(s*n) rendering command length
2 4116 rendering command opcode
4 CARD32 n (number of array elements)
4 CARD32 m (number of enabled arrays)
4 ENUM mode /* GL_POINTS etc */
12*m LISTofARRAY_INFO
s*n LISTofVERTEX_DATA
Where s = ns + cs + is + ts + es + vs + np + cp + ip + tp + ep + vp. (See
description below, under VERTEX_DATA.) Note that if an array is disabled
then no information is sent for it. For example, when the normal array is
disabled, there is no ARRAY_INFO record for the normal array and ns and np
are both zero.
Note that the list of ARRAY_INFO is unordered: since the ARRAY_INFO
record contains the array type, the arrays in the list may be stored
in any order. Also, the VERTEX_DATA list is a packed list of vertices.
For each vertex, data is retrieved from the enabled arrays, and stored
in the list.
If the command is encoded in a glXRenderLarge request, the command
opcode and command length fields above are expanded to 4 bytes each:
4 20+(12*m)+(s*n) rendering command length
4 4116 rendering command opcode
ARRAY_INFO
4 ENUM data type
0x1400 i=1 BYTE
0x1401 i=1 UNSIGNED_BYTE
0x1402 i=2 SHORT
0x1403 i=2 UNSIGNED_SHORT
0x1404 i=4 INT
0x1405 i=4 UNSIGNED_INT
0x1406 i=4 FLOAT
0x140A i=8 DOUBLE_EXT
4 INT32 j (number of values in array element)
4 ENUM array type
0x8074 j=2/3/4 VERTEX_ARRAY_EXT
0x8075 j=3 NORMAL_ARRAY_EXT
0x8076 j=3/4 COLOR_ARRAY_EXT
0x8077 j=1 INDEX_ARRAY_EXT
0x8078 j=1/2/3/4 TEXTURE_COORD_ARRAY_EXT
0x8079 j=1 EDGE_FLAG_ARRAY_EXT
For each array, the size of an array element is i*j. Some arrays
(e.g., the texture coordinate array) support different data sizes;
for these arrays, the size, j, is specified when the array is defined.
VERTEX_DATA
if the normal array is enabled:
ns LISTofBYTE normal array element
np unused, np=pad(ns)
if the color array is enabled:
cs LISTofBYTE color array element
cp unused, cp=pad(cs)
if the index array is enabled:
is LISTofBYTE index array element
ip unused, ip=pad(is)
if the texture coord array is enabled:
ts LISTofBYTE texture coord array element
tp unused, tp=pad(ts)
if the edge flag array is enabled:
es LISTofBYTE edge flag array element
ep unused, ep=pad(es)
if the vertex array is enabled:
vs LISTofBYTE vertex array element
vp unused, vp=pad(vs)
where ns, cs, is, ts, es, vs is the size of the normal, color, index,
texture, edge and vertex array elements and np, cp, ip, tp, ep, vp is
the padding for the normal, color, index, texture, edge and vertex array
elements, respectively.
Errors
INVALID_OPERATION is generated if DrawArraysEXT is called between the
execution of Begin and the corresponding execution of End.
INVALID_ENUM is generated if DrawArraysEXT parameter <mode> is not
POINTS, LINE_STRIP, LINE_LOOP, LINES, TRIANGLE_STRIP, TRIANGLE_FAN,
TRIANGLES, QUAD_STRIP, QUADS, or POLYGON.
INVALID_VALUE is generated if DrawArraysEXT parameter <count> is
negative.
INVALID_VALUE is generated if VertexPointerEXT parameter <size> is not
2, 3, or 4.
INVALID_ENUM is generated if VertexPointerEXT parameter <type> is not
SHORT, INT, FLOAT, or DOUBLE_EXT.
INVALID_VALUE is generated if VertexPointerEXT parameter <stride> or
<count> is negative.
INVALID_ENUM is generated if NormalPointerEXT parameter <type> is not
BYTE, SHORT, INT, FLOAT, or DOUBLE_EXT.
INVALID_VALUE is generated if NormalPointerEXT parameter <stride> or
<count> is negative.
INVALID_VALUE is generated if ColorPointerEXT parameter <size> is not
3 or 4.
INVALID_ENUM is generated if ColorPointerEXT parameter <type> is not
BYTE, UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, FLOAT,
or DOUBLE_EXT.
INVALID_VALUE is generated if ColorPointerEXT parameter <stride> or
<count> is negative.
INVALID_ENUM is generated if IndexPointerEXT parameter <type> is not
SHORT, INT, FLOAT, or DOUBLE_EXT.
INVALID_VALUE is generated if IndexPointerEXT parameter <stride> or
<count> is negative.
INVALID_VALUE is generated if TexCoordPointerEXT parameter <size> is not
1, 2, 3, or 4.
INVALID_ENUM is generated if TexCoordPointerEXT parameter <type> is not
SHORT, INT, FLOAT, or DOUBLE_EXT.
INVALID_VALUE is generated if TexCoordPointerEXT parameter <stride> or
<count> is negative.
INVALID_VALUE is generated if EdgeFlagPointerEXT parameter <stride> or
<count> is negative.
INVALID_ENUM is generated if GetPointervEXT parameter <pname> is not
VERTEX_ARRAY_POINTER_EXT, NORMAL_ARRAY_POINTER_EXT,
COLOR_ARRAY_POINTER_EXT, INDEX_ARRAY_POINTER_EXT,
TEXTURE_COORD_ARRAY_POINTER_EXT, or EDGE_FLAG_ARRAY_POINTER_EXT.
New State
Initial
Get Value Get Command Type Value Attrib
--------- ----------- ---- ------- ------
VERTEX_ARRAY_EXT IsEnabled B False client
VERTEX_ARRAY_SIZE_EXT GetIntegerv Z+ 4 client
VERTEX_ARRAY_TYPE_EXT GetIntegerv Z4 FLOAT client
VERTEX_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client
VERTEX_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client
VERTEX_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client
NORMAL_ARRAY_EXT IsEnabled B False client
NORMAL_ARRAY_TYPE_EXT GetIntegerv Z5 FLOAT client
NORMAL_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client
NORMAL_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client
NORMAL_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client
COLOR_ARRAY_EXT IsEnabled B False client
COLOR_ARRAY_SIZE_EXT GetIntegerv Z+ 4 client
COLOR_ARRAY_TYPE_EXT GetIntegerv Z8 FLOAT client
COLOR_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client
COLOR_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client
COLOR_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client
INDEX_ARRAY_EXT IsEnabled B False client
INDEX_ARRAY_TYPE_EXT GetIntegerv Z4 FLOAT client
INDEX_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client
INDEX_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client
INDEX_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client
TEXTURE_COORD_ARRAY_EXT IsEnabled B False client
TEXTURE_COORD_ARRAY_SIZE_EXT GetIntegerv Z+ 4 client
TEXTURE_COORD_ARRAY_TYPE_EXT GetIntegerv Z4 FLOAT client
TEXTURE_COORD_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client
TEXTURE_COORD_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client
TEXTURE_COORD_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client
EDGE_FLAG_ARRAY_EXT IsEnabled B False client
EDGE_FLAG_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client
EDGE_FLAG_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client
EDGE_FLAG_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client
New Implementation Dependent State
None