src/mesa/array_cache/ac_import.c

   1 /* $Id: ac_import.c,v 1.20 2002/10/24 23:57:24 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  4.1
   6  *
   7  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  * Authors:
  27  *    Keith Whitwell <keithw@valinux.com>
  28  */
  29
  30 #include "glheader.h"
  31 #include "macros.h"
  32 #include "imports.h"
  33 #include "mmath.h"
  34 #include "mtypes.h"
  35
  36 #include "math/m_translate.h"
  37 #include "array_cache/ac_context.h"
  38 #include "math/m_translate.h"
  39
  40 #define STRIDE_ARRAY( array, offset )           \
  41 do {                                            \
  42    char *tmp = (char *) (array).Ptr;            \
  43    tmp += (offset) * (array).StrideB;           \
  44    (array).Ptr = tmp;                           \
  45 } while (0)
  46
  47 /* Set the array pointer back to its source when the cached data is
  48  * invalidated:
  49  */
  50
  51 static void reset_texcoord( GLcontext *ctx, GLuint unit )
  52 {
  53    ACcontext *ac = AC_CONTEXT(ctx);
  54
  55    if (ctx->Array._Enabled & _NEW_ARRAY_TEXCOORD(unit)) {
  56       ac->Raw.TexCoord[unit] = ctx->Array.TexCoord[unit];
  57       STRIDE_ARRAY(ac->Raw.TexCoord[unit], ac->start);
  58    }
  59    else {
  60       ac->Raw.TexCoord[unit] = ac->Fallback.TexCoord[unit];
  61
  62       if (ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3] != 1.0)
  63          ac->Raw.TexCoord[unit].Size = 4;
  64       else if (ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2] != 0.0)
  65          ac->Raw.TexCoord[unit].Size = 3;
  66       else
  67          ac->Raw.TexCoord[unit].Size = 2;
  68    }
  69
  70    ac->IsCached.TexCoord[unit] = GL_FALSE;
  71    ac->NewArrayState &= ~_NEW_ARRAY_TEXCOORD(unit);
  72 }
  73
  74 static void reset_vertex( GLcontext *ctx )
  75 {
  76    ACcontext *ac = AC_CONTEXT(ctx);
  77    ASSERT(ctx->Array.Vertex.Enabled
  78           || (ctx->VertexProgram.Enabled && ctx->Array.VertexAttrib[0].Enabled));
  79    ac->Raw.Vertex = ctx->Array.Vertex;
  80    STRIDE_ARRAY(ac->Raw.Vertex, ac->start);
  81    ac->IsCached.Vertex = GL_FALSE;
  82    ac->NewArrayState &= ~_NEW_ARRAY_VERTEX;
  83 }
  84
  85
  86 static void reset_normal( GLcontext *ctx )
  87 {
  88    ACcontext *ac = AC_CONTEXT(ctx);
  89
  90    if (ctx->Array._Enabled & _NEW_ARRAY_NORMAL) {
  91       ac->Raw.Normal = ctx->Array.Normal;
  92       STRIDE_ARRAY(ac->Raw.Normal, ac->start);
  93    }
  94    else {
  95       ac->Raw.Normal = ac->Fallback.Normal;
  96    }
  97
  98    ac->IsCached.Normal = GL_FALSE;
  99    ac->NewArrayState &= ~_NEW_ARRAY_NORMAL;
 100 }
 101
 102
 103 static void reset_color( GLcontext *ctx )
 104 {
 105    ACcontext *ac = AC_CONTEXT(ctx);
 106
 107
 108    if (ctx->Array._Enabled & _NEW_ARRAY_COLOR0) {
 109       ac->Raw.Color = ctx->Array.Color;
 110       STRIDE_ARRAY(ac->Raw.Color, ac->start);
 111    }
 112    else
 113       ac->Raw.Color = ac->Fallback.Color;
 114
 115    ac->IsCached.Color = GL_FALSE;
 116    ac->NewArrayState &= ~_NEW_ARRAY_COLOR0;
 117 }
 118
 119
 120 static void reset_secondarycolor( GLcontext *ctx )
 121 {
 122    ACcontext *ac = AC_CONTEXT(ctx);
 123
 124    if (ctx->Array._Enabled & _NEW_ARRAY_COLOR1) {
 125       ac->Raw.SecondaryColor = ctx->Array.SecondaryColor;
 126       STRIDE_ARRAY(ac->Raw.SecondaryColor, ac->start);
 127    }
 128    else
 129       ac->Raw.SecondaryColor = ac->Fallback.SecondaryColor;
 130
 131    ac->IsCached.SecondaryColor = GL_FALSE;
 132    ac->NewArrayState &= ~_NEW_ARRAY_COLOR1;
 133 }
 134
 135
 136 static void reset_index( GLcontext *ctx )
 137 {
 138    ACcontext *ac = AC_CONTEXT(ctx);
 139
 140    if (ctx->Array._Enabled & _NEW_ARRAY_INDEX) {
 141       ac->Raw.Index = ctx->Array.Index;
 142       STRIDE_ARRAY(ac->Raw.Index, ac->start);
 143    }
 144    else
 145       ac->Raw.Index = ac->Fallback.Index;
 146
 147    ac->IsCached.Index = GL_FALSE;
 148    ac->NewArrayState &= ~_NEW_ARRAY_INDEX;
 149 }
 150
 151
 152 static void reset_fogcoord( GLcontext *ctx )
 153 {
 154    ACcontext *ac = AC_CONTEXT(ctx);
 155
 156    if (ctx->Array._Enabled & _NEW_ARRAY_FOGCOORD) {
 157       ac->Raw.FogCoord = ctx->Array.FogCoord;
 158       STRIDE_ARRAY(ac->Raw.FogCoord, ac->start);
 159    }
 160    else
 161       ac->Raw.FogCoord = ac->Fallback.FogCoord;
 162
 163    ac->IsCached.FogCoord = GL_FALSE;
 164    ac->NewArrayState &= ~_NEW_ARRAY_FOGCOORD;
 165 }
 166
 167
 168 static void reset_edgeflag( GLcontext *ctx )
 169 {
 170    ACcontext *ac = AC_CONTEXT(ctx);
 171
 172    if (ctx->Array._Enabled & _NEW_ARRAY_EDGEFLAG) {
 173       ac->Raw.EdgeFlag = ctx->Array.EdgeFlag;
 174       STRIDE_ARRAY(ac->Raw.EdgeFlag, ac->start);
 175    }
 176    else
 177       ac->Raw.EdgeFlag = ac->Fallback.EdgeFlag;
 178
 179    ac->IsCached.EdgeFlag = GL_FALSE;
 180    ac->NewArrayState &= ~_NEW_ARRAY_EDGEFLAG;
 181 }
 182
 183
 184 static void reset_attrib( GLcontext *ctx, GLuint index )
 185 {
 186    ACcontext *ac = AC_CONTEXT(ctx);
 187    GLboolean fallback = GL_FALSE;
 188
 189    /*
 190     * The 16 NV vertex attribute arrays have top priority.  If one of those
 191     * is not enabled, look if a corresponding conventional array is enabled.
 192     * If nothing else, use the fallback (ctx->Current.Attrib) values.
 193     */
 194    if (ctx->Array._Enabled & _NEW_ARRAY_ATTRIB(index)) {
 195       ac->Raw.Attrib[index] = ctx->Array.VertexAttrib[index];
 196       STRIDE_ARRAY(ac->Raw.Attrib[index], ac->start);
 197    }
 198    else if (ctx->Array._Enabled & (1 << index)) {
 199       /* use conventional vertex array if possible */
 200       if (index == VERT_ATTRIB_POS) {
 201          ac->Raw.Attrib[index] = ctx->Array.Vertex;
 202       }
 203       else if (index == VERT_ATTRIB_NORMAL) {
 204          ac->Raw.Attrib[index] = ctx->Array.Normal;
 205       }
 206       else if (index == VERT_ATTRIB_COLOR0) {
 207          ac->Raw.Attrib[index] = ctx->Array.Color;
 208       }
 209       else if (index == VERT_ATTRIB_COLOR1) {
 210          ac->Raw.Attrib[index] = ctx->Array.SecondaryColor;
 211       }
 212       else if (index == VERT_ATTRIB_FOG) {
 213          ac->Raw.Attrib[index] = ctx->Array.FogCoord;
 214       }
 215       else if (index >= VERT_ATTRIB_TEX0 && index <= VERT_ATTRIB_TEX7) {
 216          GLuint unit = index - VERT_ATTRIB_TEX0;
 217          ASSERT(unit < MAX_TEXTURE_UNITS);
 218          ac->Raw.Attrib[index] = ctx->Array.TexCoord[unit];
 219       }
 220       else {
 221          /* missing conventional array (vertex weight, for example) */
 222          fallback = GL_TRUE;
 223       }
 224       if (!fallback)
 225          STRIDE_ARRAY(ac->Raw.Attrib[index], ac->start);
 226    }
 227    else {
 228       fallback = GL_TRUE;
 229    }
 230
 231    if (fallback) {
 232       /* fallback to ctx->Current.Attrib values */
 233       ac->Raw.Attrib[index] = ac->Fallback.Attrib[index];
 234
 235       if (ctx->Current.Attrib[index][3] != 1.0)
 236          ac->Raw.Attrib[index].Size = 4;
 237       else if (ctx->Current.Attrib[index][2] != 0.0)
 238          ac->Raw.Attrib[index].Size = 3;
 239       else
 240          ac->Raw.Attrib[index].Size = 2;
 241    }
 242
 243    ac->IsCached.Attrib[index] = GL_FALSE;
 244    ac->NewArrayState &= ~_NEW_ARRAY_ATTRIB(index);
 245 }
 246
 247
 248 /*
 249  * Generic import function for color data
 250  */
 251 static void import( GLcontext *ctx,
 252                     GLenum type,
 253                     struct gl_client_array *to,
 254                     struct gl_client_array *from )
 255 {
 256    ACcontext *ac = AC_CONTEXT(ctx);
 257
 258    if (type == 0)
 259       type = from->Type;
 260
 261    switch (type) {
 262    case GL_FLOAT:
 263       _math_trans_4f( (GLfloat (*)[4]) to->Ptr,
 264                       from->Ptr,
 265                       from->StrideB,
 266                       from->Type,
 267                       from->Size,
 268                       0,
 269                       ac->count - ac->start);
 270
 271       to->StrideB = 4 * sizeof(GLfloat);
 272       to->Type = GL_FLOAT;
 273       break;
 274
 275    case GL_UNSIGNED_BYTE:
 276       _math_trans_4ub( (GLubyte (*)[4]) to->Ptr,
 277                        from->Ptr,
 278                        from->StrideB,
 279                        from->Type,
 280                        from->Size,
 281                        0,
 282                        ac->count - ac->start);
 283
 284       to->StrideB = 4 * sizeof(GLubyte);
 285       to->Type = GL_UNSIGNED_BYTE;
 286       break;
 287
 288    case GL_UNSIGNED_SHORT:
 289       _math_trans_4us( (GLushort (*)[4]) to->Ptr,
 290                        from->Ptr,
 291                        from->StrideB,
 292                        from->Type,
 293                        from->Size,
 294                        0,
 295                        ac->count - ac->start);
 296
 297       to->StrideB = 4 * sizeof(GLushort);
 298       to->Type = GL_UNSIGNED_SHORT;
 299       break;
 300
 301    default:
 302       ASSERT(0);
 303       break;
 304    }
 305 }
 306
 307
 308
 309 /*
 310  * Functions to import array ranges with specified types and strides.
 311  * For example, if the vertex data is GLshort[2] and we want GLfloat[3]
 312  * we'll use an import function to do the data conversion.
 313  */
 314
 315 static void import_texcoord( GLcontext *ctx, GLuint unit,
 316                              GLenum type, GLuint stride )
 317 {
 318    ACcontext *ac = AC_CONTEXT(ctx);
 319    struct gl_client_array *from = &ac->Raw.TexCoord[unit];
 320    struct gl_client_array *to = &ac->Cache.TexCoord[unit];
 321
 322    ASSERT(unit < ctx->Const.MaxTextureUnits);
 323
 324    /* Limited choices at this stage:
 325     */
 326    ASSERT(type == GL_FLOAT);
 327    ASSERT(stride == 4*sizeof(GLfloat) || stride == 0);
 328    ASSERT(ac->count - ac->start < ctx->Const.MaxArrayLockSize);
 329
 330    _math_trans_4f( (GLfloat (*)[4]) to->Ptr,
 331                    from->Ptr,
 332                    from->StrideB,
 333                    from->Type,
 334                    from->Size,
 335                    0,
 336                    ac->count - ac->start);
 337
 338    to->Size = from->Size;
 339    to->StrideB = 4 * sizeof(GLfloat);
 340    to->Type = GL_FLOAT;
 341    ac->IsCached.TexCoord[unit] = GL_TRUE;
 342 }
 343
 344 static void import_vertex( GLcontext *ctx,
 345                            GLenum type, GLuint stride )
 346 {
 347    ACcontext *ac = AC_CONTEXT(ctx);
 348    struct gl_client_array *from = &ac->Raw.Vertex;
 349    struct gl_client_array *to = &ac->Cache.Vertex;
 350
 351    /* Limited choices at this stage:
 352     */
 353    ASSERT(type == GL_FLOAT);
 354    ASSERT(stride == 4*sizeof(GLfloat) || stride == 0);
 355
 356    _math_trans_4f( (GLfloat (*)[4]) to->Ptr,
 357                    from->Ptr,
 358                    from->StrideB,
 359                    from->Type,
 360                    from->Size,
 361                    0,
 362                    ac->count - ac->start);
 363
 364    to->Size = from->Size;
 365    to->StrideB = 4 * sizeof(GLfloat);
 366    to->Type = GL_FLOAT;
 367    ac->IsCached.Vertex = GL_TRUE;
 368 }
 369
 370 static void import_normal( GLcontext *ctx,
 371                            GLenum type, GLuint stride )
 372 {
 373    ACcontext *ac = AC_CONTEXT(ctx);
 374    struct gl_client_array *from = &ac->Raw.Normal;
 375    struct gl_client_array *to = &ac->Cache.Normal;
 376
 377    /* Limited choices at this stage:
 378     */
 379    ASSERT(type == GL_FLOAT);
 380    ASSERT(stride == 3*sizeof(GLfloat) || stride == 0);
 381
 382    _math_trans_3f( (GLfloat (*)[3]) to->Ptr,
 383                    from->Ptr,
 384                    from->StrideB,
 385                    from->Type,
 386                    0,
 387                    ac->count - ac->start);
 388
 389    to->StrideB = 3 * sizeof(GLfloat);
 390    to->Type = GL_FLOAT;
 391    ac->IsCached.Normal = GL_TRUE;
 392 }
 393
 394 static void import_color( GLcontext *ctx,
 395                           GLenum type, GLuint stride )
 396 {
 397    ACcontext *ac = AC_CONTEXT(ctx);
 398    struct gl_client_array *from = &ac->Raw.Color;
 399    struct gl_client_array *to = &ac->Cache.Color;
 400
 401    import( ctx, type, to, from );
 402
 403    ac->IsCached.Color = GL_TRUE;
 404 }
 405
 406 static void import_index( GLcontext *ctx,
 407                           GLenum type, GLuint stride )
 408 {
 409    ACcontext *ac = AC_CONTEXT(ctx);
 410    struct gl_client_array *from = &ac->Raw.Index;
 411    struct gl_client_array *to = &ac->Cache.Index;
 412
 413    /* Limited choices at this stage:
 414     */
 415    ASSERT(type == GL_UNSIGNED_INT);
 416    ASSERT(stride == sizeof(GLuint) || stride == 0);
 417
 418    _math_trans_1ui( (GLuint *) to->Ptr,
 419                     from->Ptr,
 420                     from->StrideB,
 421                     from->Type,
 422                     0,
 423                     ac->count - ac->start);
 424
 425    to->StrideB = sizeof(GLuint);
 426    to->Type = GL_UNSIGNED_INT;
 427    ac->IsCached.Index = GL_TRUE;
 428 }
 429
 430 static void import_secondarycolor( GLcontext *ctx,
 431                                    GLenum type, GLuint stride )
 432 {
 433    ACcontext *ac = AC_CONTEXT(ctx);
 434    struct gl_client_array *from = &ac->Raw.SecondaryColor;
 435    struct gl_client_array *to = &ac->Cache.SecondaryColor;
 436
 437    import( ctx, type, to, from );
 438
 439    ac->IsCached.SecondaryColor = GL_TRUE;
 440 }
 441
 442 static void import_fogcoord( GLcontext *ctx,
 443                              GLenum type, GLuint stride )
 444 {
 445    ACcontext *ac = AC_CONTEXT(ctx);
 446    struct gl_client_array *from = &ac->Raw.FogCoord;
 447    struct gl_client_array *to = &ac->Cache.FogCoord;
 448
 449    /* Limited choices at this stage:
 450     */
 451    ASSERT(type == GL_FLOAT);
 452    ASSERT(stride == sizeof(GLfloat) || stride == 0);
 453
 454    _math_trans_1f( (GLfloat *) to->Ptr,
 455                    from->Ptr,
 456                    from->StrideB,
 457                    from->Type,
 458                    0,
 459                    ac->count - ac->start);
 460
 461    to->StrideB = sizeof(GLfloat);
 462    to->Type = GL_FLOAT;
 463    ac->IsCached.FogCoord = GL_TRUE;
 464 }
 465
 466 static void import_edgeflag( GLcontext *ctx,
 467                              GLenum type, GLuint stride )
 468 {
 469    ACcontext *ac = AC_CONTEXT(ctx);
 470    struct gl_client_array *from = &ac->Raw.EdgeFlag;
 471    struct gl_client_array *to = &ac->Cache.EdgeFlag;
 472
 473    /* Limited choices at this stage:
 474     */
 475    ASSERT(type == GL_UNSIGNED_BYTE);
 476    ASSERT(stride == sizeof(GLubyte) || stride == 0);
 477
 478    _math_trans_1ub( (GLubyte *) to->Ptr,
 479                     from->Ptr,
 480                     from->StrideB,
 481                     from->Type,
 482                     0,
 483                     ac->count - ac->start);
 484
 485    to->StrideB = sizeof(GLubyte);
 486    to->Type = GL_UNSIGNED_BYTE;
 487    ac->IsCached.EdgeFlag = GL_TRUE;
 488 }
 489
 490 static void import_attrib( GLcontext *ctx, GLuint index,
 491                            GLenum type, GLuint stride )
 492 {
 493    ACcontext *ac = AC_CONTEXT(ctx);
 494    struct gl_client_array *from = &ac->Raw.Attrib[index];
 495    struct gl_client_array *to = &ac->Cache.Attrib[index];
 496
 497    ASSERT(index < VERT_ATTRIB_MAX);
 498
 499    /* Limited choices at this stage:
 500     */
 501    ASSERT(type == GL_FLOAT);
 502    ASSERT(stride == 4*sizeof(GLfloat) || stride == 0);
 503    ASSERT(ac->count - ac->start < ctx->Const.MaxArrayLockSize);
 504
 505    _math_trans_4f( (GLfloat (*)[4]) to->Ptr,
 506                    from->Ptr,
 507                    from->StrideB,
 508                    from->Type,
 509                    from->Size,
 510                    0,
 511                    ac->count - ac->start);
 512
 513    to->Size = from->Size;
 514    to->StrideB = 4 * sizeof(GLfloat);
 515    to->Type = GL_FLOAT;
 516    ac->IsCached.Attrib[index] = GL_TRUE;
 517 }
 518
 519
 520
 521 /*
 522  * Externals to request arrays with specific properties:
 523  */
 524
 525
 526 struct gl_client_array *_ac_import_texcoord( GLcontext *ctx,
 527                                              GLuint unit,
 528                                              GLenum type,
 529                                              GLuint reqstride,
 530                                              GLuint reqsize,
 531                                              GLboolean reqwriteable,
 532                                              GLboolean *writeable )
 533 {
 534    ACcontext *ac = AC_CONTEXT(ctx);
 535
 536    ASSERT(unit < ctx->Const.MaxTextureUnits);
 537
 538    /* Can we keep the existing version?
 539     */
 540    if (ac->NewArrayState & _NEW_ARRAY_TEXCOORD(unit))
 541       reset_texcoord( ctx, unit );
 542
 543    /* Is the request impossible?
 544     */
 545    if (reqsize != 0 && ac->Raw.TexCoord[unit].Size > (GLint) reqsize)
 546       return 0;
 547
 548    /* Do we need to pull in a copy of the client data:
 549     */
 550    if (ac->Raw.TexCoord[unit].Type != type ||
 551        (reqstride != 0 && ac->Raw.TexCoord[unit].StrideB != (GLint)reqstride) ||
 552        reqwriteable)
 553    {
 554       if (!ac->IsCached.TexCoord[unit])
 555          import_texcoord(ctx, unit, type, reqstride );
 556       *writeable = GL_TRUE;
 557       return &ac->Cache.TexCoord[unit];
 558    }
 559    else {
 560       *writeable = GL_FALSE;
 561       return &ac->Raw.TexCoord[unit];
 562    }
 563 }
 564
 565 struct gl_client_array *_ac_import_vertex( GLcontext *ctx,
 566                                            GLenum type,
 567                                            GLuint reqstride,
 568                                            GLuint reqsize,
 569                                            GLboolean reqwriteable,
 570                                            GLboolean *writeable )
 571 {
 572    ACcontext *ac = AC_CONTEXT(ctx);
 573
 574    /* Can we keep the existing version?
 575     */
 576    if (ac->NewArrayState & _NEW_ARRAY_VERTEX)
 577       reset_vertex( ctx );
 578
 579    /* Is the request impossible?
 580     */
 581    if (reqsize != 0 && ac->Raw.Vertex.Size > (GLint) reqsize)
 582       return 0;
 583
 584    /* Do we need to pull in a copy of the client data:
 585     */
 586    if (ac->Raw.Vertex.Type != type ||
 587        (reqstride != 0 && ac->Raw.Vertex.StrideB != (GLint) reqstride) ||
 588        reqwriteable)
 589    {
 590       if (!ac->IsCached.Vertex)
 591          import_vertex(ctx, type, reqstride );
 592       *writeable = GL_TRUE;
 593       return &ac->Cache.Vertex;
 594    }
 595    else {
 596       *writeable = GL_FALSE;
 597       return &ac->Raw.Vertex;
 598    }
 599 }
 600
 601 struct gl_client_array *_ac_import_normal( GLcontext *ctx,
 602                                            GLenum type,
 603                                            GLuint reqstride,
 604                                            GLboolean reqwriteable,
 605                                            GLboolean *writeable )
 606 {
 607    ACcontext *ac = AC_CONTEXT(ctx);
 608
 609    /* Can we keep the existing version?
 610     */
 611    if (ac->NewArrayState & _NEW_ARRAY_NORMAL)
 612       reset_normal( ctx );
 613
 614    /* Do we need to pull in a copy of the client data:
 615     */
 616    if (ac->Raw.Normal.Type != type ||
 617        (reqstride != 0 && ac->Raw.Normal.StrideB != (GLint) reqstride) ||
 618        reqwriteable)
 619    {
 620       if (!ac->IsCached.Normal)
 621          import_normal(ctx, type, reqstride );
 622       *writeable = GL_TRUE;
 623       return &ac->Cache.Normal;
 624    }
 625    else {
 626       *writeable = GL_FALSE;
 627       return &ac->Raw.Normal;
 628    }
 629 }
 630
 631 struct gl_client_array *_ac_import_color( GLcontext *ctx,
 632                                           GLenum type,
 633                                           GLuint reqstride,
 634                                           GLuint reqsize,
 635                                           GLboolean reqwriteable,
 636                                           GLboolean *writeable )
 637 {
 638    ACcontext *ac = AC_CONTEXT(ctx);
 639
 640    /* Can we keep the existing version?
 641     */
 642    if (ac->NewArrayState & _NEW_ARRAY_COLOR0)
 643       reset_color( ctx );
 644
 645    /* Is the request impossible?
 646     */
 647    if (reqsize != 0 && ac->Raw.Color.Size > (GLint) reqsize) {
 648       return 0;
 649    }
 650
 651    /* Do we need to pull in a copy of the client data:
 652     */
 653    if ((type != 0 && ac->Raw.Color.Type != type) ||
 654        (reqstride != 0 && ac->Raw.Color.StrideB != (GLint) reqstride) ||
 655        reqwriteable)
 656    {
 657       if (!ac->IsCached.Color)
 658          import_color(ctx, type, reqstride );
 659       *writeable = GL_TRUE;
 660       return &ac->Cache.Color;
 661    }
 662    else {
 663       *writeable = GL_FALSE;
 664       return &ac->Raw.Color;
 665    }
 666 }
 667
 668 struct gl_client_array *_ac_import_index( GLcontext *ctx,
 669                                           GLenum type,
 670                                           GLuint reqstride,
 671                                           GLboolean reqwriteable,
 672                                           GLboolean *writeable )
 673 {
 674    ACcontext *ac = AC_CONTEXT(ctx);
 675
 676    /* Can we keep the existing version?
 677     */
 678    if (ac->NewArrayState & _NEW_ARRAY_INDEX)
 679       reset_index( ctx );
 680
 681
 682    /* Do we need to pull in a copy of the client data:
 683     */
 684    if (ac->Raw.Index.Type != type ||
 685        (reqstride != 0 && ac->Raw.Index.StrideB != (GLint) reqstride) ||
 686        reqwriteable)
 687    {
 688       if (!ac->IsCached.Index)
 689          import_index(ctx, type, reqstride );
 690       *writeable = GL_TRUE;
 691       return &ac->Cache.Index;
 692    }
 693    else {
 694       *writeable = GL_FALSE;
 695       return &ac->Raw.Index;
 696    }
 697 }
 698
 699 struct gl_client_array *_ac_import_secondarycolor( GLcontext *ctx,
 700                                                    GLenum type,
 701                                                    GLuint reqstride,
 702                                                    GLuint reqsize,
 703                                                    GLboolean reqwriteable,
 704                                                    GLboolean *writeable )
 705 {
 706    ACcontext *ac = AC_CONTEXT(ctx);
 707
 708    /* Can we keep the existing version?
 709     */
 710    if (ac->NewArrayState & _NEW_ARRAY_COLOR1)
 711       reset_secondarycolor( ctx );
 712
 713    /* Is the request impossible?
 714     */
 715    if (reqsize != 0 && ac->Raw.SecondaryColor.Size > (GLint) reqsize)
 716       return 0;
 717
 718    /* Do we need to pull in a copy of the client data:
 719     */
 720    if ((type != 0 && ac->Raw.SecondaryColor.Type != type) ||
 721        (reqstride != 0 && ac->Raw.SecondaryColor.StrideB != (GLint)reqstride) ||
 722        reqwriteable)
 723    {
 724       if (!ac->IsCached.SecondaryColor)
 725          import_secondarycolor(ctx, type, reqstride );
 726       *writeable = GL_TRUE;
 727       return &ac->Cache.SecondaryColor;
 728    }
 729    else {
 730       *writeable = GL_FALSE;
 731       return &ac->Raw.SecondaryColor;
 732    }
 733 }
 734
 735 struct gl_client_array *_ac_import_fogcoord( GLcontext *ctx,
 736                                              GLenum type,
 737                                              GLuint reqstride,
 738                                              GLboolean reqwriteable,
 739                                              GLboolean *writeable )
 740 {
 741    ACcontext *ac = AC_CONTEXT(ctx);
 742
 743    /* Can we keep the existing version?
 744     */
 745    if (ac->NewArrayState & _NEW_ARRAY_FOGCOORD)
 746       reset_fogcoord( ctx );
 747
 748    /* Do we need to pull in a copy of the client data:
 749     */
 750    if (ac->Raw.FogCoord.Type != type ||
 751        (reqstride != 0 && ac->Raw.FogCoord.StrideB != (GLint) reqstride) ||
 752        reqwriteable)
 753    {
 754       if (!ac->IsCached.FogCoord)
 755          import_fogcoord(ctx, type, reqstride );
 756       *writeable = GL_TRUE;
 757       return &ac->Cache.FogCoord;
 758    }
 759    else {
 760       *writeable = GL_FALSE;
 761       return &ac->Raw.FogCoord;
 762    }
 763 }
 764
 765 struct gl_client_array *_ac_import_edgeflag( GLcontext *ctx,
 766                                              GLenum type,
 767                                              GLuint reqstride,
 768                                              GLboolean reqwriteable,
 769                                              GLboolean *writeable )
 770 {
 771    ACcontext *ac = AC_CONTEXT(ctx);
 772
 773    /* Can we keep the existing version?
 774     */
 775    if (ac->NewArrayState & _NEW_ARRAY_EDGEFLAG)
 776       reset_edgeflag( ctx );
 777
 778    /* Do we need to pull in a copy of the client data:
 779     */
 780    if (ac->Raw.EdgeFlag.Type != type ||
 781        (reqstride != 0 && ac->Raw.EdgeFlag.StrideB != (GLint) reqstride) ||
 782        reqwriteable)
 783    {
 784       if (!ac->IsCached.EdgeFlag)
 785          import_edgeflag(ctx, type, reqstride );
 786       *writeable = GL_TRUE;
 787       return &ac->Cache.EdgeFlag;
 788    }
 789    else {
 790       *writeable = GL_FALSE;
 791       return &ac->Raw.EdgeFlag;
 792    }
 793 }
 794
 795 /* GL_NV_vertex_program */
 796 struct gl_client_array *_ac_import_attrib( GLcontext *ctx,
 797                                            GLuint index,
 798                                            GLenum type,
 799                                            GLuint reqstride,
 800                                            GLuint reqsize,
 801                                            GLboolean reqwriteable,
 802                                            GLboolean *writeable )
 803 {
 804    ACcontext *ac = AC_CONTEXT(ctx);
 805
 806    ASSERT(index < VERT_ATTRIB_MAX);
 807
 808    /* Can we keep the existing version?
 809     */
 810    if (ac->NewArrayState & _NEW_ARRAY_ATTRIB(index)) {
 811       reset_attrib( ctx, index );
 812    }
 813    else if (ac->NewArrayState & (1 << index)) {
 814       /* Also need to check conventional attributes */
 815       reset_attrib( ctx, index );
 816    }
 817
 818    /* Is the request impossible?
 819     */
 820    if (reqsize != 0 && ac->Raw.Attrib[index].Size > (GLint) reqsize)
 821       return NULL;
 822
 823    /* Do we need to pull in a copy of the client data:
 824     */
 825    if (ac->Raw.Attrib[index].Type != type ||
 826        (reqstride != 0 && ac->Raw.Attrib[index].StrideB != (GLint)reqstride) ||
 827        reqwriteable)
 828    {
 829       if (!ac->IsCached.Attrib[index])
 830          import_attrib(ctx, index, type, reqstride );
 831       *writeable = GL_TRUE;
 832       return &ac->Cache.Attrib[index];
 833    }
 834    else {
 835       *writeable = GL_FALSE;
 836       return &ac->Raw.Attrib[index];
 837    }
 838 }
 839
 840
 841 /* Clients must call this function to validate state and set bounds
 842  * before importing any data:
 843  */
 844 void _ac_import_range( GLcontext *ctx, GLuint start, GLuint count )
 845 {
 846    ACcontext *ac = AC_CONTEXT(ctx);
 847
 848    if (!ctx->Array.LockCount) {
 849       /* Not locked, discard cached data.  Changes to lock
 850        * status are caught via. _ac_invalidate_state().
 851        */
 852       ac->NewArrayState = _NEW_ARRAY_ALL;
 853       ac->start = start;
 854       ac->count = count;
 855    }
 856    else {
 857       /* Locked, discard data for any disabled arrays.  Require that
 858        * the whole locked range always be dealt with, otherwise hard to
 859        * maintain cached data in the face of clipping.
 860        */
 861       ac->NewArrayState |= ~ctx->Array._Enabled;
 862       ac->start = ctx->Array.LockFirst;
 863       ac->count = ctx->Array.LockCount;
 864       ASSERT(ac->start == start); /* hmm? */
 865       ASSERT(ac->count == count);
 866    }
 867 }
 868
 869
 870
 871 /* Additional convienence function for importing the element list
 872  * for glDrawElements() and glDrawRangeElements().
 873  */
 874 CONST void *
 875 _ac_import_elements( GLcontext *ctx,
 876                      GLenum new_type,
 877                      GLuint count,
 878                      GLenum old_type,
 879                      CONST void *indices )
 880 {
 881    ACcontext *ac = AC_CONTEXT(ctx);
 882
 883    if (old_type == new_type)
 884       return indices;
 885
 886    if (ac->elt_size < count * sizeof(GLuint)) {
 887       if (ac->Elts) FREE(ac->Elts);
 888       while (ac->elt_size < count * sizeof(GLuint))
 889          ac->elt_size *= 2;
 890       ac->Elts = (GLuint *) MALLOC(ac->elt_size);
 891    }
 892
 893    switch (new_type) {
 894    case GL_UNSIGNED_BYTE:
 895       ASSERT(0);
 896       return 0;
 897    case GL_UNSIGNED_SHORT:
 898       ASSERT(0);
 899       return 0;
 900    case GL_UNSIGNED_INT: {
 901       GLuint *out = (GLuint *)ac->Elts;
 902       GLuint i;
 903
 904       switch (old_type) {
 905       case GL_UNSIGNED_BYTE: {
 906          CONST GLubyte *in = (CONST GLubyte *)indices;
 907          for (i = 0 ; i < count ; i++)
 908             out[i] = in[i];
 909          break;
 910       }
 911       case GL_UNSIGNED_SHORT: {
 912          CONST GLushort *in = (CONST GLushort *)indices;
 913          for (i = 0 ; i < count ; i++)
 914                out[i] = in[i];
 915          break;
 916       }
 917       default:
 918          ASSERT(0);
 919       }
 920
 921       return (CONST void *)out;
 922    }
 923    default:
 924       ASSERT(0);
 925       break;
 926    }
 927
 928    return 0;
 929 }