1Name 2 3 EXT_vertex_array 4 5Name Strings 6 7 GL_EXT_vertex_array 8 9Version 10 11 $Date: 1995/10/03 05:39:58 $ $Revision: 1.16 $ FINAL 12 13Number 14 15 30 16 17Dependencies 18 19 None 20 21Overview 22 23 This extension adds the ability to specify multiple geometric primitives 24 with very few subroutine calls. Instead of calling an OpenGL procedure 25 to pass each individual vertex, normal, or color, separate arrays 26 of vertexes, normals, and colors are prespecified, and are used to 27 define a sequence of primitives (all of the same type) when a single 28 call is made to DrawArraysEXT. A stride mechanism is provided so that 29 an application can choose to keep all vertex data staggered in a 30 single array, or sparsely in separate arrays. Single-array storage 31 may optimize performance on some implementations. 32 33 This extension also supports the rendering of individual array elements, 34 each specified as an index into the enabled arrays. 35 36Issues 37 38 * Should arrays for material parameters be provided? If so, how? 39 40 A: No. Let's leave this to a separate extension, and keep this 41 extension lean. 42 43 * Should a FORTRAN interface be specified in this document? 44 45 * It may not be possible to implement GetPointervEXT in FORTRAN. If 46 not, should we eliminate it from this proposal? 47 48 A: Leave it in. 49 50 * Should a stride be specified by DrawArraysEXT which, if non-zero, 51 would override the strides specified for the individual arrays? 52 This might improve the efficiency of single-array transfers. 53 54 A: No, it's not worth the effort and complexity. 55 56 * Should entry points for byte vertexes, byte indexes, and byte 57 texture coordinates be added in this extension? 58 59 A: No, do this in a separate extension, which defines byte support 60 for arrays and for the current procedural interface. 61 62 * Should support for meshes (not strips) of rectangles be provided? 63 64 A: No. If this is necessary, define a separate quad_mesh extension 65 that supports both immediate mode and arrays. (Add QUAD_MESH_EXT 66 as a token accepted by Begin and DrawArraysEXT. Add 67 QuadMeshLengthEXT to specify the length of the mesh.) 68 69Reasoning 70 71 * DrawArraysEXT requires that VERTEX_ARRAY_EXT be enabled so that 72 future extensions can support evaluation as well as direct 73 specification of vertex coordinates. 74 75 * This extension does not support evaluation. It could be extended 76 to provide such support by adding arrays of points to be evaluated, 77 and by adding enables to indicate that the arrays are to be 78 evaluated. I think we may choose to add an array version of 79 EvalMesh, rather than extending the operation of DrawArraysEXT, 80 so I'd rather wait on this one. 81 82 * <size> is specified before <type> to match the order of the 83 information in immediate mode commands, such as Vertex3f. 84 (first 3, then f) 85 86 * It seems reasonable to allow attribute values to be undefined after 87 DrawArraysEXT executes. This avoids implementation overhead in 88 the case where an incomplete primitive is specified, and will allow 89 optimization on multiprocessor systems. I don't expect this to be 90 a burden to programmers. 91 92 * It is not an error to call VertexPointerEXT, NormalPointerEXT, 93 ColorPointerEXT, IndexPointerEXT, TexCoordPointerEXT, 94 or EdgeFlagPointerEXT between the execution of Begin and the 95 corresponding execution of End. Because these commands will 96 typically be implemented on the client side with no protocol, 97 testing for between-Begin-End status requires that the client 98 track this state, or that a round trip be made. Neither is 99 desirable. 100 101 * Arrays are enabled and disabled individually, rather than with a 102 single mask parameter, for two reasons. First, we have had trouble 103 allocating bits in masks, so eliminating a mask eliminates potential 104 trouble down the road. We may eventually require a larger number of 105 array types than there are bits in a mask. Second, making the 106 enables into state eliminates a parameter in ArrayElementEXT, and 107 may allow it to execute more efficiently. Of course this state 108 model may result in programming errors, but OpenGL is full of such 109 hazards anyway! 110 111 * ArrayElementEXT is provided to support applications that construct 112 primitives by indexing vertex data, rather than by streaming through 113 arrays of data in first-to-last order. Because each call specifies 114 only a single vertex, it is possible for an application to explicitly 115 specify per-primitive attributes, such as a single normal per 116 individual triangle. 117 118 * The <count> parameters are added to the *PointerEXT commands to 119 allow implementations to cache array data, and in particular to 120 cache the transformed results of array data that are rendered 121 repeatedly by ArrayElementEXT. Implementations that do not wish 122 to perform such caching can ignore the <count> parameter. 123 124 * The <first> parameter of DrawArraysEXT allows a single set of 125 arrays to be used repeatedly, possibly improving performance. 126 127New Procedures and Functions 128 129 void ArrayElementEXT(int i); 130 131 void DrawArraysEXT(enum mode, 132 int first, 133 sizei count); 134 135 void VertexPointerEXT(int size, 136 enum type, 137 sizei stride, 138 sizei count, 139 const void* pointer); 140 141 void NormalPointerEXT(enum type, 142 sizei stride, 143 sizei count, 144 const void* pointer); 145 146 void ColorPointerEXT(int size, 147 enum type, 148 sizei stride, 149 sizei count, 150 const void* pointer); 151 152 void IndexPointerEXT(enum type, 153 sizei stride, 154 sizei count, 155 const void* pointer); 156 157 void TexCoordPointerEXT(int size, 158 enum type, 159 sizei stride, 160 sizei count, 161 const void* pointer); 162 163 void EdgeFlagPointerEXT(sizei stride, 164 sizei count, 165 const Boolean* pointer); 166 167 void GetPointervEXT(enum pname, 168 void** params); 169 170New Tokens 171 172 Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, and 173 by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and 174 GetDoublev: 175 176 VERTEX_ARRAY_EXT 0x8074 177 NORMAL_ARRAY_EXT 0x8075 178 COLOR_ARRAY_EXT 0x8076 179 INDEX_ARRAY_EXT 0x8077 180 TEXTURE_COORD_ARRAY_EXT 0x8078 181 EDGE_FLAG_ARRAY_EXT 0x8079 182 183 Accepted by the <type> parameter of VertexPointerEXT, NormalPointerEXT, 184 ColorPointerEXT, IndexPointerEXT, and TexCoordPointerEXT: 185 186 DOUBLE_EXT 0x140A 187 188 Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, 189 GetFloatv, and GetDoublev: 190 191 VERTEX_ARRAY_SIZE_EXT 0x807A 192 VERTEX_ARRAY_TYPE_EXT 0x807B 193 VERTEX_ARRAY_STRIDE_EXT 0x807C 194 VERTEX_ARRAY_COUNT_EXT 0x807D 195 NORMAL_ARRAY_TYPE_EXT 0x807E 196 NORMAL_ARRAY_STRIDE_EXT 0x807F 197 NORMAL_ARRAY_COUNT_EXT 0x8080 198 COLOR_ARRAY_SIZE_EXT 0x8081 199 COLOR_ARRAY_TYPE_EXT 0x8082 200 COLOR_ARRAY_STRIDE_EXT 0x8083 201 COLOR_ARRAY_COUNT_EXT 0x8084 202 INDEX_ARRAY_TYPE_EXT 0x8085 203 INDEX_ARRAY_STRIDE_EXT 0x8086 204 INDEX_ARRAY_COUNT_EXT 0x8087 205 TEXTURE_COORD_ARRAY_SIZE_EXT 0x8088 206 TEXTURE_COORD_ARRAY_TYPE_EXT 0x8089 207 TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A 208 TEXTURE_COORD_ARRAY_COUNT_EXT 0x808B 209 EDGE_FLAG_ARRAY_STRIDE_EXT 0x808C 210 EDGE_FLAG_ARRAY_COUNT_EXT 0x808D 211 212 Accepted by the <pname> parameter of GetPointervEXT: 213 214 VERTEX_ARRAY_POINTER_EXT 0x808E 215 NORMAL_ARRAY_POINTER_EXT 0x808F 216 COLOR_ARRAY_POINTER_EXT 0x8090 217 INDEX_ARRAY_POINTER_EXT 0x8091 218 TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092 219 EDGE_FLAG_ARRAY_POINTER_EXT 0x8093 220 221Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation) 222 223 Array Specification 224 ------------------- 225 226 Individual array pointers and associated data are maintained for an 227 array of vertexes, an array of normals, an array of colors, an array 228 of color indexes, an array of texture coordinates, and an array of edge 229 flags. The data associated with each array specify the data type of 230 the values in the array, the number of values per element in the array 231 (e.g. vertexes of 2, 3, or 4 coordinates), the byte stride from one 232 array element to the next, and the number of elements (counting from 233 the first) that are static. Static elements may be modified by the 234 application, but once they are modified, the application must explicitly 235 respecify the array before using it for any rendering. When an array is 236 specified, the pointer and associated data are saved as client-side 237 state, and static elements may be cached by the implementation. Non- 238 static (dynamic) elements are never accessed until ArrayElementEXT or 239 DrawArraysEXT is issued. 240 241 VertexPointerEXT specifies the location and data format of an array 242 of vertex coordinates. <pointer> specifies a pointer to the first 243 coordinate of the first vertex in the array. <type> specifies the data 244 type of each coordinate in the array, and must be one of SHORT, INT, 245 FLOAT, or DOUBLE_EXT, implying GL data types short, int, float, and 246 double respectively. <size> specifies the number of coordinates per 247 vertex, and must be 2, 3, or 4. <stride> specifies the byte offset 248 between pointers to consecutive vertexes. If <stride> is zero, the 249 vertex data are understood to be tightly packed in the array. <count> 250 specifies the number of vertexes, counting from the first, that are 251 static. 252 253 NormalPointerEXT specifies the location and data format of an array 254 of normals. <pointer> specifies a pointer to the first coordinate 255 of the first normal in the array. <type> specifies the data type 256 of each coordinate in the array, and must be one of BYTE, SHORT, INT, 257 FLOAT, or DOUBLE_EXT, implying GL data types byte, short, int, float, 258 and double respectively. It is understood that each normal comprises 259 three coordinates. <stride> specifies the byte offset between 260 pointers to consecutive normals. If <stride> is zero, the normal 261 data are understood to be tightly packed in the array. <count> 262 specifies the number of normals, counting from the first, that are 263 static. 264 265 ColorPointerEXT specifies the location and data format of an array 266 of color components. <pointer> specifies a pointer to the first 267 component of the first color element in the array. <type> specifies the 268 data type of each component in the array, and must be one of BYTE, 269 UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, FLOAT, or 270 DOUBLE_EXT, implying GL data types byte, ubyte, short, ushort, int, 271 uint, float, and double respectively. <size> specifies the number of 272 components per color, and must be 3 or 4. <stride> specifies the byte 273 offset between pointers to consecutive colors. If <stride> is zero, 274 the color data are understood to be tightly packed in the array. 275 <count> specifies the number of colors, counting from the first, that 276 are static. 277 278 IndexPointerEXT specifies the location and data format of an array 279 of color indexes. <pointer> specifies a pointer to the first index in 280 the array. <type> specifies the data type of each index in the 281 array, and must be one of SHORT, INT, FLOAT, or DOUBLE_EXT, implying 282 GL data types short, int, float, and double respectively. <stride> 283 specifies the byte offset between pointers to consecutive indexes. If 284 <stride> is zero, the index data are understood to be tightly packed 285 in the array. <count> specifies the number of indexes, counting from 286 the first, that are static. 287 288 TexCoordPointerEXT specifies the location and data format of an array 289 of texture coordinates. <pointer> specifies a pointer to the first 290 coordinate of the first element in the array. <type> specifies the data 291 type of each coordinate in the array, and must be one of SHORT, INT, 292 FLOAT, or DOUBLE_EXT, implying GL data types short, int, float, and 293 double respectively. <size> specifies the number of coordinates per 294 element, and must be 1, 2, 3, or 4. <stride> specifies the byte offset 295 between pointers to consecutive elements of coordinates. If <stride> is 296 zero, the coordinate data are understood to be tightly packed in the 297 array. <count> specifies the number of texture coordinate elements, 298 counting from the first, that are static. 299 300 EdgeFlagPointerEXT specifies the location and data format of an array 301 of boolean edge flags. <pointer> specifies a pointer to the first flag 302 in the array. <stride> specifies the byte offset between pointers to 303 consecutive edge flags. If <stride> is zero, the edge flag data are 304 understood to be tightly packed in the array. <count> specifies the 305 number of edge flags, counting from the first, that are static. 306 307 The table below summarizes the sizes and data types accepted (or 308 understood implicitly) by each of the six pointer-specification commands. 309 310 Command Sizes Types 311 ------- ----- ----- 312 VertexPointerEXT 2,3,4 short, int, float, double 313 NormalPointerEXT 3 byte, short, int, float, double 314 ColorPointerEXT 3,4 byte, short, int, float, double, 315 ubyte, ushort, uint 316 IndexPointerEXT 1 short, int, float, double 317 TexCoordPointerEXT 1,2,3,4 short, int, float, double 318 EdgeFlagPointerEXT 1 boolean 319 320 Rendering the Arrays 321 -------------------- 322 323 By default all the arrays are disabled, meaning that they will not 324 be accessed when either ArrayElementEXT or DrawArraysEXT is called. 325 An individual array is enabled or disabled by calling Enable or 326 Disable with <cap> set to appropriate value, as specified in the 327 table below: 328 329 Array Specification Command Enable Token 330 --------------------------- ------------ 331 VertexPointerEXT VERTEX_ARRAY_EXT 332 NormalPointerEXT NORMAL_ARRAY_EXT 333 ColorPointerEXT COLOR_ARRAY_EXT 334 IndexPointerEXT INDEX_ARRAY_EXT 335 TexCoordPointerEXT TEXTURE_COORD_ARRAY_EXT 336 EdgeFlagPointerEXT EDGE_FLAG_ARRAY_EXT 337 338 When ArrayElementEXT is called, a single vertex is drawn, using vertex 339 and attribute data taken from location <i> of the enabled arrays. The 340 semantics of ArrayElementEXT are defined in the C-code below: 341 342 void ArrayElementEXT (int i) { 343 byte* p; 344 if (NORMAL_ARRAY_EXT) { 345 if (normal_stride == 0) 346 p = (byte*)normal_pointer + i * 3 * sizeof(normal_type); 347 else 348 p = (byte*)normal_pointer + i * normal_stride; 349 Normal3<normal_type>v ((normal_type*)p); 350 } 351 if (COLOR_ARRAY_EXT) { 352 if (color_stride == 0) 353 p = (byte*)color_pointer + 354 i * color_size * sizeof(color_type); 355 else 356 p = (byte*)color_pointer + i * color_stride; 357 Color<color_size><color_type>v ((color_type*)p); 358 } 359 if (INDEX_ARRAY_EXT) { 360 if (index_stride == 0) 361 p = (byte*)index_pointer + i * sizeof(index_type); 362 else 363 p = (byte*)index_pointer + i * index_stride; 364 Index<index_type>v ((index_type*)p); 365 } 366 if (TEXTURE_COORD_ARRAY_EXT) { 367 if (texcoord_stride == 0) 368 p = (byte*)texcoord_pointer + 369 i * texcoord_size * sizeof(texcoord_type); 370 else 371 p = (byte*)texcoord_pointer + i * texcoord_stride; 372 TexCoord<texcoord_size><texcoord_type>v ((texcoord_type*)p); 373 } 374 if (EDGE_FLAG_ARRAY_EXT) { 375 if (edgeflag_stride == 0) 376 p = (byte*)edgeflag_pointer + i * sizeof(boolean); 377 else 378 p = (byte*)edgeflag_pointer + i * edgeflag_stride; 379 EdgeFlagv ((boolean*)p); 380 } 381 if (VERTEX_ARRAY_EXT) { 382 if (vertex_stride == 0) 383 p = (byte*)vertex_pointer + 384 i * vertex_size * sizeof(vertex_type); 385 else 386 p = (byte*)vertex_pointer + i * vertex_stride; 387 Vertex<vertex_size><vertex_type>v ((vertex_type*)p); 388 } 389 } 390 391 ArrayElementEXT executes even if VERTEX_ARRAY_EXT is not enabled. No 392 drawing occurs in this case, but the attributes corresponding to 393 enabled arrays are modified. 394 395 When DrawArraysEXT is called, <count> sequential elements from each 396 enabled array are used to construct a sequence of geometric primitives, 397 beginning with element <first>. <mode> specifies what kind of 398 primitives are constructed, and how the array elements are used to 399 construct these primitives. Accepted values for <mode> are POINTS, 400 LINE_STRIP, LINE_LOOP, LINES, TRIANGLE_STRIP, TRIANGLE_FAN, TRIANGLES, 401 QUAD_STRIP, QUADS, and POLYGON. If VERTEX_ARRAY_EXT is not enabled, no 402 geometric primitives are generated. 403 404 The semantics of DrawArraysEXT are defined in the C-code below: 405 406 void DrawArraysEXT(enum mode, int first, sizei count) { 407 int i; 408 if (count < 0) 409 /* generate INVALID_VALUE error and abort */ 410 else { 411 Begin (mode); 412 for (i=0; i < count; i++) 413 ArrayElementEXT(first + i); 414 End (); 415 } 416 } 417 418 The ways in which the execution of DrawArraysEXT differs from the 419 semantics indicated in the pseudo-code above are: 420 421 1. Vertex attributes that are modified by DrawArraysEXT have an 422 unspecified value after DrawArraysEXT returns. For example, if 423 COLOR_ARRAY_EXT is enabled, the value of the current color is 424 undefined after DrawArraysEXT executes. Attributes that aren't 425 modified remain well defined. 426 427 2. Operation of DrawArraysEXT is atomic with respect to error 428 generation. If an error is generated, no other operations take 429 place. 430 431 Although it is not an error to respecify an array between the execution 432 of Begin and the corresponding execution of End, the result of such 433 respecification is undefined. Static array data may be read and cached 434 by the implementation at any time. If static array data are modified by 435 the application, the results of any subsequently issued ArrayElementEXT 436 or DrawArraysEXT commands are undefined. 437 438Additions to Chapter 3 of the 1.0 Specification (Rasterization) 439 440 None 441 442Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations 443and the Frame buffer) 444 445 None 446 447Additions to Chapter 5 of the 1.0 Specification (Special Functions) 448 449 ArrayElementEXT and DrawArraysEXT are included in display lists. 450 When either command is entered into a display list, the necessary 451 array data (determined by the array pointers and enables) is also 452 entered into the display list. Because the array pointers and 453 enables are client side state, their values affect display lists 454 when the lists are created, not when the lists are executed. 455 456 Array specification commands VertexPointerEXT, NormalPointerEXT, 457 ColorPointerEXT, IndexPointerEXT, TexCoordPointerEXT, and 458 EdgeFlagPointerEXT specify client side state, and are therefore 459 not included in display lists. Likewise Enable and Disable, when 460 called with <cap> set to VERTEX_ARRAY_EXT, NORMAL_ARRAY_EXT, 461 COLOR_ARRAY_EXT, INDEX_ARRAY_EXT, TEXTURE_COORD_ARRAY_EXT, or 462 EDGE_FLAG_ARRAY_EXT, are not included in display lists. 463 GetPointervEXT returns state information, and so is not included 464 in display lists. 465 466Additions to Chapter 6 of the 1.0 Specification (State and State Requests) 467 468 GetPointervEXT returns in <param> the array pointer value specified 469 by <pname>. Accepted values for <pname> are VERTEX_ARRAY_POINTER_EXT, 470 NORMAL_ARRAY_POINTER_EXT, COLOR_ARRAY_POINTER_EXT, 471 INDEX_ARRAY_POINTER_EXT, TEXTURE_COORD_ARRAY_POINTER_EXT, 472 and EDGE_FLAG_ARRAY_POINTER_EXT. 473 474 All array data are client side state, and are not saved or restored 475 by PushAttrib and PopAttrib. 476 477Additions to the GLX Specification 478 479 None 480 481GLX Protocol 482 483 A new rendering command is added; it can be sent to the server as part of a 484 glXRender request or as part of a glXRenderLarge request: 485 486 The DrawArraysEXT command consists of three sections, in the following order: 487 (1) header information, (2) a list of array information, containing the type 488 and size of the array values for each enabled array and (3) a list of vertex 489 data. Each element in the list of vertex data contains information for a single 490 vertex taken from the enabled arrays. 491 492 DrawArraysEXT 493 2 16+(12*m)+(s*n) rendering command length 494 2 4116 rendering command opcode 495 4 CARD32 n (number of array elements) 496 4 CARD32 m (number of enabled arrays) 497 4 ENUM mode /* GL_POINTS etc */ 498 12*m LISTofARRAY_INFO 499 s*n LISTofVERTEX_DATA 500 501 Where s = ns + cs + is + ts + es + vs + np + cp + ip + tp + ep + vp. (See 502 description below, under VERTEX_DATA.) Note that if an array is disabled 503 then no information is sent for it. For example, when the normal array is 504 disabled, there is no ARRAY_INFO record for the normal array and ns and np 505 are both zero. 506 507 Note that the list of ARRAY_INFO is unordered: since the ARRAY_INFO 508 record contains the array type, the arrays in the list may be stored 509 in any order. Also, the VERTEX_DATA list is a packed list of vertices. 510 For each vertex, data is retrieved from the enabled arrays, and stored 511 in the list. 512 513 If the command is encoded in a glXRenderLarge request, the command 514 opcode and command length fields above are expanded to 4 bytes each: 515 516 4 20+(12*m)+(s*n) rendering command length 517 4 4116 rendering command opcode 518 519 ARRAY_INFO 520 4 ENUM data type 521 0x1400 i=1 BYTE 522 0x1401 i=1 UNSIGNED_BYTE 523 0x1402 i=2 SHORT 524 0x1403 i=2 UNSIGNED_SHORT 525 0x1404 i=4 INT 526 0x1405 i=4 UNSIGNED_INT 527 0x1406 i=4 FLOAT 528 0x140A i=8 DOUBLE_EXT 529 4 INT32 j (number of values in array element) 530 4 ENUM array type 531 0x8074 j=2/3/4 VERTEX_ARRAY_EXT 532 0x8075 j=3 NORMAL_ARRAY_EXT 533 0x8076 j=3/4 COLOR_ARRAY_EXT 534 0x8077 j=1 INDEX_ARRAY_EXT 535 0x8078 j=1/2/3/4 TEXTURE_COORD_ARRAY_EXT 536 0x8079 j=1 EDGE_FLAG_ARRAY_EXT 537 538 For each array, the size of an array element is i*j. Some arrays 539 (e.g., the texture coordinate array) support different data sizes; 540 for these arrays, the size, j, is specified when the array is defined. 541 542 VERTEX_DATA 543 if the normal array is enabled: 544 545 ns LISTofBYTE normal array element 546 np unused, np=pad(ns) 547 548 if the color array is enabled: 549 550 cs LISTofBYTE color array element 551 cp unused, cp=pad(cs) 552 553 if the index array is enabled: 554 555 is LISTofBYTE index array element 556 ip unused, ip=pad(is) 557 558 if the texture coord array is enabled: 559 560 ts LISTofBYTE texture coord array element 561 tp unused, tp=pad(ts) 562 563 if the edge flag array is enabled: 564 565 es LISTofBYTE edge flag array element 566 ep unused, ep=pad(es) 567 568 if the vertex array is enabled: 569 570 vs LISTofBYTE vertex array element 571 vp unused, vp=pad(vs) 572 573 where ns, cs, is, ts, es, vs is the size of the normal, color, index, 574 texture, edge and vertex array elements and np, cp, ip, tp, ep, vp is 575 the padding for the normal, color, index, texture, edge and vertex array 576 elements, respectively. 577 578Errors 579 580 INVALID_OPERATION is generated if DrawArraysEXT is called between the 581 execution of Begin and the corresponding execution of End. 582 583 INVALID_ENUM is generated if DrawArraysEXT parameter <mode> is not 584 POINTS, LINE_STRIP, LINE_LOOP, LINES, TRIANGLE_STRIP, TRIANGLE_FAN, 585 TRIANGLES, QUAD_STRIP, QUADS, or POLYGON. 586 587 INVALID_VALUE is generated if DrawArraysEXT parameter <count> is 588 negative. 589 590 INVALID_VALUE is generated if VertexPointerEXT parameter <size> is not 591 2, 3, or 4. 592 593 INVALID_ENUM is generated if VertexPointerEXT parameter <type> is not 594 SHORT, INT, FLOAT, or DOUBLE_EXT. 595 596 INVALID_VALUE is generated if VertexPointerEXT parameter <stride> or 597 <count> is negative. 598 599 INVALID_ENUM is generated if NormalPointerEXT parameter <type> is not 600 BYTE, SHORT, INT, FLOAT, or DOUBLE_EXT. 601 602 INVALID_VALUE is generated if NormalPointerEXT parameter <stride> or 603 <count> is negative. 604 605 INVALID_VALUE is generated if ColorPointerEXT parameter <size> is not 606 3 or 4. 607 608 INVALID_ENUM is generated if ColorPointerEXT parameter <type> is not 609 BYTE, UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, FLOAT, 610 or DOUBLE_EXT. 611 612 INVALID_VALUE is generated if ColorPointerEXT parameter <stride> or 613 <count> is negative. 614 615 INVALID_ENUM is generated if IndexPointerEXT parameter <type> is not 616 SHORT, INT, FLOAT, or DOUBLE_EXT. 617 618 INVALID_VALUE is generated if IndexPointerEXT parameter <stride> or 619 <count> is negative. 620 621 INVALID_VALUE is generated if TexCoordPointerEXT parameter <size> is not 622 1, 2, 3, or 4. 623 624 INVALID_ENUM is generated if TexCoordPointerEXT parameter <type> is not 625 SHORT, INT, FLOAT, or DOUBLE_EXT. 626 627 INVALID_VALUE is generated if TexCoordPointerEXT parameter <stride> or 628 <count> is negative. 629 630 INVALID_VALUE is generated if EdgeFlagPointerEXT parameter <stride> or 631 <count> is negative. 632 633 INVALID_ENUM is generated if GetPointervEXT parameter <pname> is not 634 VERTEX_ARRAY_POINTER_EXT, NORMAL_ARRAY_POINTER_EXT, 635 COLOR_ARRAY_POINTER_EXT, INDEX_ARRAY_POINTER_EXT, 636 TEXTURE_COORD_ARRAY_POINTER_EXT, or EDGE_FLAG_ARRAY_POINTER_EXT. 637 638New State 639 Initial 640 Get Value Get Command Type Value Attrib 641 --------- ----------- ---- ------- ------ 642 VERTEX_ARRAY_EXT IsEnabled B False client 643 VERTEX_ARRAY_SIZE_EXT GetIntegerv Z+ 4 client 644 VERTEX_ARRAY_TYPE_EXT GetIntegerv Z4 FLOAT client 645 VERTEX_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client 646 VERTEX_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client 647 VERTEX_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client 648 NORMAL_ARRAY_EXT IsEnabled B False client 649 NORMAL_ARRAY_TYPE_EXT GetIntegerv Z5 FLOAT client 650 NORMAL_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client 651 NORMAL_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client 652 NORMAL_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client 653 COLOR_ARRAY_EXT IsEnabled B False client 654 COLOR_ARRAY_SIZE_EXT GetIntegerv Z+ 4 client 655 COLOR_ARRAY_TYPE_EXT GetIntegerv Z8 FLOAT client 656 COLOR_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client 657 COLOR_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client 658 COLOR_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client 659 INDEX_ARRAY_EXT IsEnabled B False client 660 INDEX_ARRAY_TYPE_EXT GetIntegerv Z4 FLOAT client 661 INDEX_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client 662 INDEX_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client 663 INDEX_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client 664 TEXTURE_COORD_ARRAY_EXT IsEnabled B False client 665 TEXTURE_COORD_ARRAY_SIZE_EXT GetIntegerv Z+ 4 client 666 TEXTURE_COORD_ARRAY_TYPE_EXT GetIntegerv Z4 FLOAT client 667 TEXTURE_COORD_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client 668 TEXTURE_COORD_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client 669 TEXTURE_COORD_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client 670 EDGE_FLAG_ARRAY_EXT IsEnabled B False client 671 EDGE_FLAG_ARRAY_STRIDE_EXT GetIntegerv Z+ 0 client 672 EDGE_FLAG_ARRAY_COUNT_EXT GetIntegerv Z+ 0 client 673 EDGE_FLAG_ARRAY_POINTER_EXT GetPointervEXT Z+ 0 client 674 675New Implementation Dependent State 676 677 None 678