src/mesa/tnl/t_imm_fixup.c

   1 /* $Id: t_imm_fixup.c,v 1.39 2002/10/29 20:29:03 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
  27 /*
  28  * Authors:
  29  *    Keith Whitwell <keith@tungstengraphics.com>
  30  */
  31
  32
  33 #include "glheader.h"
  34 #include "context.h"
  35 #include "enums.h"
  36 #include "dlist.h"
  37 #include "colormac.h"
  38 #include "light.h"
  39 #include "macros.h"
  40 #include "imports.h"
  41 #include "mmath.h"
  42 #include "state.h"
  43 #include "mtypes.h"
  44
  45 #include "math/m_matrix.h"
  46 #include "math/m_xform.h"
  47
  48 #include "t_context.h"
  49 #include "t_imm_alloc.h"
  50 #include "t_imm_debug.h"
  51 #include "t_imm_elt.h"
  52 #include "t_imm_fixup.h"
  53 #include "t_imm_exec.h"
  54 #include "t_pipeline.h"
  55
  56
  57 static const GLuint increment[GL_POLYGON+2] = { 1,2,1,1,3,1,1,4,2,1,1 };
  58 static const GLuint intro[GL_POLYGON+2]     = { 0,0,2,2,0,2,2,0,2,2,0 };
  59
  60 void
  61 _tnl_fixup_4f( GLfloat data[][4], GLuint flag[], GLuint start, GLuint match )
  62 {
  63    GLuint i = start;
  64
  65    for (;;) {
  66       if ((flag[++i] & match) == 0) {
  67          COPY_4FV(data[i], data[i-1]);
  68          if (flag[i] & VERT_BIT_END_VB) break;
  69       }
  70    }
  71 }
  72
  73 void
  74 _tnl_fixup_3f( float data[][3], GLuint flag[], GLuint start, GLuint match )
  75 {
  76    GLuint i = start;
  77
  78
  79    for (;;) {
  80       if ((flag[++i] & match) == 0) {
  81 /*       _mesa_debug(NULL, "_tnl_fixup_3f copy to %p values %f %f %f\n", */
  82 /*               data[i],  */
  83 /*               data[i-1][0], */
  84 /*               data[i-1][1], */
  85 /*               data[i-1][2]); */
  86          COPY_3V(data[i], data[i-1]);
  87          if (flag[i] & VERT_BIT_END_VB) break;
  88       }
  89    }
  90 }
  91
  92
  93 void
  94 _tnl_fixup_1ui( GLuint *data, GLuint flag[], GLuint start, GLuint match )
  95 {
  96    GLuint i = start;
  97
  98    for (;;) {
  99       if ((flag[++i] & match) == 0) {
 100          data[i] = data[i-1];
 101          if (flag[i] & VERT_BIT_END_VB) break;
 102       }
 103    }
 104    flag[i] |= match;
 105 }
 106
 107
 108 void
 109 _tnl_fixup_1f( GLfloat *data, GLuint flag[], GLuint start, GLuint match )
 110 {
 111    GLuint i = start;
 112
 113    for (;;) {
 114       if ((flag[++i] & match) == 0) {
 115          data[i] = data[i-1];
 116          if (flag[i] & VERT_BIT_END_VB) break;
 117       }
 118    }
 119    flag[i] |= match;
 120 }
 121
 122 void
 123 _tnl_fixup_1ub( GLubyte *data, GLuint flag[], GLuint start, GLuint match )
 124 {
 125    GLuint i = start;
 126
 127    for (;;) {
 128       if ((flag[++i] & match) == 0) {
 129          data[i] = data[i-1];
 130          if (flag[i] & VERT_BIT_END_VB) break;
 131       }
 132    }
 133    flag[i] |= match;
 134 }
 135
 136
 137 static void
 138 fixup_first_4f( GLfloat data[][4], GLuint flag[], GLuint match,
 139                 GLuint start, GLfloat *dflt )
 140 {
 141    GLuint i = start-1;
 142    match |= VERT_BIT_END_VB;
 143
 144    while ((flag[++i]&match) == 0)
 145       COPY_4FV(data[i], dflt);
 146 }
 147
 148 #if 0
 149 static void
 150 fixup_first_3f( GLfloat data[][3], GLuint flag[], GLuint match,
 151                 GLuint start, GLfloat *dflt )
 152 {
 153    GLuint i = start-1;
 154    match |= VERT_BIT_END_VB;
 155
 156 /*     _mesa_debug(NULL, "fixup_first_3f default: %f %f %f start: %d\n", */
 157 /*         dflt[0], dflt[1], dflt[2], start);  */
 158
 159    while ((flag[++i]&match) == 0)
 160       COPY_3FV(data[i], dflt);
 161 }
 162 #endif
 163
 164 static void
 165 fixup_first_1ui( GLuint data[], GLuint flag[], GLuint match,
 166                  GLuint start, GLuint dflt )
 167 {
 168    GLuint i = start-1;
 169    match |= VERT_BIT_END_VB;
 170
 171    while ((flag[++i]&match) == 0)
 172       data[i] = dflt;
 173 }
 174
 175 #if 00
 176 static void
 177 fixup_first_1f( GLfloat data[], GLuint flag[], GLuint match,
 178                 GLuint start, GLfloat dflt )
 179 {
 180    GLuint i = start-1;
 181    match |= VERT_BIT_END_VB;
 182
 183    while ((flag[++i]&match) == 0)
 184       data[i] = dflt;
 185 }
 186 #endif
 187
 188 static void
 189 fixup_first_1ub( GLubyte data[], GLuint flag[], GLuint match,
 190                  GLuint start, GLubyte dflt )
 191 {
 192    GLuint i = start-1;
 193    match |= VERT_BIT_END_VB;
 194
 195    while ((flag[++i]&match) == 0)
 196       data[i] = dflt;
 197 }
 198
 199 /*
 200  * Copy vertex attributes from the ctx->Current group into the immediate
 201  * struct at the given position according to copyMask.
 202  */
 203 static void copy_from_current( GLcontext *ctx, struct immediate *IM,
 204                               GLuint pos, GLuint copyMask )
 205 {
 206    GLuint attrib, attribBit;
 207
 208    if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
 209       _tnl_print_vert_flags("copy from current", copyMask);
 210
 211 #if 0
 212    if (copyMask & VERT_BIT_NORMAL) {
 213       COPY_4V(IM->Attrib[VERT_ATTRIB_NORMAL][pos],
 214               ctx->Current.Attrib[VERT_ATTRIB_NORMAL]);
 215    }
 216
 217    if (copyMask & VERT_BIT_COLOR0) {
 218       COPY_4FV( IM->Attrib[VERT_ATTRIB_COLOR0][pos],
 219                 ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);
 220    }
 221
 222    if (copyMask & VERT_BIT_COLOR1)
 223       COPY_4FV( IM->Attrib[VERT_ATTRIB_COLOR1][pos],
 224                 ctx->Current.Attrib[VERT_ATTRIB_COLOR1]);
 225
 226    if (copyMask & VERT_BIT_FOG)
 227       IM->Attrib[VERT_ATTRIB_FOG][pos][0] = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
 228
 229    if (copyMask & VERT_BITS_TEX_ANY) {
 230       GLuint i;
 231       for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
 232          if (copyMask & VERT_BIT_TEX(i))
 233             COPY_4FV(IM->Attrib[VERT_ATTRIB_TEX0 + i][pos],
 234                      ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i]);
 235       }
 236    }
 237 #else
 238    for (attrib = 0, attribBit = 1; attrib < 16; attrib++, attribBit <<= 1) {
 239       if (copyMask & attribBit) {
 240          COPY_4FV( IM->Attrib[attrib][pos], ctx->Current.Attrib[attrib]);
 241       }
 242    }
 243 #endif
 244
 245    if (copyMask & VERT_BIT_INDEX)
 246       IM->Index[pos] = ctx->Current.Index;
 247
 248    if (copyMask & VERT_BIT_EDGEFLAG)
 249       IM->EdgeFlag[pos] = ctx->Current.EdgeFlag;
 250 }
 251
 252
 253 void _tnl_fixup_input( GLcontext *ctx, struct immediate *IM )
 254 {
 255    TNLcontext *tnl = TNL_CONTEXT(ctx);
 256    GLuint start = IM->CopyStart;
 257    GLuint andflag = IM->CopyAndFlag;
 258    GLuint orflag = IM->CopyOrFlag | IM->Evaluated;
 259    GLuint fixup;
 260
 261    IM->CopyTexSize = IM->TexSize;
 262
 263 /*     _mesa_debug(ctx, "Fixup input, Start: %u Count: %u LastData: %u\n", */
 264 /*         IM->Start, IM->Count, IM->LastData); */
 265 /*     _tnl_print_vert_flags("Orflag", orflag); */
 266 /*     _tnl_print_vert_flags("Andflag", andflag); */
 267
 268
 269    fixup = ~andflag & VERT_BITS_FIXUP;
 270
 271    if (!ctx->CompileFlag)
 272       fixup &= tnl->pipeline.inputs;
 273
 274    if (!ctx->ExecuteFlag)
 275       fixup &= orflag;
 276
 277    if ((orflag & (VERT_BIT_POS|VERT_BITS_EVAL_ANY)) == 0)
 278       fixup = 0;
 279
 280    if (fixup) {
 281       GLuint copy = fixup & ~IM->Flag[start];
 282
 283
 284       /* Equivalent to a lazy copy-from-current when setting up the
 285        * immediate.
 286        */
 287       if (ctx->ExecuteFlag && copy)
 288          copy_from_current( ctx, IM, start, copy );
 289
 290       if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
 291          _tnl_print_vert_flags("fixup", fixup);
 292
 293       /* XXX replace these conditionals with a loop over the 16
 294        * vertex attributes.
 295        */
 296
 297       if (fixup & VERT_BITS_TEX_ANY) {
 298          GLuint i;
 299          for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
 300             if (fixup & VERT_BIT_TEX(i)) {
 301                if (orflag & VERT_BIT_TEX(i))
 302                   _tnl_fixup_4f( IM->Attrib[VERT_ATTRIB_TEX0 + i], IM->Flag,
 303                                  start, VERT_BIT_TEX(i) );
 304                else
 305                   fixup_first_4f( IM->Attrib[VERT_ATTRIB_TEX0 + i], IM->Flag,
 306                                   VERT_BIT_END_VB, start,
 307                                   IM->Attrib[VERT_ATTRIB_TEX0 + i][start]);
 308             }
 309          }
 310       }
 311
 312
 313       if (fixup & VERT_BIT_EDGEFLAG) {
 314          if (orflag & VERT_BIT_EDGEFLAG)
 315             _tnl_fixup_1ub( IM->EdgeFlag, IM->Flag, start, VERT_BIT_EDGEFLAG );
 316          else
 317             fixup_first_1ub( IM->EdgeFlag, IM->Flag, VERT_BIT_END_VB, start,
 318                              IM->EdgeFlag[start] );
 319       }
 320
 321       if (fixup & VERT_BIT_INDEX) {
 322          if (orflag & VERT_BIT_INDEX)
 323             _tnl_fixup_1ui( IM->Index, IM->Flag, start, VERT_BIT_INDEX );
 324          else
 325             fixup_first_1ui( IM->Index, IM->Flag, VERT_BIT_END_VB, start,
 326                              IM->Index[start] );
 327       }
 328
 329       if (fixup & VERT_BIT_COLOR0) {
 330          if (orflag & VERT_BIT_COLOR0)
 331             _tnl_fixup_4f( IM->Attrib[VERT_ATTRIB_COLOR0], IM->Flag, start,
 332                            VERT_BIT_COLOR0 );
 333          /* No need for else case as the drivers understand stride
 334           * zero here.  (TODO - propogate this)
 335           */
 336       }
 337
 338       if (fixup & VERT_BIT_COLOR1) {
 339          if (orflag & VERT_BIT_COLOR1)
 340             _tnl_fixup_4f( IM->Attrib[VERT_ATTRIB_COLOR1], IM->Flag, start,
 341                            VERT_BIT_COLOR1 );
 342          else
 343             fixup_first_4f( IM->Attrib[VERT_ATTRIB_COLOR1], IM->Flag, VERT_BIT_END_VB, start,
 344                             IM->Attrib[VERT_ATTRIB_COLOR1][start] );
 345       }
 346
 347       if (fixup & VERT_BIT_FOG) {
 348          if (orflag & VERT_BIT_FOG)
 349             _tnl_fixup_4f( IM->Attrib[VERT_ATTRIB_FOG], IM->Flag,
 350                            start, VERT_BIT_FOG );
 351          else
 352             fixup_first_4f( IM->Attrib[VERT_ATTRIB_FOG], IM->Flag, VERT_BIT_END_VB,
 353                             start, IM->Attrib[VERT_ATTRIB_FOG][start] );
 354       }
 355
 356       if (fixup & VERT_BIT_NORMAL) {
 357          if (orflag & VERT_BIT_NORMAL)
 358             _tnl_fixup_4f( IM->Attrib[VERT_ATTRIB_NORMAL], IM->Flag, start,
 359                            VERT_BIT_NORMAL );
 360          else
 361             fixup_first_4f( IM->Attrib[VERT_ATTRIB_NORMAL], IM->Flag,
 362                             VERT_BIT_END_VB, start,
 363                             IM->Attrib[VERT_ATTRIB_NORMAL][start] );
 364       }
 365    }
 366
 367    /* Prune possible half-filled slot.
 368     */
 369    IM->Flag[IM->LastData+1] &= ~VERT_BIT_END_VB;
 370    IM->Flag[IM->Count] |= VERT_BIT_END_VB;
 371
 372
 373    /* Materials:
 374     */
 375    if (IM->MaterialOrMask & ~IM->MaterialAndMask) {
 376       GLuint vulnerable = IM->MaterialOrMask;
 377       GLuint i = IM->Start;
 378
 379       do {
 380          while (!(IM->Flag[i] & VERT_BIT_MATERIAL))
 381             i++;
 382
 383          vulnerable &= ~IM->MaterialMask[i];
 384          _mesa_copy_material_pairs( IM->Material[i],
 385                                     ctx->Light.Material,
 386                                     vulnerable );
 387
 388
 389         ++i;
 390       } while (vulnerable);
 391    }
 392 }
 393
 394
 395 static void
 396 copy_material( struct immediate *next,
 397                struct immediate *prev,
 398                GLuint dst, GLuint src )
 399 {
 400 /*     _mesa_debug(NULL, "%s\n", __FUNCTION__); */
 401
 402    if (next->Material == 0) {
 403       next->Material = (struct gl_material (*)[2])
 404          MALLOC( sizeof(struct gl_material) * IMM_SIZE * 2 );
 405       next->MaterialMask = (GLuint *) MALLOC( sizeof(GLuint) * IMM_SIZE );
 406    }
 407
 408    next->MaterialMask[dst] = prev->MaterialOrMask;
 409    MEMCPY(next->Material[dst], prev->Material[src],
 410           2 * sizeof(struct gl_material));
 411 }
 412
 413
 414
 415 static GLboolean is_fan_like[GL_POLYGON+1] = {
 416    GL_FALSE,
 417    GL_FALSE,
 418    GL_TRUE,                     /* line loop */
 419    GL_FALSE,
 420    GL_FALSE,
 421    GL_FALSE,
 422    GL_TRUE,                     /* tri fan */
 423    GL_FALSE,
 424    GL_FALSE,
 425    GL_TRUE                      /* polygon */
 426 };
 427
 428
 429 /* Copy the untransformed data from the shared vertices of a primitive
 430  * that wraps over two immediate structs.  This is done prior to
 431  * set_immediate so that prev and next may point to the same
 432  * structure.  In general it's difficult to avoid this copy on long
 433  * primitives.
 434  *
 435  * Have to be careful with the transitions between display list
 436  * replay, compile and normal execute modes.
 437  */
 438 void _tnl_copy_immediate_vertices( GLcontext *ctx, struct immediate *next )
 439 {
 440    TNLcontext *tnl = TNL_CONTEXT(ctx);
 441    struct immediate *prev = tnl->ExecCopySource;
 442    struct vertex_arrays *inputs = &tnl->imm_inputs;
 443    GLuint count = tnl->ExecCopyCount;
 444    GLuint *elts = tnl->ExecCopyElts;
 445    GLuint offset = IMM_MAX_COPIED_VERTS - count;
 446    GLuint i;
 447
 448    if (!prev) {
 449       ASSERT(tnl->ExecCopyCount == 0);
 450       return;
 451    }
 452
 453    next->CopyStart = next->Start - count;
 454
 455    if ((prev->CopyOrFlag & VERT_BITS_DATA) == VERT_BIT_ELT &&
 456        ctx->Array.LockCount &&
 457        ctx->Array.Vertex.Enabled)
 458    {
 459       /* Copy Elt values only
 460        */
 461       for (i = 0 ; i < count ; i++)
 462       {
 463          GLuint src = elts[i+offset];
 464          GLuint dst = next->CopyStart+i;
 465          next->Elt[dst] = prev->Elt[src];
 466          next->Flag[dst] = VERT_BIT_ELT;
 467          elts[i+offset] = dst;
 468       }
 469 /*        _mesa_debug(ctx, "ADDING VERT_BIT_ELT!\n"); */
 470       next->CopyOrFlag |= VERT_BIT_ELT;
 471       next->CopyAndFlag &= VERT_BIT_ELT;
 472    }
 473    else {
 474       GLuint copy = tnl->pipeline.inputs & (prev->CopyOrFlag|prev->Evaluated);
 475       GLuint flag;
 476
 477       if (is_fan_like[ctx->Driver.CurrentExecPrimitive]) {
 478          flag = ((prev->CopyOrFlag|prev->Evaluated) & VERT_BITS_FIXUP);
 479          next->CopyOrFlag |= flag;
 480       }
 481       else {
 482          /* Don't let an early 'glColor', etc. poison the elt path.
 483           */
 484          flag = ((prev->OrFlag|prev->Evaluated) & VERT_BITS_FIXUP);
 485       }
 486
 487       next->TexSize |= tnl->ExecCopyTexSize;
 488       next->CopyAndFlag &= flag;
 489
 490
 491 /*        _tnl_print_vert_flags("copy vertex components", copy); */
 492 /*        _tnl_print_vert_flags("prev copyorflag", prev->CopyOrFlag); */
 493 /*        _tnl_print_vert_flags("flag", flag); */
 494
 495       /* Copy whole vertices
 496        */
 497       for (i = 0 ; i < count ; i++)
 498       {
 499          GLuint src = elts[i+offset];
 500          GLuint isrc = src - prev->CopyStart;
 501          GLuint dst = next->CopyStart+i;
 502
 503          /* Values subject to eval must be copied out of the 'inputs'
 504           * struct.  (Copied rows should not be evaluated twice).
 505           *
 506           * Note these pointers are null when inactive.
 507           */
 508          COPY_4FV( next->Attrib[VERT_ATTRIB_POS][dst],
 509                    inputs->Obj.data[isrc] );
 510
 511          if (copy & VERT_BIT_NORMAL) {
 512 /*          _mesa_debug(ctx, "copy vert norm %d to %d (%p): %f %f %f\n", */
 513 /*                  isrc, dst,  */
 514 /*                  next->Normal[dst], */
 515 /*                  inputs->Normal.data[isrc][0], */
 516 /*                  inputs->Normal.data[isrc][1], */
 517 /*                  inputs->Normal.data[isrc][2]); */
 518             COPY_3FV( next->Attrib[VERT_ATTRIB_NORMAL][dst], inputs->Normal.data[isrc] );
 519          }
 520
 521          if (copy & VERT_BIT_COLOR0)
 522             COPY_4FV( next->Attrib[VERT_ATTRIB_COLOR0][dst],
 523                       ((GLfloat (*)[4])inputs->Color.Ptr)[isrc] );
 524
 525          if (copy & VERT_BIT_INDEX)
 526             next->Index[dst] = inputs->Index.data[isrc];
 527
 528          if (copy & VERT_BITS_TEX_ANY) {
 529             GLuint i;
 530             for (i = 0 ; i < prev->MaxTextureUnits ; i++) {
 531                if (copy & VERT_BIT_TEX(i))
 532                   COPY_4FV( next->Attrib[VERT_ATTRIB_TEX0 + i][dst],
 533                             inputs->TexCoord[i].data[isrc] );
 534             }
 535          }
 536
 537          /* Remaining values should be the same in the 'input' struct and the
 538           * original immediate.
 539           */
 540          if (copy & (VERT_BIT_ELT|VERT_BIT_EDGEFLAG|VERT_BIT_COLOR1|VERT_BIT_FOG|
 541                      VERT_BIT_MATERIAL)) {
 542
 543             if (prev->Flag[src] & VERT_BIT_MATERIAL)
 544                copy_material(next, prev, dst, src);
 545
 546             next->Elt[dst] = prev->Elt[src];
 547             next->EdgeFlag[dst] = prev->EdgeFlag[src];
 548             COPY_4FV( next->Attrib[VERT_ATTRIB_COLOR1][dst],
 549                       prev->Attrib[VERT_ATTRIB_COLOR1][src] );
 550             COPY_4FV( next->Attrib[VERT_ATTRIB_FOG][dst],
 551                       prev->Attrib[VERT_ATTRIB_FOG][src] );
 552          }
 553
 554          next->Flag[dst] = flag;
 555          next->CopyOrFlag |= prev->Flag[src] & (VERT_BITS_FIXUP|
 556                                                 VERT_BIT_MATERIAL|
 557                                                 VERT_BIT_POS);
 558          elts[i+offset] = dst;
 559       }
 560    }
 561
 562    if (--tnl->ExecCopySource->ref_count == 0)
 563       _tnl_free_immediate( ctx, tnl->ExecCopySource );
 564
 565    tnl->ExecCopySource = next; next->ref_count++;
 566 }
 567
 568
 569
 570 /* Revive a compiled immediate struct - propogate new 'Current'
 571  * values.  Often this is redundant because the current values were
 572  * known and fixed up at compile time (or in the first execution of
 573  * the cassette).
 574  */
 575 void _tnl_fixup_compiled_cassette( GLcontext *ctx, struct immediate *IM )
 576 {
 577    TNLcontext *tnl = TNL_CONTEXT(ctx);
 578    GLuint fixup;
 579    GLuint start = IM->Start;
 580
 581 /*     _mesa_debug(ctx, "%s\n", __FUNCTION__); */
 582
 583    IM->Evaluated = 0;
 584    IM->CopyOrFlag = IM->OrFlag;
 585    IM->CopyAndFlag = IM->AndFlag;
 586    IM->CopyTexSize = IM->TexSize | tnl->ExecCopyTexSize;
 587
 588    _tnl_copy_immediate_vertices( ctx, IM );
 589
 590    if (ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1) {
 591       ASSERT(IM->CopyStart == IM->Start);
 592    }
 593
 594    /* Naked array elements can be copied into the first cassette in a
 595     * display list.  Need to translate them away:
 596     */
 597    if (IM->CopyOrFlag & VERT_BIT_ELT) {
 598       GLuint copy = tnl->pipeline.inputs & ~ctx->Array._Enabled;
 599       GLuint i;
 600
 601       ASSERT(IM->CopyStart < IM->Start);
 602
 603       _tnl_translate_array_elts( ctx, IM, IM->CopyStart, IM->Start );
 604
 605       for (i = IM->CopyStart ; i < IM->Start ; i++)
 606          copy_from_current( ctx, IM, i, copy );
 607
 608       _tnl_copy_to_current( ctx, IM, ctx->Array._Enabled, IM->Start );
 609    }
 610
 611    fixup = tnl->pipeline.inputs & ~IM->Flag[start] & VERT_BITS_FIXUP;
 612
 613 /*     _tnl_print_vert_flags("fixup compiled", fixup); */
 614
 615    if (fixup) {
 616
 617       /* XXX try to replace this code with a loop over the 16 vertex
 618        * attributes.
 619        */
 620
 621       if (fixup & VERT_BIT_NORMAL) {
 622          fixup_first_4f(IM->Attrib[VERT_ATTRIB_NORMAL], IM->Flag,
 623                         VERT_BIT_NORMAL, start,
 624                         ctx->Current.Attrib[VERT_ATTRIB_NORMAL] );
 625       }
 626
 627       if (fixup & VERT_BIT_COLOR0) {
 628          if (IM->CopyOrFlag & VERT_BIT_COLOR0)
 629             fixup_first_4f(IM->Attrib[VERT_ATTRIB_COLOR0], IM->Flag,
 630                            VERT_BIT_COLOR0, start,
 631                            ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
 632          else
 633             fixup &= ~VERT_BIT_COLOR0;
 634       }
 635
 636       if (fixup & VERT_BIT_COLOR1)
 637          fixup_first_4f(IM->Attrib[VERT_ATTRIB_COLOR1], IM->Flag,
 638                         VERT_BIT_COLOR1, start,
 639                         ctx->Current.Attrib[VERT_ATTRIB_COLOR1] );
 640
 641       if (fixup & VERT_BIT_FOG)
 642          fixup_first_4f( IM->Attrib[VERT_ATTRIB_FOG], IM->Flag,
 643                          VERT_BIT_FOG, start,
 644                          ctx->Current.Attrib[VERT_ATTRIB_FOG] );
 645
 646       if (fixup & VERT_BITS_TEX_ANY) {
 647          GLuint i;
 648          for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
 649             if (fixup & VERT_BIT_TEX(i))
 650                fixup_first_4f( IM->Attrib[VERT_ATTRIB_TEX0 + i], IM->Flag,
 651                                VERT_BIT_TEX(i), start,
 652                                ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i] );
 653          }
 654       }
 655
 656       if (fixup & VERT_BIT_EDGEFLAG)
 657          fixup_first_1ub(IM->EdgeFlag, IM->Flag, VERT_BIT_EDGEFLAG, start,
 658                          ctx->Current.EdgeFlag );
 659
 660       if (fixup & VERT_BIT_INDEX)
 661          fixup_first_1ui(IM->Index, IM->Flag, VERT_BIT_INDEX, start,
 662                          ctx->Current.Index );
 663
 664       IM->CopyOrFlag |= fixup;
 665    }
 666
 667
 668    /* Materials:
 669     */
 670    if (IM->MaterialOrMask & ~IM->MaterialAndMask) {
 671       GLuint vulnerable = IM->MaterialOrMask;
 672       GLuint i = IM->Start;
 673
 674       do {
 675          while (!(IM->Flag[i] & VERT_BIT_MATERIAL))
 676             i++;
 677
 678          vulnerable &= ~IM->MaterialMask[i];
 679          _mesa_copy_material_pairs( IM->Material[i],
 680                                     ctx->Light.Material,
 681                                     vulnerable );
 682
 683
 684          ++i;
 685       } while (vulnerable);
 686    }
 687 }
 688
 689
 690
 691
 692
 693
 694 static void copy_none( TNLcontext *tnl, GLuint start, GLuint count, GLuint ovf)
 695 {
 696    (void) (start && ovf && tnl && count);
 697 }
 698
 699 static void copy_last( TNLcontext *tnl, GLuint start, GLuint count, GLuint ovf)
 700 {
 701    (void) start; (void) ovf;
 702    tnl->ExecCopyCount = 1;
 703    tnl->ExecCopyElts[2] = count-1;
 704 }
 705
 706 static void copy_first_and_last( TNLcontext *tnl, GLuint start, GLuint count,
 707                                  GLuint ovf)
 708 {
 709    (void) ovf;
 710    tnl->ExecCopyCount = 2;
 711    tnl->ExecCopyElts[1] = start;
 712    tnl->ExecCopyElts[2] = count-1;
 713 }
 714
 715 static void copy_last_two( TNLcontext *tnl, GLuint start, GLuint count,
 716                            GLuint ovf )
 717 {
 718    (void) start;
 719    tnl->ExecCopyCount = 2+ovf;
 720    tnl->ExecCopyElts[0] = count-3;
 721    tnl->ExecCopyElts[1] = count-2;
 722    tnl->ExecCopyElts[2] = count-1;
 723 }
 724
 725 static void copy_overflow( TNLcontext *tnl, GLuint start, GLuint count,
 726                            GLuint ovf )
 727 {
 728    (void) start;
 729    tnl->ExecCopyCount = ovf;
 730    tnl->ExecCopyElts[0] = count-3;
 731    tnl->ExecCopyElts[1] = count-2;
 732    tnl->ExecCopyElts[2] = count-1;
 733 }
 734
 735
 736 typedef void (*copy_func)( TNLcontext *tnl, GLuint start, GLuint count,
 737                            GLuint ovf );
 738
 739 static copy_func copy_tab[GL_POLYGON+2] =
 740 {
 741    copy_none,
 742    copy_overflow,
 743    copy_first_and_last,
 744    copy_last,
 745    copy_overflow,
 746    copy_last_two,
 747    copy_first_and_last,
 748    copy_overflow,
 749    copy_last_two,
 750    copy_first_and_last,
 751    copy_none
 752 };
 753
 754
 755
 756
 757
 758 /* Figure out what vertices need to be copied next time.
 759  */
 760 void
 761 _tnl_get_exec_copy_verts( GLcontext *ctx, struct immediate *IM )
 762 {
 763
 764    TNLcontext *tnl = TNL_CONTEXT(ctx);
 765    GLuint last = IM->LastPrimitive;
 766    GLuint prim = ctx->Driver.CurrentExecPrimitive;
 767    GLuint pincr = increment[prim];
 768    GLuint pintro = intro[prim];
 769    GLuint ovf = 0;
 770
 771 /*     _mesa_debug(ctx, "_tnl_get_exec_copy_verts %s\n",  */
 772 /*         _mesa_lookup_enum_by_nr(prim)); */
 773
 774    if (tnl->ExecCopySource)
 775       if (--tnl->ExecCopySource->ref_count == 0)
 776          _tnl_free_immediate( ctx, tnl->ExecCopySource );
 777
 778    if (prim == GL_POLYGON+1) {
 779       tnl->ExecCopySource = 0;
 780       tnl->ExecCopyCount = 0;
 781       tnl->ExecCopyTexSize = 0;
 782       tnl->ExecParity = 0;
 783    } else {
 784       /* Remember this immediate as the one to copy from.
 785        */
 786       tnl->ExecCopySource = IM; IM->ref_count++;
 787       tnl->ExecCopyCount = 0;
 788       tnl->ExecCopyTexSize = IM->CopyTexSize;
 789
 790       if (IM->LastPrimitive != IM->CopyStart)
 791          tnl->ExecParity = 0;
 792
 793       tnl->ExecParity ^= IM->PrimitiveLength[IM->LastPrimitive] & 1;
 794
 795
 796       if (pincr != 1 && (IM->Count - last - pintro))
 797          ovf = (IM->Count - last - pintro) % pincr;
 798
 799       if (last < IM->Count)
 800          copy_tab[prim]( tnl, last, IM->Count, ovf );
 801    }
 802 }
 803
 804
 805 /* Recalculate ExecCopyElts, ExecParity, etc.
 806  */
 807 void
 808 _tnl_get_purged_copy_verts( GLcontext *ctx, struct immediate *IM )
 809 {
 810    TNLcontext *tnl = TNL_CONTEXT(ctx);
 811
 812    if (ctx->Driver.CurrentExecPrimitive != GL_POLYGON+1) {
 813       GLuint last = IM->LastPrimitive;
 814       GLenum prim = IM->Primitive[last];
 815       GLuint pincr = increment[prim];
 816       GLuint pintro = intro[prim];
 817       GLuint ovf = 0, i;
 818
 819       tnl->ExecCopyCount = 0;
 820       if (IM->LastPrimitive != IM->CopyStart)
 821          tnl->ExecParity = 0;
 822
 823       tnl->ExecParity ^= IM->PrimitiveLength[IM->LastPrimitive] & 1;
 824
 825       if (pincr != 1 && (IM->Count - last - pintro))
 826          ovf = (IM->Count - last - pintro) % pincr;
 827
 828       if (last < IM->Count)
 829          copy_tab[prim]( tnl, last, IM->Count, ovf );
 830
 831       for (i = 0 ; i < tnl->ExecCopyCount ; i++)
 832          tnl->ExecCopyElts[i] = IM->Elt[tnl->ExecCopyElts[i]];
 833    }
 834 }
 835
 836
 837 void _tnl_upgrade_current_data( GLcontext *ctx,
 838                                 GLuint required,
 839                                 GLuint flags )
 840 {
 841    TNLcontext *tnl = TNL_CONTEXT(ctx);
 842    struct vertex_buffer *VB = &tnl->vb;
 843    struct immediate *IM = (struct immediate *)VB->import_source;
 844
 845    ASSERT(IM);
 846
 847 /*     _tnl_print_vert_flags("_tnl_upgrade_client_data", required); */
 848
 849    if ((required & VERT_BIT_COLOR0) && (VB->ColorPtr[0]->Flags & CA_CLIENT_DATA)) {
 850       struct gl_client_array *tmp = &tnl->imm_inputs.Color;
 851       GLuint start = IM->CopyStart;
 852
 853       tmp->Ptr = IM->Attrib[VERT_ATTRIB_COLOR0] + start;
 854       tmp->StrideB = 4 * sizeof(GLfloat);
 855       tmp->Flags = 0;
 856
 857       COPY_4FV( IM->Attrib[VERT_ATTRIB_COLOR0][start],
 858                 ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);
 859
 860       /*
 861       ASSERT(IM->Flag[IM->LastData+1] & VERT_BIT_END_VB);
 862       */
 863
 864       fixup_first_4f( IM->Attrib[VERT_ATTRIB_COLOR0], IM->Flag,
 865                       VERT_BIT_END_VB,
 866                       start, IM->Attrib[VERT_ATTRIB_COLOR0][start] );
 867
 868       VB->importable_data &= ~VERT_BIT_COLOR0;
 869    }
 870 }
 871