varray.c revision 2c87030a00eb5b7034f14f6060093d4b264bc5c0
1/* 2 * Mesa 3-D graphics library 3 * Version: 7.6 4 * 5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 6 * Copyright (C) 2009 VMware, Inc. All Rights Reserved. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the "Software"), 10 * to deal in the Software without restriction, including without limitation 11 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 12 * and/or sell copies of the Software, and to permit persons to whom the 13 * Software is furnished to do so, subject to the following conditions: 14 * 15 * The above copyright notice and this permission notice shall be included 16 * in all copies or substantial portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 27#include "glheader.h" 28#include "imports.h" 29#include "bufferobj.h" 30#include "context.h" 31#include "enable.h" 32#include "enums.h" 33#include "hash.h" 34#include "image.h" 35#include "macros.h" 36#include "mfeatures.h" 37#include "mtypes.h" 38#include "varray.h" 39#include "arrayobj.h" 40#include "main/dispatch.h" 41 42 43/** Used to do error checking for GL_EXT_vertex_array_bgra */ 44#define BGRA_OR_4 5 45 46 47/** Used to indicate which GL datatypes are accepted by each of the 48 * glVertex/Color/Attrib/EtcPointer() functions. 49 */ 50#define BOOL_BIT 0x1 51#define BYTE_BIT 0x2 52#define UNSIGNED_BYTE_BIT 0x4 53#define SHORT_BIT 0x8 54#define UNSIGNED_SHORT_BIT 0x10 55#define INT_BIT 0x20 56#define UNSIGNED_INT_BIT 0x40 57#define HALF_BIT 0x80 58#define FLOAT_BIT 0x100 59#define DOUBLE_BIT 0x200 60#define FIXED_ES_BIT 0x400 61#define FIXED_GL_BIT 0x800 62#define UNSIGNED_INT_2_10_10_10_REV_BIT 0x1000 63#define INT_2_10_10_10_REV_BIT 0x2000 64 65 66/** Convert GL datatype enum into a <type>_BIT value seen above */ 67static GLbitfield 68type_to_bit(const struct gl_context *ctx, GLenum type) 69{ 70 switch (type) { 71 case GL_BOOL: 72 return BOOL_BIT; 73 case GL_BYTE: 74 return BYTE_BIT; 75 case GL_UNSIGNED_BYTE: 76 return UNSIGNED_BYTE_BIT; 77 case GL_SHORT: 78 return SHORT_BIT; 79 case GL_UNSIGNED_SHORT: 80 return UNSIGNED_SHORT_BIT; 81 case GL_INT: 82 return INT_BIT; 83 case GL_UNSIGNED_INT: 84 return UNSIGNED_INT_BIT; 85 case GL_HALF_FLOAT: 86 if (ctx->Extensions.ARB_half_float_vertex) 87 return HALF_BIT; 88 else 89 return 0x0; 90 case GL_FLOAT: 91 return FLOAT_BIT; 92 case GL_DOUBLE: 93 return DOUBLE_BIT; 94 case GL_FIXED: 95 return _mesa_is_desktop_gl(ctx) ? FIXED_GL_BIT : FIXED_ES_BIT; 96 case GL_UNSIGNED_INT_2_10_10_10_REV: 97 return UNSIGNED_INT_2_10_10_10_REV_BIT; 98 case GL_INT_2_10_10_10_REV: 99 return INT_2_10_10_10_REV_BIT; 100 default: 101 return 0; 102 } 103} 104 105 106/** 107 * Do error checking and update state for glVertex/Color/TexCoord/...Pointer 108 * functions. 109 * 110 * \param func name of calling function used for error reporting 111 * \param attrib the attribute array index to update 112 * \param legalTypes bitmask of *_BIT above indicating legal datatypes 113 * \param sizeMin min allowable size value 114 * \param sizeMax max allowable size value (may also be BGRA_OR_4) 115 * \param size components per element (1, 2, 3 or 4) 116 * \param type datatype of each component (GL_FLOAT, GL_INT, etc) 117 * \param stride stride between elements, in elements 118 * \param normalized are integer types converted to floats in [-1, 1]? 119 * \param integer integer-valued values (will not be normalized to [-1,1]) 120 * \param ptr the address (or offset inside VBO) of the array data 121 */ 122static void 123update_array(struct gl_context *ctx, 124 const char *func, 125 GLuint attrib, GLbitfield legalTypesMask, 126 GLint sizeMin, GLint sizeMax, 127 GLint size, GLenum type, GLsizei stride, 128 GLboolean normalized, GLboolean integer, 129 const GLvoid *ptr) 130{ 131 struct gl_client_array *array; 132 GLbitfield typeBit; 133 GLsizei elementSize; 134 GLenum format = GL_RGBA; 135 136 if (_mesa_is_gles(ctx)) { 137 /* Once Mesa gets support for GL_OES_vertex_half_float this mask will 138 * change. Adding support for this extension isn't quite as trivial as 139 * we'd like because ES uses a different enum value for GL_HALF_FLOAT. 140 */ 141 legalTypesMask &= ~(FIXED_GL_BIT | HALF_BIT | DOUBLE_BIT); 142 143 /* GL_INT and GL_UNSIGNED_INT data is not allowed in OpenGL ES until 144 * 3.0. The 2_10_10_10 types are added in OpenGL ES 3.0 or 145 * GL_OES_vertex_type_10_10_10_2. 146 */ 147 if (ctx->Version < 30) { 148 legalTypesMask &= ~(UNSIGNED_INT_BIT 149 | INT_BIT 150 | UNSIGNED_INT_2_10_10_10_REV_BIT 151 | INT_2_10_10_10_REV_BIT); 152 } 153 154 /* BGRA ordering is not supported in ES contexts. 155 */ 156 if (sizeMax == BGRA_OR_4) 157 sizeMax = 4; 158 } else { 159 legalTypesMask &= ~FIXED_ES_BIT; 160 161 if (!ctx->Extensions.ARB_ES2_compatibility) 162 legalTypesMask &= ~FIXED_GL_BIT; 163 164 if (!ctx->Extensions.ARB_vertex_type_2_10_10_10_rev) 165 legalTypesMask &= ~(UNSIGNED_INT_2_10_10_10_REV_BIT | 166 INT_2_10_10_10_REV_BIT); 167 } 168 169 typeBit = type_to_bit(ctx, type); 170 if (typeBit == 0x0 || (typeBit & legalTypesMask) == 0x0) { 171 _mesa_error(ctx, GL_INVALID_ENUM, "%s(type = %s)", 172 func, _mesa_lookup_enum_by_nr(type)); 173 return; 174 } 175 176 /* Do size parameter checking. 177 * If sizeMax = BGRA_OR_4 it means that size = GL_BGRA is legal and 178 * must be handled specially. 179 */ 180 if (ctx->Extensions.EXT_vertex_array_bgra && 181 sizeMax == BGRA_OR_4 && 182 size == GL_BGRA) { 183 GLboolean bgra_error = GL_FALSE; 184 185 if (ctx->Extensions.ARB_vertex_type_2_10_10_10_rev) { 186 if (type != GL_UNSIGNED_INT_2_10_10_10_REV && 187 type != GL_INT_2_10_10_10_REV && 188 type != GL_UNSIGNED_BYTE) 189 bgra_error = GL_TRUE; 190 } else if (type != GL_UNSIGNED_BYTE) 191 bgra_error = GL_TRUE; 192 193 if (bgra_error) { 194 _mesa_error(ctx, GL_INVALID_VALUE, "%s(GL_BGRA/GLubyte)", func); 195 return; 196 } 197 format = GL_BGRA; 198 size = 4; 199 } 200 else if (size < sizeMin || size > sizeMax || size > 4) { 201 _mesa_error(ctx, GL_INVALID_VALUE, "%s(size=%d)", func, size); 202 return; 203 } 204 205 if (ctx->Extensions.ARB_vertex_type_2_10_10_10_rev && 206 (type == GL_UNSIGNED_INT_2_10_10_10_REV || 207 type == GL_INT_2_10_10_10_REV) && size != 4) { 208 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(size=%d)", func, size); 209 return; 210 } 211 212 ASSERT(size <= 4); 213 214 if (stride < 0) { 215 _mesa_error( ctx, GL_INVALID_VALUE, "%s(stride=%d)", func, stride ); 216 return; 217 } 218 219 if (ctx->Array.ArrayObj->ARBsemantics && 220 !_mesa_is_bufferobj(ctx->Array.ArrayBufferObj)) { 221 /* GL_ARB_vertex_array_object requires that all arrays reside in VBOs. 222 * Generate GL_INVALID_OPERATION if that's not true. 223 */ 224 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-VBO array)", func); 225 return; 226 } 227 228 elementSize = _mesa_sizeof_type(type) * size; 229 230 array = &ctx->Array.ArrayObj->VertexAttrib[attrib]; 231 array->Size = size; 232 array->Type = type; 233 array->Format = format; 234 array->Stride = stride; 235 array->StrideB = stride ? stride : elementSize; 236 array->Normalized = normalized; 237 array->Integer = integer; 238 array->Ptr = (const GLubyte *) ptr; 239 array->_ElementSize = elementSize; 240 241 _mesa_reference_buffer_object(ctx, &array->BufferObj, 242 ctx->Array.ArrayBufferObj); 243 244 ctx->NewState |= _NEW_ARRAY; 245 ctx->Array.ArrayObj->NewArrays |= VERT_BIT(attrib); 246} 247 248 249void GLAPIENTRY 250_mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) 251{ 252 GET_CURRENT_CONTEXT(ctx); 253 GLbitfield legalTypes = (ctx->API == API_OPENGLES) 254 ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT) 255 : (SHORT_BIT | INT_BIT | FLOAT_BIT | 256 DOUBLE_BIT | HALF_BIT | 257 UNSIGNED_INT_2_10_10_10_REV_BIT | 258 INT_2_10_10_10_REV_BIT); 259 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 260 261 update_array(ctx, "glVertexPointer", VERT_ATTRIB_POS, 262 legalTypes, 2, 4, 263 size, type, stride, GL_FALSE, GL_FALSE, ptr); 264} 265 266 267void GLAPIENTRY 268_mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr ) 269{ 270 GET_CURRENT_CONTEXT(ctx); 271 const GLbitfield legalTypes = (ctx->API == API_OPENGLES) 272 ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT) 273 : (BYTE_BIT | SHORT_BIT | INT_BIT | 274 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 275 UNSIGNED_INT_2_10_10_10_REV_BIT | 276 INT_2_10_10_10_REV_BIT); 277 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 278 279 update_array(ctx, "glNormalPointer", VERT_ATTRIB_NORMAL, 280 legalTypes, 3, 3, 281 3, type, stride, GL_TRUE, GL_FALSE, ptr); 282} 283 284 285void GLAPIENTRY 286_mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) 287{ 288 GET_CURRENT_CONTEXT(ctx); 289 const GLbitfield legalTypes = (ctx->API == API_OPENGLES) 290 ? (UNSIGNED_BYTE_BIT | HALF_BIT | FLOAT_BIT | FIXED_ES_BIT) 291 : (BYTE_BIT | UNSIGNED_BYTE_BIT | 292 SHORT_BIT | UNSIGNED_SHORT_BIT | 293 INT_BIT | UNSIGNED_INT_BIT | 294 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 295 UNSIGNED_INT_2_10_10_10_REV_BIT | 296 INT_2_10_10_10_REV_BIT); 297 const GLint sizeMin = (ctx->API == API_OPENGLES) ? 4 : 3; 298 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 299 300 update_array(ctx, "glColorPointer", VERT_ATTRIB_COLOR0, 301 legalTypes, sizeMin, BGRA_OR_4, 302 size, type, stride, GL_TRUE, GL_FALSE, ptr); 303} 304 305 306void GLAPIENTRY 307_mesa_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr) 308{ 309 const GLbitfield legalTypes = (HALF_BIT | FLOAT_BIT | DOUBLE_BIT); 310 GET_CURRENT_CONTEXT(ctx); 311 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 312 313 update_array(ctx, "glFogCoordPointer", VERT_ATTRIB_FOG, 314 legalTypes, 1, 1, 315 1, type, stride, GL_FALSE, GL_FALSE, ptr); 316} 317 318 319void GLAPIENTRY 320_mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr) 321{ 322 const GLbitfield legalTypes = (UNSIGNED_BYTE_BIT | SHORT_BIT | INT_BIT | 323 FLOAT_BIT | DOUBLE_BIT); 324 GET_CURRENT_CONTEXT(ctx); 325 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 326 327 update_array(ctx, "glIndexPointer", VERT_ATTRIB_COLOR_INDEX, 328 legalTypes, 1, 1, 329 1, type, stride, GL_FALSE, GL_FALSE, ptr); 330} 331 332 333void GLAPIENTRY 334_mesa_SecondaryColorPointerEXT(GLint size, GLenum type, 335 GLsizei stride, const GLvoid *ptr) 336{ 337 const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT | 338 SHORT_BIT | UNSIGNED_SHORT_BIT | 339 INT_BIT | UNSIGNED_INT_BIT | 340 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 341 UNSIGNED_INT_2_10_10_10_REV_BIT | 342 INT_2_10_10_10_REV_BIT); 343 GET_CURRENT_CONTEXT(ctx); 344 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 345 346 update_array(ctx, "glSecondaryColorPointer", VERT_ATTRIB_COLOR1, 347 legalTypes, 3, BGRA_OR_4, 348 size, type, stride, GL_TRUE, GL_FALSE, ptr); 349} 350 351 352void GLAPIENTRY 353_mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride, 354 const GLvoid *ptr) 355{ 356 GET_CURRENT_CONTEXT(ctx); 357 GLbitfield legalTypes = (ctx->API == API_OPENGLES) 358 ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT) 359 : (SHORT_BIT | INT_BIT | 360 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 361 UNSIGNED_INT_2_10_10_10_REV_BIT | 362 INT_2_10_10_10_REV_BIT); 363 const GLint sizeMin = (ctx->API == API_OPENGLES) ? 2 : 1; 364 const GLuint unit = ctx->Array.ActiveTexture; 365 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 366 367 update_array(ctx, "glTexCoordPointer", VERT_ATTRIB_TEX(unit), 368 legalTypes, sizeMin, 4, 369 size, type, stride, GL_FALSE, GL_FALSE, 370 ptr); 371} 372 373 374void GLAPIENTRY 375_mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr) 376{ 377 const GLbitfield legalTypes = UNSIGNED_BYTE_BIT; 378 /* see table 2.4 edits in GL_EXT_gpu_shader4 spec: */ 379 const GLboolean integer = GL_TRUE; 380 GET_CURRENT_CONTEXT(ctx); 381 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 382 383 update_array(ctx, "glEdgeFlagPointer", VERT_ATTRIB_EDGEFLAG, 384 legalTypes, 1, 1, 385 1, GL_UNSIGNED_BYTE, stride, GL_FALSE, integer, ptr); 386} 387 388 389void GLAPIENTRY 390_mesa_PointSizePointer(GLenum type, GLsizei stride, const GLvoid *ptr) 391{ 392 const GLbitfield legalTypes = (FLOAT_BIT | FIXED_ES_BIT); 393 GET_CURRENT_CONTEXT(ctx); 394 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 395 396 if (ctx->API != API_OPENGLES) { 397 _mesa_error(ctx, GL_INVALID_OPERATION, 398 "glPointSizePointer(ES 1.x only)"); 399 return; 400 } 401 402 update_array(ctx, "glPointSizePointer", VERT_ATTRIB_POINT_SIZE, 403 legalTypes, 1, 1, 404 1, type, stride, GL_FALSE, GL_FALSE, ptr); 405} 406 407 408#if FEATURE_NV_vertex_program 409/** 410 * Set a vertex attribute array. 411 * Note that these arrays DO alias the conventional GL vertex arrays 412 * (position, normal, color, fog, texcoord, etc). 413 * The generic attribute slots at #16 and above are not touched. 414 */ 415void GLAPIENTRY 416_mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type, 417 GLsizei stride, const GLvoid *ptr) 418{ 419 const GLbitfield legalTypes = (UNSIGNED_BYTE_BIT | SHORT_BIT | 420 FLOAT_BIT | DOUBLE_BIT); 421 GLboolean normalized = GL_FALSE; 422 GET_CURRENT_CONTEXT(ctx); 423 ASSERT_OUTSIDE_BEGIN_END(ctx); 424 425 if (index >= MAX_NV_VERTEX_PROGRAM_INPUTS) { 426 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerNV(index)"); 427 return; 428 } 429 430 if (type == GL_UNSIGNED_BYTE && size != 4) { 431 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerNV(size!=4)"); 432 return; 433 } 434 435 update_array(ctx, "glVertexAttribPointerNV", VERT_ATTRIB_GENERIC(index), 436 legalTypes, 1, BGRA_OR_4, 437 size, type, stride, normalized, GL_FALSE, ptr); 438} 439#endif 440 441 442#if FEATURE_ARB_vertex_program 443/** 444 * Set a generic vertex attribute array. 445 * Note that these arrays DO NOT alias the conventional GL vertex arrays 446 * (position, normal, color, fog, texcoord, etc). 447 */ 448void GLAPIENTRY 449_mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type, 450 GLboolean normalized, 451 GLsizei stride, const GLvoid *ptr) 452{ 453 const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT | 454 SHORT_BIT | UNSIGNED_SHORT_BIT | 455 INT_BIT | UNSIGNED_INT_BIT | 456 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | 457 FIXED_ES_BIT | FIXED_GL_BIT | 458 UNSIGNED_INT_2_10_10_10_REV_BIT | 459 INT_2_10_10_10_REV_BIT); 460 GET_CURRENT_CONTEXT(ctx); 461 ASSERT_OUTSIDE_BEGIN_END(ctx); 462 463 if (index >= ctx->Const.VertexProgram.MaxAttribs) { 464 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(index)"); 465 return; 466 } 467 468 update_array(ctx, "glVertexAttribPointer", VERT_ATTRIB_GENERIC(index), 469 legalTypes, 1, BGRA_OR_4, 470 size, type, stride, normalized, GL_FALSE, ptr); 471} 472#endif 473 474 475/** 476 * GL_EXT_gpu_shader4 / GL 3.0. 477 * Set an integer-valued vertex attribute array. 478 * Note that these arrays DO NOT alias the conventional GL vertex arrays 479 * (position, normal, color, fog, texcoord, etc). 480 */ 481void GLAPIENTRY 482_mesa_VertexAttribIPointer(GLuint index, GLint size, GLenum type, 483 GLsizei stride, const GLvoid *ptr) 484{ 485 const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT | 486 SHORT_BIT | UNSIGNED_SHORT_BIT | 487 INT_BIT | UNSIGNED_INT_BIT); 488 const GLboolean normalized = GL_FALSE; 489 const GLboolean integer = GL_TRUE; 490 GET_CURRENT_CONTEXT(ctx); 491 ASSERT_OUTSIDE_BEGIN_END(ctx); 492 493 if (index >= ctx->Const.VertexProgram.MaxAttribs) { 494 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribIPointer(index)"); 495 return; 496 } 497 498 update_array(ctx, "glVertexAttribIPointer", VERT_ATTRIB_GENERIC(index), 499 legalTypes, 1, 4, 500 size, type, stride, normalized, integer, ptr); 501} 502 503 504 505void GLAPIENTRY 506_mesa_EnableVertexAttribArrayARB(GLuint index) 507{ 508 struct gl_array_object *arrayObj; 509 GET_CURRENT_CONTEXT(ctx); 510 ASSERT_OUTSIDE_BEGIN_END(ctx); 511 512 if (index >= ctx->Const.VertexProgram.MaxAttribs) { 513 _mesa_error(ctx, GL_INVALID_VALUE, 514 "glEnableVertexAttribArrayARB(index)"); 515 return; 516 } 517 518 arrayObj = ctx->Array.ArrayObj; 519 520 ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(arrayObj->VertexAttrib)); 521 522 if (!arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled) { 523 /* was disabled, now being enabled */ 524 FLUSH_VERTICES(ctx, _NEW_ARRAY); 525 arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled = GL_TRUE; 526 arrayObj->_Enabled |= VERT_BIT_GENERIC(index); 527 arrayObj->NewArrays |= VERT_BIT_GENERIC(index); 528 } 529} 530 531 532void GLAPIENTRY 533_mesa_DisableVertexAttribArrayARB(GLuint index) 534{ 535 struct gl_array_object *arrayObj; 536 GET_CURRENT_CONTEXT(ctx); 537 ASSERT_OUTSIDE_BEGIN_END(ctx); 538 539 if (index >= ctx->Const.VertexProgram.MaxAttribs) { 540 _mesa_error(ctx, GL_INVALID_VALUE, 541 "glDisableVertexAttribArrayARB(index)"); 542 return; 543 } 544 545 arrayObj = ctx->Array.ArrayObj; 546 547 ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(arrayObj->VertexAttrib)); 548 549 if (arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled) { 550 /* was enabled, now being disabled */ 551 FLUSH_VERTICES(ctx, _NEW_ARRAY); 552 arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled = GL_FALSE; 553 arrayObj->_Enabled &= ~VERT_BIT_GENERIC(index); 554 arrayObj->NewArrays |= VERT_BIT_GENERIC(index); 555 } 556} 557 558 559/** 560 * Return info for a vertex attribute array (no alias with legacy 561 * vertex attributes (pos, normal, color, etc)). This function does 562 * not handle the 4-element GL_CURRENT_VERTEX_ATTRIB_ARB query. 563 */ 564static GLuint 565get_vertex_array_attrib(struct gl_context *ctx, GLuint index, GLenum pname, 566 const char *caller) 567{ 568 const struct gl_client_array *array; 569 570 if (index >= ctx->Const.VertexProgram.MaxAttribs) { 571 _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)", caller, index); 572 return 0; 573 } 574 575 ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib)); 576 577 array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)]; 578 579 switch (pname) { 580 case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB: 581 return array->Enabled; 582 case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB: 583 return array->Size; 584 case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB: 585 return array->Stride; 586 case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB: 587 return array->Type; 588 case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB: 589 return array->Normalized; 590 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB: 591 return array->BufferObj->Name; 592 case GL_VERTEX_ATTRIB_ARRAY_INTEGER: 593 if ((_mesa_is_desktop_gl(ctx) 594 && (ctx->Version >= 30 || ctx->Extensions.EXT_gpu_shader4)) 595 || _mesa_is_gles3(ctx)) { 596 return array->Integer; 597 } 598 goto error; 599 case GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB: 600 if ((_mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_instanced_arrays) 601 || _mesa_is_gles3(ctx)) { 602 return array->InstanceDivisor; 603 } 604 goto error; 605 default: 606 ; /* fall-through */ 607 } 608 609error: 610 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=0x%x)", caller, pname); 611 return 0; 612} 613 614 615static const GLfloat * 616get_current_attrib(struct gl_context *ctx, GLuint index, const char *function) 617{ 618 if (index == 0) { 619 /* In OpenGL 3.1 attribute 0 becomes non-magic, just like in OpenGL ES 620 * 2.0. Note that we cannot just check for API_OPENGL_CORE here because 621 * that will erroneously allow this usage in a 3.0 forward-compatible 622 * context too. 623 */ 624 if ((ctx->API != API_OPENGL_CORE || ctx->Version < 31) 625 && ctx->API != API_OPENGLES2) { 626 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(index==0)", function); 627 return NULL; 628 } 629 } 630 else if (index >= ctx->Const.VertexProgram.MaxAttribs) { 631 _mesa_error(ctx, GL_INVALID_VALUE, 632 "%s(index>=GL_MAX_VERTEX_ATTRIBS)", function); 633 return NULL; 634 } 635 636 ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib)); 637 638 FLUSH_CURRENT(ctx, 0); 639 return ctx->Current.Attrib[VERT_ATTRIB_GENERIC(index)]; 640} 641 642void GLAPIENTRY 643_mesa_GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params) 644{ 645 GET_CURRENT_CONTEXT(ctx); 646 ASSERT_OUTSIDE_BEGIN_END(ctx); 647 648 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 649 const GLfloat *v = get_current_attrib(ctx, index, "glGetVertexAttribfv"); 650 if (v != NULL) { 651 COPY_4V(params, v); 652 } 653 } 654 else { 655 params[0] = (GLfloat) get_vertex_array_attrib(ctx, index, pname, 656 "glGetVertexAttribfv"); 657 } 658} 659 660 661void GLAPIENTRY 662_mesa_GetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params) 663{ 664 GET_CURRENT_CONTEXT(ctx); 665 ASSERT_OUTSIDE_BEGIN_END(ctx); 666 667 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 668 const GLfloat *v = get_current_attrib(ctx, index, "glGetVertexAttribdv"); 669 if (v != NULL) { 670 params[0] = (GLdouble) v[0]; 671 params[1] = (GLdouble) v[1]; 672 params[2] = (GLdouble) v[2]; 673 params[3] = (GLdouble) v[3]; 674 } 675 } 676 else { 677 params[0] = (GLdouble) get_vertex_array_attrib(ctx, index, pname, 678 "glGetVertexAttribdv"); 679 } 680} 681 682 683void GLAPIENTRY 684_mesa_GetVertexAttribivARB(GLuint index, GLenum pname, GLint *params) 685{ 686 GET_CURRENT_CONTEXT(ctx); 687 ASSERT_OUTSIDE_BEGIN_END(ctx); 688 689 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 690 const GLfloat *v = get_current_attrib(ctx, index, "glGetVertexAttribiv"); 691 if (v != NULL) { 692 /* XXX should floats in[0,1] be scaled to full int range? */ 693 params[0] = (GLint) v[0]; 694 params[1] = (GLint) v[1]; 695 params[2] = (GLint) v[2]; 696 params[3] = (GLint) v[3]; 697 } 698 } 699 else { 700 params[0] = (GLint) get_vertex_array_attrib(ctx, index, pname, 701 "glGetVertexAttribiv"); 702 } 703} 704 705 706/** GL 3.0 */ 707void GLAPIENTRY 708_mesa_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params) 709{ 710 GET_CURRENT_CONTEXT(ctx); 711 ASSERT_OUTSIDE_BEGIN_END(ctx); 712 713 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 714 const GLfloat *v = 715 get_current_attrib(ctx, index, "glGetVertexAttribIiv"); 716 if (v != NULL) { 717 /* XXX we don't have true integer-valued vertex attribs yet */ 718 params[0] = (GLint) v[0]; 719 params[1] = (GLint) v[1]; 720 params[2] = (GLint) v[2]; 721 params[3] = (GLint) v[3]; 722 } 723 } 724 else { 725 params[0] = (GLint) get_vertex_array_attrib(ctx, index, pname, 726 "glGetVertexAttribIiv"); 727 } 728} 729 730 731/** GL 3.0 */ 732void GLAPIENTRY 733_mesa_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params) 734{ 735 GET_CURRENT_CONTEXT(ctx); 736 ASSERT_OUTSIDE_BEGIN_END(ctx); 737 738 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { 739 const GLfloat *v = 740 get_current_attrib(ctx, index, "glGetVertexAttribIuiv"); 741 if (v != NULL) { 742 /* XXX we don't have true integer-valued vertex attribs yet */ 743 params[0] = (GLuint) v[0]; 744 params[1] = (GLuint) v[1]; 745 params[2] = (GLuint) v[2]; 746 params[3] = (GLuint) v[3]; 747 } 748 } 749 else { 750 params[0] = get_vertex_array_attrib(ctx, index, pname, 751 "glGetVertexAttribIuiv"); 752 } 753} 754 755 756void GLAPIENTRY 757_mesa_GetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid **pointer) 758{ 759 GET_CURRENT_CONTEXT(ctx); 760 ASSERT_OUTSIDE_BEGIN_END(ctx); 761 762 if (index >= ctx->Const.VertexProgram.MaxAttribs) { 763 _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribPointerARB(index)"); 764 return; 765 } 766 767 if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB) { 768 _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribPointerARB(pname)"); 769 return; 770 } 771 772 ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib)); 773 774 *pointer = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Ptr; 775} 776 777 778void GLAPIENTRY 779_mesa_VertexPointerEXT(GLint size, GLenum type, GLsizei stride, 780 GLsizei count, const GLvoid *ptr) 781{ 782 (void) count; 783 _mesa_VertexPointer(size, type, stride, ptr); 784} 785 786 787void GLAPIENTRY 788_mesa_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, 789 const GLvoid *ptr) 790{ 791 (void) count; 792 _mesa_NormalPointer(type, stride, ptr); 793} 794 795 796void GLAPIENTRY 797_mesa_ColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, 798 const GLvoid *ptr) 799{ 800 (void) count; 801 _mesa_ColorPointer(size, type, stride, ptr); 802} 803 804 805void GLAPIENTRY 806_mesa_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, 807 const GLvoid *ptr) 808{ 809 (void) count; 810 _mesa_IndexPointer(type, stride, ptr); 811} 812 813 814void GLAPIENTRY 815_mesa_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, 816 GLsizei count, const GLvoid *ptr) 817{ 818 (void) count; 819 _mesa_TexCoordPointer(size, type, stride, ptr); 820} 821 822 823void GLAPIENTRY 824_mesa_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr) 825{ 826 (void) count; 827 _mesa_EdgeFlagPointer(stride, ptr); 828} 829 830 831void GLAPIENTRY 832_mesa_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) 833{ 834 GET_CURRENT_CONTEXT(ctx); 835 GLboolean tflag, cflag, nflag; /* enable/disable flags */ 836 GLint tcomps, ccomps, vcomps; /* components per texcoord, color, vertex */ 837 GLenum ctype = 0; /* color type */ 838 GLint coffset = 0, noffset = 0, voffset;/* color, normal, vertex offsets */ 839 const GLint toffset = 0; /* always zero */ 840 GLint defstride; /* default stride */ 841 GLint c, f; 842 843 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 844 845 f = sizeof(GLfloat); 846 c = f * ((4 * sizeof(GLubyte) + (f - 1)) / f); 847 848 if (stride < 0) { 849 _mesa_error( ctx, GL_INVALID_VALUE, "glInterleavedArrays(stride)" ); 850 return; 851 } 852 853 switch (format) { 854 case GL_V2F: 855 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_FALSE; 856 tcomps = 0; ccomps = 0; vcomps = 2; 857 voffset = 0; 858 defstride = 2*f; 859 break; 860 case GL_V3F: 861 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_FALSE; 862 tcomps = 0; ccomps = 0; vcomps = 3; 863 voffset = 0; 864 defstride = 3*f; 865 break; 866 case GL_C4UB_V2F: 867 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE; 868 tcomps = 0; ccomps = 4; vcomps = 2; 869 ctype = GL_UNSIGNED_BYTE; 870 coffset = 0; 871 voffset = c; 872 defstride = c + 2*f; 873 break; 874 case GL_C4UB_V3F: 875 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE; 876 tcomps = 0; ccomps = 4; vcomps = 3; 877 ctype = GL_UNSIGNED_BYTE; 878 coffset = 0; 879 voffset = c; 880 defstride = c + 3*f; 881 break; 882 case GL_C3F_V3F: 883 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE; 884 tcomps = 0; ccomps = 3; vcomps = 3; 885 ctype = GL_FLOAT; 886 coffset = 0; 887 voffset = 3*f; 888 defstride = 6*f; 889 break; 890 case GL_N3F_V3F: 891 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_TRUE; 892 tcomps = 0; ccomps = 0; vcomps = 3; 893 noffset = 0; 894 voffset = 3*f; 895 defstride = 6*f; 896 break; 897 case GL_C4F_N3F_V3F: 898 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_TRUE; 899 tcomps = 0; ccomps = 4; vcomps = 3; 900 ctype = GL_FLOAT; 901 coffset = 0; 902 noffset = 4*f; 903 voffset = 7*f; 904 defstride = 10*f; 905 break; 906 case GL_T2F_V3F: 907 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_FALSE; 908 tcomps = 2; ccomps = 0; vcomps = 3; 909 voffset = 2*f; 910 defstride = 5*f; 911 break; 912 case GL_T4F_V4F: 913 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_FALSE; 914 tcomps = 4; ccomps = 0; vcomps = 4; 915 voffset = 4*f; 916 defstride = 8*f; 917 break; 918 case GL_T2F_C4UB_V3F: 919 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_FALSE; 920 tcomps = 2; ccomps = 4; vcomps = 3; 921 ctype = GL_UNSIGNED_BYTE; 922 coffset = 2*f; 923 voffset = c+2*f; 924 defstride = c+5*f; 925 break; 926 case GL_T2F_C3F_V3F: 927 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_FALSE; 928 tcomps = 2; ccomps = 3; vcomps = 3; 929 ctype = GL_FLOAT; 930 coffset = 2*f; 931 voffset = 5*f; 932 defstride = 8*f; 933 break; 934 case GL_T2F_N3F_V3F: 935 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_TRUE; 936 tcomps = 2; ccomps = 0; vcomps = 3; 937 noffset = 2*f; 938 voffset = 5*f; 939 defstride = 8*f; 940 break; 941 case GL_T2F_C4F_N3F_V3F: 942 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_TRUE; 943 tcomps = 2; ccomps = 4; vcomps = 3; 944 ctype = GL_FLOAT; 945 coffset = 2*f; 946 noffset = 6*f; 947 voffset = 9*f; 948 defstride = 12*f; 949 break; 950 case GL_T4F_C4F_N3F_V4F: 951 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_TRUE; 952 tcomps = 4; ccomps = 4; vcomps = 4; 953 ctype = GL_FLOAT; 954 coffset = 4*f; 955 noffset = 8*f; 956 voffset = 11*f; 957 defstride = 15*f; 958 break; 959 default: 960 _mesa_error( ctx, GL_INVALID_ENUM, "glInterleavedArrays(format)" ); 961 return; 962 } 963 964 if (stride==0) { 965 stride = defstride; 966 } 967 968 _mesa_DisableClientState( GL_EDGE_FLAG_ARRAY ); 969 _mesa_DisableClientState( GL_INDEX_ARRAY ); 970 /* XXX also disable secondary color and generic arrays? */ 971 972 /* Texcoords */ 973 if (tflag) { 974 _mesa_EnableClientState( GL_TEXTURE_COORD_ARRAY ); 975 _mesa_TexCoordPointer( tcomps, GL_FLOAT, stride, 976 (GLubyte *) pointer + toffset ); 977 } 978 else { 979 _mesa_DisableClientState( GL_TEXTURE_COORD_ARRAY ); 980 } 981 982 /* Color */ 983 if (cflag) { 984 _mesa_EnableClientState( GL_COLOR_ARRAY ); 985 _mesa_ColorPointer( ccomps, ctype, stride, 986 (GLubyte *) pointer + coffset ); 987 } 988 else { 989 _mesa_DisableClientState( GL_COLOR_ARRAY ); 990 } 991 992 993 /* Normals */ 994 if (nflag) { 995 _mesa_EnableClientState( GL_NORMAL_ARRAY ); 996 _mesa_NormalPointer( GL_FLOAT, stride, (GLubyte *) pointer + noffset ); 997 } 998 else { 999 _mesa_DisableClientState( GL_NORMAL_ARRAY ); 1000 } 1001 1002 /* Vertices */ 1003 _mesa_EnableClientState( GL_VERTEX_ARRAY ); 1004 _mesa_VertexPointer( vcomps, GL_FLOAT, stride, 1005 (GLubyte *) pointer + voffset ); 1006} 1007 1008 1009void GLAPIENTRY 1010_mesa_LockArraysEXT(GLint first, GLsizei count) 1011{ 1012 GET_CURRENT_CONTEXT(ctx); 1013 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 1014 1015 if (MESA_VERBOSE & VERBOSE_API) 1016 _mesa_debug(ctx, "glLockArrays %d %d\n", first, count); 1017 1018 if (first < 0) { 1019 _mesa_error( ctx, GL_INVALID_VALUE, "glLockArraysEXT(first)" ); 1020 return; 1021 } 1022 if (count <= 0) { 1023 _mesa_error( ctx, GL_INVALID_VALUE, "glLockArraysEXT(count)" ); 1024 return; 1025 } 1026 if (ctx->Array.LockCount != 0) { 1027 _mesa_error( ctx, GL_INVALID_OPERATION, "glLockArraysEXT(reentry)" ); 1028 return; 1029 } 1030 1031 ctx->Array.LockFirst = first; 1032 ctx->Array.LockCount = count; 1033 1034 ctx->NewState |= _NEW_ARRAY; 1035} 1036 1037 1038void GLAPIENTRY 1039_mesa_UnlockArraysEXT( void ) 1040{ 1041 GET_CURRENT_CONTEXT(ctx); 1042 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 1043 1044 if (MESA_VERBOSE & VERBOSE_API) 1045 _mesa_debug(ctx, "glUnlockArrays\n"); 1046 1047 if (ctx->Array.LockCount == 0) { 1048 _mesa_error( ctx, GL_INVALID_OPERATION, "glUnlockArraysEXT(reexit)" ); 1049 return; 1050 } 1051 1052 ctx->Array.LockFirst = 0; 1053 ctx->Array.LockCount = 0; 1054 ctx->NewState |= _NEW_ARRAY; 1055} 1056 1057 1058/* GL_EXT_multi_draw_arrays */ 1059void GLAPIENTRY 1060_mesa_MultiDrawArraysEXT( GLenum mode, const GLint *first, 1061 const GLsizei *count, GLsizei primcount ) 1062{ 1063 GET_CURRENT_CONTEXT(ctx); 1064 GLint i; 1065 1066 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 1067 1068 for (i = 0; i < primcount; i++) { 1069 if (count[i] > 0) { 1070 CALL_DrawArrays(ctx->Exec, (mode, first[i], count[i])); 1071 } 1072 } 1073} 1074 1075 1076/* GL_IBM_multimode_draw_arrays */ 1077void GLAPIENTRY 1078_mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first, 1079 const GLsizei * count, 1080 GLsizei primcount, GLint modestride ) 1081{ 1082 GET_CURRENT_CONTEXT(ctx); 1083 GLint i; 1084 1085 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 1086 1087 for ( i = 0 ; i < primcount ; i++ ) { 1088 if ( count[i] > 0 ) { 1089 GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride)); 1090 CALL_DrawArrays(ctx->Exec, ( m, first[i], count[i] )); 1091 } 1092 } 1093} 1094 1095 1096/* GL_IBM_multimode_draw_arrays */ 1097void GLAPIENTRY 1098_mesa_MultiModeDrawElementsIBM( const GLenum * mode, const GLsizei * count, 1099 GLenum type, const GLvoid * const * indices, 1100 GLsizei primcount, GLint modestride ) 1101{ 1102 GET_CURRENT_CONTEXT(ctx); 1103 GLint i; 1104 1105 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 1106 1107 /* XXX not sure about ARB_vertex_buffer_object handling here */ 1108 1109 for ( i = 0 ; i < primcount ; i++ ) { 1110 if ( count[i] > 0 ) { 1111 GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride)); 1112 CALL_DrawElements(ctx->Exec, ( m, count[i], type, indices[i] )); 1113 } 1114 } 1115} 1116 1117 1118/** 1119 * GL_NV_primitive_restart and GL 3.1 1120 */ 1121void GLAPIENTRY 1122_mesa_PrimitiveRestartIndex(GLuint index) 1123{ 1124 GET_CURRENT_CONTEXT(ctx); 1125 1126 if (!ctx->Extensions.NV_primitive_restart && ctx->Version < 31) { 1127 _mesa_error(ctx, GL_INVALID_OPERATION, "glPrimitiveRestartIndexNV()"); 1128 return; 1129 } 1130 1131 ASSERT_OUTSIDE_BEGIN_END(ctx); 1132 1133 if (ctx->Array.RestartIndex != index) { 1134 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 1135 ctx->Array.RestartIndex = index; 1136 } 1137} 1138 1139 1140/** 1141 * See GL_ARB_instanced_arrays. 1142 * Note that the instance divisor only applies to generic arrays, not 1143 * the legacy vertex arrays. 1144 */ 1145void GLAPIENTRY 1146_mesa_VertexAttribDivisor(GLuint index, GLuint divisor) 1147{ 1148 struct gl_client_array *array; 1149 GET_CURRENT_CONTEXT(ctx); 1150 ASSERT_OUTSIDE_BEGIN_END(ctx); 1151 1152 if (!ctx->Extensions.ARB_instanced_arrays) { 1153 _mesa_error(ctx, GL_INVALID_OPERATION, "glVertexAttribDivisor()"); 1154 return; 1155 } 1156 1157 if (index >= ctx->Const.VertexProgram.MaxAttribs) { 1158 _mesa_error(ctx, GL_INVALID_ENUM, "glVertexAttribDivisor(index = %u)", 1159 index); 1160 return; 1161 } 1162 1163 ASSERT(VERT_ATTRIB_GENERIC(index) < Elements(ctx->Array.ArrayObj->VertexAttrib)); 1164 1165 array = &ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(index)]; 1166 if (array->InstanceDivisor != divisor) { 1167 FLUSH_VERTICES(ctx, _NEW_ARRAY); 1168 array->InstanceDivisor = divisor; 1169 ctx->Array.ArrayObj->NewArrays |= VERT_BIT(VERT_ATTRIB_GENERIC(index)); 1170 } 1171} 1172 1173 1174 1175/** 1176 * Copy one client vertex array to another. 1177 */ 1178void 1179_mesa_copy_client_array(struct gl_context *ctx, 1180 struct gl_client_array *dst, 1181 struct gl_client_array *src) 1182{ 1183 dst->Size = src->Size; 1184 dst->Type = src->Type; 1185 dst->Format = src->Format; 1186 dst->Stride = src->Stride; 1187 dst->StrideB = src->StrideB; 1188 dst->Ptr = src->Ptr; 1189 dst->Enabled = src->Enabled; 1190 dst->Normalized = src->Normalized; 1191 dst->Integer = src->Integer; 1192 dst->InstanceDivisor = src->InstanceDivisor; 1193 dst->_ElementSize = src->_ElementSize; 1194 _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj); 1195 dst->_MaxElement = src->_MaxElement; 1196} 1197 1198 1199 1200/** 1201 * Print vertex array's fields. 1202 */ 1203static void 1204print_array(const char *name, GLint index, const struct gl_client_array *array) 1205{ 1206 if (index >= 0) 1207 printf(" %s[%d]: ", name, index); 1208 else 1209 printf(" %s: ", name); 1210 printf("Ptr=%p, Type=0x%x, Size=%d, ElemSize=%u, Stride=%d, Buffer=%u(Size %lu), MaxElem=%u\n", 1211 array->Ptr, array->Type, array->Size, 1212 array->_ElementSize, array->StrideB, 1213 array->BufferObj->Name, (unsigned long) array->BufferObj->Size, 1214 array->_MaxElement); 1215} 1216 1217 1218/** 1219 * Print current vertex object/array info. For debug. 1220 */ 1221void 1222_mesa_print_arrays(struct gl_context *ctx) 1223{ 1224 struct gl_array_object *arrayObj = ctx->Array.ArrayObj; 1225 GLuint i; 1226 1227 _mesa_update_array_object_max_element(ctx, arrayObj); 1228 1229 printf("Array Object %u\n", arrayObj->Name); 1230 if (arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) 1231 print_array("Vertex", -1, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]); 1232 if (arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) 1233 print_array("Normal", -1, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]); 1234 if (arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) 1235 print_array("Color", -1, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]); 1236 for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) 1237 if (arrayObj->VertexAttrib[VERT_ATTRIB_TEX(i)].Enabled) 1238 print_array("TexCoord", i, &arrayObj->VertexAttrib[VERT_ATTRIB_TEX(i)]); 1239 for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; i++) 1240 if (arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(i)].Enabled) 1241 print_array("Attrib", i, &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(i)]); 1242 printf(" _MaxElement = %u\n", arrayObj->_MaxElement); 1243} 1244 1245 1246/** 1247 * Initialize vertex array state for given context. 1248 */ 1249void 1250_mesa_init_varray(struct gl_context *ctx) 1251{ 1252 ctx->Array.DefaultArrayObj = ctx->Driver.NewArrayObject(ctx, 0); 1253 _mesa_reference_array_object(ctx, &ctx->Array.ArrayObj, 1254 ctx->Array.DefaultArrayObj); 1255 ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */ 1256 1257 ctx->Array.Objects = _mesa_NewHashTable(); 1258} 1259 1260 1261/** 1262 * Callback for deleting an array object. Called by _mesa_HashDeleteAll(). 1263 */ 1264static void 1265delete_arrayobj_cb(GLuint id, void *data, void *userData) 1266{ 1267 struct gl_array_object *arrayObj = (struct gl_array_object *) data; 1268 struct gl_context *ctx = (struct gl_context *) userData; 1269 _mesa_delete_array_object(ctx, arrayObj); 1270} 1271 1272 1273/** 1274 * Free vertex array state for given context. 1275 */ 1276void 1277_mesa_free_varray_data(struct gl_context *ctx) 1278{ 1279 _mesa_HashDeleteAll(ctx->Array.Objects, delete_arrayobj_cb, ctx); 1280 _mesa_DeleteHashTable(ctx->Array.Objects); 1281} 1282