src/mesa/drivers/dri/mach64/mach64_native_vbtmp.h

   1 /* -*- mode: c; c-basic-offset: 3 -*- */
   2 /*
   3  * Mesa 3-D graphics library
   4  * Version:  3.5
   5  *
   6  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  * Original authors:
  26  *    Keith Whitwell <keithw@valinux.com>
  27  *
  28  * Adapted to Mach64 by:
  29  *    José Fonseca <j_r_fonseca@yahoo.co.uk>
  30  */
  31
  32
  33 /* DO_XYZW:  Emit xyz and maybe w coordinates.
  34  * DO_RGBA:  Emit color.
  35  * DO_SPEC:  Emit specular color.
  36  * DO_FOG:   Emit fog coordinate in specular alpha.
  37  * DO_TEX0:  Emit tex0 u,v coordinates.
  38  * DO_TEX1:  Emit tex1 u,v coordinates.
  39  * DO_PTEX:  Emit tex0,1 q coordinates where possible.
  40  *
  41  * Additionally, this template assumes it is emitting *transformed*
  42  * vertices; the modifications to emit untransformed vertices (ie. to
  43  * t&l hardware) are probably too great to cooexist with the code
  44  * already in this file.
  45  */
  46
  47 #define VIEWPORT_X(x)  ((GLint) ((s[0]  * (x) + s[12]) * 4.0))
  48 #define VIEWPORT_Y(y)  ((GLint) ((s[5]  * (y) + s[13]) * 4.0))
  49 #define VIEWPORT_Z(z) (((GLuint) (s[10] * (z) + s[14])) << 15)
  50
  51 #ifndef LOCALVARS
  52 #define LOCALVARS
  53 #endif
  54
  55 static void TAG(emit)( struct gl_context *ctx,
  56                        GLuint start, GLuint end,
  57                        void *dest,
  58                        GLuint stride )
  59 {
  60    LOCALVARS
  61    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
  62 #if DO_TEX1
  63    GLfloat (*tc1)[4];
  64    GLuint tc1_stride;
  65 #if DO_PTEX
  66    GLuint tc1_size;
  67 #endif
  68 #endif
  69 #if DO_TEX0
  70    GLfloat (*tc0)[4];
  71    GLuint tc0_stride;
  72 #if DO_PTEX
  73    GLuint tc0_size;
  74 #endif
  75 #endif
  76 #if DO_SPEC
  77    GLfloat (*spec)[4];
  78    GLuint spec_stride;
  79 #endif
  80 #if DO_FOG
  81    GLfloat (*fog)[4];
  82    GLuint fog_stride;
  83 #endif
  84 #if DO_RGBA
  85    GLfloat (*col)[4];
  86    GLuint col_stride;
  87 #endif
  88    GLfloat (*coord)[4];
  89    GLuint coord_stride;
  90    VERTEX *v = (VERTEX *)dest;
  91    const GLfloat *s = GET_VIEWPORT_MAT();
  92 #if DO_TEX1 || DO_TEX0 || DO_XYZW
  93    const GLubyte *mask = VB->ClipMask;
  94 #endif
  95    int i;
  96
  97 #if !DO_XYZW
  98    (void) s; /* Quiet compiler */
  99 #endif
 100 /*     fprintf(stderr, "%s(big) importable %d %d..%d\n",  */
 101 /*         __FUNCTION__, VB->importable_data, start, end); */
 102
 103 #if DO_TEX1
 104    {
 105       const GLuint t1 = GET_TEXSOURCE(1);
 106       tc1 = VB->AttribPtr[_TNL_ATTRIB_TEX0 + t1]->data;
 107       tc1_stride = VB->AttribPtr[_TNL_ATTRIB_TEX0 + t1]->stride;
 108 #if DO_PTEX
 109       tc1_size = VB->AttribPtr[_TNL_ATTRIB_TEX0 + t1]->size;
 110 #endif
 111    }
 112 #endif
 113
 114 #if DO_TEX0
 115    {
 116       const GLuint t0 = GET_TEXSOURCE(0);
 117       tc0 = VB->AttribPtr[_TNL_ATTRIB_TEX0 + t0]->data;
 118       tc0_stride = VB->AttribPtr[_TNL_ATTRIB_TEX0 + t0]->stride;
 119 #if DO_PTEX
 120       tc0_size = VB->AttribPtr[_TNL_ATTRIB_TEX0 + t0]->size;
 121 #endif
 122    }
 123 #endif
 124
 125 #if DO_SPEC
 126    if (VB->AttribPtr[_TNL_ATTRIB_COLOR1]) {
 127       spec = VB->AttribPtr[_TNL_ATTRIB_COLOR1]->data;
 128       spec_stride = VB->AttribPtr[_TNL_ATTRIB_COLOR1]->stride;
 129    } else {
 130       spec = (GLfloat (*)[4])ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
 131       spec_stride = 0;
 132    }
 133 #endif
 134
 135 #if DO_FOG
 136    if (VB->AttribPtr[_TNL_ATTRIB_FOG]) {
 137       fog = VB->AttribPtr[_TNL_ATTRIB_FOG]->data;
 138       fog_stride = VB->AttribPtr[_TNL_ATTRIB_FOG]->stride;
 139    } else {
 140       static GLfloat tmp[4] = {0, 0, 0, 0};
 141       fog = &tmp;
 142       fog_stride = 0;
 143    }
 144 #endif
 145
 146 #if DO_RGBA
 147    col = VB->AttribPtr[_TNL_ATTRIB_COLOR0]->data;
 148    col_stride = VB->AttribPtr[_TNL_ATTRIB_COLOR0]->stride;
 149 #endif
 150
 151    coord = VB->NdcPtr->data;
 152    coord_stride = VB->NdcPtr->stride;
 153
 154    if (start) {
 155 #if DO_TEX1
 156          STRIDE_4F(tc1, start * tc1_stride);
 157 #endif
 158 #if DO_TEX0
 159          STRIDE_4F(tc0, start * tc0_stride);
 160 #endif
 161 #if DO_SPEC
 162          STRIDE_4F(spec, start * spec_stride);
 163 #endif
 164 #if DO_FOG
 165          STRIDE_4F(fog, start * fog_stride);
 166 #endif
 167 #if DO_RGBA
 168          STRIDE_4F(col, start * col_stride);
 169 #endif
 170          STRIDE_4F(coord, start * coord_stride);
 171    }
 172
 173    for (i=start; i < end; i++, v = (VERTEX *)((GLubyte *)v + stride)) {
 174          CARD32 *p = (CARD32 *)v;
 175 #if DO_TEX1 || DO_TEX0
 176          GLfloat w;
 177
 178          if (mask[i] == 0) {
 179             /* unclipped */
 180             w = coord[0][3];
 181          } else {
 182             /* clipped */
 183             w = 1.0;
 184          }
 185 #endif
 186
 187 #if DO_TEX1
 188 #if DO_PTEX
 189          if (tc1_size == 4) {
 190 #ifdef MACH64_PREMULT_TEXCOORDS
 191             LE32_OUT_FLOAT( p++, w*tc1[0][0] );         /* VERTEX_?_SECONDARY_S */
 192             LE32_OUT_FLOAT( p++, w*tc1[0][1] );         /* VERTEX_?_SECONDARY_T */
 193             LE32_OUT_FLOAT( p++, w*tc1[0][3] );         /* VERTEX_?_SECONDARY_W */
 194 #else /* !MACH64_PREMULT_TEXCOORDS */
 195             float rhw = 1.0 / tc1[0][3];
 196             LE32_OUT_FLOAT( p++, rhw*tc1[0][0] );       /* VERTEX_?_SECONDARY_S */
 197             LE32_OUT_FLOAT( p++, rhw*tc1[0][1] );       /* VERTEX_?_SECONDARY_T */
 198             LE32_OUT_FLOAT( p++, w*tc1[0][3] );         /* VERTEX_?_SECONDARY_W */
 199 #endif /* !MACH64_PREMULT_TEXCOORDS */
 200          } else {
 201 #endif /* DO_PTEX */
 202 #ifdef MACH64_PREMULT_TEXCOORDS
 203             LE32_OUT_FLOAT( p++, w*tc1[0][0] );         /* VERTEX_?_SECONDARY_S */
 204             LE32_OUT_FLOAT( p++, w*tc1[0][1] );         /* VERTEX_?_SECONDARY_T */
 205             LE32_OUT_FLOAT( p++, w );                   /* VERTEX_?_SECONDARY_W */
 206 #else /* !MACH64_PREMULT_TEXCOORDS */
 207             LE32_OUT_FLOAT( p++, tc1[0][0] );           /* VERTEX_?_SECONDARY_S */
 208             LE32_OUT_FLOAT( p++, tc1[0][1] );           /* VERTEX_?_SECONDARY_T */
 209             LE32_OUT_FLOAT( p++, w );                   /* VERTEX_?_SECONDARY_W */
 210 #endif /* !MACH64_PREMULT_TEXCOORDS */
 211 #if DO_PTEX
 212          }
 213 #endif /* DO_PTEX */
 214          STRIDE_4F(tc1, tc1_stride);
 215 #else /* !DO_TEX1 */
 216          p += 3;
 217 #endif /* !DO_TEX1 */
 218
 219 #if DO_TEX0
 220 #if DO_PTEX
 221          if (tc0_size == 4) {
 222 #ifdef MACH64_PREMULT_TEXCOORDS
 223             LE32_OUT_FLOAT( p++, w*tc0[0][0] );                 /* VERTEX_?_S */
 224             LE32_OUT_FLOAT( p++, w*tc0[0][1] );                 /* VERTEX_?_T */
 225             LE32_OUT_FLOAT( p++, w*tc0[0][3] );                 /* VERTEX_?_W */
 226 #else /* !MACH64_PREMULT_TEXCOORDS */
 227             float rhw = 1.0 / tc0[0][3];
 228             LE32_OUT_FLOAT( p++, rhw*tc0[0][0] );               /* VERTEX_?_S */
 229             LE32_OUT_FLOAT( p++, rhw*tc0[0][1] );               /* VERTEX_?_T */
 230             LE32_OUT_FLOAT( p++, w*tc0[0][3] );                 /* VERTEX_?_W */
 231 #endif /* !MACH64_PREMULT_TEXCOORDS */
 232          } else {
 233 #endif /* DO_PTEX */
 234 #ifdef MACH64_PREMULT_TEXCOORDS
 235             LE32_OUT_FLOAT( p++, w*tc0[0][0] );                 /* VERTEX_?_S */
 236             LE32_OUT_FLOAT( p++, w*tc0[0][1] );                 /* VERTEX_?_T */
 237             LE32_OUT_FLOAT( p++, w );                           /* VERTEX_?_W */
 238 #else /* !MACH64_PREMULT_TEXCOORDS */
 239             LE32_OUT_FLOAT( p++, tc0[0][0] );                   /* VERTEX_?_S */
 240             LE32_OUT_FLOAT( p++, tc0[0][1] );                   /* VERTEX_?_T */
 241             LE32_OUT_FLOAT( p++, w );                           /* VERTEX_?_W */
 242 #endif /* !MACH64_PREMULT_TEXCOORDS */
 243 #if DO_PTEX
 244          }
 245 #endif /* DO_PTEX */
 246          STRIDE_4F(tc0, tc0_stride);
 247 #else /* !DO_TEX0 */
 248          p += 3;
 249 #endif /* !DO_TEX0 */
 250
 251 #if DO_SPEC
 252          UNCLAMPED_FLOAT_TO_UBYTE(((GLubyte *)p)[0],  spec[0][2]);      /* VERTEX_?_SPEC_B */
 253          UNCLAMPED_FLOAT_TO_UBYTE(((GLubyte *)p)[1],  spec[0][1]);      /* VERTEX_?_SPEC_G */
 254          UNCLAMPED_FLOAT_TO_UBYTE(((GLubyte *)p)[2],  spec[0][0]);      /* VERTEX_?_SPEC_R */
 255
 256          STRIDE_4F(spec, spec_stride);
 257 #endif
 258 #if DO_FOG
 259          UNCLAMPED_FLOAT_TO_UBYTE(((GLubyte *)p)[3], fog[0][0]);  /* VERTEX_?_SPEC_A */
 260          /*      ((GLubyte *)p)[3] = fog[0][0] * 255.0;  */
 261          STRIDE_4F(fog, fog_stride);
 262 #endif
 263          p++;
 264
 265 #if DO_XYZW
 266          if (mask[i] == 0) {
 267             /* unclipped */
 268             LE32_OUT( p++, VIEWPORT_Z( coord[0][2] ) ); /* VERTEX_?_Z */
 269          } else {
 270 #endif
 271             p++;
 272 #if DO_XYZW
 273          }
 274 #endif
 275
 276 #if DO_RGBA
 277          UNCLAMPED_FLOAT_TO_UBYTE(((GLubyte *)p)[0], col[0][2]);
 278          UNCLAMPED_FLOAT_TO_UBYTE(((GLubyte *)p)[1], col[0][1]);
 279          UNCLAMPED_FLOAT_TO_UBYTE(((GLubyte *)p)[2], col[0][0]);
 280          UNCLAMPED_FLOAT_TO_UBYTE(((GLubyte *)p)[3], col[0][3]);
 281          p++;
 282          STRIDE_4F(col, col_stride);
 283 #else
 284          p++;
 285 #endif
 286
 287 #if DO_XYZW
 288          if (mask[i] == 0) {
 289             /* unclipped */
 290             LE32_OUT( p,
 291                       (VIEWPORT_X( coord[0][0] ) << 16) |       /* VERTEX_?_X */
 292                       (VIEWPORT_Y( coord[0][1] ) & 0xffff) );   /* VERTEX_?_Y */
 293
 294             if (MACH64_DEBUG & DEBUG_VERBOSE_PRIMS) {
 295                fprintf( stderr, "%s: vert %d: %.2f %.2f %.2f %x\n",
 296                         __FUNCTION__,
 297                         i,
 298                         (LE32_IN( p ) >> 16)/4.0,
 299                         (LE32_IN( p ) & 0xffff)/4.0,
 300                         LE32_IN( p - 2 )/65536.0,
 301                         *(GLuint *)(p - 1) );
 302             }
 303          }
 304 #endif
 305 #if DO_TEX1 || DO_TEX0 || DO_XYZW
 306          STRIDE_4F(coord, coord_stride);
 307 #endif
 308
 309          assert( p + 1 - (CARD32 *)v == 10 );
 310       }
 311 }
 312
 313 #if DO_XYZW && DO_RGBA
 314
 315 static GLboolean TAG(check_tex_sizes)( struct gl_context *ctx )
 316 {
 317    LOCALVARS
 318    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 319
 320    /* Force 'missing' texcoords to something valid.
 321     */
 322    if (DO_TEX1 && VB->AttribPtr[_TNL_ATTRIB_TEX0] == 0)
 323       VB->AttribPtr[_TNL_ATTRIB_TEX0] = VB->AttribPtr[_TNL_ATTRIB_TEX1];
 324
 325    if (DO_PTEX)
 326       return GL_TRUE;
 327
 328    /* No hardware support for projective texture.  Can fake it for
 329     * TEX0 only.
 330     */
 331    if ((DO_TEX1 && VB->AttribPtr[_TNL_ATTRIB_TEX0 + GET_TEXSOURCE(1)]->size == 4)) {
 332       PTEX_FALLBACK();
 333       return GL_FALSE;
 334    }
 335
 336    if (DO_TEX0 && VB->AttribPtr[_TNL_ATTRIB_TEX0 + GET_TEXSOURCE(0)]->size == 4) {
 337       if (DO_TEX1) {
 338          PTEX_FALLBACK();
 339       }
 340       return GL_FALSE;
 341    }
 342
 343    return GL_TRUE;
 344 }
 345
 346
 347 static void TAG(interp)( struct gl_context *ctx,
 348                          GLfloat t,
 349                          GLuint edst, GLuint eout, GLuint ein,
 350                          GLboolean force_boundary )
 351 {
 352    LOCALVARS
 353    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 354    GLubyte *ddverts = GET_VERTEX_STORE();
 355    GLuint size = GET_VERTEX_SIZE();
 356    const GLfloat *dstclip = VB->ClipPtr->data[edst];
 357    GLfloat w;
 358    const GLfloat *s = GET_VIEWPORT_MAT();
 359
 360    CARD32 *dst = (CARD32 *)(ddverts + (edst * size));
 361    CARD32 *in  = (CARD32 *)(ddverts + (ein  * size));
 362    CARD32 *out = (CARD32 *)(ddverts + (eout * size));
 363
 364    (void)s;
 365
 366    w = (dstclip[3] == 0.0F) ? 1.0 : (1.0 / dstclip[3]);
 367
 368 #if DO_TEX1
 369    {
 370       GLfloat temp;
 371 #if DO_PTEX
 372       GLfloat wout = VB->NdcPtr->data[eout][3];
 373       GLfloat win = VB->NdcPtr->data[ein][3];
 374       GLfloat qout = LE32_IN_FLOAT( out + 2 ) / wout;
 375       GLfloat qin = LE32_IN_FLOAT( in + 2 ) / win;
 376       GLfloat qdst, rqdst;
 377
 378       INTERP_F( t, qdst, qout, qin );
 379       rqdst = 1.0 / qdst;
 380
 381       INTERP_F( t, temp, LE32_IN_FLOAT( out ) * qout, LE32_IN_FLOAT( in ) * qin );
 382       LE32_OUT_FLOAT( dst, temp*rqdst );                        /* VERTEX_?_SECONDARY_S */
 383       dst++; out++; in++;
 384
 385       INTERP_F( t, temp, LE32_IN_FLOAT( out ) * qout, LE32_IN_FLOAT( in ) * qin );
 386       LE32_OUT_FLOAT( dst, temp*rqdst );                        /* VERTEX_?_SECONDARY_T */
 387       dst++; out++; in++;
 388
 389       LE32_OUT_FLOAT( dst, w*rqdst );                           /* VERTEX_?_SECONDARY_W */
 390       dst++; out++; in++;
 391 #else /* !DO_PTEX */
 392 #ifdef MACH64_PREMULT_TEXCOORDS
 393       GLfloat qout = w / LE32_IN_FLOAT( out + 2 );
 394       GLfloat qin = w / LE32_IN_FLOAT( in + 2 );
 395
 396       INTERP_F( t, temp, LE32_IN_FLOAT( out ) * qout, LE32_IN_FLOAT( in ) * qin );
 397       LE32_OUT_FLOAT( dst, temp );                              /* VERTEX_?_SECONDARY_S */
 398       dst++; out++; in++;
 399
 400       INTERP_F( t, temp, LE32_IN_FLOAT( out ) * qout, LE32_IN_FLOAT( in ) * qin );
 401       LE32_OUT_FLOAT( dst, temp );                              /* VERTEX_?_SECONDARY_T */
 402       dst++; out++; in++;
 403 #else /* !MACH64_PREMULT_TEXCOORDS */
 404       INTERP_F( t, temp, LE32_IN_FLOAT( out ), LE32_IN_FLOAT( in ) );
 405       LE32_OUT_FLOAT( dst, temp );                              /* VERTEX_?_SECONDARY_S */
 406       dst++; out++; in++;
 407
 408       INTERP_F( t, temp, LE32_IN_FLOAT( out ), LE32_IN_FLOAT( in ) );
 409       LE32_OUT_FLOAT( dst, temp );                              /* VERTEX_?_SECONDARY_T */
 410       dst++; out++; in++;
 411 #endif /* !MACH64_PREMULT_TEXCOORDS */
 412       LE32_OUT_FLOAT( dst, w );                                 /* VERTEX_?_SECONDARY_W */
 413       dst++; out++; in++;
 414 #endif /* !DO_PTEX */
 415    }
 416 #else /* !DO_TEX1 */
 417    dst += 3; out += 3; in += 3;
 418 #endif /* !DO_TEX1 */
 419
 420 #if DO_TEX0
 421    {
 422       GLfloat temp;
 423 #if DO_PTEX
 424       GLfloat wout = VB->NdcPtr->data[eout][3];
 425       GLfloat win = VB->NdcPtr->data[ein][3];
 426       GLfloat qout = LE32_IN_FLOAT( out + 2 ) / wout;
 427       GLfloat qin = LE32_IN_FLOAT( in + 2 ) / win;
 428       GLfloat qdst, rqdst;
 429
 430       INTERP_F( t, qdst, qout, qin );
 431       rqdst = 1.0 / qdst;
 432
 433       INTERP_F( t, temp, LE32_IN_FLOAT( out ) * qout, LE32_IN_FLOAT( in ) * qin );
 434       LE32_OUT_FLOAT( dst, temp*rqdst );                        /* VERTEX_?_S */
 435       dst++; out++; in++;
 436
 437       INTERP_F( t, temp, LE32_IN_FLOAT( out ) * qout, LE32_IN_FLOAT( in ) * qin );
 438       LE32_OUT_FLOAT( dst, temp*rqdst );                        /* VERTEX_?_T */
 439       dst++; out++; in++;
 440
 441       LE32_OUT_FLOAT( dst, w*rqdst );                           /* VERTEX_?_W */
 442       dst++; out++; in++;
 443 #else /* !DO_PTEX */
 444 #ifdef MACH64_PREMULT_TEXCOORDS
 445       GLfloat qout = w / LE32_IN_FLOAT( out + 2 );
 446       GLfloat qin = w / LE32_IN_FLOAT( in + 2 );
 447
 448       INTERP_F( t, temp, LE32_IN_FLOAT( out ) * qout, LE32_IN_FLOAT( in ) * qin );
 449       LE32_OUT_FLOAT( dst, temp );                              /* VERTEX_?_S */
 450       dst++; out++; in++;
 451
 452       INTERP_F( t, temp, LE32_IN_FLOAT( out ) * qout, LE32_IN_FLOAT( in ) * qin );
 453       LE32_OUT_FLOAT( dst, temp );                              /* VERTEX_?_T */
 454       dst++; out++; in++;
 455 #else /* !MACH64_PREMULT_TEXCOORDS */
 456       INTERP_F( t, temp, LE32_IN_FLOAT( out ), LE32_IN_FLOAT( in ) );
 457       LE32_OUT_FLOAT( dst, temp );                              /* VERTEX_?_S */
 458       dst++; out++; in++;
 459
 460       INTERP_F( t, temp, LE32_IN_FLOAT( out ), LE32_IN_FLOAT( in ) );
 461       LE32_OUT_FLOAT( dst, temp );                              /* VERTEX_?_T */
 462       dst++; out++; in++;
 463 #endif /* !MACH64_PREMULT_TEXCOORDS */
 464       LE32_OUT_FLOAT( dst, w );                                 /* VERTEX_?_W */
 465       dst++; out++; in++;
 466 #endif /* !DO_PTEX */
 467    }
 468 #else /* !DO_TEX0 */
 469    dst += 3; out += 3; in += 3;
 470 #endif /* !DO_TEX0 */
 471
 472 #if DO_SPEC
 473    INTERP_UB( t, ((GLubyte *)dst)[0], ((GLubyte *)out)[0], ((GLubyte *)in)[0] );        /* VERTEX_?_SPEC_B */
 474    INTERP_UB( t, ((GLubyte *)dst)[1], ((GLubyte *)out)[1], ((GLubyte *)in)[1] );        /* VERTEX_?_SPEC_G */
 475    INTERP_UB( t, ((GLubyte *)dst)[2], ((GLubyte *)out)[2], ((GLubyte *)in)[2] );        /* VERTEX_?_SPEC_R */
 476 #endif
 477
 478 #if DO_FOG
 479    INTERP_UB( t, ((GLubyte *)dst)[3], ((GLubyte *)out)[3], ((GLubyte *)in)[3] );        /* VERTEX_?_SPEC_A */
 480 #endif /* DO_FOG */
 481
 482    dst++; out++; in++;
 483
 484    LE32_OUT( dst, VIEWPORT_Z( dstclip[2] * w ) );               /* VERTEX_?_Z */
 485    dst++; out++; in++;
 486
 487    INTERP_UB( t, ((GLubyte *)dst)[0], ((GLubyte *)out)[0], ((GLubyte *)in)[0] );        /* VERTEX_?_B */
 488    INTERP_UB( t, ((GLubyte *)dst)[1], ((GLubyte *)out)[1], ((GLubyte *)in)[1] );        /* VERTEX_?_G */
 489    INTERP_UB( t, ((GLubyte *)dst)[2], ((GLubyte *)out)[2], ((GLubyte *)in)[2] );        /* VERTEX_?_R */
 490    INTERP_UB( t, ((GLubyte *)dst)[3], ((GLubyte *)out)[3], ((GLubyte *)in)[3] );        /* VERTEX_?_A */
 491    dst++; /*out++; in++;*/
 492
 493    LE32_OUT( dst,
 494              (VIEWPORT_X( dstclip[0] * w ) << 16) |             /* VERTEX_?_X */
 495              (VIEWPORT_Y( dstclip[1] * w ) & 0xffff) );         /* VERTEX_?_Y */
 496
 497    assert( dst + 1 - (CARD32 *)(ddverts + (edst * size)) == 10 );
 498    assert( in  + 2 - (CARD32 *)(ddverts + (ein  * size)) == 10 );
 499    assert( out + 2 - (CARD32 *)(ddverts + (eout * size)) == 10 );
 500
 501    if (MACH64_DEBUG & DEBUG_VERBOSE_PRIMS) {
 502       fprintf( stderr, "%s: dst vert: %.2f %.2f %.2f %x\n",
 503                __FUNCTION__,
 504                (GLshort)(LE32_IN( dst ) >> 16)/4.0,
 505                (GLshort)(LE32_IN( dst ) & 0xffff)/4.0,
 506                LE32_IN( dst - 2 )/65536.0,
 507                *(GLuint *)(dst - 1) );
 508    }
 509 }
 510
 511 #endif /* DO_RGBA && DO_XYZW */
 512
 513
 514 static void TAG(copy_pv)( struct gl_context *ctx, GLuint edst, GLuint esrc )
 515 {
 516 #if DO_SPEC || DO_FOG || DO_RGBA
 517    LOCALVARS
 518    GLubyte *verts = GET_VERTEX_STORE();
 519    GLuint size = GET_VERTEX_SIZE();
 520    GLuint *dst = (GLuint *)(verts + (edst * size));
 521    GLuint *src = (GLuint *)(verts + (esrc * size));
 522 #endif
 523
 524 #if DO_SPEC || DO_FOG
 525    dst[6] = src[6];                     /* VERTEX_?_SPEC_ARGB */
 526 #endif
 527
 528 #if DO_RGBA
 529    dst[8] = src[8];                     /* VERTEX_?_ARGB */
 530 #endif
 531 }
 532
 533 static void TAG(init)( void )
 534 {
 535    setup_tab[IND].emit = TAG(emit);
 536
 537 #if DO_XYZW && DO_RGBA
 538    setup_tab[IND].check_tex_sizes = TAG(check_tex_sizes);
 539    setup_tab[IND].interp = TAG(interp);
 540 #endif
 541
 542    setup_tab[IND].copy_pv = TAG(copy_pv);
 543
 544 #if DO_TEX1
 545    setup_tab[IND].vertex_format = TEX1_VERTEX_FORMAT;
 546    setup_tab[IND].vertex_size = 10;
 547 #elif DO_TEX0
 548    setup_tab[IND].vertex_format = TEX0_VERTEX_FORMAT;
 549    setup_tab[IND].vertex_size = 7;
 550 #elif DO_SPEC || DO_FOG
 551    setup_tab[IND].vertex_format = NOTEX_VERTEX_FORMAT;
 552    setup_tab[IND].vertex_size = 4;
 553 #else
 554    setup_tab[IND].vertex_format = TINY_VERTEX_FORMAT;
 555    setup_tab[IND].vertex_size = 3;
 556 #endif
 557
 558 }
 559
 560
 561 #undef IND
 562 #undef TAG