1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 5 * Copyright (C) 2009 VMware, Inc. All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 27 #include <stdio.h> 28 #include <inttypes.h> /* for PRId64 macro */ 29 30 #include "glheader.h" 31 #include "imports.h" 32 #include "bufferobj.h" 33 #include "context.h" 34 #include "enable.h" 35 #include "enums.h" 36 #include "hash.h" 37 #include "image.h" 38 #include "macros.h" 39 #include "mtypes.h" 40 #include "varray.h" 41 #include "arrayobj.h" 42 #include "main/dispatch.h" 43 44 45 /** Used to do error checking for GL_EXT_vertex_array_bgra */ 46 #define BGRA_OR_4 5 47 48 49 /** Used to indicate which GL datatypes are accepted by each of the 50 * glVertex/Color/Attrib/EtcPointer() functions. 51 */ 52 #define BOOL_BIT (1 << 0) 53 #define BYTE_BIT (1 << 1) 54 #define UNSIGNED_BYTE_BIT (1 << 2) 55 #define SHORT_BIT (1 << 3) 56 #define UNSIGNED_SHORT_BIT (1 << 4) 57 #define INT_BIT (1 << 5) 58 #define UNSIGNED_INT_BIT (1 << 6) 59 #define HALF_BIT (1 << 7) 60 #define FLOAT_BIT (1 << 8) 61 #define DOUBLE_BIT (1 << 9) 62 #define FIXED_ES_BIT (1 << 10) 63 #define FIXED_GL_BIT (1 << 11) 64 #define UNSIGNED_INT_2_10_10_10_REV_BIT (1 << 12) 65 #define INT_2_10_10_10_REV_BIT (1 << 13) 66 #define UNSIGNED_INT_10F_11F_11F_REV_BIT (1 << 14) 67 #define ALL_TYPE_BITS ((1 << 15) - 1) 68 69 #define ATTRIB_FORMAT_TYPES_MASK (BYTE_BIT | UNSIGNED_BYTE_BIT | \ 70 SHORT_BIT | UNSIGNED_SHORT_BIT | \ 71 INT_BIT | UNSIGNED_INT_BIT | \ 72 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | \ 73 FIXED_GL_BIT | \ 74 UNSIGNED_INT_2_10_10_10_REV_BIT | \ 75 INT_2_10_10_10_REV_BIT | \ 76 UNSIGNED_INT_10F_11F_11F_REV_BIT) 77 78 #define ATTRIB_IFORMAT_TYPES_MASK (BYTE_BIT | UNSIGNED_BYTE_BIT | \ 79 SHORT_BIT | UNSIGNED_SHORT_BIT | \ 80 INT_BIT | UNSIGNED_INT_BIT) 81 82 #define ATTRIB_LFORMAT_TYPES_MASK DOUBLE_BIT 83 84 85 /** Convert GL datatype enum into a <type>_BIT value seen above */ 86 static GLbitfield 87 type_to_bit(const struct gl_context *ctx, GLenum type) 88 { 89 switch (type) { 90 case GL_BOOL: 91 return BOOL_BIT; 92 case GL_BYTE: 93 return BYTE_BIT; 94 case GL_UNSIGNED_BYTE: 95 return UNSIGNED_BYTE_BIT; 96 case GL_SHORT: 97 return SHORT_BIT; 98 case GL_UNSIGNED_SHORT: 99 return UNSIGNED_SHORT_BIT; 100 case GL_INT: 101 return INT_BIT; 102 case GL_UNSIGNED_INT: 103 return UNSIGNED_INT_BIT; 104 case GL_HALF_FLOAT: 105 case GL_HALF_FLOAT_OES: 106 if (ctx->Extensions.ARB_half_float_vertex) 107 return HALF_BIT; 108 else 109 return 0x0; 110 case GL_FLOAT: 111 return FLOAT_BIT; 112 case GL_DOUBLE: 113 return DOUBLE_BIT; 114 case GL_FIXED: 115 return _mesa_is_desktop_gl(ctx) ? FIXED_GL_BIT : FIXED_ES_BIT; 116 case GL_UNSIGNED_INT_2_10_10_10_REV: 117 return UNSIGNED_INT_2_10_10_10_REV_BIT; 118 case GL_INT_2_10_10_10_REV: 119 return INT_2_10_10_10_REV_BIT; 120 case GL_UNSIGNED_INT_10F_11F_11F_REV: 121 return UNSIGNED_INT_10F_11F_11F_REV_BIT; 122 default: 123 return 0; 124 } 125 } 126 127 128 /** 129 * Sets the BufferBindingIndex field for the vertex attribute given by 130 * attribIndex. 131 */ 132 static void 133 vertex_attrib_binding(struct gl_context *ctx, 134 struct gl_vertex_array_object *vao, 135 GLuint attribIndex, 136 GLuint bindingIndex) 137 { 138 struct gl_array_attributes *array = &vao->VertexAttrib[attribIndex]; 139 140 if (array->BufferBindingIndex != bindingIndex) { 141 const GLbitfield array_bit = VERT_BIT(attribIndex); 142 143 if (_mesa_is_bufferobj(vao->BufferBinding[bindingIndex].BufferObj)) 144 vao->VertexAttribBufferMask |= array_bit; 145 146 FLUSH_VERTICES(ctx, _NEW_ARRAY); 147 148 vao->BufferBinding[array->BufferBindingIndex]._BoundArrays &= ~array_bit; 149 vao->BufferBinding[bindingIndex]._BoundArrays |= array_bit; 150 151 array->BufferBindingIndex = bindingIndex; 152 153 vao->NewArrays |= array_bit; 154 } 155 } 156 157 158 /** 159 * Binds a buffer object to the vertex buffer binding point given by index, 160 * and sets the Offset and Stride fields. 161 */ 162 void 163 _mesa_bind_vertex_buffer(struct gl_context *ctx, 164 struct gl_vertex_array_object *vao, 165 GLuint index, 166 struct gl_buffer_object *vbo, 167 GLintptr offset, GLsizei stride) 168 { 169 struct gl_vertex_buffer_binding *binding = &vao->BufferBinding[index]; 170 171 if (binding->BufferObj != vbo || 172 binding->Offset != offset || 173 binding->Stride != stride) { 174 175 FLUSH_VERTICES(ctx, _NEW_ARRAY); 176 177 _mesa_reference_buffer_object(ctx, &binding->BufferObj, vbo); 178 179 binding->Offset = offset; 180 binding->Stride = stride; 181 182 if (!_mesa_is_bufferobj(vbo)) 183 vao->VertexAttribBufferMask &= ~binding->_BoundArrays; 184 else 185 vao->VertexAttribBufferMask |= binding->_BoundArrays; 186 187 vao->NewArrays |= binding->_BoundArrays; 188 } 189 } 190 191 192 /** 193 * Sets the InstanceDivisor field in the vertex buffer binding point 194 * given by bindingIndex. 195 */ 196 static void 197 vertex_binding_divisor(struct gl_context *ctx, 198 struct gl_vertex_array_object *vao, 199 GLuint bindingIndex, 200 GLuint divisor) 201 { 202 struct gl_vertex_buffer_binding *binding = 203 &vao->BufferBinding[bindingIndex]; 204 205 if (binding->InstanceDivisor != divisor) { 206 FLUSH_VERTICES(ctx, _NEW_ARRAY); 207 binding->InstanceDivisor = divisor; 208 vao->NewArrays |= binding->_BoundArrays; 209 } 210 } 211 212 213 /** 214 * Examine the API profile and extensions to determine which types are legal 215 * for vertex arrays. This is called once from update_array_format(). 216 */ 217 static GLbitfield 218 get_legal_types_mask(const struct gl_context *ctx) 219 { 220 GLbitfield legalTypesMask = ALL_TYPE_BITS; 221 222 if (_mesa_is_gles(ctx)) { 223 legalTypesMask &= ~(FIXED_GL_BIT | 224 DOUBLE_BIT | 225 UNSIGNED_INT_10F_11F_11F_REV_BIT); 226 227 /* GL_INT and GL_UNSIGNED_INT data is not allowed in OpenGL ES until 228 * 3.0. The 2_10_10_10 types are added in OpenGL ES 3.0 or 229 * GL_OES_vertex_type_10_10_10_2. GL_HALF_FLOAT data is not allowed 230 * until 3.0 or with the GL_OES_vertex_half float extension, which isn't 231 * quite as trivial as we'd like because it uses a different enum value 232 * for GL_HALF_FLOAT_OES. 233 */ 234 if (ctx->Version < 30) { 235 legalTypesMask &= ~(UNSIGNED_INT_BIT | 236 INT_BIT | 237 UNSIGNED_INT_2_10_10_10_REV_BIT | 238 INT_2_10_10_10_REV_BIT); 239 240 if (!_mesa_has_OES_vertex_half_float(ctx)) 241 legalTypesMask &= ~HALF_BIT; 242 } 243 } 244 else { 245 legalTypesMask &= ~FIXED_ES_BIT; 246 247 if (!ctx->Extensions.ARB_ES2_compatibility) 248 legalTypesMask &= ~FIXED_GL_BIT; 249 250 if (!ctx->Extensions.ARB_vertex_type_2_10_10_10_rev) 251 legalTypesMask &= ~(UNSIGNED_INT_2_10_10_10_REV_BIT | 252 INT_2_10_10_10_REV_BIT); 253 254 if (!ctx->Extensions.ARB_vertex_type_10f_11f_11f_rev) 255 legalTypesMask &= ~UNSIGNED_INT_10F_11F_11F_REV_BIT; 256 } 257 258 return legalTypesMask; 259 } 260 261 static GLenum 262 get_array_format(const struct gl_context *ctx, GLint sizeMax, GLint *size) 263 { 264 GLenum format = GL_RGBA; 265 266 /* Do size parameter checking. 267 * If sizeMax = BGRA_OR_4 it means that size = GL_BGRA is legal and 268 * must be handled specially. 269 */ 270 if (ctx->Extensions.EXT_vertex_array_bgra && sizeMax == BGRA_OR_4 && 271 *size == GL_BGRA) { 272 format = GL_BGRA; 273 *size = 4; 274 } 275 276 return format; 277 } 278 279 280 /** 281 * \param attrib The index of the attribute array 282 * \param size Components per element (1, 2, 3 or 4) 283 * \param type Datatype of each component (GL_FLOAT, GL_INT, etc) 284 * \param format Either GL_RGBA or GL_BGRA. 285 * \param normalized Whether integer types are converted to floats in [-1, 1] 286 * \param integer Integer-valued values (will not be normalized to [-1, 1]) 287 * \param doubles Double values not reduced to floats 288 * \param relativeOffset Offset of the first element relative to the binding 289 * offset. 290 * \param flush_verties Should \c FLUSH_VERTICES be invoked before updating 291 * state? 292 */ 293 void 294 _mesa_update_array_format(struct gl_context *ctx, 295 struct gl_vertex_array_object *vao, 296 GLuint attrib, GLint size, GLenum type, 297 GLenum format, GLboolean normalized, 298 GLboolean integer, GLboolean doubles, 299 GLuint relativeOffset) 300 { 301 struct gl_array_attributes *const array = &vao->VertexAttrib[attrib]; 302 GLint elementSize; 303 304 assert(size <= 4); 305 306 elementSize = _mesa_bytes_per_vertex_attrib(size, type); 307 assert(elementSize != -1); 308 309 array->Size = size; 310 array->Type = type; 311 array->Format = format; 312 array->Normalized = normalized; 313 array->Integer = integer; 314 array->Doubles = doubles; 315 array->RelativeOffset = relativeOffset; 316 array->_ElementSize = elementSize; 317 318 vao->NewArrays |= VERT_BIT(attrib); 319 ctx->NewState |= _NEW_ARRAY; 320 } 321 322 /** 323 * Does error checking of the format in an attrib array. 324 * 325 * Called by *Pointer() and VertexAttrib*Format(). 326 * 327 * \param func Name of calling function used for error reporting 328 * \param attrib The index of the attribute array 329 * \param legalTypes Bitmask of *_BIT above indicating legal datatypes 330 * \param sizeMin Min allowable size value 331 * \param sizeMax Max allowable size value (may also be BGRA_OR_4) 332 * \param size Components per element (1, 2, 3 or 4) 333 * \param type Datatype of each component (GL_FLOAT, GL_INT, etc) 334 * \param normalized Whether integer types are converted to floats in [-1, 1] 335 * \param integer Integer-valued values (will not be normalized to [-1, 1]) 336 * \param doubles Double values not reduced to floats 337 * \param relativeOffset Offset of the first element relative to the binding offset. 338 * \return bool True if validation is successful, False otherwise. 339 */ 340 static bool 341 validate_array_format(struct gl_context *ctx, const char *func, 342 struct gl_vertex_array_object *vao, 343 GLuint attrib, GLbitfield legalTypesMask, 344 GLint sizeMin, GLint sizeMax, 345 GLint size, GLenum type, GLboolean normalized, 346 GLboolean integer, GLboolean doubles, 347 GLuint relativeOffset, GLenum format) 348 { 349 GLbitfield typeBit; 350 351 /* at most, one of these bools can be true */ 352 assert((int) normalized + (int) integer + (int) doubles <= 1); 353 354 if (ctx->Array.LegalTypesMask == 0 || ctx->Array.LegalTypesMaskAPI != ctx->API) { 355 /* Compute the LegalTypesMask only once, unless the context API has 356 * changed, in which case we want to compute it again. We can't do this 357 * in _mesa_init_varrays() below because extensions are not yet enabled 358 * at that point. 359 */ 360 ctx->Array.LegalTypesMask = get_legal_types_mask(ctx); 361 ctx->Array.LegalTypesMaskAPI = ctx->API; 362 } 363 364 legalTypesMask &= ctx->Array.LegalTypesMask; 365 366 if (_mesa_is_gles(ctx) && sizeMax == BGRA_OR_4) { 367 /* BGRA ordering is not supported in ES contexts. 368 */ 369 sizeMax = 4; 370 } 371 372 typeBit = type_to_bit(ctx, type); 373 if (typeBit == 0x0 || (typeBit & legalTypesMask) == 0x0) { 374 _mesa_error(ctx, GL_INVALID_ENUM, "%s(type = %s)", 375 func, _mesa_enum_to_string(type)); 376 return false; 377 } 378 379 if (format == GL_BGRA) { 380 /* Page 298 of the PDF of the OpenGL 4.3 (Core Profile) spec says: 381 * 382 * "An INVALID_OPERATION error is generated under any of the following 383 * conditions: 384 * ... 385 * size is BGRA and type is not UNSIGNED_BYTE, INT_2_10_10_10_REV 386 * or UNSIGNED_INT_2_10_10_10_REV; 387 * ... 388 * size is BGRA and normalized is FALSE;" 389 */ 390 bool bgra_error = false; 391 392 if (ctx->Extensions.ARB_vertex_type_2_10_10_10_rev) { 393 if (type != GL_UNSIGNED_INT_2_10_10_10_REV && 394 type != GL_INT_2_10_10_10_REV && 395 type != GL_UNSIGNED_BYTE) 396 bgra_error = true; 397 } else if (type != GL_UNSIGNED_BYTE) 398 bgra_error = true; 399 400 if (bgra_error) { 401 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(size=GL_BGRA and type=%s)", 402 func, _mesa_enum_to_string(type)); 403 return false; 404 } 405 406 if (!normalized) { 407 _mesa_error(ctx, GL_INVALID_OPERATION, 408 "%s(size=GL_BGRA and normalized=GL_FALSE)", func); 409 return false; 410 } 411 } 412 else if (size < sizeMin || size > sizeMax || size > 4) { 413 _mesa_error(ctx, GL_INVALID_VALUE, "%s(size=%d)", func, size); 414 return false; 415 } 416 417 if (ctx->Extensions.ARB_vertex_type_2_10_10_10_rev && 418 (type == GL_UNSIGNED_INT_2_10_10_10_REV || 419 type == GL_INT_2_10_10_10_REV) && size != 4) { 420 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(size=%d)", func, size); 421 return false; 422 } 423 424 /* The ARB_vertex_attrib_binding_spec says: 425 * 426 * An INVALID_VALUE error is generated if <relativeoffset> is larger than 427 * the value of MAX_VERTEX_ATTRIB_RELATIVE_OFFSET. 428 */ 429 if (relativeOffset > ctx->Const.MaxVertexAttribRelativeOffset) { 430 _mesa_error(ctx, GL_INVALID_VALUE, 431 "%s(relativeOffset=%d > " 432 "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET)", 433 func, relativeOffset); 434 return false; 435 } 436 437 if (ctx->Extensions.ARB_vertex_type_10f_11f_11f_rev && 438 type == GL_UNSIGNED_INT_10F_11F_11F_REV && size != 3) { 439 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(size=%d)", func, size); 440 return false; 441 } 442 443 return true; 444 } 445 446 /** 447 * Do error checking for glVertex/Color/TexCoord/...Pointer functions. 448 * 449 * \param func name of calling function used for error reporting 450 * \param attrib the attribute array index to update 451 * \param legalTypes bitmask of *_BIT above indicating legal datatypes 452 * \param sizeMin min allowable size value 453 * \param sizeMax max allowable size value (may also be BGRA_OR_4) 454 * \param size components per element (1, 2, 3 or 4) 455 * \param type datatype of each component (GL_FLOAT, GL_INT, etc) 456 * \param stride stride between elements, in elements 457 * \param normalized are integer types converted to floats in [-1, 1]? 458 * \param integer integer-valued values (will not be normalized to [-1,1]) 459 * \param doubles Double values not reduced to floats 460 * \param ptr the address (or offset inside VBO) of the array data 461 */ 462 static void 463 validate_array(struct gl_context *ctx, const char *func, 464 GLuint attrib, GLbitfield legalTypesMask, 465 GLint sizeMin, GLint sizeMax, 466 GLint size, GLenum type, GLsizei stride, 467 GLboolean normalized, GLboolean integer, GLboolean doubles, 468 const GLvoid *ptr) 469 { 470 struct gl_vertex_array_object *vao = ctx->Array.VAO; 471 472 /* Page 407 (page 423 of the PDF) of the OpenGL 3.0 spec says: 473 * 474 * "Client vertex arrays - all vertex array attribute pointers must 475 * refer to buffer objects (section 2.9.2). The default vertex array 476 * object (the name zero) is also deprecated. Calling 477 * VertexAttribPointer when no buffer object or no vertex array object 478 * is bound will generate an INVALID_OPERATION error..." 479 * 480 * The check for VBOs is handled below. 481 */ 482 if (ctx->API == API_OPENGL_CORE && (vao == ctx->Array.DefaultVAO)) { 483 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(no array object bound)", 484 func); 485 return; 486 } 487 488 if (stride < 0) { 489 _mesa_error( ctx, GL_INVALID_VALUE, "%s(stride=%d)", func, stride ); 490 return; 491 } 492 493 if (ctx->API == API_OPENGL_CORE && ctx->Version >= 44 && 494 stride > ctx->Const.MaxVertexAttribStride) { 495 _mesa_error(ctx, GL_INVALID_VALUE, "%s(stride=%d > " 496 "GL_MAX_VERTEX_ATTRIB_STRIDE)", func, stride); 497 return; 498 } 499 500 /* Page 29 (page 44 of the PDF) of the OpenGL 3.3 spec says: 501 * 502 * "An INVALID_OPERATION error is generated under any of the following 503 * conditions: 504 * 505 * ... 506 * 507 * * any of the *Pointer commands specifying the location and 508 * organization of vertex array data are called while zero is bound 509 * to the ARRAY_BUFFER buffer object binding point (see section 510 * 2.9.6), and the pointer argument is not NULL." 511 */ 512 if (ptr != NULL && vao != ctx->Array.DefaultVAO && 513 !_mesa_is_bufferobj(ctx->Array.ArrayBufferObj)) { 514 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-VBO array)", func); 515 return; 516 } 517 } 518 519 520 static bool 521 validate_array_and_format(struct gl_context *ctx, const char *func, 522 GLuint attrib, GLbitfield legalTypes, 523 GLint sizeMin, GLint sizeMax, 524 GLint size, GLenum type, GLsizei stride, 525 GLboolean normalized, GLboolean integer, 526 GLboolean doubles, GLenum format, const GLvoid *ptr, 527 struct gl_vertex_array_object *vao) 528 { 529 validate_array(ctx, func, attrib, legalTypes, sizeMin, sizeMax, size, 530 type, stride, normalized, integer, doubles, ptr); 531 532 return validate_array_format(ctx, func, vao, attrib, legalTypes, sizeMin, 533 sizeMax, size, type, normalized, integer, 534 doubles, 0, format); 535 } 536 537 538 /** 539 * Update state for glVertex/Color/TexCoord/...Pointer functions. 540 * 541 * \param attrib the attribute array index to update 542 * \param format Either GL_RGBA or GL_BGRA. 543 * \param sizeMax max allowable size value (may also be BGRA_OR_4) 544 * \param size components per element (1, 2, 3 or 4) 545 * \param type datatype of each component (GL_FLOAT, GL_INT, etc) 546 * \param stride stride between elements, in elements 547 * \param normalized are integer types converted to floats in [-1, 1]? 548 * \param integer integer-valued values (will not be normalized to [-1,1]) 549 * \param doubles Double values not reduced to floats 550 * \param ptr the address (or offset inside VBO) of the array data 551 */ 552 static void 553 update_array(struct gl_context *ctx, 554 GLuint attrib, GLenum format, 555 GLint sizeMax, 556 GLint size, GLenum type, GLsizei stride, 557 GLboolean normalized, GLboolean integer, GLboolean doubles, 558 const GLvoid *ptr) 559 { 560 struct gl_vertex_array_object *vao = ctx->Array.VAO; 561 562 _mesa_update_array_format(ctx, vao, attrib, size, type, format, 563 normalized, integer, doubles, 0); 564 565 /* Reset the vertex attrib binding */ 566 vertex_attrib_binding(ctx, vao, attrib, attrib); 567 568 /* The Stride and Ptr fields are not set by update_array_format() */ 569 struct gl_array_attributes *array = &vao->VertexAttrib[attrib]; 570 array->Stride = stride; 571 array->Ptr = ptr; 572 573 /* Update the vertex buffer binding */ 574 GLsizei effectiveStride = stride != 0 ? stride : array->_ElementSize; 575 _mesa_bind_vertex_buffer(ctx, vao, attrib, 576 ctx->Array.ArrayBufferObj, (GLintptr) ptr, 577 effectiveStride); 578 } 579 580 void GLAPIENTRY 581 _mesa_VertexPointer_no_error(GLint size, GLenum type, GLsizei stride, 582 const GLvoid *ptr) 583 { 584 GET_CURRENT_CONTEXT(ctx); 585 FLUSH_VERTICES(ctx, 0); 586 587 update_array(ctx, VERT_ATTRIB_POS, GL_RGBA, 4, size, type, stride, 588 GL_FALSE, GL_FALSE, GL_FALSE, ptr); 589 } 590 591 592 void GLAPIENTRY 593 _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) 594 { 595 GET_CURRENT_CONTEXT(ctx); 596 597 FLUSH_VERTICES(ctx, 0); 598 599 GLenum format = GL_RGBA; 600 GLbitfield legalTypes = (ctx->API == API_OPENGLES) 601 ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT) 602 : (SHORT_BIT | INT_BIT | FLOAT_BIT | 603 DOUBLE_BIT | HALF_BIT | 604 UNSIGNED_INT_2_10_10_10_REV_BIT | 605 INT_2_10_10_10_REV_BIT); 606 607 if (!validate_array_and_format(ctx, "glVertexPointer", VERT_ATTRIB_POS, 608 legalTypes, 2, 4, size, type, stride, 609 GL_FALSE, GL_FALSE, GL_FALSE, format, 610 ptr, ctx->Array.VAO)) 611 return; 612 613 update_array(ctx, VERT_ATTRIB_POS, format, 4, size, type, stride, 614 GL_FALSE, GL_FALSE, GL_FALSE, ptr); 615 } 616 617 618 void GLAPIENTRY 619 _mesa_NormalPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr ) 620 { 621 GET_CURRENT_CONTEXT(ctx); 622 FLUSH_VERTICES(ctx, 0); 623 624 update_array(ctx, VERT_ATTRIB_NORMAL, GL_RGBA, 3, 3, type, stride, GL_TRUE, 625 GL_FALSE, GL_FALSE, ptr); 626 } 627 628 629 void GLAPIENTRY 630 _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr ) 631 { 632 GET_CURRENT_CONTEXT(ctx); 633 634 FLUSH_VERTICES(ctx, 0); 635 636 GLenum format = GL_RGBA; 637 const GLbitfield legalTypes = (ctx->API == API_OPENGLES) 638 ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT) 639 : (BYTE_BIT | SHORT_BIT | INT_BIT | 640 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 641 UNSIGNED_INT_2_10_10_10_REV_BIT | 642 INT_2_10_10_10_REV_BIT); 643 644 if (!validate_array_and_format(ctx, "glNormalPointer", 645 VERT_ATTRIB_NORMAL, legalTypes, 3, 3, 3, 646 type, stride, GL_TRUE, GL_FALSE, 647 GL_FALSE, format, ptr, ctx->Array.VAO)) 648 return; 649 650 update_array(ctx, VERT_ATTRIB_NORMAL, format, 3, 3, type, stride, GL_TRUE, 651 GL_FALSE, GL_FALSE, ptr); 652 } 653 654 655 void GLAPIENTRY 656 _mesa_ColorPointer_no_error(GLint size, GLenum type, GLsizei stride, 657 const GLvoid *ptr) 658 { 659 GET_CURRENT_CONTEXT(ctx); 660 FLUSH_VERTICES(ctx, 0); 661 662 GLenum format = get_array_format(ctx, BGRA_OR_4, &size); 663 update_array(ctx, VERT_ATTRIB_COLOR0, format, BGRA_OR_4, size, 664 type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr); 665 } 666 667 668 void GLAPIENTRY 669 _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) 670 { 671 GET_CURRENT_CONTEXT(ctx); 672 const GLint sizeMin = (ctx->API == API_OPENGLES) ? 4 : 3; 673 674 FLUSH_VERTICES(ctx, 0); 675 676 GLenum format = get_array_format(ctx, BGRA_OR_4, &size); 677 const GLbitfield legalTypes = (ctx->API == API_OPENGLES) 678 ? (UNSIGNED_BYTE_BIT | HALF_BIT | FLOAT_BIT | FIXED_ES_BIT) 679 : (BYTE_BIT | UNSIGNED_BYTE_BIT | 680 SHORT_BIT | UNSIGNED_SHORT_BIT | 681 INT_BIT | UNSIGNED_INT_BIT | 682 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 683 UNSIGNED_INT_2_10_10_10_REV_BIT | 684 INT_2_10_10_10_REV_BIT); 685 686 if (!validate_array_and_format(ctx, "glColorPointer", 687 VERT_ATTRIB_COLOR0, legalTypes, sizeMin, 688 BGRA_OR_4, size, type, stride, GL_TRUE, 689 GL_FALSE, GL_FALSE, format, ptr, 690 ctx->Array.VAO)) 691 return; 692 693 update_array(ctx, VERT_ATTRIB_COLOR0, format, BGRA_OR_4, size, 694 type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr); 695 } 696 697 698 void GLAPIENTRY 699 _mesa_FogCoordPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr) 700 { 701 GET_CURRENT_CONTEXT(ctx); 702 FLUSH_VERTICES(ctx, 0); 703 704 update_array(ctx, VERT_ATTRIB_FOG, GL_RGBA, 1, 1, type, stride, GL_FALSE, 705 GL_FALSE, GL_FALSE, ptr); 706 } 707 708 709 void GLAPIENTRY 710 _mesa_FogCoordPointer(GLenum type, GLsizei stride, const GLvoid *ptr) 711 { 712 GET_CURRENT_CONTEXT(ctx); 713 714 FLUSH_VERTICES(ctx, 0); 715 716 GLenum format = GL_RGBA; 717 const GLbitfield legalTypes = (HALF_BIT | FLOAT_BIT | DOUBLE_BIT); 718 719 if (!validate_array_and_format(ctx, "glFogCoordPointer", 720 VERT_ATTRIB_FOG, legalTypes, 1, 1, 1, 721 type, stride, GL_FALSE, GL_FALSE, 722 GL_FALSE, format, ptr, ctx->Array.VAO)) 723 return; 724 725 update_array(ctx, VERT_ATTRIB_FOG, format, 1, 1, type, stride, GL_FALSE, 726 GL_FALSE, GL_FALSE, ptr); 727 } 728 729 730 void GLAPIENTRY 731 _mesa_IndexPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr) 732 { 733 GET_CURRENT_CONTEXT(ctx); 734 FLUSH_VERTICES(ctx, 0); 735 736 update_array(ctx, VERT_ATTRIB_COLOR_INDEX, GL_RGBA, 1, 1, type, stride, 737 GL_FALSE, GL_FALSE, GL_FALSE, ptr); 738 } 739 740 741 void GLAPIENTRY 742 _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr) 743 { 744 GET_CURRENT_CONTEXT(ctx); 745 746 FLUSH_VERTICES(ctx, 0); 747 748 GLenum format = GL_RGBA; 749 const GLbitfield legalTypes = (UNSIGNED_BYTE_BIT | SHORT_BIT | INT_BIT | 750 FLOAT_BIT | DOUBLE_BIT); 751 752 if (!validate_array_and_format(ctx, "glIndexPointer", 753 VERT_ATTRIB_COLOR_INDEX, 754 legalTypes, 1, 1, 1, type, stride, 755 GL_FALSE, GL_FALSE, GL_FALSE, format, 756 ptr, ctx->Array.VAO)) 757 return; 758 759 update_array(ctx, VERT_ATTRIB_COLOR_INDEX, format, 1, 1, type, stride, 760 GL_FALSE, GL_FALSE, GL_FALSE, ptr); 761 } 762 763 764 void GLAPIENTRY 765 _mesa_SecondaryColorPointer_no_error(GLint size, GLenum type, 766 GLsizei stride, const GLvoid *ptr) 767 { 768 GET_CURRENT_CONTEXT(ctx); 769 FLUSH_VERTICES(ctx, 0); 770 771 GLenum format = get_array_format(ctx, BGRA_OR_4, &size); 772 update_array(ctx, VERT_ATTRIB_COLOR1, format, BGRA_OR_4, size, type, 773 stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr); 774 } 775 776 777 void GLAPIENTRY 778 _mesa_SecondaryColorPointer(GLint size, GLenum type, 779 GLsizei stride, const GLvoid *ptr) 780 { 781 GET_CURRENT_CONTEXT(ctx); 782 783 FLUSH_VERTICES(ctx, 0); 784 785 GLenum format = get_array_format(ctx, BGRA_OR_4, &size); 786 const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT | 787 SHORT_BIT | UNSIGNED_SHORT_BIT | 788 INT_BIT | UNSIGNED_INT_BIT | 789 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 790 UNSIGNED_INT_2_10_10_10_REV_BIT | 791 INT_2_10_10_10_REV_BIT); 792 793 if (!validate_array_and_format(ctx, "glSecondaryColorPointer", 794 VERT_ATTRIB_COLOR1, legalTypes, 3, 795 BGRA_OR_4, size, type, stride, 796 GL_TRUE, GL_FALSE, GL_FALSE, format, ptr, 797 ctx->Array.VAO)) 798 return; 799 800 update_array(ctx, VERT_ATTRIB_COLOR1, format, BGRA_OR_4, size, type, 801 stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr); 802 } 803 804 805 void GLAPIENTRY 806 _mesa_TexCoordPointer_no_error(GLint size, GLenum type, GLsizei stride, 807 const GLvoid *ptr) 808 { 809 GET_CURRENT_CONTEXT(ctx); 810 const GLuint unit = ctx->Array.ActiveTexture; 811 FLUSH_VERTICES(ctx, 0); 812 813 update_array(ctx, VERT_ATTRIB_TEX(unit), GL_RGBA, 4, size, type, 814 stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr); 815 } 816 817 818 void GLAPIENTRY 819 _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride, 820 const GLvoid *ptr) 821 { 822 GET_CURRENT_CONTEXT(ctx); 823 const GLint sizeMin = (ctx->API == API_OPENGLES) ? 2 : 1; 824 const GLuint unit = ctx->Array.ActiveTexture; 825 826 FLUSH_VERTICES(ctx, 0); 827 828 GLenum format = GL_RGBA; 829 const GLbitfield legalTypes = (ctx->API == API_OPENGLES) 830 ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT) 831 : (SHORT_BIT | INT_BIT | 832 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 833 UNSIGNED_INT_2_10_10_10_REV_BIT | 834 INT_2_10_10_10_REV_BIT); 835 836 if (!validate_array_and_format(ctx, "glTexCoordPointer", 837 VERT_ATTRIB_TEX(unit), legalTypes, 838 sizeMin, 4, size, type, stride, 839 GL_FALSE, GL_FALSE, GL_FALSE, format, ptr, 840 ctx->Array.VAO)) 841 return; 842 843 update_array(ctx, VERT_ATTRIB_TEX(unit), format, 4, size, type, 844 stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr); 845 } 846 847 848 void GLAPIENTRY 849 _mesa_EdgeFlagPointer_no_error(GLsizei stride, const GLvoid *ptr) 850 { 851 /* this is the same type that glEdgeFlag uses */ 852 const GLboolean integer = GL_FALSE; 853 GET_CURRENT_CONTEXT(ctx); 854 FLUSH_VERTICES(ctx, 0); 855 856 update_array(ctx, VERT_ATTRIB_EDGEFLAG, GL_RGBA, 1, 1, GL_UNSIGNED_BYTE, 857 stride, GL_FALSE, integer, GL_FALSE, ptr); 858 } 859 860 861 void GLAPIENTRY 862 _mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr) 863 { 864 /* this is the same type that glEdgeFlag uses */ 865 const GLboolean integer = GL_FALSE; 866 GET_CURRENT_CONTEXT(ctx); 867 868 FLUSH_VERTICES(ctx, 0); 869 870 GLenum format = GL_RGBA; 871 const GLbitfield legalTypes = UNSIGNED_BYTE_BIT; 872 873 if (!validate_array_and_format(ctx, "glEdgeFlagPointer", 874 VERT_ATTRIB_EDGEFLAG, legalTypes, 875 1, 1, 1, GL_UNSIGNED_BYTE, stride, 876 GL_FALSE, integer, GL_FALSE, format, ptr, 877 ctx->Array.VAO)) 878 return; 879 880 update_array(ctx, VERT_ATTRIB_EDGEFLAG, format, 1, 1, GL_UNSIGNED_BYTE, 881 stride, GL_FALSE, integer, GL_FALSE, ptr); 882 } 883 884 885 void GLAPIENTRY 886 _mesa_PointSizePointerOES_no_error(GLenum type, GLsizei stride, 887 const GLvoid *ptr) 888 { 889 GET_CURRENT_CONTEXT(ctx); 890 FLUSH_VERTICES(ctx, 0); 891 892 update_array(ctx, VERT_ATTRIB_POINT_SIZE, GL_RGBA, 1, 1, type, stride, 893 GL_FALSE, GL_FALSE, GL_FALSE, ptr); 894 } 895 896 897 void GLAPIENTRY 898 _mesa_PointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *ptr) 899 { 900 GET_CURRENT_CONTEXT(ctx); 901 902 FLUSH_VERTICES(ctx, 0); 903 904 GLenum format = GL_RGBA; 905 if (ctx->API != API_OPENGLES) { 906 _mesa_error(ctx, GL_INVALID_OPERATION, 907 "glPointSizePointer(ES 1.x only)"); 908 return; 909 } 910 911 const GLbitfield legalTypes = (FLOAT_BIT | FIXED_ES_BIT); 912 913 if (!validate_array_and_format(ctx, "glPointSizePointer", 914 VERT_ATTRIB_POINT_SIZE, legalTypes, 915 1, 1, 1, type, stride, GL_FALSE, GL_FALSE, 916 GL_FALSE, format, ptr, ctx->Array.VAO)) 917 return; 918 919 update_array(ctx, VERT_ATTRIB_POINT_SIZE, format, 1, 1, type, stride, 920 GL_FALSE, GL_FALSE, GL_FALSE, ptr); 921 } 922 923 924 void GLAPIENTRY 925 _mesa_VertexAttribPointer_no_error(GLuint index, GLint size, GLenum type, 926 GLboolean normalized, 927 GLsizei stride, const GLvoid *ptr) 928 { 929 GET_CURRENT_CONTEXT(ctx); 930 931 GLenum format = get_array_format(ctx, BGRA_OR_4, &size); 932 update_array(ctx, VERT_ATTRIB_GENERIC(index), format, BGRA_OR_4, 933 size, type, stride, normalized, GL_FALSE, GL_FALSE, ptr); 934 } 935 936 937 /** 938 * Set a generic vertex attribute array. 939 * Note that these arrays DO NOT alias the conventional GL vertex arrays 940 * (position, normal, color, fog, texcoord, etc). 941 */ 942 void GLAPIENTRY 943 _mesa_VertexAttribPointer(GLuint index, GLint size, GLenum type, 944 GLboolean normalized, 945 GLsizei stride, const GLvoid *ptr) 946 { 947 GET_CURRENT_CONTEXT(ctx); 948 949 GLenum format = get_array_format(ctx, BGRA_OR_4, &size); 950 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 951 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(idx)"); 952 return; 953 } 954 955 const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT | 956 SHORT_BIT | UNSIGNED_SHORT_BIT | 957 INT_BIT | UNSIGNED_INT_BIT | 958 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 959 FIXED_ES_BIT | FIXED_GL_BIT | 960 UNSIGNED_INT_2_10_10_10_REV_BIT | 961 INT_2_10_10_10_REV_BIT | 962 UNSIGNED_INT_10F_11F_11F_REV_BIT); 963 964 if (!validate_array_and_format(ctx, "glVertexAttribPointer", 965 VERT_ATTRIB_GENERIC(index), legalTypes, 966 1, BGRA_OR_4, size, type, stride, 967 normalized, GL_FALSE, GL_FALSE, format, 968 ptr, ctx->Array.VAO)) 969 return; 970 971 update_array(ctx, VERT_ATTRIB_GENERIC(index), format, BGRA_OR_4, 972 size, type, stride, normalized, GL_FALSE, GL_FALSE, ptr); 973 } 974 975 976 void GLAPIENTRY 977 _mesa_VertexAttribIPointer_no_error(GLuint index, GLint size, GLenum type, 978 GLsizei stride, const GLvoid *ptr) 979 { 980 const GLboolean normalized = GL_FALSE; 981 const GLboolean integer = GL_TRUE; 982 GET_CURRENT_CONTEXT(ctx); 983 984 update_array(ctx, VERT_ATTRIB_GENERIC(index), GL_RGBA, 4, size, type, 985 stride, normalized, integer, GL_FALSE, ptr); 986 } 987 988 989 /** 990 * GL_EXT_gpu_shader4 / GL 3.0. 991 * Set an integer-valued vertex attribute array. 992 * Note that these arrays DO NOT alias the conventional GL vertex arrays 993 * (position, normal, color, fog, texcoord, etc). 994 */ 995 void GLAPIENTRY 996 _mesa_VertexAttribIPointer(GLuint index, GLint size, GLenum type, 997 GLsizei stride, const GLvoid *ptr) 998 { 999 const GLboolean normalized = GL_FALSE; 1000 const GLboolean integer = GL_TRUE; 1001 GET_CURRENT_CONTEXT(ctx); 1002 1003 GLenum format = GL_RGBA; 1004 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 1005 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribIPointer(index)"); 1006 return; 1007 } 1008 1009 const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT | 1010 SHORT_BIT | UNSIGNED_SHORT_BIT | 1011 INT_BIT | UNSIGNED_INT_BIT); 1012 1013 if (!validate_array_and_format(ctx, "glVertexAttribIPointer", 1014 VERT_ATTRIB_GENERIC(index), legalTypes, 1015 1, 4, size, type, stride, 1016 normalized, integer, GL_FALSE, format, 1017 ptr, ctx->Array.VAO)) 1018 return; 1019 1020 update_array(ctx, VERT_ATTRIB_GENERIC(index), format, 4, size, type, 1021 stride, normalized, integer, GL_FALSE, ptr); 1022 } 1023 1024 1025 void GLAPIENTRY 1026 _mesa_VertexAttribLPointer_no_error(GLuint index, GLint size, GLenum type, 1027 GLsizei stride, const GLvoid *ptr) 1028 { 1029 GET_CURRENT_CONTEXT(ctx); 1030 1031 update_array(ctx, VERT_ATTRIB_GENERIC(index), GL_RGBA, 4, size, type, 1032 stride, GL_FALSE, GL_FALSE, GL_TRUE, ptr); 1033 } 1034 1035 1036 void GLAPIENTRY 1037 _mesa_VertexAttribLPointer(GLuint index, GLint size, GLenum type, 1038 GLsizei stride, const GLvoid *ptr) 1039 { 1040 GET_CURRENT_CONTEXT(ctx); 1041 1042 GLenum format = GL_RGBA; 1043 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 1044 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribLPointer(index)"); 1045 return; 1046 } 1047 1048 const GLbitfield legalTypes = DOUBLE_BIT; 1049 1050 if (!validate_array_and_format(ctx, "glVertexAttribLPointer", 1051 VERT_ATTRIB_GENERIC(index), legalTypes, 1052 1, 4, size, type, stride, 1053 GL_FALSE, GL_FALSE, GL_TRUE, format, 1054 ptr, ctx->Array.VAO)) 1055 return; 1056 1057 update_array(ctx, VERT_ATTRIB_GENERIC(index), format, 4, size, type, 1058 stride, GL_FALSE, GL_FALSE, GL_TRUE, ptr); 1059 } 1060 1061 1062 void 1063 _mesa_enable_vertex_array_attrib(struct gl_context *ctx, 1064 struct gl_vertex_array_object *vao, 1065 unsigned attrib) 1066 { 1067 assert(attrib < ARRAY_SIZE(vao->VertexAttrib)); 1068 1069 if (!vao->VertexAttrib[attrib].Enabled) { 1070 /* was disabled, now being enabled */ 1071 FLUSH_VERTICES(ctx, _NEW_ARRAY); 1072 vao->VertexAttrib[attrib].Enabled = GL_TRUE; 1073 vao->_Enabled |= VERT_BIT(attrib); 1074 vao->NewArrays |= VERT_BIT(attrib); 1075 } 1076 } 1077 1078 static void 1079 enable_vertex_array_attrib(struct gl_context *ctx, 1080 struct gl_vertex_array_object *vao, 1081 GLuint index, 1082 const char *func) 1083 { 1084 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 1085 _mesa_error(ctx, GL_INVALID_VALUE, "%s(index)", func); 1086 return; 1087 } 1088 1089 _mesa_enable_vertex_array_attrib(ctx, vao, VERT_ATTRIB_GENERIC(index)); 1090 } 1091 1092 1093 void GLAPIENTRY 1094 _mesa_EnableVertexAttribArray(GLuint index) 1095 { 1096 GET_CURRENT_CONTEXT(ctx); 1097 enable_vertex_array_attrib(ctx, ctx->Array.VAO, index, 1098 "glEnableVertexAttribArray"); 1099 } 1100 1101 1102 void GLAPIENTRY 1103 _mesa_EnableVertexAttribArray_no_error(GLuint index) 1104 { 1105 GET_CURRENT_CONTEXT(ctx); 1106 _mesa_enable_vertex_array_attrib(ctx, ctx->Array.VAO, 1107 VERT_ATTRIB_GENERIC(index)); 1108 } 1109 1110 1111 void GLAPIENTRY 1112 _mesa_EnableVertexArrayAttrib(GLuint vaobj, GLuint index) 1113 { 1114 GET_CURRENT_CONTEXT(ctx); 1115 struct gl_vertex_array_object *vao; 1116 1117 /* The ARB_direct_state_access specification says: 1118 * 1119 * "An INVALID_OPERATION error is generated by EnableVertexArrayAttrib 1120 * and DisableVertexArrayAttrib if <vaobj> is not 1121 * [compatibility profile: zero or] the name of an existing vertex 1122 * array object." 1123 */ 1124 vao = _mesa_lookup_vao_err(ctx, vaobj, "glEnableVertexArrayAttrib"); 1125 if (!vao) 1126 return; 1127 1128 enable_vertex_array_attrib(ctx, vao, index, "glEnableVertexArrayAttrib"); 1129 } 1130 1131 1132 void GLAPIENTRY 1133 _mesa_EnableVertexArrayAttrib_no_error(GLuint vaobj, GLuint index) 1134 { 1135 GET_CURRENT_CONTEXT(ctx); 1136 struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj); 1137 _mesa_enable_vertex_array_attrib(ctx, vao, VERT_ATTRIB_GENERIC(index)); 1138 } 1139 1140 1141 static void 1142 disable_vertex_array_attrib(struct gl_context *ctx, 1143 struct gl_vertex_array_object *vao, 1144 GLuint index) 1145 { 1146 assert(VERT_ATTRIB_GENERIC(index) < ARRAY_SIZE(vao->VertexAttrib)); 1147 1148 if (vao->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled) { 1149 /* was enabled, now being disabled */ 1150 FLUSH_VERTICES(ctx, _NEW_ARRAY); 1151 vao->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled = GL_FALSE; 1152 vao->_Enabled &= ~VERT_BIT_GENERIC(index); 1153 vao->NewArrays |= VERT_BIT_GENERIC(index); 1154 } 1155 } 1156 1157 1158 void GLAPIENTRY 1159 _mesa_DisableVertexAttribArray(GLuint index) 1160 { 1161 GET_CURRENT_CONTEXT(ctx); 1162 1163 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 1164 _mesa_error(ctx, GL_INVALID_VALUE, "glDisableVertexAttribArray(index)"); 1165 return; 1166 } 1167 1168 disable_vertex_array_attrib(ctx, ctx->Array.VAO, index); 1169 } 1170 1171 1172 void GLAPIENTRY 1173 _mesa_DisableVertexAttribArray_no_error(GLuint index) 1174 { 1175 GET_CURRENT_CONTEXT(ctx); 1176 disable_vertex_array_attrib(ctx, ctx->Array.VAO, index); 1177 } 1178 1179 1180 void GLAPIENTRY 1181 _mesa_DisableVertexArrayAttrib(GLuint vaobj, GLuint index) 1182 { 1183 GET_CURRENT_CONTEXT(ctx); 1184 struct gl_vertex_array_object *vao; 1185 1186 /* The ARB_direct_state_access specification says: 1187 * 1188 * "An INVALID_OPERATION error is generated by EnableVertexArrayAttrib 1189 * and DisableVertexArrayAttrib if <vaobj> is not 1190 * [compatibility profile: zero or] the name of an existing vertex 1191 * array object." 1192 */ 1193 vao = _mesa_lookup_vao_err(ctx, vaobj, "glDisableVertexArrayAttrib"); 1194 if (!vao) 1195 return; 1196 1197 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 1198 _mesa_error(ctx, GL_INVALID_VALUE, "glDisableVertexArrayAttrib(index)"); 1199 return; 1200 } 1201 1202 disable_vertex_array_attrib(ctx, vao, index); 1203 } 1204 1205 1206 void GLAPIENTRY 1207 _mesa_DisableVertexArrayAttrib_no_error(GLuint vaobj, GLuint index) 1208 { 1209 GET_CURRENT_CONTEXT(ctx); 1210 struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj); 1211 disable_vertex_array_attrib(ctx, vao, index); 1212 } 1213 1214 1215 /** 1216 * Return info for a vertex attribute array (no alias with legacy 1217 * vertex attributes (pos, normal, color, etc)). This function does 1218 * not handle the 4-element GL_CURRENT_VERTEX_ATTRIB_ARB query. 1219 */ 1220 static GLuint 1221 get_vertex_array_attrib(struct gl_context *ctx, 1222 const struct gl_vertex_array_object *vao, 1223 GLuint index, GLenum pname, 1224 const char *caller) 1225 { 1226 const struct gl_array_attributes *array; 1227 1228 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 1229 _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)", caller, index); 1230 return 0; 1231 } 1232 1233 assert(VERT_ATTRIB_GENERIC(index) < ARRAY_SIZE(vao->VertexAttrib)); 1234 1235 array = &vao->VertexAttrib[VERT_ATTRIB_GENERIC(index)]; 1236 1237 switch (pname) { 1238 case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB: 1239 return array->Enabled; 1240 case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB: 1241 return (array->Format == GL_BGRA) ? GL_BGRA : array->Size; 1242 case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB: 1243 return array->Stride; 1244 case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB: 1245 return array->Type; 1246 case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB: 1247 return array->Normalized; 1248 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB: 1249 return vao->BufferBinding[array->BufferBindingIndex].BufferObj->Name; 1250 case GL_VERTEX_ATTRIB_ARRAY_INTEGER: 1251 if ((_mesa_is_desktop_gl(ctx) 1252 && (ctx->Version >= 30 || ctx->Extensions.EXT_gpu_shader4)) 1253 || _mesa_is_gles3(ctx)) { 1254 return array->Integer; 1255 } 1256 goto error; 1257 case GL_VERTEX_ATTRIB_ARRAY_LONG: 1258 if (_mesa_is_desktop_gl(ctx)) { 1259 return array->Doubles; 1260 } 1261 goto error; 1262 case GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB: 1263 if ((_mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_instanced_arrays) 1264 || _mesa_is_gles3(ctx)) { 1265 return vao->BufferBinding[array->BufferBindingIndex].InstanceDivisor; 1266 } 1267 goto error; 1268 case GL_VERTEX_ATTRIB_BINDING: 1269 if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles31(ctx)) { 1270 return array->BufferBindingIndex - VERT_ATTRIB_GENERIC0; 1271 } 1272 goto error; 1273 case GL_VERTEX_ATTRIB_RELATIVE_OFFSET: 1274 if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles31(ctx)) { 1275 return array->RelativeOffset; 1276 } 1277 goto error; 1278 default: 1279 ; /* fall-through */ 1280 } 1281 1282 error: 1283 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=0x%x)", caller, pname); 1284 return 0; 1285 } 1286 1287 1288 static const GLfloat * 1289 get_current_attrib(struct gl_context *ctx, GLuint index, const char *function) 1290 { 1291 if (index == 0) { 1292 if (_mesa_attr_zero_aliases_vertex(ctx)) { 1293 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(index==0)", function); 1294 return NULL; 1295 } 1296 } 1297 else if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 1298 _mesa_error(ctx, GL_INVALID_VALUE, 1299 "%s(index>=GL_MAX_VERTEX_ATTRIBS)", function); 1300 return NULL; 1301 } 1302 1303 assert(VERT_ATTRIB_GENERIC(index) < 1304 ARRAY_SIZE(ctx->Array.VAO->VertexAttrib)); 1305 1306 FLUSH_CURRENT(ctx, 0); 1307 return ctx->Current.Attrib[VERT_ATTRIB_GENERIC(index)]; 1308 } 1309 1310 void GLAPIENTRY 1311 _mesa_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) 1312 { 1313 GET_CURRENT_CONTEXT(ctx); 1314 1315 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 1316 const GLfloat *v = get_current_attrib(ctx, index, "glGetVertexAttribfv"); 1317 if (v != NULL) { 1318 COPY_4V(params, v); 1319 } 1320 } 1321 else { 1322 params[0] = (GLfloat) get_vertex_array_attrib(ctx, ctx->Array.VAO, 1323 index, pname, 1324 "glGetVertexAttribfv"); 1325 } 1326 } 1327 1328 1329 void GLAPIENTRY 1330 _mesa_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) 1331 { 1332 GET_CURRENT_CONTEXT(ctx); 1333 1334 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 1335 const GLfloat *v = get_current_attrib(ctx, index, "glGetVertexAttribdv"); 1336 if (v != NULL) { 1337 params[0] = (GLdouble) v[0]; 1338 params[1] = (GLdouble) v[1]; 1339 params[2] = (GLdouble) v[2]; 1340 params[3] = (GLdouble) v[3]; 1341 } 1342 } 1343 else { 1344 params[0] = (GLdouble) get_vertex_array_attrib(ctx, ctx->Array.VAO, 1345 index, pname, 1346 "glGetVertexAttribdv"); 1347 } 1348 } 1349 1350 void GLAPIENTRY 1351 _mesa_GetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params) 1352 { 1353 GET_CURRENT_CONTEXT(ctx); 1354 1355 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 1356 const GLdouble *v = 1357 (const GLdouble *)get_current_attrib(ctx, index, 1358 "glGetVertexAttribLdv"); 1359 if (v != NULL) { 1360 params[0] = v[0]; 1361 params[1] = v[1]; 1362 params[2] = v[2]; 1363 params[3] = v[3]; 1364 } 1365 } 1366 else { 1367 params[0] = (GLdouble) get_vertex_array_attrib(ctx, ctx->Array.VAO, 1368 index, pname, 1369 "glGetVertexAttribLdv"); 1370 } 1371 } 1372 1373 void GLAPIENTRY 1374 _mesa_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params) 1375 { 1376 GET_CURRENT_CONTEXT(ctx); 1377 1378 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 1379 const GLfloat *v = get_current_attrib(ctx, index, "glGetVertexAttribiv"); 1380 if (v != NULL) { 1381 /* XXX should floats in[0,1] be scaled to full int range? */ 1382 params[0] = (GLint) v[0]; 1383 params[1] = (GLint) v[1]; 1384 params[2] = (GLint) v[2]; 1385 params[3] = (GLint) v[3]; 1386 } 1387 } 1388 else { 1389 params[0] = (GLint) get_vertex_array_attrib(ctx, ctx->Array.VAO, 1390 index, pname, 1391 "glGetVertexAttribiv"); 1392 } 1393 } 1394 1395 void GLAPIENTRY 1396 _mesa_GetVertexAttribLui64vARB(GLuint index, GLenum pname, GLuint64EXT *params) 1397 { 1398 GET_CURRENT_CONTEXT(ctx); 1399 1400 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 1401 const GLuint64 *v = 1402 (const GLuint64 *)get_current_attrib(ctx, index, 1403 "glGetVertexAttribLui64vARB"); 1404 if (v != NULL) { 1405 params[0] = v[0]; 1406 params[1] = v[1]; 1407 params[2] = v[2]; 1408 params[3] = v[3]; 1409 } 1410 } 1411 else { 1412 params[0] = (GLuint64) get_vertex_array_attrib(ctx, ctx->Array.VAO, 1413 index, pname, 1414 "glGetVertexAttribLui64vARB"); 1415 } 1416 } 1417 1418 1419 /** GL 3.0 */ 1420 void GLAPIENTRY 1421 _mesa_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params) 1422 { 1423 GET_CURRENT_CONTEXT(ctx); 1424 1425 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 1426 const GLint *v = (const GLint *) 1427 get_current_attrib(ctx, index, "glGetVertexAttribIiv"); 1428 if (v != NULL) { 1429 COPY_4V(params, v); 1430 } 1431 } 1432 else { 1433 params[0] = (GLint) get_vertex_array_attrib(ctx, ctx->Array.VAO, 1434 index, pname, 1435 "glGetVertexAttribIiv"); 1436 } 1437 } 1438 1439 1440 /** GL 3.0 */ 1441 void GLAPIENTRY 1442 _mesa_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params) 1443 { 1444 GET_CURRENT_CONTEXT(ctx); 1445 1446 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 1447 const GLuint *v = (const GLuint *) 1448 get_current_attrib(ctx, index, "glGetVertexAttribIuiv"); 1449 if (v != NULL) { 1450 COPY_4V(params, v); 1451 } 1452 } 1453 else { 1454 params[0] = get_vertex_array_attrib(ctx, ctx->Array.VAO, 1455 index, pname, 1456 "glGetVertexAttribIuiv"); 1457 } 1458 } 1459 1460 1461 void GLAPIENTRY 1462 _mesa_GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) 1463 { 1464 GET_CURRENT_CONTEXT(ctx); 1465 1466 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 1467 _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribPointerARB(index)"); 1468 return; 1469 } 1470 1471 if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB) { 1472 _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribPointerARB(pname)"); 1473 return; 1474 } 1475 1476 assert(VERT_ATTRIB_GENERIC(index) < 1477 ARRAY_SIZE(ctx->Array.VAO->VertexAttrib)); 1478 1479 *pointer = (GLvoid *) 1480 ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Ptr; 1481 } 1482 1483 1484 /** ARB_direct_state_access */ 1485 void GLAPIENTRY 1486 _mesa_GetVertexArrayIndexediv(GLuint vaobj, GLuint index, 1487 GLenum pname, GLint *params) 1488 { 1489 GET_CURRENT_CONTEXT(ctx); 1490 struct gl_vertex_array_object *vao; 1491 1492 /* The ARB_direct_state_access specification says: 1493 * 1494 * "An INVALID_OPERATION error is generated if <vaobj> is not 1495 * [compatibility profile: zero or] the name of an existing 1496 * vertex array object." 1497 */ 1498 vao = _mesa_lookup_vao_err(ctx, vaobj, "glGetVertexArrayIndexediv"); 1499 if (!vao) 1500 return; 1501 1502 /* The ARB_direct_state_access specification says: 1503 * 1504 * "For GetVertexArrayIndexediv, <pname> must be one of 1505 * VERTEX_ATTRIB_ARRAY_ENABLED, VERTEX_ATTRIB_ARRAY_SIZE, 1506 * VERTEX_ATTRIB_ARRAY_STRIDE, VERTEX_ATTRIB_ARRAY_TYPE, 1507 * VERTEX_ATTRIB_ARRAY_NORMALIZED, VERTEX_ATTRIB_ARRAY_INTEGER, 1508 * VERTEX_ATTRIB_ARRAY_LONG, VERTEX_ATTRIB_ARRAY_DIVISOR, or 1509 * VERTEX_ATTRIB_RELATIVE_OFFSET." 1510 * 1511 * and: 1512 * 1513 * "Add GetVertexArrayIndexediv in 'Get Command' for 1514 * VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 1515 * VERTEX_ATTRIB_BINDING, 1516 * VERTEX_ATTRIB_RELATIVE_OFFSET, 1517 * VERTEX_BINDING_OFFSET, and 1518 * VERTEX_BINDING_STRIDE states" 1519 * 1520 * The only parameter name common to both lists is 1521 * VERTEX_ATTRIB_RELATIVE_OFFSET. Also note that VERTEX_BINDING_BUFFER 1522 * and VERTEX_BINDING_DIVISOR are missing from both lists. It seems 1523 * pretty clear however that the intent is that it should be possible 1524 * to query all vertex attrib and binding states that can be set with 1525 * a DSA function. 1526 */ 1527 switch (pname) { 1528 case GL_VERTEX_BINDING_OFFSET: 1529 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].Offset; 1530 break; 1531 case GL_VERTEX_BINDING_STRIDE: 1532 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].Stride; 1533 break; 1534 case GL_VERTEX_BINDING_DIVISOR: 1535 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].InstanceDivisor; 1536 break; 1537 case GL_VERTEX_BINDING_BUFFER: 1538 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].BufferObj->Name; 1539 break; 1540 default: 1541 params[0] = get_vertex_array_attrib(ctx, vao, index, pname, 1542 "glGetVertexArrayIndexediv"); 1543 break; 1544 } 1545 } 1546 1547 1548 void GLAPIENTRY 1549 _mesa_GetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, 1550 GLenum pname, GLint64 *params) 1551 { 1552 GET_CURRENT_CONTEXT(ctx); 1553 struct gl_vertex_array_object *vao; 1554 1555 /* The ARB_direct_state_access specification says: 1556 * 1557 * "An INVALID_OPERATION error is generated if <vaobj> is not 1558 * [compatibility profile: zero or] the name of an existing 1559 * vertex array object." 1560 */ 1561 vao = _mesa_lookup_vao_err(ctx, vaobj, "glGetVertexArrayIndexed64iv"); 1562 if (!vao) 1563 return; 1564 1565 /* The ARB_direct_state_access specification says: 1566 * 1567 * "For GetVertexArrayIndexed64iv, <pname> must be 1568 * VERTEX_BINDING_OFFSET." 1569 * 1570 * and: 1571 * 1572 * "An INVALID_ENUM error is generated if <pname> is not one of 1573 * the valid values listed above for the corresponding command." 1574 */ 1575 if (pname != GL_VERTEX_BINDING_OFFSET) { 1576 _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexArrayIndexed64iv(" 1577 "pname != GL_VERTEX_BINDING_OFFSET)"); 1578 return; 1579 } 1580 1581 /* The ARB_direct_state_access specification says: 1582 * 1583 * "An INVALID_VALUE error is generated if <index> is greater than 1584 * or equal to the value of MAX_VERTEX_ATTRIBS." 1585 * 1586 * Since the index refers to a buffer binding in this case, the intended 1587 * limit must be MAX_VERTEX_ATTRIB_BINDINGS. Both limits are currently 1588 * required to be the same, so in practice this doesn't matter. 1589 */ 1590 if (index >= ctx->Const.MaxVertexAttribBindings) { 1591 _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexArrayIndexed64iv(index" 1592 "%d >= the value of GL_MAX_VERTEX_ATTRIB_BINDINGS (%d))", 1593 index, ctx->Const.MaxVertexAttribBindings); 1594 return; 1595 } 1596 1597 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].Offset; 1598 } 1599 1600 1601 void GLAPIENTRY 1602 _mesa_VertexPointerEXT(GLint size, GLenum type, GLsizei stride, 1603 GLsizei count, const GLvoid *ptr) 1604 { 1605 (void) count; 1606 _mesa_VertexPointer(size, type, stride, ptr); 1607 } 1608 1609 1610 void GLAPIENTRY 1611 _mesa_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, 1612 const GLvoid *ptr) 1613 { 1614 (void) count; 1615 _mesa_NormalPointer(type, stride, ptr); 1616 } 1617 1618 1619 void GLAPIENTRY 1620 _mesa_ColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, 1621 const GLvoid *ptr) 1622 { 1623 (void) count; 1624 _mesa_ColorPointer(size, type, stride, ptr); 1625 } 1626 1627 1628 void GLAPIENTRY 1629 _mesa_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, 1630 const GLvoid *ptr) 1631 { 1632 (void) count; 1633 _mesa_IndexPointer(type, stride, ptr); 1634 } 1635 1636 1637 void GLAPIENTRY 1638 _mesa_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, 1639 GLsizei count, const GLvoid *ptr) 1640 { 1641 (void) count; 1642 _mesa_TexCoordPointer(size, type, stride, ptr); 1643 } 1644 1645 1646 void GLAPIENTRY 1647 _mesa_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr) 1648 { 1649 (void) count; 1650 _mesa_EdgeFlagPointer(stride, ptr); 1651 } 1652 1653 1654 void GLAPIENTRY 1655 _mesa_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) 1656 { 1657 GET_CURRENT_CONTEXT(ctx); 1658 GLboolean tflag, cflag, nflag; /* enable/disable flags */ 1659 GLint tcomps, ccomps, vcomps; /* components per texcoord, color, vertex */ 1660 GLenum ctype = 0; /* color type */ 1661 GLint coffset = 0, noffset = 0, voffset;/* color, normal, vertex offsets */ 1662 const GLint toffset = 0; /* always zero */ 1663 GLint defstride; /* default stride */ 1664 GLint c, f; 1665 1666 FLUSH_VERTICES(ctx, 0); 1667 1668 f = sizeof(GLfloat); 1669 c = f * ((4 * sizeof(GLubyte) + (f - 1)) / f); 1670 1671 if (stride < 0) { 1672 _mesa_error( ctx, GL_INVALID_VALUE, "glInterleavedArrays(stride)" ); 1673 return; 1674 } 1675 1676 switch (format) { 1677 case GL_V2F: 1678 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_FALSE; 1679 tcomps = 0; ccomps = 0; vcomps = 2; 1680 voffset = 0; 1681 defstride = 2*f; 1682 break; 1683 case GL_V3F: 1684 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_FALSE; 1685 tcomps = 0; ccomps = 0; vcomps = 3; 1686 voffset = 0; 1687 defstride = 3*f; 1688 break; 1689 case GL_C4UB_V2F: 1690 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE; 1691 tcomps = 0; ccomps = 4; vcomps = 2; 1692 ctype = GL_UNSIGNED_BYTE; 1693 coffset = 0; 1694 voffset = c; 1695 defstride = c + 2*f; 1696 break; 1697 case GL_C4UB_V3F: 1698 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE; 1699 tcomps = 0; ccomps = 4; vcomps = 3; 1700 ctype = GL_UNSIGNED_BYTE; 1701 coffset = 0; 1702 voffset = c; 1703 defstride = c + 3*f; 1704 break; 1705 case GL_C3F_V3F: 1706 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE; 1707 tcomps = 0; ccomps = 3; vcomps = 3; 1708 ctype = GL_FLOAT; 1709 coffset = 0; 1710 voffset = 3*f; 1711 defstride = 6*f; 1712 break; 1713 case GL_N3F_V3F: 1714 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_TRUE; 1715 tcomps = 0; ccomps = 0; vcomps = 3; 1716 noffset = 0; 1717 voffset = 3*f; 1718 defstride = 6*f; 1719 break; 1720 case GL_C4F_N3F_V3F: 1721 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_TRUE; 1722 tcomps = 0; ccomps = 4; vcomps = 3; 1723 ctype = GL_FLOAT; 1724 coffset = 0; 1725 noffset = 4*f; 1726 voffset = 7*f; 1727 defstride = 10*f; 1728 break; 1729 case GL_T2F_V3F: 1730 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_FALSE; 1731 tcomps = 2; ccomps = 0; vcomps = 3; 1732 voffset = 2*f; 1733 defstride = 5*f; 1734 break; 1735 case GL_T4F_V4F: 1736 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_FALSE; 1737 tcomps = 4; ccomps = 0; vcomps = 4; 1738 voffset = 4*f; 1739 defstride = 8*f; 1740 break; 1741 case GL_T2F_C4UB_V3F: 1742 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_FALSE; 1743 tcomps = 2; ccomps = 4; vcomps = 3; 1744 ctype = GL_UNSIGNED_BYTE; 1745 coffset = 2*f; 1746 voffset = c+2*f; 1747 defstride = c+5*f; 1748 break; 1749 case GL_T2F_C3F_V3F: 1750 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_FALSE; 1751 tcomps = 2; ccomps = 3; vcomps = 3; 1752 ctype = GL_FLOAT; 1753 coffset = 2*f; 1754 voffset = 5*f; 1755 defstride = 8*f; 1756 break; 1757 case GL_T2F_N3F_V3F: 1758 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_TRUE; 1759 tcomps = 2; ccomps = 0; vcomps = 3; 1760 noffset = 2*f; 1761 voffset = 5*f; 1762 defstride = 8*f; 1763 break; 1764 case GL_T2F_C4F_N3F_V3F: 1765 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_TRUE; 1766 tcomps = 2; ccomps = 4; vcomps = 3; 1767 ctype = GL_FLOAT; 1768 coffset = 2*f; 1769 noffset = 6*f; 1770 voffset = 9*f; 1771 defstride = 12*f; 1772 break; 1773 case GL_T4F_C4F_N3F_V4F: 1774 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_TRUE; 1775 tcomps = 4; ccomps = 4; vcomps = 4; 1776 ctype = GL_FLOAT; 1777 coffset = 4*f; 1778 noffset = 8*f; 1779 voffset = 11*f; 1780 defstride = 15*f; 1781 break; 1782 default: 1783 _mesa_error( ctx, GL_INVALID_ENUM, "glInterleavedArrays(format)" ); 1784 return; 1785 } 1786 1787 if (stride==0) { 1788 stride = defstride; 1789 } 1790 1791 _mesa_DisableClientState( GL_EDGE_FLAG_ARRAY ); 1792 _mesa_DisableClientState( GL_INDEX_ARRAY ); 1793 /* XXX also disable secondary color and generic arrays? */ 1794 1795 /* Texcoords */ 1796 if (tflag) { 1797 _mesa_EnableClientState( GL_TEXTURE_COORD_ARRAY ); 1798 _mesa_TexCoordPointer( tcomps, GL_FLOAT, stride, 1799 (GLubyte *) pointer + toffset ); 1800 } 1801 else { 1802 _mesa_DisableClientState( GL_TEXTURE_COORD_ARRAY ); 1803 } 1804 1805 /* Color */ 1806 if (cflag) { 1807 _mesa_EnableClientState( GL_COLOR_ARRAY ); 1808 _mesa_ColorPointer( ccomps, ctype, stride, 1809 (GLubyte *) pointer + coffset ); 1810 } 1811 else { 1812 _mesa_DisableClientState( GL_COLOR_ARRAY ); 1813 } 1814 1815 1816 /* Normals */ 1817 if (nflag) { 1818 _mesa_EnableClientState( GL_NORMAL_ARRAY ); 1819 _mesa_NormalPointer( GL_FLOAT, stride, (GLubyte *) pointer + noffset ); 1820 } 1821 else { 1822 _mesa_DisableClientState( GL_NORMAL_ARRAY ); 1823 } 1824 1825 /* Vertices */ 1826 _mesa_EnableClientState( GL_VERTEX_ARRAY ); 1827 _mesa_VertexPointer( vcomps, GL_FLOAT, stride, 1828 (GLubyte *) pointer + voffset ); 1829 } 1830 1831 1832 void GLAPIENTRY 1833 _mesa_LockArraysEXT(GLint first, GLsizei count) 1834 { 1835 GET_CURRENT_CONTEXT(ctx); 1836 1837 FLUSH_VERTICES(ctx, 0); 1838 1839 if (MESA_VERBOSE & VERBOSE_API) 1840 _mesa_debug(ctx, "glLockArrays %d %d\n", first, count); 1841 1842 if (first < 0) { 1843 _mesa_error( ctx, GL_INVALID_VALUE, "glLockArraysEXT(first)" ); 1844 return; 1845 } 1846 if (count <= 0) { 1847 _mesa_error( ctx, GL_INVALID_VALUE, "glLockArraysEXT(count)" ); 1848 return; 1849 } 1850 if (ctx->Array.LockCount != 0) { 1851 _mesa_error( ctx, GL_INVALID_OPERATION, "glLockArraysEXT(reentry)" ); 1852 return; 1853 } 1854 1855 ctx->Array.LockFirst = first; 1856 ctx->Array.LockCount = count; 1857 1858 ctx->NewState |= _NEW_ARRAY; 1859 } 1860 1861 1862 void GLAPIENTRY 1863 _mesa_UnlockArraysEXT( void ) 1864 { 1865 GET_CURRENT_CONTEXT(ctx); 1866 1867 FLUSH_VERTICES(ctx, 0); 1868 1869 if (MESA_VERBOSE & VERBOSE_API) 1870 _mesa_debug(ctx, "glUnlockArrays\n"); 1871 1872 if (ctx->Array.LockCount == 0) { 1873 _mesa_error( ctx, GL_INVALID_OPERATION, "glUnlockArraysEXT(reexit)" ); 1874 return; 1875 } 1876 1877 ctx->Array.LockFirst = 0; 1878 ctx->Array.LockCount = 0; 1879 ctx->NewState |= _NEW_ARRAY; 1880 } 1881 1882 1883 /* GL_IBM_multimode_draw_arrays */ 1884 void GLAPIENTRY 1885 _mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first, 1886 const GLsizei * count, 1887 GLsizei primcount, GLint modestride ) 1888 { 1889 GET_CURRENT_CONTEXT(ctx); 1890 GLint i; 1891 1892 FLUSH_VERTICES(ctx, 0); 1893 1894 for ( i = 0 ; i < primcount ; i++ ) { 1895 if ( count[i] > 0 ) { 1896 GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride)); 1897 CALL_DrawArrays(ctx->CurrentServerDispatch, ( m, first[i], count[i] )); 1898 } 1899 } 1900 } 1901 1902 1903 /* GL_IBM_multimode_draw_arrays */ 1904 void GLAPIENTRY 1905 _mesa_MultiModeDrawElementsIBM( const GLenum * mode, const GLsizei * count, 1906 GLenum type, const GLvoid * const * indices, 1907 GLsizei primcount, GLint modestride ) 1908 { 1909 GET_CURRENT_CONTEXT(ctx); 1910 GLint i; 1911 1912 FLUSH_VERTICES(ctx, 0); 1913 1914 /* XXX not sure about ARB_vertex_buffer_object handling here */ 1915 1916 for ( i = 0 ; i < primcount ; i++ ) { 1917 if ( count[i] > 0 ) { 1918 GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride)); 1919 CALL_DrawElements(ctx->CurrentServerDispatch, ( m, count[i], type, 1920 indices[i] )); 1921 } 1922 } 1923 } 1924 1925 1926 static void 1927 primitive_restart_index(struct gl_context *ctx, GLuint index) 1928 { 1929 if (ctx->Array.RestartIndex != index) { 1930 FLUSH_VERTICES(ctx, 0); 1931 ctx->Array.RestartIndex = index; 1932 } 1933 } 1934 1935 1936 /** 1937 * GL_NV_primitive_restart and GL 3.1 1938 */ 1939 void GLAPIENTRY 1940 _mesa_PrimitiveRestartIndex_no_error(GLuint index) 1941 { 1942 GET_CURRENT_CONTEXT(ctx); 1943 primitive_restart_index(ctx, index); 1944 } 1945 1946 1947 void GLAPIENTRY 1948 _mesa_PrimitiveRestartIndex(GLuint index) 1949 { 1950 GET_CURRENT_CONTEXT(ctx); 1951 1952 if (!ctx->Extensions.NV_primitive_restart && ctx->Version < 31) { 1953 _mesa_error(ctx, GL_INVALID_OPERATION, "glPrimitiveRestartIndexNV()"); 1954 return; 1955 } 1956 1957 primitive_restart_index(ctx, index); 1958 } 1959 1960 1961 void GLAPIENTRY 1962 _mesa_VertexAttribDivisor_no_error(GLuint index, GLuint divisor) 1963 { 1964 GET_CURRENT_CONTEXT(ctx); 1965 1966 const GLuint genericIndex = VERT_ATTRIB_GENERIC(index); 1967 struct gl_vertex_array_object * const vao = ctx->Array.VAO; 1968 1969 assert(genericIndex < ARRAY_SIZE(vao->VertexAttrib)); 1970 1971 /* The ARB_vertex_attrib_binding spec says: 1972 * 1973 * "The command 1974 * 1975 * void VertexAttribDivisor(uint index, uint divisor); 1976 * 1977 * is equivalent to (assuming no errors are generated): 1978 * 1979 * VertexAttribBinding(index, index); 1980 * VertexBindingDivisor(index, divisor);" 1981 */ 1982 vertex_attrib_binding(ctx, vao, genericIndex, genericIndex); 1983 vertex_binding_divisor(ctx, vao, genericIndex, divisor); 1984 } 1985 1986 1987 /** 1988 * See GL_ARB_instanced_arrays. 1989 * Note that the instance divisor only applies to generic arrays, not 1990 * the legacy vertex arrays. 1991 */ 1992 void GLAPIENTRY 1993 _mesa_VertexAttribDivisor(GLuint index, GLuint divisor) 1994 { 1995 GET_CURRENT_CONTEXT(ctx); 1996 1997 const GLuint genericIndex = VERT_ATTRIB_GENERIC(index); 1998 struct gl_vertex_array_object * const vao = ctx->Array.VAO; 1999 2000 if (!ctx->Extensions.ARB_instanced_arrays) { 2001 _mesa_error(ctx, GL_INVALID_OPERATION, "glVertexAttribDivisor()"); 2002 return; 2003 } 2004 2005 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 2006 _mesa_error(ctx, GL_INVALID_VALUE, 2007 "glVertexAttribDivisor(index = %u)", index); 2008 return; 2009 } 2010 2011 assert(genericIndex < ARRAY_SIZE(vao->VertexAttrib)); 2012 2013 /* The ARB_vertex_attrib_binding spec says: 2014 * 2015 * "The command 2016 * 2017 * void VertexAttribDivisor(uint index, uint divisor); 2018 * 2019 * is equivalent to (assuming no errors are generated): 2020 * 2021 * VertexAttribBinding(index, index); 2022 * VertexBindingDivisor(index, divisor);" 2023 */ 2024 vertex_attrib_binding(ctx, vao, genericIndex, genericIndex); 2025 vertex_binding_divisor(ctx, vao, genericIndex, divisor); 2026 } 2027 2028 2029 static ALWAYS_INLINE void 2030 vertex_array_vertex_buffer(struct gl_context *ctx, 2031 struct gl_vertex_array_object *vao, 2032 GLuint bindingIndex, GLuint buffer, GLintptr offset, 2033 GLsizei stride, bool no_error, const char *func) 2034 { 2035 struct gl_buffer_object *vbo; 2036 if (buffer == 2037 vao->BufferBinding[VERT_ATTRIB_GENERIC(bindingIndex)].BufferObj->Name) { 2038 vbo = vao->BufferBinding[VERT_ATTRIB_GENERIC(bindingIndex)].BufferObj; 2039 } else if (buffer != 0) { 2040 vbo = _mesa_lookup_bufferobj(ctx, buffer); 2041 2042 if (!no_error && !vbo && _mesa_is_gles31(ctx)) { 2043 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-gen name)", func); 2044 return; 2045 } 2046 /* From the GL_ARB_vertex_attrib_array spec: 2047 * 2048 * "[Core profile only:] 2049 * An INVALID_OPERATION error is generated if buffer is not zero or a 2050 * name returned from a previous call to GenBuffers, or if such a name 2051 * has since been deleted with DeleteBuffers. 2052 * 2053 * Otherwise, we fall back to the same compat profile behavior as other 2054 * object references (automatically gen it). 2055 */ 2056 if (!_mesa_handle_bind_buffer_gen(ctx, buffer, &vbo, func)) 2057 return; 2058 } else { 2059 /* The ARB_vertex_attrib_binding spec says: 2060 * 2061 * "If <buffer> is zero, any buffer object attached to this 2062 * bindpoint is detached." 2063 */ 2064 vbo = ctx->Shared->NullBufferObj; 2065 } 2066 2067 _mesa_bind_vertex_buffer(ctx, vao, VERT_ATTRIB_GENERIC(bindingIndex), 2068 vbo, offset, stride); 2069 } 2070 2071 2072 /** 2073 * GL_ARB_vertex_attrib_binding 2074 */ 2075 static void 2076 vertex_array_vertex_buffer_err(struct gl_context *ctx, 2077 struct gl_vertex_array_object *vao, 2078 GLuint bindingIndex, GLuint buffer, 2079 GLintptr offset, GLsizei stride, 2080 const char *func) 2081 { 2082 ASSERT_OUTSIDE_BEGIN_END(ctx); 2083 2084 /* The ARB_vertex_attrib_binding spec says: 2085 * 2086 * "An INVALID_VALUE error is generated if <bindingindex> is greater than 2087 * the value of MAX_VERTEX_ATTRIB_BINDINGS." 2088 */ 2089 if (bindingIndex >= ctx->Const.MaxVertexAttribBindings) { 2090 _mesa_error(ctx, GL_INVALID_VALUE, 2091 "%s(bindingindex=%u > " 2092 "GL_MAX_VERTEX_ATTRIB_BINDINGS)", 2093 func, bindingIndex); 2094 return; 2095 } 2096 2097 /* The ARB_vertex_attrib_binding spec says: 2098 * 2099 * "The error INVALID_VALUE is generated if <stride> or <offset> 2100 * are negative." 2101 */ 2102 if (offset < 0) { 2103 _mesa_error(ctx, GL_INVALID_VALUE, 2104 "%s(offset=%" PRId64 " < 0)", 2105 func, (int64_t) offset); 2106 return; 2107 } 2108 2109 if (stride < 0) { 2110 _mesa_error(ctx, GL_INVALID_VALUE, 2111 "%s(stride=%d < 0)", func, stride); 2112 return; 2113 } 2114 2115 if (((ctx->API == API_OPENGL_CORE && ctx->Version >= 44) || _mesa_is_gles31(ctx)) && 2116 stride > ctx->Const.MaxVertexAttribStride) { 2117 _mesa_error(ctx, GL_INVALID_VALUE, "%s(stride=%d > " 2118 "GL_MAX_VERTEX_ATTRIB_STRIDE)", func, stride); 2119 return; 2120 } 2121 2122 vertex_array_vertex_buffer(ctx, vao, bindingIndex, buffer, offset, 2123 stride, false, func); 2124 } 2125 2126 2127 void GLAPIENTRY 2128 _mesa_BindVertexBuffer_no_error(GLuint bindingIndex, GLuint buffer, 2129 GLintptr offset, GLsizei stride) 2130 { 2131 GET_CURRENT_CONTEXT(ctx); 2132 vertex_array_vertex_buffer(ctx, ctx->Array.VAO, bindingIndex, 2133 buffer, offset, stride, true, 2134 "glBindVertexBuffer"); 2135 } 2136 2137 2138 void GLAPIENTRY 2139 _mesa_BindVertexBuffer(GLuint bindingIndex, GLuint buffer, GLintptr offset, 2140 GLsizei stride) 2141 { 2142 GET_CURRENT_CONTEXT(ctx); 2143 2144 /* The ARB_vertex_attrib_binding spec says: 2145 * 2146 * "An INVALID_OPERATION error is generated if no vertex array object 2147 * is bound." 2148 */ 2149 if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) && 2150 ctx->Array.VAO == ctx->Array.DefaultVAO) { 2151 _mesa_error(ctx, GL_INVALID_OPERATION, 2152 "glBindVertexBuffer(No array object bound)"); 2153 return; 2154 } 2155 2156 vertex_array_vertex_buffer_err(ctx, ctx->Array.VAO, bindingIndex, 2157 buffer, offset, stride, 2158 "glBindVertexBuffer"); 2159 } 2160 2161 2162 void GLAPIENTRY 2163 _mesa_VertexArrayVertexBuffer_no_error(GLuint vaobj, GLuint bindingIndex, 2164 GLuint buffer, GLintptr offset, 2165 GLsizei stride) 2166 { 2167 GET_CURRENT_CONTEXT(ctx); 2168 2169 struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj); 2170 vertex_array_vertex_buffer(ctx, vao, bindingIndex, buffer, offset, 2171 stride, true, "glVertexArrayVertexBuffer"); 2172 } 2173 2174 2175 void GLAPIENTRY 2176 _mesa_VertexArrayVertexBuffer(GLuint vaobj, GLuint bindingIndex, GLuint buffer, 2177 GLintptr offset, GLsizei stride) 2178 { 2179 GET_CURRENT_CONTEXT(ctx); 2180 struct gl_vertex_array_object *vao; 2181 2182 /* The ARB_direct_state_access specification says: 2183 * 2184 * "An INVALID_OPERATION error is generated by VertexArrayVertexBuffer 2185 * if <vaobj> is not [compatibility profile: zero or] the name of an 2186 * existing vertex array object." 2187 */ 2188 vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayVertexBuffer"); 2189 if (!vao) 2190 return; 2191 2192 vertex_array_vertex_buffer_err(ctx, vao, bindingIndex, buffer, offset, 2193 stride, "glVertexArrayVertexBuffer"); 2194 } 2195 2196 2197 static ALWAYS_INLINE void 2198 vertex_array_vertex_buffers(struct gl_context *ctx, 2199 struct gl_vertex_array_object *vao, 2200 GLuint first, GLsizei count, const GLuint *buffers, 2201 const GLintptr *offsets, const GLsizei *strides, 2202 bool no_error, const char *func) 2203 { 2204 GLint i; 2205 2206 if (!buffers) { 2207 /** 2208 * The ARB_multi_bind spec says: 2209 * 2210 * "If <buffers> is NULL, each affected vertex buffer binding point 2211 * from <first> through <first>+<count>-1 will be reset to have no 2212 * bound buffer object. In this case, the offsets and strides 2213 * associated with the binding points are set to default values, 2214 * ignoring <offsets> and <strides>." 2215 */ 2216 struct gl_buffer_object *vbo = ctx->Shared->NullBufferObj; 2217 2218 for (i = 0; i < count; i++) 2219 _mesa_bind_vertex_buffer(ctx, vao, VERT_ATTRIB_GENERIC(first + i), 2220 vbo, 0, 16); 2221 2222 return; 2223 } 2224 2225 /* Note that the error semantics for multi-bind commands differ from 2226 * those of other GL commands. 2227 * 2228 * The Issues section in the ARB_multi_bind spec says: 2229 * 2230 * "(11) Typically, OpenGL specifies that if an error is generated by 2231 * a command, that command has no effect. This is somewhat 2232 * unfortunate for multi-bind commands, because it would require 2233 * a first pass to scan the entire list of bound objects for 2234 * errors and then a second pass to actually perform the 2235 * bindings. Should we have different error semantics? 2236 * 2237 * RESOLVED: Yes. In this specification, when the parameters for 2238 * one of the <count> binding points are invalid, that binding 2239 * point is not updated and an error will be generated. However, 2240 * other binding points in the same command will be updated if 2241 * their parameters are valid and no other error occurs." 2242 */ 2243 2244 _mesa_HashLockMutex(ctx->Shared->BufferObjects); 2245 2246 for (i = 0; i < count; i++) { 2247 struct gl_buffer_object *vbo; 2248 2249 if (!no_error) { 2250 /* The ARB_multi_bind spec says: 2251 * 2252 * "An INVALID_VALUE error is generated if any value in 2253 * <offsets> or <strides> is negative (per binding)." 2254 */ 2255 if (offsets[i] < 0) { 2256 _mesa_error(ctx, GL_INVALID_VALUE, 2257 "%s(offsets[%u]=%" PRId64 " < 0)", 2258 func, i, (int64_t) offsets[i]); 2259 continue; 2260 } 2261 2262 if (strides[i] < 0) { 2263 _mesa_error(ctx, GL_INVALID_VALUE, 2264 "%s(strides[%u]=%d < 0)", 2265 func, i, strides[i]); 2266 continue; 2267 } 2268 2269 if (ctx->API == API_OPENGL_CORE && ctx->Version >= 44 && 2270 strides[i] > ctx->Const.MaxVertexAttribStride) { 2271 _mesa_error(ctx, GL_INVALID_VALUE, 2272 "%s(strides[%u]=%d > " 2273 "GL_MAX_VERTEX_ATTRIB_STRIDE)", func, i, strides[i]); 2274 continue; 2275 } 2276 } 2277 2278 if (buffers[i]) { 2279 struct gl_vertex_buffer_binding *binding = 2280 &vao->BufferBinding[VERT_ATTRIB_GENERIC(first + i)]; 2281 2282 if (buffers[i] == binding->BufferObj->Name) 2283 vbo = binding->BufferObj; 2284 else 2285 vbo = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i, func); 2286 2287 if (!vbo) 2288 continue; 2289 } else { 2290 vbo = ctx->Shared->NullBufferObj; 2291 } 2292 2293 _mesa_bind_vertex_buffer(ctx, vao, VERT_ATTRIB_GENERIC(first + i), 2294 vbo, offsets[i], strides[i]); 2295 } 2296 2297 _mesa_HashUnlockMutex(ctx->Shared->BufferObjects); 2298 } 2299 2300 2301 static void 2302 vertex_array_vertex_buffers_err(struct gl_context *ctx, 2303 struct gl_vertex_array_object *vao, 2304 GLuint first, GLsizei count, 2305 const GLuint *buffers, const GLintptr *offsets, 2306 const GLsizei *strides, const char *func) 2307 { 2308 ASSERT_OUTSIDE_BEGIN_END(ctx); 2309 2310 /* The ARB_multi_bind spec says: 2311 * 2312 * "An INVALID_OPERATION error is generated if <first> + <count> 2313 * is greater than the value of MAX_VERTEX_ATTRIB_BINDINGS." 2314 */ 2315 if (first + count > ctx->Const.MaxVertexAttribBindings) { 2316 _mesa_error(ctx, GL_INVALID_OPERATION, 2317 "%s(first=%u + count=%d > the value of " 2318 "GL_MAX_VERTEX_ATTRIB_BINDINGS=%u)", 2319 func, first, count, ctx->Const.MaxVertexAttribBindings); 2320 return; 2321 } 2322 2323 vertex_array_vertex_buffers(ctx, vao, first, count, buffers, offsets, 2324 strides, false, func); 2325 } 2326 2327 2328 void GLAPIENTRY 2329 _mesa_BindVertexBuffers_no_error(GLuint first, GLsizei count, 2330 const GLuint *buffers, const GLintptr *offsets, 2331 const GLsizei *strides) 2332 { 2333 GET_CURRENT_CONTEXT(ctx); 2334 2335 vertex_array_vertex_buffers(ctx, ctx->Array.VAO, first, count, 2336 buffers, offsets, strides, true, 2337 "glBindVertexBuffers"); 2338 } 2339 2340 2341 void GLAPIENTRY 2342 _mesa_BindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, 2343 const GLintptr *offsets, const GLsizei *strides) 2344 { 2345 GET_CURRENT_CONTEXT(ctx); 2346 2347 /* The ARB_vertex_attrib_binding spec says: 2348 * 2349 * "An INVALID_OPERATION error is generated if no 2350 * vertex array object is bound." 2351 */ 2352 if (ctx->API == API_OPENGL_CORE && 2353 ctx->Array.VAO == ctx->Array.DefaultVAO) { 2354 _mesa_error(ctx, GL_INVALID_OPERATION, 2355 "glBindVertexBuffers(No array object bound)"); 2356 return; 2357 } 2358 2359 vertex_array_vertex_buffers_err(ctx, ctx->Array.VAO, first, count, 2360 buffers, offsets, strides, 2361 "glBindVertexBuffers"); 2362 } 2363 2364 2365 void GLAPIENTRY 2366 _mesa_VertexArrayVertexBuffers_no_error(GLuint vaobj, GLuint first, 2367 GLsizei count, const GLuint *buffers, 2368 const GLintptr *offsets, 2369 const GLsizei *strides) 2370 { 2371 GET_CURRENT_CONTEXT(ctx); 2372 2373 struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj); 2374 vertex_array_vertex_buffers(ctx, vao, first, count, 2375 buffers, offsets, strides, true, 2376 "glVertexArrayVertexBuffers"); 2377 } 2378 2379 2380 void GLAPIENTRY 2381 _mesa_VertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, 2382 const GLuint *buffers, 2383 const GLintptr *offsets, const GLsizei *strides) 2384 { 2385 GET_CURRENT_CONTEXT(ctx); 2386 struct gl_vertex_array_object *vao; 2387 2388 /* The ARB_direct_state_access specification says: 2389 * 2390 * "An INVALID_OPERATION error is generated by VertexArrayVertexBuffer 2391 * if <vaobj> is not [compatibility profile: zero or] the name of an 2392 * existing vertex array object." 2393 */ 2394 vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayVertexBuffers"); 2395 if (!vao) 2396 return; 2397 2398 vertex_array_vertex_buffers_err(ctx, vao, first, count, 2399 buffers, offsets, strides, 2400 "glVertexArrayVertexBuffers"); 2401 } 2402 2403 2404 static void 2405 vertex_attrib_format(GLuint attribIndex, GLint size, GLenum type, 2406 GLboolean normalized, GLboolean integer, 2407 GLboolean doubles, GLbitfield legalTypes, 2408 GLsizei sizeMax, GLuint relativeOffset, 2409 const char *func) 2410 { 2411 GET_CURRENT_CONTEXT(ctx); 2412 ASSERT_OUTSIDE_BEGIN_END(ctx); 2413 2414 GLenum format = get_array_format(ctx, sizeMax, &size); 2415 2416 if (!_mesa_is_no_error_enabled(ctx)) { 2417 /* The ARB_vertex_attrib_binding spec says: 2418 * 2419 * "An INVALID_OPERATION error is generated under any of the 2420 * following conditions: 2421 * - if no vertex array object is currently bound (see section 2422 * 2.10); 2423 * - ..." 2424 * 2425 * This error condition only applies to VertexAttribFormat and 2426 * VertexAttribIFormat in the extension spec, but we assume that this 2427 * is an oversight. In the OpenGL 4.3 (Core Profile) spec, it applies 2428 * to all three functions. 2429 */ 2430 if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) && 2431 ctx->Array.VAO == ctx->Array.DefaultVAO) { 2432 _mesa_error(ctx, GL_INVALID_OPERATION, 2433 "%s(No array object bound)", func); 2434 return; 2435 } 2436 2437 /* The ARB_vertex_attrib_binding spec says: 2438 * 2439 * "The error INVALID_VALUE is generated if index is greater than or 2440 * equal to the value of MAX_VERTEX_ATTRIBS." 2441 */ 2442 if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 2443 _mesa_error(ctx, GL_INVALID_VALUE, 2444 "%s(attribindex=%u > " 2445 "GL_MAX_VERTEX_ATTRIBS)", 2446 func, attribIndex); 2447 return; 2448 } 2449 2450 if (!validate_array_format(ctx, func, ctx->Array.VAO, 2451 VERT_ATTRIB_GENERIC(attribIndex), 2452 legalTypes, 1, sizeMax, size, type, 2453 normalized, integer, doubles, relativeOffset, 2454 format)) { 2455 return; 2456 } 2457 } 2458 2459 FLUSH_VERTICES(ctx, 0); 2460 2461 _mesa_update_array_format(ctx, ctx->Array.VAO, 2462 VERT_ATTRIB_GENERIC(attribIndex), size, type, 2463 format, normalized, integer, doubles, 2464 relativeOffset); 2465 } 2466 2467 2468 void GLAPIENTRY 2469 _mesa_VertexAttribFormat(GLuint attribIndex, GLint size, GLenum type, 2470 GLboolean normalized, GLuint relativeOffset) 2471 { 2472 vertex_attrib_format(attribIndex, size, type, normalized, 2473 GL_FALSE, GL_FALSE, ATTRIB_FORMAT_TYPES_MASK, 2474 BGRA_OR_4, relativeOffset, 2475 "glVertexAttribFormat"); 2476 } 2477 2478 2479 void GLAPIENTRY 2480 _mesa_VertexAttribIFormat(GLuint attribIndex, GLint size, GLenum type, 2481 GLuint relativeOffset) 2482 { 2483 vertex_attrib_format(attribIndex, size, type, GL_FALSE, 2484 GL_TRUE, GL_FALSE, ATTRIB_IFORMAT_TYPES_MASK, 4, 2485 relativeOffset, "glVertexAttribIFormat"); 2486 } 2487 2488 2489 void GLAPIENTRY 2490 _mesa_VertexAttribLFormat(GLuint attribIndex, GLint size, GLenum type, 2491 GLuint relativeOffset) 2492 { 2493 vertex_attrib_format(attribIndex, size, type, GL_FALSE, GL_FALSE, 2494 GL_TRUE, ATTRIB_LFORMAT_TYPES_MASK, 4, 2495 relativeOffset, "glVertexAttribLFormat"); 2496 } 2497 2498 2499 static void 2500 vertex_array_attrib_format(GLuint vaobj, GLuint attribIndex, GLint size, 2501 GLenum type, GLboolean normalized, 2502 GLboolean integer, GLboolean doubles, 2503 GLbitfield legalTypes, GLsizei sizeMax, 2504 GLuint relativeOffset, const char *func) 2505 { 2506 GET_CURRENT_CONTEXT(ctx); 2507 struct gl_vertex_array_object *vao; 2508 2509 ASSERT_OUTSIDE_BEGIN_END(ctx); 2510 2511 GLenum format = get_array_format(ctx, sizeMax, &size); 2512 2513 if (_mesa_is_no_error_enabled(ctx)) { 2514 vao = _mesa_lookup_vao(ctx, vaobj); 2515 if (!vao) 2516 return; 2517 } else { 2518 /* The ARB_direct_state_access spec says: 2519 * 2520 * "An INVALID_OPERATION error is generated by 2521 * VertexArrayAttrib*Format if <vaobj> is not [compatibility profile: 2522 * zero or] the name of an existing vertex array object." 2523 */ 2524 vao = _mesa_lookup_vao_err(ctx, vaobj, func); 2525 if (!vao) 2526 return; 2527 2528 /* The ARB_vertex_attrib_binding spec says: 2529 * 2530 * "The error INVALID_VALUE is generated if index is greater than or 2531 * equal to the value of MAX_VERTEX_ATTRIBS." 2532 */ 2533 if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 2534 _mesa_error(ctx, GL_INVALID_VALUE, 2535 "%s(attribindex=%u > GL_MAX_VERTEX_ATTRIBS)", 2536 func, attribIndex); 2537 return; 2538 } 2539 2540 if (!validate_array_format(ctx, func, vao, 2541 VERT_ATTRIB_GENERIC(attribIndex), 2542 legalTypes, 1, sizeMax, size, type, 2543 normalized, integer, doubles, relativeOffset, 2544 format)) { 2545 return; 2546 } 2547 } 2548 2549 FLUSH_VERTICES(ctx, 0); 2550 2551 _mesa_update_array_format(ctx, vao, VERT_ATTRIB_GENERIC(attribIndex), size, 2552 type, format, normalized, integer, doubles, 2553 relativeOffset); 2554 } 2555 2556 2557 void GLAPIENTRY 2558 _mesa_VertexArrayAttribFormat(GLuint vaobj, GLuint attribIndex, GLint size, 2559 GLenum type, GLboolean normalized, 2560 GLuint relativeOffset) 2561 { 2562 vertex_array_attrib_format(vaobj, attribIndex, size, type, normalized, 2563 GL_FALSE, GL_FALSE, ATTRIB_FORMAT_TYPES_MASK, 2564 BGRA_OR_4, relativeOffset, 2565 "glVertexArrayAttribFormat"); 2566 } 2567 2568 2569 void GLAPIENTRY 2570 _mesa_VertexArrayAttribIFormat(GLuint vaobj, GLuint attribIndex, 2571 GLint size, GLenum type, 2572 GLuint relativeOffset) 2573 { 2574 vertex_array_attrib_format(vaobj, attribIndex, size, type, GL_FALSE, 2575 GL_TRUE, GL_FALSE, ATTRIB_IFORMAT_TYPES_MASK, 2576 4, relativeOffset, 2577 "glVertexArrayAttribIFormat"); 2578 } 2579 2580 2581 void GLAPIENTRY 2582 _mesa_VertexArrayAttribLFormat(GLuint vaobj, GLuint attribIndex, 2583 GLint size, GLenum type, 2584 GLuint relativeOffset) 2585 { 2586 vertex_array_attrib_format(vaobj, attribIndex, size, type, GL_FALSE, 2587 GL_FALSE, GL_TRUE, ATTRIB_LFORMAT_TYPES_MASK, 2588 4, relativeOffset, 2589 "glVertexArrayAttribLFormat"); 2590 } 2591 2592 2593 static void 2594 vertex_array_attrib_binding(struct gl_context *ctx, 2595 struct gl_vertex_array_object *vao, 2596 GLuint attribIndex, GLuint bindingIndex, 2597 const char *func) 2598 { 2599 ASSERT_OUTSIDE_BEGIN_END(ctx); 2600 2601 /* The ARB_vertex_attrib_binding spec says: 2602 * 2603 * "<attribindex> must be less than the value of MAX_VERTEX_ATTRIBS and 2604 * <bindingindex> must be less than the value of 2605 * MAX_VERTEX_ATTRIB_BINDINGS, otherwise the error INVALID_VALUE 2606 * is generated." 2607 */ 2608 if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) { 2609 _mesa_error(ctx, GL_INVALID_VALUE, 2610 "%s(attribindex=%u >= " 2611 "GL_MAX_VERTEX_ATTRIBS)", 2612 func, attribIndex); 2613 return; 2614 } 2615 2616 if (bindingIndex >= ctx->Const.MaxVertexAttribBindings) { 2617 _mesa_error(ctx, GL_INVALID_VALUE, 2618 "%s(bindingindex=%u >= " 2619 "GL_MAX_VERTEX_ATTRIB_BINDINGS)", 2620 func, bindingIndex); 2621 return; 2622 } 2623 2624 assert(VERT_ATTRIB_GENERIC(attribIndex) < ARRAY_SIZE(vao->VertexAttrib)); 2625 2626 vertex_attrib_binding(ctx, vao, 2627 VERT_ATTRIB_GENERIC(attribIndex), 2628 VERT_ATTRIB_GENERIC(bindingIndex)); 2629 } 2630 2631 2632 void GLAPIENTRY 2633 _mesa_VertexAttribBinding_no_error(GLuint attribIndex, GLuint bindingIndex) 2634 { 2635 GET_CURRENT_CONTEXT(ctx); 2636 vertex_attrib_binding(ctx, ctx->Array.VAO, 2637 VERT_ATTRIB_GENERIC(attribIndex), 2638 VERT_ATTRIB_GENERIC(bindingIndex)); 2639 } 2640 2641 2642 void GLAPIENTRY 2643 _mesa_VertexAttribBinding(GLuint attribIndex, GLuint bindingIndex) 2644 { 2645 GET_CURRENT_CONTEXT(ctx); 2646 2647 /* The ARB_vertex_attrib_binding spec says: 2648 * 2649 * "An INVALID_OPERATION error is generated if no vertex array object 2650 * is bound." 2651 */ 2652 if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) && 2653 ctx->Array.VAO == ctx->Array.DefaultVAO) { 2654 _mesa_error(ctx, GL_INVALID_OPERATION, 2655 "glVertexAttribBinding(No array object bound)"); 2656 return; 2657 } 2658 2659 vertex_array_attrib_binding(ctx, ctx->Array.VAO, 2660 attribIndex, bindingIndex, 2661 "glVertexAttribBinding"); 2662 } 2663 2664 2665 void GLAPIENTRY 2666 _mesa_VertexArrayAttribBinding_no_error(GLuint vaobj, GLuint attribIndex, 2667 GLuint bindingIndex) 2668 { 2669 GET_CURRENT_CONTEXT(ctx); 2670 2671 struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj); 2672 vertex_attrib_binding(ctx, vao, 2673 VERT_ATTRIB_GENERIC(attribIndex), 2674 VERT_ATTRIB_GENERIC(bindingIndex)); 2675 } 2676 2677 2678 void GLAPIENTRY 2679 _mesa_VertexArrayAttribBinding(GLuint vaobj, GLuint attribIndex, GLuint bindingIndex) 2680 { 2681 GET_CURRENT_CONTEXT(ctx); 2682 struct gl_vertex_array_object *vao; 2683 2684 /* The ARB_direct_state_access specification says: 2685 * 2686 * "An INVALID_OPERATION error is generated by VertexArrayAttribBinding 2687 * if <vaobj> is not [compatibility profile: zero or] the name of an 2688 * existing vertex array object." 2689 */ 2690 vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayAttribBinding"); 2691 if (!vao) 2692 return; 2693 2694 vertex_array_attrib_binding(ctx, vao, attribIndex, bindingIndex, 2695 "glVertexArrayAttribBinding"); 2696 } 2697 2698 2699 static void 2700 vertex_array_binding_divisor(struct gl_context *ctx, 2701 struct gl_vertex_array_object *vao, 2702 GLuint bindingIndex, GLuint divisor, 2703 const char *func) 2704 { 2705 ASSERT_OUTSIDE_BEGIN_END(ctx); 2706 2707 if (!ctx->Extensions.ARB_instanced_arrays) { 2708 _mesa_error(ctx, GL_INVALID_OPERATION, "%s()", func); 2709 return; 2710 } 2711 2712 /* The ARB_vertex_attrib_binding spec says: 2713 * 2714 * "An INVALID_VALUE error is generated if <bindingindex> is greater 2715 * than or equal to the value of MAX_VERTEX_ATTRIB_BINDINGS." 2716 */ 2717 if (bindingIndex >= ctx->Const.MaxVertexAttribBindings) { 2718 _mesa_error(ctx, GL_INVALID_VALUE, 2719 "%s(bindingindex=%u > " 2720 "GL_MAX_VERTEX_ATTRIB_BINDINGS)", 2721 func, bindingIndex); 2722 return; 2723 } 2724 2725 vertex_binding_divisor(ctx, vao, VERT_ATTRIB_GENERIC(bindingIndex), divisor); 2726 } 2727 2728 2729 void GLAPIENTRY 2730 _mesa_VertexBindingDivisor_no_error(GLuint bindingIndex, GLuint divisor) 2731 { 2732 GET_CURRENT_CONTEXT(ctx); 2733 vertex_binding_divisor(ctx, ctx->Array.VAO, 2734 VERT_ATTRIB_GENERIC(bindingIndex), divisor); 2735 } 2736 2737 2738 void GLAPIENTRY 2739 _mesa_VertexBindingDivisor(GLuint bindingIndex, GLuint divisor) 2740 { 2741 GET_CURRENT_CONTEXT(ctx); 2742 2743 /* The ARB_vertex_attrib_binding spec says: 2744 * 2745 * "An INVALID_OPERATION error is generated if no vertex array object 2746 * is bound." 2747 */ 2748 if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) && 2749 ctx->Array.VAO == ctx->Array.DefaultVAO) { 2750 _mesa_error(ctx, GL_INVALID_OPERATION, 2751 "glVertexBindingDivisor(No array object bound)"); 2752 return; 2753 } 2754 2755 vertex_array_binding_divisor(ctx, ctx->Array.VAO, 2756 bindingIndex, divisor, 2757 "glVertexBindingDivisor"); 2758 } 2759 2760 2761 void GLAPIENTRY 2762 _mesa_VertexArrayBindingDivisor_no_error(GLuint vaobj, GLuint bindingIndex, 2763 GLuint divisor) 2764 { 2765 GET_CURRENT_CONTEXT(ctx); 2766 2767 struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj); 2768 vertex_binding_divisor(ctx, vao, VERT_ATTRIB_GENERIC(bindingIndex), divisor); 2769 } 2770 2771 2772 void GLAPIENTRY 2773 _mesa_VertexArrayBindingDivisor(GLuint vaobj, GLuint bindingIndex, 2774 GLuint divisor) 2775 { 2776 struct gl_vertex_array_object *vao; 2777 GET_CURRENT_CONTEXT(ctx); 2778 2779 /* The ARB_direct_state_access specification says: 2780 * 2781 * "An INVALID_OPERATION error is generated by VertexArrayBindingDivisor 2782 * if <vaobj> is not [compatibility profile: zero or] the name of an 2783 * existing vertex array object." 2784 */ 2785 vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayBindingDivisor"); 2786 if (!vao) 2787 return; 2788 2789 vertex_array_binding_divisor(ctx, vao, bindingIndex, divisor, 2790 "glVertexArrayBindingDivisor"); 2791 } 2792 2793 2794 /** 2795 * Copy one client vertex array to another. 2796 */ 2797 void 2798 _mesa_copy_client_array(struct gl_context *ctx, 2799 struct gl_vertex_array *dst, 2800 struct gl_vertex_array *src) 2801 { 2802 dst->Size = src->Size; 2803 dst->Type = src->Type; 2804 dst->Format = src->Format; 2805 dst->StrideB = src->StrideB; 2806 dst->Ptr = src->Ptr; 2807 dst->Normalized = src->Normalized; 2808 dst->Integer = src->Integer; 2809 dst->Doubles = src->Doubles; 2810 dst->InstanceDivisor = src->InstanceDivisor; 2811 dst->_ElementSize = src->_ElementSize; 2812 _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj); 2813 } 2814 2815 void 2816 _mesa_copy_vertex_attrib_array(struct gl_context *ctx, 2817 struct gl_array_attributes *dst, 2818 const struct gl_array_attributes *src) 2819 { 2820 dst->Size = src->Size; 2821 dst->Type = src->Type; 2822 dst->Format = src->Format; 2823 dst->BufferBindingIndex = src->BufferBindingIndex; 2824 dst->RelativeOffset = src->RelativeOffset; 2825 dst->Format = src->Format; 2826 dst->Integer = src->Integer; 2827 dst->Doubles = src->Doubles; 2828 dst->Normalized = src->Normalized; 2829 dst->Ptr = src->Ptr; 2830 dst->Enabled = src->Enabled; 2831 dst->_ElementSize = src->_ElementSize; 2832 } 2833 2834 void 2835 _mesa_copy_vertex_buffer_binding(struct gl_context *ctx, 2836 struct gl_vertex_buffer_binding *dst, 2837 const struct gl_vertex_buffer_binding *src) 2838 { 2839 dst->Offset = src->Offset; 2840 dst->Stride = src->Stride; 2841 dst->InstanceDivisor = src->InstanceDivisor; 2842 dst->_BoundArrays = src->_BoundArrays; 2843 2844 _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj); 2845 } 2846 2847 /** 2848 * Print current vertex object/array info. For debug. 2849 */ 2850 void 2851 _mesa_print_arrays(struct gl_context *ctx) 2852 { 2853 const struct gl_vertex_array_object *vao = ctx->Array.VAO; 2854 2855 fprintf(stderr, "Array Object %u\n", vao->Name); 2856 2857 unsigned i; 2858 for (i = 0; i < VERT_ATTRIB_MAX; ++i) { 2859 const struct gl_array_attributes *array = &vao->VertexAttrib[i]; 2860 if (!array->Enabled) 2861 continue; 2862 2863 const struct gl_vertex_buffer_binding *binding = 2864 &vao->BufferBinding[array->BufferBindingIndex]; 2865 const struct gl_buffer_object *bo = binding->BufferObj; 2866 2867 fprintf(stderr, " %s: Ptr=%p, Type=%s, Size=%d, ElemSize=%u, " 2868 "Stride=%d, Buffer=%u(Size %lu)\n", 2869 gl_vert_attrib_name((gl_vert_attrib)i), 2870 array->Ptr, _mesa_enum_to_string(array->Type), array->Size, 2871 array->_ElementSize, binding->Stride, bo->Name, 2872 (unsigned long) bo->Size); 2873 } 2874 } 2875 2876 2877 /** 2878 * Initialize vertex array state for given context. 2879 */ 2880 void 2881 _mesa_init_varray(struct gl_context *ctx) 2882 { 2883 ctx->Array.DefaultVAO = _mesa_new_vao(ctx, 0); 2884 _mesa_reference_vao(ctx, &ctx->Array.VAO, ctx->Array.DefaultVAO); 2885 ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */ 2886 2887 ctx->Array.Objects = _mesa_NewHashTable(); 2888 } 2889 2890 2891 /** 2892 * Callback for deleting an array object. Called by _mesa_HashDeleteAll(). 2893 */ 2894 static void 2895 delete_arrayobj_cb(GLuint id, void *data, void *userData) 2896 { 2897 struct gl_vertex_array_object *vao = (struct gl_vertex_array_object *) data; 2898 struct gl_context *ctx = (struct gl_context *) userData; 2899 _mesa_delete_vao(ctx, vao); 2900 } 2901 2902 2903 /** 2904 * Free vertex array state for given context. 2905 */ 2906 void 2907 _mesa_free_varray_data(struct gl_context *ctx) 2908 { 2909 _mesa_HashDeleteAll(ctx->Array.Objects, delete_arrayobj_cb, ctx); 2910 _mesa_DeleteHashTable(ctx->Array.Objects); 2911 } 2912
