src/mesa/main/varray.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5.1
   4  *
   5  * Copyright (C) 1999-2006  Brian Paul   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  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 #include "glheader.h"
  27 #include "imports.h"
  28 #include "bufferobj.h"
  29 #include "context.h"
  30 #include "enable.h"
  31 #include "enums.h"
  32 #include "mtypes.h"
  33 #include "varray.h"
  34 #include "arrayobj.h"
  35 #include "glapi/dispatch.h"
  36
  37
  38 /**
  39  * Update the fields of a vertex array object.
  40  * We need to do a few special things for arrays that live in
  41  * vertex buffer objects.
  42  *
  43  * \param array  the array to update
  44  * \param dirtyBit  which bit to set in ctx->Array.NewState for this array
  45  * \param elementSize  size of each array element, in bytes
  46  * \param size  components per element (1, 2, 3 or 4)
  47  * \param type  datatype of each component (GL_FLOAT, GL_INT, etc)
  48  * \param stride  stride between elements, in elements
  49  * \param normalized  are integer types converted to floats in [-1, 1]?
  50  * \param ptr  the address (or offset inside VBO) of the array data
  51  */
  52 static void
  53 update_array(GLcontext *ctx, struct gl_client_array *array,
  54              GLbitfield dirtyBit, GLsizei elementSize,
  55              GLint size, GLenum type,
  56              GLsizei stride, GLboolean normalized, const GLvoid *ptr)
  57 {
  58    array->Size = size;
  59    array->Type = type;
  60    array->Stride = stride;
  61    array->StrideB = stride ? stride : elementSize;
  62    array->Normalized = normalized;
  63    array->Ptr = (const GLubyte *) ptr;
  64 #if FEATURE_ARB_vertex_buffer_object
  65    array->BufferObj->RefCount--;
  66    if (array->BufferObj->RefCount <= 0) {
  67       ASSERT(array->BufferObj->Name);
  68       _mesa_remove_buffer_object( ctx, array->BufferObj );
  69       (*ctx->Driver.DeleteBuffer)( ctx, array->BufferObj );
  70    }
  71    array->BufferObj = ctx->Array.ArrayBufferObj;
  72    array->BufferObj->RefCount++;
  73    /* Compute the index of the last array element that's inside the buffer.
  74     * Later in glDrawArrays we'll check if start + count > _MaxElement to
  75     * be sure we won't go out of bounds.
  76     */
  77    if (ctx->Array.ArrayBufferObj->Name)
  78       array->_MaxElement = ((GLsizeiptrARB) ctx->Array.ArrayBufferObj->Size
  79                             - (GLsizeiptrARB) array->Ptr + array->StrideB
  80                             - elementSize) / array->StrideB;
  81    else
  82 #endif
  83       array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */
  84
  85    ctx->NewState |= _NEW_ARRAY;
  86    ctx->Array.NewState |= dirtyBit;
  87 }
  88
  89
  90 void GLAPIENTRY
  91 _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
  92 {
  93    GLsizei elementSize;
  94    GET_CURRENT_CONTEXT(ctx);
  95    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
  96
  97    if (size < 2 || size > 4) {
  98       _mesa_error( ctx, GL_INVALID_VALUE, "glVertexPointer(size)" );
  99       return;
 100    }
 101    if (stride < 0) {
 102       _mesa_error( ctx, GL_INVALID_VALUE, "glVertexPointer(stride)" );
 103       return;
 104    }
 105
 106    if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
 107       _mesa_debug(ctx, "glVertexPointer( sz %d type %s stride %d )\n", size,
 108                   _mesa_lookup_enum_by_nr( type ), stride);
 109
 110    /* always need to check that <type> is legal */
 111    switch (type) {
 112       case GL_SHORT:
 113          elementSize = size * sizeof(GLshort);
 114          break;
 115       case GL_INT:
 116          elementSize = size * sizeof(GLint);
 117          break;
 118       case GL_FLOAT:
 119          elementSize = size * sizeof(GLfloat);
 120          break;
 121       case GL_DOUBLE:
 122          elementSize = size * sizeof(GLdouble);
 123          break;
 124       default:
 125          _mesa_error( ctx, GL_INVALID_ENUM, "glVertexPointer(type)" );
 126          return;
 127    }
 128
 129    update_array(ctx, &ctx->Array.ArrayObj->Vertex, _NEW_ARRAY_VERTEX,
 130                 elementSize, size, type, stride, GL_FALSE, ptr);
 131
 132    if (ctx->Driver.VertexPointer)
 133       ctx->Driver.VertexPointer( ctx, size, type, stride, ptr );
 134 }
 135
 136
 137 void GLAPIENTRY
 138 _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
 139 {
 140    GLsizei elementSize;
 141    GET_CURRENT_CONTEXT(ctx);
 142    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 143
 144    if (stride < 0) {
 145       _mesa_error( ctx, GL_INVALID_VALUE, "glNormalPointer(stride)" );
 146       return;
 147    }
 148
 149    if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
 150       _mesa_debug(ctx, "glNormalPointer( type %s stride %d )\n",
 151                   _mesa_lookup_enum_by_nr( type ), stride);
 152
 153    switch (type) {
 154       case GL_BYTE:
 155          elementSize = 3 * sizeof(GLbyte);
 156          break;
 157       case GL_SHORT:
 158          elementSize = 3 * sizeof(GLshort);
 159          break;
 160       case GL_INT:
 161          elementSize = 3 * sizeof(GLint);
 162          break;
 163       case GL_FLOAT:
 164          elementSize = 3 * sizeof(GLfloat);
 165          break;
 166       case GL_DOUBLE:
 167          elementSize = 3 * sizeof(GLdouble);
 168          break;
 169       default:
 170          _mesa_error( ctx, GL_INVALID_ENUM, "glNormalPointer(type)" );
 171          return;
 172    }
 173
 174    update_array(ctx, &ctx->Array.ArrayObj->Normal, _NEW_ARRAY_NORMAL,
 175                 elementSize, 3, type, stride, GL_TRUE, ptr);
 176
 177    if (ctx->Driver.NormalPointer)
 178       ctx->Driver.NormalPointer( ctx, type, stride, ptr );
 179 }
 180
 181
 182 void GLAPIENTRY
 183 _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 184 {
 185    GLsizei elementSize;
 186    GET_CURRENT_CONTEXT(ctx);
 187    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 188
 189    if (size < 3 || size > 4) {
 190       _mesa_error( ctx, GL_INVALID_VALUE, "glColorPointer(size)" );
 191       return;
 192    }
 193    if (stride < 0) {
 194       _mesa_error( ctx, GL_INVALID_VALUE, "glColorPointer(stride)" );
 195       return;
 196    }
 197
 198    if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
 199       _mesa_debug(ctx, "glColorPointer( sz %d type %s stride %d )\n", size,
 200                   _mesa_lookup_enum_by_nr( type ), stride);
 201
 202    switch (type) {
 203       case GL_BYTE:
 204          elementSize = size * sizeof(GLbyte);
 205          break;
 206       case GL_UNSIGNED_BYTE:
 207          elementSize = size * sizeof(GLubyte);
 208          break;
 209       case GL_SHORT:
 210          elementSize = size * sizeof(GLshort);
 211          break;
 212       case GL_UNSIGNED_SHORT:
 213          elementSize = size * sizeof(GLushort);
 214          break;
 215       case GL_INT:
 216          elementSize = size * sizeof(GLint);
 217          break;
 218       case GL_UNSIGNED_INT:
 219          elementSize = size * sizeof(GLuint);
 220          break;
 221       case GL_FLOAT:
 222          elementSize = size * sizeof(GLfloat);
 223          break;
 224       case GL_DOUBLE:
 225          elementSize = size * sizeof(GLdouble);
 226          break;
 227       default:
 228          _mesa_error( ctx, GL_INVALID_ENUM, "glColorPointer(type)" );
 229          return;
 230    }
 231
 232    update_array(ctx, &ctx->Array.ArrayObj->Color, _NEW_ARRAY_COLOR0,
 233                 elementSize, size, type, stride, GL_TRUE, ptr);
 234
 235    if (ctx->Driver.ColorPointer)
 236       ctx->Driver.ColorPointer( ctx, size, type, stride, ptr );
 237 }
 238
 239
 240 void GLAPIENTRY
 241 _mesa_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr)
 242 {
 243    GLint elementSize;
 244    GET_CURRENT_CONTEXT(ctx);
 245    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 246
 247    if (stride < 0) {
 248       _mesa_error( ctx, GL_INVALID_VALUE, "glFogCoordPointer(stride)" );
 249       return;
 250    }
 251
 252    switch (type) {
 253       case GL_FLOAT:
 254          elementSize = sizeof(GLfloat);
 255          break;
 256       case GL_DOUBLE:
 257          elementSize = sizeof(GLdouble);
 258          break;
 259       default:
 260          _mesa_error( ctx, GL_INVALID_ENUM, "glFogCoordPointer(type)" );
 261          return;
 262    }
 263
 264    update_array(ctx, &ctx->Array.ArrayObj->FogCoord, _NEW_ARRAY_FOGCOORD,
 265                 elementSize, 1, type, stride, GL_FALSE, ptr);
 266
 267    if (ctx->Driver.FogCoordPointer)
 268       ctx->Driver.FogCoordPointer( ctx, type, stride, ptr );
 269 }
 270
 271
 272 void GLAPIENTRY
 273 _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
 274 {
 275    GLsizei elementSize;
 276    GET_CURRENT_CONTEXT(ctx);
 277    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 278
 279    if (stride < 0) {
 280       _mesa_error( ctx, GL_INVALID_VALUE, "glIndexPointer(stride)" );
 281       return;
 282    }
 283
 284    switch (type) {
 285       case GL_UNSIGNED_BYTE:
 286          elementSize = sizeof(GLubyte);
 287          break;
 288       case GL_SHORT:
 289          elementSize = sizeof(GLshort);
 290          break;
 291       case GL_INT:
 292          elementSize = sizeof(GLint);
 293          break;
 294       case GL_FLOAT:
 295          elementSize = sizeof(GLfloat);
 296          break;
 297       case GL_DOUBLE:
 298          elementSize = sizeof(GLdouble);
 299          break;
 300       default:
 301          _mesa_error( ctx, GL_INVALID_ENUM, "glIndexPointer(type)" );
 302          return;
 303    }
 304
 305    update_array(ctx, &ctx->Array.ArrayObj->Index, _NEW_ARRAY_INDEX,
 306                 elementSize, 1, type, stride, GL_FALSE, ptr);
 307
 308    if (ctx->Driver.IndexPointer)
 309       ctx->Driver.IndexPointer( ctx, type, stride, ptr );
 310 }
 311
 312
 313 void GLAPIENTRY
 314 _mesa_SecondaryColorPointerEXT(GLint size, GLenum type,
 315                                GLsizei stride, const GLvoid *ptr)
 316 {
 317    GLsizei elementSize;
 318    GET_CURRENT_CONTEXT(ctx);
 319    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 320
 321    if (size != 3 && size != 4) {
 322       _mesa_error( ctx, GL_INVALID_VALUE, "glSecondaryColorPointer(size)" );
 323       return;
 324    }
 325    if (stride < 0) {
 326       _mesa_error( ctx, GL_INVALID_VALUE, "glSecondaryColorPointer(stride)" );
 327       return;
 328    }
 329
 330    if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
 331       _mesa_debug(ctx, "glSecondaryColorPointer( sz %d type %s stride %d )\n",
 332                   size, _mesa_lookup_enum_by_nr( type ), stride);
 333
 334    switch (type) {
 335       case GL_BYTE:
 336          elementSize = size * sizeof(GLbyte);
 337          break;
 338       case GL_UNSIGNED_BYTE:
 339          elementSize = size * sizeof(GLubyte);
 340          break;
 341       case GL_SHORT:
 342          elementSize = size * sizeof(GLshort);
 343          break;
 344       case GL_UNSIGNED_SHORT:
 345          elementSize = size * sizeof(GLushort);
 346          break;
 347       case GL_INT:
 348          elementSize = size * sizeof(GLint);
 349          break;
 350       case GL_UNSIGNED_INT:
 351          elementSize = size * sizeof(GLuint);
 352          break;
 353       case GL_FLOAT:
 354          elementSize = size * sizeof(GLfloat);
 355          break;
 356       case GL_DOUBLE:
 357          elementSize = size * sizeof(GLdouble);
 358          break;
 359       default:
 360          _mesa_error( ctx, GL_INVALID_ENUM, "glSecondaryColorPointer(type)" );
 361          return;
 362    }
 363
 364    update_array(ctx, &ctx->Array.ArrayObj->SecondaryColor, _NEW_ARRAY_COLOR1,
 365                 elementSize, size, type, stride, GL_TRUE, ptr);
 366
 367    if (ctx->Driver.SecondaryColorPointer)
 368       ctx->Driver.SecondaryColorPointer( ctx, size, type, stride, ptr );
 369 }
 370
 371
 372 void GLAPIENTRY
 373 _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
 374                       const GLvoid *ptr)
 375 {
 376    GLint elementSize;
 377    GET_CURRENT_CONTEXT(ctx);
 378    const GLuint unit = ctx->Array.ActiveTexture;
 379    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 380
 381    if (size < 1 || size > 4) {
 382       _mesa_error( ctx, GL_INVALID_VALUE, "glTexCoordPointer(size)" );
 383       return;
 384    }
 385    if (stride < 0) {
 386       _mesa_error( ctx, GL_INVALID_VALUE, "glTexCoordPointer(stride)" );
 387       return;
 388    }
 389
 390    if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
 391       _mesa_debug(ctx, "glTexCoordPointer(unit %u sz %d type %s stride %d)\n",
 392                   unit, size, _mesa_lookup_enum_by_nr( type ), stride);
 393
 394    /* always need to check that <type> is legal */
 395    switch (type) {
 396       case GL_SHORT:
 397          elementSize = size * sizeof(GLshort);
 398          break;
 399       case GL_INT:
 400          elementSize = size * sizeof(GLint);
 401          break;
 402       case GL_FLOAT:
 403          elementSize = size * sizeof(GLfloat);
 404          break;
 405       case GL_DOUBLE:
 406          elementSize = size * sizeof(GLdouble);
 407          break;
 408       default:
 409          _mesa_error( ctx, GL_INVALID_ENUM, "glTexCoordPointer(type)" );
 410          return;
 411    }
 412
 413    update_array(ctx, &ctx->Array.ArrayObj->TexCoord[unit],
 414                 _NEW_ARRAY_TEXCOORD(unit),
 415                 elementSize, size, type, stride, GL_FALSE, ptr);
 416
 417    if (ctx->Driver.TexCoordPointer)
 418       ctx->Driver.TexCoordPointer( ctx, size, type, stride, ptr );
 419 }
 420
 421
 422 void GLAPIENTRY
 423 _mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
 424 {
 425    GET_CURRENT_CONTEXT(ctx);
 426    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 427
 428    if (stride < 0) {
 429       _mesa_error( ctx, GL_INVALID_VALUE, "glEdgeFlagPointer(stride)" );
 430       return;
 431    }
 432
 433    update_array(ctx, &ctx->Array.ArrayObj->EdgeFlag, _NEW_ARRAY_EDGEFLAG,
 434                 sizeof(GLboolean), 1, GL_UNSIGNED_BYTE, stride, GL_FALSE, ptr);
 435
 436    if (ctx->Driver.EdgeFlagPointer)
 437       ctx->Driver.EdgeFlagPointer( ctx, stride, ptr );
 438 }
 439
 440
 441 #if FEATURE_NV_vertex_program
 442 void GLAPIENTRY
 443 _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type,
 444                             GLsizei stride, const GLvoid *ptr)
 445 {
 446    const GLboolean normalized = GL_FALSE;
 447    GLsizei elementSize;
 448    GET_CURRENT_CONTEXT(ctx);
 449    ASSERT_OUTSIDE_BEGIN_END(ctx);
 450
 451    if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) {
 452       _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerNV(index)");
 453       return;
 454    }
 455
 456    if (size < 1 || size > 4) {
 457       _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerNV(size)");
 458       return;
 459    }
 460
 461    if (stride < 0) {
 462       _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerNV(stride)");
 463       return;
 464    }
 465
 466    if (type == GL_UNSIGNED_BYTE && size != 4) {
 467       _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerNV(size!=4)");
 468       return;
 469    }
 470
 471    /* check for valid 'type' and compute StrideB right away */
 472    switch (type) {
 473       case GL_UNSIGNED_BYTE:
 474          elementSize = size * sizeof(GLubyte);
 475          break;
 476       case GL_SHORT:
 477          elementSize = size * sizeof(GLshort);
 478          break;
 479       case GL_FLOAT:
 480          elementSize = size * sizeof(GLfloat);
 481          break;
 482       case GL_DOUBLE:
 483          elementSize = size * sizeof(GLdouble);
 484          break;
 485       default:
 486          _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttribPointerNV(type)" );
 487          return;
 488    }
 489
 490    update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index],
 491                 _NEW_ARRAY_ATTRIB(index),
 492                 elementSize, size, type, stride, normalized, ptr);
 493
 494    if (ctx->Driver.VertexAttribPointer)
 495       ctx->Driver.VertexAttribPointer( ctx, index, size, type, stride, ptr );
 496 }
 497 #endif
 498
 499
 500 #if FEATURE_ARB_vertex_program
 501 void GLAPIENTRY
 502 _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type,
 503                              GLboolean normalized,
 504                              GLsizei stride, const GLvoid *ptr)
 505 {
 506    GLsizei elementSize;
 507    GET_CURRENT_CONTEXT(ctx);
 508    ASSERT_OUTSIDE_BEGIN_END(ctx);
 509
 510    if (index >= ctx->Const.VertexProgram.MaxAttribs) {
 511       _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(index)");
 512       return;
 513    }
 514
 515    if (size < 1 || size > 4) {
 516       _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(size)");
 517       return;
 518    }
 519
 520    if (stride < 0) {
 521       _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(stride)");
 522       return;
 523    }
 524
 525    if (type == GL_UNSIGNED_BYTE && size != 4) {
 526       _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(size!=4)");
 527       return;
 528    }
 529
 530    /* check for valid 'type' and compute StrideB right away */
 531    /* NOTE: more types are supported here than in the NV extension */
 532    switch (type) {
 533       case GL_BYTE:
 534          elementSize = size * sizeof(GLbyte);
 535          break;
 536       case GL_UNSIGNED_BYTE:
 537          elementSize = size * sizeof(GLubyte);
 538          break;
 539       case GL_SHORT:
 540          elementSize = size * sizeof(GLshort);
 541          break;
 542       case GL_UNSIGNED_SHORT:
 543          elementSize = size * sizeof(GLushort);
 544          break;
 545       case GL_INT:
 546          elementSize = size * sizeof(GLint);
 547          break;
 548       case GL_UNSIGNED_INT:
 549          elementSize = size * sizeof(GLuint);
 550          break;
 551       case GL_FLOAT:
 552          elementSize = size * sizeof(GLfloat);
 553          break;
 554       case GL_DOUBLE:
 555          elementSize = size * sizeof(GLdouble);
 556          break;
 557       default:
 558          _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttribPointerARB(type)" );
 559          return;
 560    }
 561
 562    update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index],
 563                 _NEW_ARRAY_ATTRIB(index),
 564                 elementSize, size, type, stride, normalized, ptr);
 565
 566    if (ctx->Driver.VertexAttribPointer)
 567       ctx->Driver.VertexAttribPointer(ctx, index, size, type, stride, ptr);
 568 }
 569 #endif
 570
 571
 572 void GLAPIENTRY
 573 _mesa_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
 574                        GLsizei count, const GLvoid *ptr)
 575 {
 576    (void) count;
 577    _mesa_VertexPointer(size, type, stride, ptr);
 578 }
 579
 580
 581 void GLAPIENTRY
 582 _mesa_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
 583                        const GLvoid *ptr)
 584 {
 585    (void) count;
 586    _mesa_NormalPointer(type, stride, ptr);
 587 }
 588
 589
 590 void GLAPIENTRY
 591 _mesa_ColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count,
 592                       const GLvoid *ptr)
 593 {
 594    (void) count;
 595    _mesa_ColorPointer(size, type, stride, ptr);
 596 }
 597
 598
 599 void GLAPIENTRY
 600 _mesa_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,
 601                       const GLvoid *ptr)
 602 {
 603    (void) count;
 604    _mesa_IndexPointer(type, stride, ptr);
 605 }
 606
 607
 608 void GLAPIENTRY
 609 _mesa_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
 610                          GLsizei count, const GLvoid *ptr)
 611 {
 612    (void) count;
 613    _mesa_TexCoordPointer(size, type, stride, ptr);
 614 }
 615
 616
 617 void GLAPIENTRY
 618 _mesa_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr)
 619 {
 620    (void) count;
 621    _mesa_EdgeFlagPointer(stride, ptr);
 622 }
 623
 624
 625 void GLAPIENTRY
 626 _mesa_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 627 {
 628    GET_CURRENT_CONTEXT(ctx);
 629    GLboolean tflag, cflag, nflag;  /* enable/disable flags */
 630    GLint tcomps, ccomps, vcomps;   /* components per texcoord, color, vertex */
 631    GLenum ctype = 0;               /* color type */
 632    GLint coffset = 0, noffset = 0, voffset;/* color, normal, vertex offsets */
 633    const GLint toffset = 0;        /* always zero */
 634    GLint defstride;                /* default stride */
 635    GLint c, f;
 636
 637    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 638
 639    f = sizeof(GLfloat);
 640    c = f * ((4 * sizeof(GLubyte) + (f - 1)) / f);
 641
 642    if (stride < 0) {
 643       _mesa_error( ctx, GL_INVALID_VALUE, "glInterleavedArrays(stride)" );
 644       return;
 645    }
 646
 647    switch (format) {
 648       case GL_V2F:
 649          tflag = GL_FALSE;  cflag = GL_FALSE;  nflag = GL_FALSE;
 650          tcomps = 0;  ccomps = 0;  vcomps = 2;
 651          voffset = 0;
 652          defstride = 2*f;
 653          break;
 654       case GL_V3F:
 655          tflag = GL_FALSE;  cflag = GL_FALSE;  nflag = GL_FALSE;
 656          tcomps = 0;  ccomps = 0;  vcomps = 3;
 657          voffset = 0;
 658          defstride = 3*f;
 659          break;
 660       case GL_C4UB_V2F:
 661          tflag = GL_FALSE;  cflag = GL_TRUE;  nflag = GL_FALSE;
 662          tcomps = 0;  ccomps = 4;  vcomps = 2;
 663          ctype = GL_UNSIGNED_BYTE;
 664          coffset = 0;
 665          voffset = c;
 666          defstride = c + 2*f;
 667          break;
 668       case GL_C4UB_V3F:
 669          tflag = GL_FALSE;  cflag = GL_TRUE;  nflag = GL_FALSE;
 670          tcomps = 0;  ccomps = 4;  vcomps = 3;
 671          ctype = GL_UNSIGNED_BYTE;
 672          coffset = 0;
 673          voffset = c;
 674          defstride = c + 3*f;
 675          break;
 676       case GL_C3F_V3F:
 677          tflag = GL_FALSE;  cflag = GL_TRUE;  nflag = GL_FALSE;
 678          tcomps = 0;  ccomps = 3;  vcomps = 3;
 679          ctype = GL_FLOAT;
 680          coffset = 0;
 681          voffset = 3*f;
 682          defstride = 6*f;
 683          break;
 684       case GL_N3F_V3F:
 685          tflag = GL_FALSE;  cflag = GL_FALSE;  nflag = GL_TRUE;
 686          tcomps = 0;  ccomps = 0;  vcomps = 3;
 687          noffset = 0;
 688          voffset = 3*f;
 689          defstride = 6*f;
 690          break;
 691       case GL_C4F_N3F_V3F:
 692          tflag = GL_FALSE;  cflag = GL_TRUE;  nflag = GL_TRUE;
 693          tcomps = 0;  ccomps = 4;  vcomps = 3;
 694          ctype = GL_FLOAT;
 695          coffset = 0;
 696          noffset = 4*f;
 697          voffset = 7*f;
 698          defstride = 10*f;
 699          break;
 700       case GL_T2F_V3F:
 701          tflag = GL_TRUE;  cflag = GL_FALSE;  nflag = GL_FALSE;
 702          tcomps = 2;  ccomps = 0;  vcomps = 3;
 703          voffset = 2*f;
 704          defstride = 5*f;
 705          break;
 706       case GL_T4F_V4F:
 707          tflag = GL_TRUE;  cflag = GL_FALSE;  nflag = GL_FALSE;
 708          tcomps = 4;  ccomps = 0;  vcomps = 4;
 709          voffset = 4*f;
 710          defstride = 8*f;
 711          break;
 712       case GL_T2F_C4UB_V3F:
 713          tflag = GL_TRUE;  cflag = GL_TRUE;  nflag = GL_FALSE;
 714          tcomps = 2;  ccomps = 4;  vcomps = 3;
 715          ctype = GL_UNSIGNED_BYTE;
 716          coffset = 2*f;
 717          voffset = c+2*f;
 718          defstride = c+5*f;
 719          break;
 720       case GL_T2F_C3F_V3F:
 721          tflag = GL_TRUE;  cflag = GL_TRUE;  nflag = GL_FALSE;
 722          tcomps = 2;  ccomps = 3;  vcomps = 3;
 723          ctype = GL_FLOAT;
 724          coffset = 2*f;
 725          voffset = 5*f;
 726          defstride = 8*f;
 727          break;
 728       case GL_T2F_N3F_V3F:
 729          tflag = GL_TRUE;  cflag = GL_FALSE;  nflag = GL_TRUE;
 730          tcomps = 2;  ccomps = 0;  vcomps = 3;
 731          noffset = 2*f;
 732          voffset = 5*f;
 733          defstride = 8*f;
 734          break;
 735       case GL_T2F_C4F_N3F_V3F:
 736          tflag = GL_TRUE;  cflag = GL_TRUE;  nflag = GL_TRUE;
 737          tcomps = 2;  ccomps = 4;  vcomps = 3;
 738          ctype = GL_FLOAT;
 739          coffset = 2*f;
 740          noffset = 6*f;
 741          voffset = 9*f;
 742          defstride = 12*f;
 743          break;
 744       case GL_T4F_C4F_N3F_V4F:
 745          tflag = GL_TRUE;  cflag = GL_TRUE;  nflag = GL_TRUE;
 746          tcomps = 4;  ccomps = 4;  vcomps = 4;
 747          ctype = GL_FLOAT;
 748          coffset = 4*f;
 749          noffset = 8*f;
 750          voffset = 11*f;
 751          defstride = 15*f;
 752          break;
 753       default:
 754          _mesa_error( ctx, GL_INVALID_ENUM, "glInterleavedArrays(format)" );
 755          return;
 756    }
 757
 758    if (stride==0) {
 759       stride = defstride;
 760    }
 761
 762    _mesa_DisableClientState( GL_EDGE_FLAG_ARRAY );
 763    _mesa_DisableClientState( GL_INDEX_ARRAY );
 764    /* XXX also disable secondary color and generic arrays? */
 765
 766    /* Texcoords */
 767    if (tflag) {
 768       _mesa_EnableClientState( GL_TEXTURE_COORD_ARRAY );
 769       _mesa_TexCoordPointer( tcomps, GL_FLOAT, stride,
 770                              (GLubyte *) pointer + toffset );
 771    }
 772    else {
 773       _mesa_DisableClientState( GL_TEXTURE_COORD_ARRAY );
 774    }
 775
 776    /* Color */
 777    if (cflag) {
 778       _mesa_EnableClientState( GL_COLOR_ARRAY );
 779       _mesa_ColorPointer( ccomps, ctype, stride,
 780                           (GLubyte *) pointer + coffset );
 781    }
 782    else {
 783       _mesa_DisableClientState( GL_COLOR_ARRAY );
 784    }
 785
 786
 787    /* Normals */
 788    if (nflag) {
 789       _mesa_EnableClientState( GL_NORMAL_ARRAY );
 790       _mesa_NormalPointer( GL_FLOAT, stride, (GLubyte *) pointer + noffset );
 791    }
 792    else {
 793       _mesa_DisableClientState( GL_NORMAL_ARRAY );
 794    }
 795
 796    /* Vertices */
 797    _mesa_EnableClientState( GL_VERTEX_ARRAY );
 798    _mesa_VertexPointer( vcomps, GL_FLOAT, stride,
 799                         (GLubyte *) pointer + voffset );
 800 }
 801
 802
 803 void GLAPIENTRY
 804 _mesa_LockArraysEXT(GLint first, GLsizei count)
 805 {
 806    GET_CURRENT_CONTEXT(ctx);
 807    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 808
 809    if (MESA_VERBOSE & VERBOSE_API)
 810       _mesa_debug(ctx, "glLockArrays %d %d\n", first, count);
 811
 812    if (first == 0 && count > 0 &&
 813        count <= (GLint) ctx->Const.MaxArrayLockSize) {
 814       ctx->Array.LockFirst = first;
 815       ctx->Array.LockCount = count;
 816    }
 817    else {
 818       ctx->Array.LockFirst = 0;
 819       ctx->Array.LockCount = 0;
 820    }
 821
 822    ctx->NewState |= _NEW_ARRAY;
 823    ctx->Array.NewState |= _NEW_ARRAY_ALL;
 824
 825    if (ctx->Driver.LockArraysEXT)
 826       ctx->Driver.LockArraysEXT( ctx, first, count );
 827 }
 828
 829
 830 void GLAPIENTRY
 831 _mesa_UnlockArraysEXT( void )
 832 {
 833    GET_CURRENT_CONTEXT(ctx);
 834    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 835
 836    if (MESA_VERBOSE & VERBOSE_API)
 837       _mesa_debug(ctx, "glUnlockArrays\n");
 838
 839    ctx->Array.LockFirst = 0;
 840    ctx->Array.LockCount = 0;
 841    ctx->NewState |= _NEW_ARRAY;
 842    ctx->Array.NewState |= _NEW_ARRAY_ALL;
 843
 844    if (ctx->Driver.UnlockArraysEXT)
 845       ctx->Driver.UnlockArraysEXT( ctx );
 846 }
 847
 848
 849 /* GL_EXT_multi_draw_arrays */
 850 /* Somebody forgot to spec the first and count parameters as const! <sigh> */
 851 void GLAPIENTRY
 852 _mesa_MultiDrawArraysEXT( GLenum mode, GLint *first,
 853                           GLsizei *count, GLsizei primcount )
 854 {
 855    GET_CURRENT_CONTEXT(ctx);
 856    GLint i;
 857
 858    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 859
 860    for (i = 0; i < primcount; i++) {
 861       if (count[i] > 0) {
 862          CALL_DrawArrays(ctx->Exec, (mode, first[i], count[i]));
 863       }
 864    }
 865 }
 866
 867
 868 /* GL_EXT_multi_draw_arrays */
 869 void GLAPIENTRY
 870 _mesa_MultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type,
 871                             const GLvoid **indices, GLsizei primcount )
 872 {
 873    GET_CURRENT_CONTEXT(ctx);
 874    GLint i;
 875
 876    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 877
 878    for (i = 0; i < primcount; i++) {
 879       if (count[i] > 0) {
 880          CALL_DrawElements(ctx->Exec, (mode, count[i], type, indices[i]));
 881       }
 882    }
 883 }
 884
 885
 886 /* GL_IBM_multimode_draw_arrays */
 887 void GLAPIENTRY
 888 _mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first,
 889                               const GLsizei * count,
 890                               GLsizei primcount, GLint modestride )
 891 {
 892    GET_CURRENT_CONTEXT(ctx);
 893    GLint i;
 894
 895    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 896
 897    for ( i = 0 ; i < primcount ; i++ ) {
 898       if ( count[i] > 0 ) {
 899          GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
 900          CALL_DrawArrays(ctx->Exec, ( m, first[i], count[i] ));
 901       }
 902    }
 903 }
 904
 905
 906 /* GL_IBM_multimode_draw_arrays */
 907 void GLAPIENTRY
 908 _mesa_MultiModeDrawElementsIBM( const GLenum * mode, const GLsizei * count,
 909                                 GLenum type, const GLvoid * const * indices,
 910                                 GLsizei primcount, GLint modestride )
 911 {
 912    GET_CURRENT_CONTEXT(ctx);
 913    GLint i;
 914
 915    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 916
 917    /* XXX not sure about ARB_vertex_buffer_object handling here */
 918
 919    for ( i = 0 ; i < primcount ; i++ ) {
 920       if ( count[i] > 0 ) {
 921          GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
 922          CALL_DrawElements(ctx->Exec, ( m, count[i], type, indices[i] ));
 923       }
 924    }
 925 }
 926
 927
 928 /**
 929  * Initialize vertex array state for given context.
 930  */
 931 void
 932 _mesa_init_varray(GLcontext *ctx)
 933 {
 934    ctx->Array.DefaultArrayObj = _mesa_new_array_object(ctx, 0);
 935    ctx->Array.ArrayObj = ctx->Array.DefaultArrayObj;
 936
 937    ctx->Array.ActiveTexture = 0;   /* GL_ARB_multitexture */
 938 }