SGI Developer Toolbox 6.1

home *** CD-ROM | disk | FTP | other *** search

/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / documents / OpenGL / opengldoc / glspec / vertex_array.spec < prev next >

Wrap

Text File | 1996-11-11 | 26.9 KB | 678 lines

Name EXT_vertex_array Name Strings GL_EXT_vertex_array Version $Date: 1996/04/02 00:09:26 $ $Revision: 1.2 $ 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 an 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