src/mesa/drivers/dri/r200/r200_vtxfmt_c.c

   1 /* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt_c.c,v 1.2 2002/12/16 16:18:56 dawes Exp $ */
   2 /*
   3 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   4
   5 The Weather Channel (TM) funded Tungsten Graphics to develop the
   6 initial release of the Radeon 8500 driver under the XFree86 license.
   7 This notice must be preserved.
   8
   9 Permission is hereby granted, free of charge, to any person obtaining
  10 a copy of this software and associated documentation files (the
  11 "Software"), to deal in the Software without restriction, including
  12 without limitation the rights to use, copy, modify, merge, publish,
  13 distribute, sublicense, and/or sell copies of the Software, and to
  14 permit persons to whom the Software is furnished to do so, subject to
  15 the following conditions:
  16
  17 The above copyright notice and this permission notice (including the
  18 next paragraph) shall be included in all copies or substantial
  19 portions of the Software.
  20
  21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  24 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  25 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28
  29 **************************************************************************/
  30
  31 /*
  32  * Authors:
  33  *   Keith Whitwell <keith@tungstengraphics.com>
  34  */
  35
  36 #include "glheader.h"
  37 #include "imports.h"
  38 #include "mtypes.h"
  39 #include "colormac.h"
  40 #include "simple_list.h"
  41 #include "api_noop.h"
  42 #include "vtxfmt.h"
  43
  44 #include "r200_vtxfmt.h"
  45
  46 /* Fallback versions of all the entrypoints for situations where
  47  * codegen isn't available.  This is still a lot faster than the
  48  * vb/pipeline implementation in Mesa.
  49  */
  50 static void r200_Vertex3f( GLfloat x, GLfloat y, GLfloat z )
  51 {
  52    GET_CURRENT_CONTEXT(ctx);
  53    r200ContextPtr rmesa = R200_CONTEXT(ctx);
  54    int i;
  55
  56    *rmesa->vb.dmaptr++ = *(int *)&x;
  57    *rmesa->vb.dmaptr++ = *(int *)&y;
  58    *rmesa->vb.dmaptr++ = *(int *)&z;
  59
  60    for (i = 3; i < rmesa->vb.vertex_size; i++)
  61       *rmesa->vb.dmaptr++ = rmesa->vb.vertex[i].i;
  62
  63    if (--rmesa->vb.counter == 0)
  64       rmesa->vb.notify();
  65 }
  66
  67
  68 static void r200_Vertex3fv( const GLfloat *v )
  69 {
  70    GET_CURRENT_CONTEXT(ctx);
  71    r200ContextPtr rmesa = R200_CONTEXT(ctx);
  72    int i;
  73
  74    *rmesa->vb.dmaptr++ = *(int *)&v[0];
  75    *rmesa->vb.dmaptr++ = *(int *)&v[1];
  76    *rmesa->vb.dmaptr++ = *(int *)&v[2];
  77
  78    for (i = 3; i < rmesa->vb.vertex_size; i++)
  79       *rmesa->vb.dmaptr++ = rmesa->vb.vertex[i].i;
  80
  81    if (--rmesa->vb.counter == 0)
  82       rmesa->vb.notify();
  83 }
  84
  85
  86 static void r200_Vertex2f( GLfloat x, GLfloat y )
  87 {
  88    GET_CURRENT_CONTEXT(ctx);
  89    r200ContextPtr rmesa = R200_CONTEXT(ctx);
  90    int i;
  91
  92    *rmesa->vb.dmaptr++ = *(int *)&x;
  93    *rmesa->vb.dmaptr++ = *(int *)&y;
  94    *rmesa->vb.dmaptr++ = 0;
  95
  96    for (i = 3; i < rmesa->vb.vertex_size; i++)
  97       *rmesa->vb.dmaptr++ = rmesa->vb.vertex[i].i;
  98
  99    if (--rmesa->vb.counter == 0)
 100       rmesa->vb.notify();
 101 }
 102
 103
 104 static void r200_Vertex2fv( const GLfloat *v )
 105 {
 106    GET_CURRENT_CONTEXT(ctx);
 107    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 108    int i;
 109
 110    *rmesa->vb.dmaptr++ = *(int *)&v[0];
 111    *rmesa->vb.dmaptr++ = *(int *)&v[1];
 112    *rmesa->vb.dmaptr++ = 0;
 113
 114    for (i = 3; i < rmesa->vb.vertex_size; i++)
 115       *rmesa->vb.dmaptr++ = rmesa->vb.vertex[i].i;
 116
 117    if (--rmesa->vb.counter == 0)
 118       rmesa->vb.notify();
 119 }
 120
 121
 122
 123 /* Color for ubyte (packed) color formats:
 124  */
 125 #if 0
 126 static void r200_Color3ub_ub( GLubyte r, GLubyte g, GLubyte b )
 127 {
 128    GET_CURRENT_CONTEXT(ctx);
 129    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 130    r200_color_t *dest = rmesa->vb.colorptr;
 131    dest->red    = r;
 132    dest->green  = g;
 133    dest->blue   = b;
 134    dest->alpha  = 0xff;
 135 }
 136
 137 static void r200_Color3ubv_ub( const GLubyte *v )
 138 {
 139    GET_CURRENT_CONTEXT(ctx);
 140    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 141    r200_color_t *dest = rmesa->vb.colorptr;
 142    dest->red    = v[0];
 143    dest->green  = v[1];
 144    dest->blue   = v[2];
 145    dest->alpha  = 0xff;
 146 }
 147
 148 static void r200_Color4ub_ub( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
 149 {
 150    GET_CURRENT_CONTEXT(ctx);
 151    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 152    r200_color_t *dest = rmesa->vb.colorptr;
 153    dest->red    = r;
 154    dest->green  = g;
 155    dest->blue   = b;
 156    dest->alpha  = a;
 157 }
 158
 159 static void r200_Color4ubv_ub( const GLubyte *v )
 160 {
 161    GET_CURRENT_CONTEXT(ctx);
 162    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 163    *(GLuint *)rmesa->vb.colorptr = LE32_TO_CPU(*(GLuint *)v);
 164 }
 165 #endif /* 0 */
 166
 167 static void r200_Color3f_ub( GLfloat r, GLfloat g, GLfloat b )
 168 {
 169    GET_CURRENT_CONTEXT(ctx);
 170    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 171    r200_color_t *dest = rmesa->vb.colorptr;
 172    UNCLAMPED_FLOAT_TO_UBYTE( dest->red,   r );
 173    UNCLAMPED_FLOAT_TO_UBYTE( dest->green, g );
 174    UNCLAMPED_FLOAT_TO_UBYTE( dest->blue,  b );
 175    dest->alpha = 255;
 176 }
 177
 178 static void r200_Color3fv_ub( const GLfloat *v )
 179 {
 180    GET_CURRENT_CONTEXT(ctx);
 181    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 182    r200_color_t *dest = rmesa->vb.colorptr;
 183    UNCLAMPED_FLOAT_TO_UBYTE( dest->red,   v[0] );
 184    UNCLAMPED_FLOAT_TO_UBYTE( dest->green, v[1] );
 185    UNCLAMPED_FLOAT_TO_UBYTE( dest->blue,  v[2] );
 186    dest->alpha = 255;
 187 }
 188
 189 static void r200_Color4f_ub( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
 190 {
 191    GET_CURRENT_CONTEXT(ctx);
 192    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 193    r200_color_t *dest = rmesa->vb.colorptr;
 194    UNCLAMPED_FLOAT_TO_UBYTE( dest->red,   r );
 195    UNCLAMPED_FLOAT_TO_UBYTE( dest->green, g );
 196    UNCLAMPED_FLOAT_TO_UBYTE( dest->blue,  b );
 197    UNCLAMPED_FLOAT_TO_UBYTE( dest->alpha, a );
 198 }
 199
 200 static void r200_Color4fv_ub( const GLfloat *v )
 201 {
 202    GET_CURRENT_CONTEXT(ctx);
 203    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 204    r200_color_t *dest = rmesa->vb.colorptr;
 205    UNCLAMPED_FLOAT_TO_UBYTE( dest->red,   v[0] );
 206    UNCLAMPED_FLOAT_TO_UBYTE( dest->green, v[1] );
 207    UNCLAMPED_FLOAT_TO_UBYTE( dest->blue,  v[2] );
 208    UNCLAMPED_FLOAT_TO_UBYTE( dest->alpha, v[3] );
 209 }
 210
 211
 212 /* Color for float color+alpha formats:
 213  */
 214 #if 0
 215 static void r200_Color3ub_4f( GLubyte r, GLubyte g, GLubyte b )
 216 {
 217    GET_CURRENT_CONTEXT(ctx);
 218    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 219    GLfloat *dest = rmesa->vb.floatcolorptr;
 220    dest[0] = UBYTE_TO_FLOAT(r);
 221    dest[1] = UBYTE_TO_FLOAT(g);
 222    dest[2] = UBYTE_TO_FLOAT(b);
 223    dest[3] = 1.0;
 224 }
 225
 226 static void r200_Color3ubv_4f( const GLubyte *v )
 227 {
 228    GET_CURRENT_CONTEXT(ctx);
 229    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 230    GLfloat *dest = rmesa->vb.floatcolorptr;
 231    dest[0] = UBYTE_TO_FLOAT(v[0]);
 232    dest[1] = UBYTE_TO_FLOAT(v[1]);
 233    dest[2] = UBYTE_TO_FLOAT(v[2]);
 234    dest[3] = 1.0;
 235 }
 236
 237 static void r200_Color4ub_4f( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
 238 {
 239    GET_CURRENT_CONTEXT(ctx);
 240    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 241    GLfloat *dest = rmesa->vb.floatcolorptr;
 242    dest[0] = UBYTE_TO_FLOAT(r);
 243    dest[1] = UBYTE_TO_FLOAT(g);
 244    dest[2] = UBYTE_TO_FLOAT(b);
 245    dest[3] = UBYTE_TO_FLOAT(a);
 246 }
 247
 248 static void r200_Color4ubv_4f( const GLubyte *v )
 249 {
 250    GET_CURRENT_CONTEXT(ctx);
 251    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 252    GLfloat *dest = rmesa->vb.floatcolorptr;
 253    dest[0] = UBYTE_TO_FLOAT(v[0]);
 254    dest[1] = UBYTE_TO_FLOAT(v[1]);
 255    dest[2] = UBYTE_TO_FLOAT(v[2]);
 256    dest[3] = UBYTE_TO_FLOAT(v[3]);
 257 }
 258 #endif /* 0 */
 259
 260
 261 static void r200_Color3f_4f( GLfloat r, GLfloat g, GLfloat b )
 262 {
 263    GET_CURRENT_CONTEXT(ctx);
 264    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 265    GLfloat *dest = rmesa->vb.floatcolorptr;
 266    dest[0] = r;
 267    dest[1] = g;
 268    dest[2] = b;
 269    dest[3] = 1.0;
 270 }
 271
 272 static void r200_Color3fv_4f( const GLfloat *v )
 273 {
 274    GET_CURRENT_CONTEXT(ctx);
 275    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 276    GLfloat *dest = rmesa->vb.floatcolorptr;
 277    dest[0] = v[0];
 278    dest[1] = v[1];
 279    dest[2] = v[2];
 280    dest[3] = 1.0;
 281 }
 282
 283 static void r200_Color4f_4f( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
 284 {
 285    GET_CURRENT_CONTEXT(ctx);
 286    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 287    GLfloat *dest = rmesa->vb.floatcolorptr;
 288    dest[0] = r;
 289    dest[1] = g;
 290    dest[2] = b;
 291    dest[3] = a;
 292 }
 293
 294 static void r200_Color4fv_4f( const GLfloat *v )
 295 {
 296    GET_CURRENT_CONTEXT(ctx);
 297    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 298    GLfloat *dest = rmesa->vb.floatcolorptr;
 299    dest[0] = v[0];
 300    dest[1] = v[1];
 301    dest[2] = v[2];
 302    dest[3] = v[3];
 303 }
 304
 305
 306 /* Color for float color formats:
 307  */
 308 #if 0
 309 static void r200_Color3ub_3f( GLubyte r, GLubyte g, GLubyte b )
 310 {
 311    GET_CURRENT_CONTEXT(ctx);
 312    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 313    GLfloat *dest = rmesa->vb.floatcolorptr;
 314    dest[0] = UBYTE_TO_FLOAT(r);
 315    dest[1] = UBYTE_TO_FLOAT(g);
 316    dest[2] = UBYTE_TO_FLOAT(b);
 317 }
 318
 319 static void r200_Color3ubv_3f( const GLubyte *v )
 320 {
 321    GET_CURRENT_CONTEXT(ctx);
 322    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 323    GLfloat *dest = rmesa->vb.floatcolorptr;
 324    dest[0] = UBYTE_TO_FLOAT(v[0]);
 325    dest[1] = UBYTE_TO_FLOAT(v[1]);
 326    dest[2] = UBYTE_TO_FLOAT(v[2]);
 327 }
 328
 329 static void r200_Color4ub_3f( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
 330 {
 331    GET_CURRENT_CONTEXT(ctx);
 332    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 333    GLfloat *dest = rmesa->vb.floatcolorptr;
 334    dest[0] = UBYTE_TO_FLOAT(r);
 335    dest[1] = UBYTE_TO_FLOAT(g);
 336    dest[2] = UBYTE_TO_FLOAT(b);
 337    ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = UBYTE_TO_FLOAT(a);
 338 }
 339
 340 static void r200_Color4ubv_3f( const GLubyte *v )
 341 {
 342    GET_CURRENT_CONTEXT(ctx);
 343    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 344    GLfloat *dest = rmesa->vb.floatcolorptr;
 345    dest[0] = UBYTE_TO_FLOAT(v[0]);
 346    dest[1] = UBYTE_TO_FLOAT(v[1]);
 347    dest[2] = UBYTE_TO_FLOAT(v[2]);
 348    ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = UBYTE_TO_FLOAT(v[3]);
 349 }
 350 #endif /* 0 */
 351
 352
 353 static void r200_Color3f_3f( GLfloat r, GLfloat g, GLfloat b )
 354 {
 355    GET_CURRENT_CONTEXT(ctx);
 356    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 357    GLfloat *dest = rmesa->vb.floatcolorptr;
 358    dest[0] = r;
 359    dest[1] = g;
 360    dest[2] = b;
 361 }
 362
 363 static void r200_Color3fv_3f( const GLfloat *v )
 364 {
 365    GET_CURRENT_CONTEXT(ctx);
 366    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 367    GLfloat *dest = rmesa->vb.floatcolorptr;
 368    dest[0] = v[0];
 369    dest[1] = v[1];
 370    dest[2] = v[2];
 371 }
 372
 373 static void r200_Color4f_3f( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
 374 {
 375    GET_CURRENT_CONTEXT(ctx);
 376    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 377    GLfloat *dest = rmesa->vb.floatcolorptr;
 378    dest[0] = r;
 379    dest[1] = g;
 380    dest[2] = b;
 381    ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = a;
 382 }
 383
 384 static void r200_Color4fv_3f( const GLfloat *v )
 385 {
 386    GET_CURRENT_CONTEXT(ctx);
 387    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 388    GLfloat *dest = rmesa->vb.floatcolorptr;
 389    dest[0] = v[0];
 390    dest[1] = v[1];
 391    dest[2] = v[2];
 392    ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = v[3];
 393 }
 394
 395
 396 /* Secondary Color:
 397  */
 398 #if 0
 399 static void r200_SecondaryColor3ubEXT_ub( GLubyte r, GLubyte g, GLubyte b )
 400 {
 401    GET_CURRENT_CONTEXT(ctx);
 402    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 403    r200_color_t *dest = rmesa->vb.specptr;
 404    dest->red    = r;
 405    dest->green  = g;
 406    dest->blue   = b;
 407    dest->alpha  = 0xff;
 408 }
 409
 410 static void r200_SecondaryColor3ubvEXT_ub( const GLubyte *v )
 411 {
 412    GET_CURRENT_CONTEXT(ctx);
 413    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 414    r200_color_t *dest = rmesa->vb.specptr;
 415    dest->red    = v[0];
 416    dest->green  = v[1];
 417    dest->blue   = v[2];
 418    dest->alpha  = 0xff;
 419 }
 420 #endif /* 0 */
 421
 422 static void r200_SecondaryColor3fEXT_ub( GLfloat r, GLfloat g, GLfloat b )
 423 {
 424    GET_CURRENT_CONTEXT(ctx);
 425    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 426    r200_color_t *dest = rmesa->vb.specptr;
 427    UNCLAMPED_FLOAT_TO_UBYTE( dest->red,   r );
 428    UNCLAMPED_FLOAT_TO_UBYTE( dest->green, g );
 429    UNCLAMPED_FLOAT_TO_UBYTE( dest->blue,  b );
 430    dest->alpha = 255;
 431 }
 432
 433 static void r200_SecondaryColor3fvEXT_ub( const GLfloat *v )
 434 {
 435    GET_CURRENT_CONTEXT(ctx);
 436    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 437    r200_color_t *dest = rmesa->vb.specptr;
 438    UNCLAMPED_FLOAT_TO_UBYTE( dest->red,   v[0] );
 439    UNCLAMPED_FLOAT_TO_UBYTE( dest->green, v[1] );
 440    UNCLAMPED_FLOAT_TO_UBYTE( dest->blue,  v[2] );
 441    dest->alpha = 255;
 442 }
 443
 444 #if 0
 445 static void r200_SecondaryColor3ubEXT_3f( GLubyte r, GLubyte g, GLubyte b )
 446 {
 447    GET_CURRENT_CONTEXT(ctx);
 448    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 449    GLfloat *dest = rmesa->vb.floatspecptr;
 450    dest[0] = UBYTE_TO_FLOAT(r);
 451    dest[1] = UBYTE_TO_FLOAT(g);
 452    dest[2] = UBYTE_TO_FLOAT(b);
 453    dest[3] = 1.0;
 454 }
 455
 456 static void r200_SecondaryColor3ubvEXT_3f( const GLubyte *v )
 457 {
 458    GET_CURRENT_CONTEXT(ctx);
 459    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 460    GLfloat *dest = rmesa->vb.floatspecptr;
 461    dest[0] = UBYTE_TO_FLOAT(v[0]);
 462    dest[1] = UBYTE_TO_FLOAT(v[1]);
 463    dest[2] = UBYTE_TO_FLOAT(v[2]);
 464    dest[3] = 1.0;
 465 }
 466 #endif /* 0 */
 467
 468 static void r200_SecondaryColor3fEXT_3f( GLfloat r, GLfloat g, GLfloat b )
 469 {
 470    GET_CURRENT_CONTEXT(ctx);
 471    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 472    GLfloat *dest = rmesa->vb.floatspecptr;
 473    dest[0] = r;
 474    dest[1] = g;
 475    dest[2] = b;
 476    dest[3] = 1.0;
 477 }
 478
 479 static void r200_SecondaryColor3fvEXT_3f( const GLfloat *v )
 480 {
 481    GET_CURRENT_CONTEXT(ctx);
 482    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 483    GLfloat *dest = rmesa->vb.floatspecptr;
 484    dest[0] = v[0];
 485    dest[1] = v[1];
 486    dest[2] = v[2];
 487    dest[3] = 1.0;
 488 }
 489
 490
 491
 492 /* Normal
 493  */
 494 static void r200_Normal3f( GLfloat n0, GLfloat n1, GLfloat n2 )
 495 {
 496    GET_CURRENT_CONTEXT(ctx);
 497    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 498    GLfloat *dest = rmesa->vb.normalptr;
 499    dest[0] = n0;
 500    dest[1] = n1;
 501    dest[2] = n2;
 502 }
 503
 504 static void r200_Normal3fv( const GLfloat *v )
 505 {
 506    GET_CURRENT_CONTEXT(ctx);
 507    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 508    GLfloat *dest = rmesa->vb.normalptr;
 509    dest[0] = v[0];
 510    dest[1] = v[1];
 511    dest[2] = v[2];
 512 }
 513
 514
 515 /* TexCoord
 516  */
 517
 518 /* \todo maybe (target & 4 ? target & 5 : target & 3) is more save than (target & 7) */
 519 static void r200_MultiTexCoord1fARB(GLenum target, GLfloat s)
 520 {
 521    GET_CURRENT_CONTEXT(ctx);
 522    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 523    GLint unit = (target & 7);
 524    GLfloat * const dest = rmesa->vb.texcoordptr[unit];
 525
 526    switch( ctx->Texture.Unit[unit]._ReallyEnabled ) {
 527    case TEXTURE_CUBE_BIT:
 528    case TEXTURE_3D_BIT:
 529       dest[2] = 0.0;
 530       /* FALLTHROUGH */
 531    case TEXTURE_2D_BIT:
 532    case TEXTURE_RECT_BIT:
 533       dest[1] = 0.0;
 534       /* FALLTHROUGH */
 535    case TEXTURE_1D_BIT:
 536       dest[0] = s;
 537    }
 538 }
 539
 540 static void r200_MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
 541 {
 542    GET_CURRENT_CONTEXT(ctx);
 543    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 544    GLint unit = (target & 7);
 545    GLfloat * const dest = rmesa->vb.texcoordptr[unit];
 546
 547    switch( ctx->Texture.Unit[unit]._ReallyEnabled ) {
 548    case TEXTURE_CUBE_BIT:
 549    case TEXTURE_3D_BIT:
 550       dest[2] = 0.0;
 551       /* FALLTHROUGH */
 552    case TEXTURE_2D_BIT:
 553    case TEXTURE_RECT_BIT:
 554       dest[1] = t;
 555       dest[0] = s;
 556       break;
 557    default:
 558       VFMT_FALLBACK(__FUNCTION__);
 559       GL_CALL(MultiTexCoord2fARB)(target, s, t);
 560       return;
 561    }
 562 }
 563
 564 static void r200_MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 565 {
 566    GET_CURRENT_CONTEXT(ctx);
 567    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 568    GLint unit = (target & 7);
 569    GLfloat * const dest = rmesa->vb.texcoordptr[unit];
 570
 571    switch( ctx->Texture.Unit[unit]._ReallyEnabled ) {
 572    case TEXTURE_CUBE_BIT:
 573    case TEXTURE_3D_BIT:
 574       dest[2] = r;
 575       dest[1] = t;
 576       dest[0] = s;
 577       break;
 578    default:
 579       VFMT_FALLBACK(__FUNCTION__);
 580       GL_CALL(MultiTexCoord3fARB)(target, s, t, r);
 581       return;
 582    }
 583 }
 584
 585 static void r200_TexCoord1f(GLfloat s)
 586 {
 587    r200_MultiTexCoord1fARB(GL_TEXTURE0, s);
 588 }
 589
 590 static void r200_TexCoord2f(GLfloat s, GLfloat t)
 591 {
 592    r200_MultiTexCoord2fARB(GL_TEXTURE0, s, t);
 593 }
 594
 595 static void r200_TexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 596 {
 597    r200_MultiTexCoord3fARB(GL_TEXTURE0, s, t, r);
 598 }
 599
 600 static void r200_TexCoord1fv(const GLfloat *v)
 601 {
 602    r200_MultiTexCoord1fARB(GL_TEXTURE0, v[0]);
 603 }
 604
 605 static void r200_TexCoord2fv(const GLfloat *v)
 606 {
 607    r200_MultiTexCoord2fARB(GL_TEXTURE0, v[0], v[1]);
 608 }
 609
 610 static void r200_TexCoord3fv(const GLfloat *v)
 611 {
 612    r200_MultiTexCoord3fARB(GL_TEXTURE0, v[0], v[1], v[2]);
 613 }
 614
 615 static void r200_MultiTexCoord1fvARB(GLenum target, const GLfloat *v)
 616 {
 617    r200_MultiTexCoord1fARB(target, v[0]);
 618 }
 619
 620 static void r200_MultiTexCoord2fvARB(GLenum target, const GLfloat *v)
 621 {
 622    r200_MultiTexCoord2fARB(target, v[0], v[1]);
 623 }
 624
 625 static void r200_MultiTexCoord3fvARB(GLenum target, const GLfloat *v)
 626 {
 627    r200_MultiTexCoord3fARB(target, v[0], v[1], v[2]);
 628 }
 629
 630
 631 static struct dynfn *lookup( struct dynfn *l, const int *key )
 632 {
 633    struct dynfn *f;
 634
 635    foreach( f, l ) {
 636       if (f->key[0] == key[0] && f->key[1] == key[1])
 637          return f;
 638    }
 639
 640    return 0;
 641 }
 642
 643 /* Can't use the loopback template for this:
 644  */
 645
 646 #define CHOOSE(FN, FNTYPE, MASK0, MASK1, ARGS1, ARGS2 )                 \
 647 static void choose_##FN ARGS1                                           \
 648 {                                                                       \
 649    GET_CURRENT_CONTEXT(ctx);                                            \
 650    r200ContextPtr rmesa = R200_CONTEXT(ctx);                            \
 651    int key[2];                                                          \
 652    struct dynfn *dfn;                                                   \
 653                                                                         \
 654    key[0] = rmesa->vb.vtxfmt_0 & MASK0;                                 \
 655    key[1] = rmesa->vb.vtxfmt_1 & MASK1;                                 \
 656                                                                         \
 657    dfn = lookup( &rmesa->vb.dfn_cache.FN, key );                        \
 658    if (dfn == 0)                                                        \
 659       dfn = rmesa->vb.codegen.FN( ctx, key );                           \
 660    else if (R200_DEBUG & DEBUG_CODEGEN)                                 \
 661       fprintf(stderr, "%s -- cached codegen\n", __FUNCTION__ );         \
 662                                                                         \
 663    if (dfn)                                                             \
 664       ctx->Exec->FN = (FNTYPE)(dfn->code);                              \
 665    else {                                                               \
 666       if (R200_DEBUG & DEBUG_CODEGEN)                                   \
 667          fprintf(stderr, "%s -- generic version\n", __FUNCTION__ );     \
 668       ctx->Exec->FN = r200_##FN;                                        \
 669    }                                                                    \
 670                                                                         \
 671    ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT;                       \
 672    ctx->Exec->FN ARGS2;                                                 \
 673 }
 674
 675
 676
 677 /* For the _3f case, only allow one color function to be hooked in at
 678  * a time.  Eventually, use a similar mechanism to allow selecting the
 679  * color component of the vertex format based on client behaviour.
 680  *
 681  * Note:  Perform these actions even if there is a codegen or cached
 682  * codegen version of the chosen function.
 683  */
 684 #define CHOOSE_COLOR(FN, FNTYPE, NR, MASK0, MASK1, ARGS1, ARGS2 )       \
 685 static void choose_##FN ARGS1                                           \
 686 {                                                                       \
 687    GET_CURRENT_CONTEXT(ctx);                                            \
 688    r200ContextPtr rmesa = R200_CONTEXT(ctx);                    \
 689    int key[2];                                                          \
 690    struct dynfn *dfn;                                                   \
 691                                                                         \
 692    key[0] = rmesa->vb.vtxfmt_0 & MASK0;                                 \
 693    key[1] = rmesa->vb.vtxfmt_1 & MASK1;                                 \
 694                                                                         \
 695    if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_PK_RGBA) {           \
 696       ctx->Exec->FN = r200_##FN##_ub;                                   \
 697    }                                                                    \
 698    else if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_FP_RGB) {       \
 699                                                                         \
 700       if (rmesa->vb.installed_color_3f_sz != NR) {                      \
 701          rmesa->vb.installed_color_3f_sz = NR;                          \
 702          if (NR == 3) ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = 1.0; \
 703          if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) {            \
 704             r200_copy_to_current( ctx );                                \
 705             _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt );        \
 706             ctx->Exec->FN ARGS2;                                        \
 707             return;                                                     \
 708          }                                                              \
 709       }                                                                 \
 710                                                                         \
 711       ctx->Exec->FN = r200_##FN##_3f;                                   \
 712    }                                                                    \
 713    else {                                                               \
 714       ctx->Exec->FN = r200_##FN##_4f;                                   \
 715    }                                                                    \
 716                                                                         \
 717                                                                         \
 718    dfn = lookup( &rmesa->vb.dfn_cache.FN, key );                        \
 719    if (!dfn) dfn = rmesa->vb.codegen.FN( ctx, key );                    \
 720                                                                         \
 721    if (dfn) {                                                           \
 722       if (R200_DEBUG & DEBUG_CODEGEN)                                   \
 723          fprintf(stderr, "%s -- codegen version\n", __FUNCTION__ );     \
 724       ctx->Exec->FN = (FNTYPE)dfn->code;                                \
 725    }                                                                    \
 726    else if (R200_DEBUG & DEBUG_CODEGEN)                                 \
 727          fprintf(stderr, "%s -- 'c' version\n", __FUNCTION__ );         \
 728                                                                         \
 729    ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT;                       \
 730    ctx->Exec->FN ARGS2;                                                 \
 731 }
 732
 733
 734
 735 /* Right now there are both _ub and _3f versions of the secondary color
 736  * functions.  Currently, we only set-up the hardware to use the _ub versions.
 737  * The _3f versions are needed for the cases where secondary color isn't used
 738  * in the vertex format, but it still needs to be stored in the context
 739  * state vector.
 740  */
 741 #define CHOOSE_SECONDARY_COLOR(FN, FNTYPE, MASK0, MASK1, ARGS1, ARGS2 ) \
 742 static void choose_##FN ARGS1                                           \
 743 {                                                                       \
 744    GET_CURRENT_CONTEXT(ctx);                                            \
 745    r200ContextPtr rmesa = R200_CONTEXT(ctx);                    \
 746    int key[2];                                                          \
 747    struct dynfn *dfn;                                                   \
 748                                                                         \
 749    key[0] = rmesa->vb.vtxfmt_0 & MASK0;                                 \
 750    key[1] = rmesa->vb.vtxfmt_1 & MASK1;                                 \
 751                                                                         \
 752    dfn = lookup( &rmesa->vb.dfn_cache.FN, key );                        \
 753    if (dfn == 0)                                                        \
 754       dfn = rmesa->vb.codegen.FN( ctx, key );                   \
 755    else  if (R200_DEBUG & DEBUG_CODEGEN)                                \
 756       fprintf(stderr, "%s -- cached version\n", __FUNCTION__ );         \
 757                                                                         \
 758    if (dfn)                                                             \
 759       ctx->Exec->FN = (FNTYPE)(dfn->code);                      \
 760    else {                                                               \
 761       if (R200_DEBUG & DEBUG_CODEGEN)                                   \
 762          fprintf(stderr, "%s -- generic version\n", __FUNCTION__ );     \
 763       ctx->Exec->FN = (VTX_COLOR(rmesa->vb.vtxfmt_0,1) == R200_VTX_PK_RGBA) \
 764           ? r200_##FN##_ub : r200_##FN##_3f;                            \
 765    }                                                                    \
 766                                                                         \
 767    ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT;               \
 768    ctx->Exec->FN ARGS2;                                         \
 769 }
 770
 771
 772
 773
 774
 775
 776
 777 /* VTXFMT_0
 778  */
 779 #define MASK_XYZW  (R200_VTX_W0|R200_VTX_Z0)
 780 #define MASK_NORM  (MASK_XYZW|R200_VTX_N0)
 781 #define MASK_COLOR (MASK_NORM |(R200_VTX_COLOR_MASK<<R200_VTX_COLOR_0_SHIFT))
 782 #define MASK_SPEC  (MASK_COLOR|(R200_VTX_COLOR_MASK<<R200_VTX_COLOR_1_SHIFT))
 783
 784 /* VTXFMT_1
 785  */
 786 #define MASK_ST0 (0x7 << R200_VTX_TEX0_COMP_CNT_SHIFT)
 787 /* FIXME: maybe something like in the radeon driver is needed here? */
 788
 789
 790 typedef void (*p4f)( GLfloat, GLfloat, GLfloat, GLfloat );
 791 typedef void (*p3f)( GLfloat, GLfloat, GLfloat );
 792 typedef void (*p2f)( GLfloat, GLfloat );
 793 typedef void (*p1f)( GLfloat );
 794 typedef void (*pe3f)( GLenum, GLfloat, GLfloat, GLfloat );
 795 typedef void (*pe2f)( GLenum, GLfloat, GLfloat );
 796 typedef void (*pe1f)( GLenum, GLfloat );
 797 typedef void (*p4ub)( GLubyte, GLubyte, GLubyte, GLubyte );
 798 typedef void (*p3ub)( GLubyte, GLubyte, GLubyte );
 799 typedef void (*pfv)( const GLfloat * );
 800 typedef void (*pefv)( GLenum, const GLfloat * );
 801 typedef void (*pubv)( const GLubyte * );
 802
 803
 804 CHOOSE(Normal3f, p3f, MASK_NORM, 0,
 805        (GLfloat a,GLfloat b,GLfloat c), (a,b,c))
 806 CHOOSE(Normal3fv, pfv, MASK_NORM, 0,
 807        (const GLfloat *v), (v))
 808
 809 #if 0
 810 CHOOSE_COLOR(Color4ub, p4ub, 4, MASK_COLOR, 0,
 811         (GLubyte a,GLubyte b, GLubyte c, GLubyte d), (a,b,c,d))
 812 CHOOSE_COLOR(Color4ubv, pubv, 4, MASK_COLOR, 0,
 813         (const GLubyte *v), (v))
 814 CHOOSE_COLOR(Color3ub, p3ub, 3, MASK_COLOR, 0,
 815         (GLubyte a,GLubyte b, GLubyte c), (a,b,c))
 816 CHOOSE_COLOR(Color3ubv, pubv, 3, MASK_COLOR, 0,
 817         (const GLubyte *v), (v))
 818 CHOOSE_SECONDARY_COLOR(SecondaryColor3ubEXT, p3ub, MASK_SPEC, 0,
 819         (GLubyte a,GLubyte b, GLubyte c), (a,b,c))
 820 CHOOSE_SECONDARY_COLOR(SecondaryColor3ubvEXT, pubv, MASK_SPEC, 0,
 821         (const GLubyte *v), (v))
 822 #endif
 823
 824 CHOOSE_COLOR(Color4f, p4f, 4, MASK_COLOR, 0,
 825         (GLfloat a,GLfloat b, GLfloat c, GLfloat d), (a,b,c,d))
 826 CHOOSE_COLOR(Color4fv, pfv, 4, MASK_COLOR, 0,
 827         (const GLfloat *v), (v))
 828 CHOOSE_COLOR(Color3f, p3f, 3, MASK_COLOR, 0,
 829         (GLfloat a,GLfloat b, GLfloat c), (a,b,c))
 830 CHOOSE_COLOR(Color3fv, pfv, 3, MASK_COLOR, 0,
 831         (const GLfloat *v), (v))
 832
 833
 834 CHOOSE_SECONDARY_COLOR(SecondaryColor3fEXT, p3f, MASK_SPEC, 0,
 835         (GLfloat a,GLfloat b, GLfloat c), (a,b,c))
 836 CHOOSE_SECONDARY_COLOR(SecondaryColor3fvEXT, pfv, MASK_SPEC, 0,
 837         (const GLfloat *v), (v))
 838
 839 CHOOSE(TexCoord3f, p3f, ~0, MASK_ST0,
 840        (GLfloat a,GLfloat b,GLfloat c), (a,b,c))
 841 CHOOSE(TexCoord3fv, pfv, ~0, MASK_ST0,
 842        (const GLfloat *v), (v))
 843 CHOOSE(TexCoord2f, p2f, ~0, MASK_ST0,
 844        (GLfloat a,GLfloat b), (a,b))
 845 CHOOSE(TexCoord2fv, pfv, ~0, MASK_ST0,
 846        (const GLfloat *v), (v))
 847 CHOOSE(TexCoord1f, p1f, ~0, MASK_ST0,
 848        (GLfloat a), (a))
 849 CHOOSE(TexCoord1fv, pfv, ~0, MASK_ST0,
 850        (const GLfloat *v), (v))
 851
 852 CHOOSE(MultiTexCoord3fARB, pe3f, ~0, ~0,
 853          (GLenum u,GLfloat a,GLfloat b,GLfloat c), (u,a,b,c))
 854 CHOOSE(MultiTexCoord3fvARB, pefv, ~0, ~0,
 855         (GLenum u,const GLfloat *v), (u,v))
 856 CHOOSE(MultiTexCoord2fARB, pe2f, ~0, ~0,
 857          (GLenum u,GLfloat a,GLfloat b), (u,a,b))
 858 CHOOSE(MultiTexCoord2fvARB, pefv, ~0, ~0,
 859         (GLenum u,const GLfloat *v), (u,v))
 860 CHOOSE(MultiTexCoord1fARB, pe1f, ~0, ~0,
 861          (GLenum u,GLfloat a), (u,a))
 862 CHOOSE(MultiTexCoord1fvARB, pefv, ~0, ~0,
 863         (GLenum u,const GLfloat *v), (u,v))
 864
 865 CHOOSE(Vertex3f, p3f, ~0, ~0,
 866        (GLfloat a,GLfloat b,GLfloat c), (a,b,c))
 867 CHOOSE(Vertex3fv, pfv, ~0, ~0,
 868        (const GLfloat *v), (v))
 869 CHOOSE(Vertex2f, p2f, ~0, ~0,
 870        (GLfloat a,GLfloat b), (a,b))
 871 CHOOSE(Vertex2fv, pfv, ~0, ~0,
 872        (const GLfloat *v), (v))
 873
 874
 875
 876
 877
 878 void r200VtxfmtInitChoosers( GLvertexformat *vfmt )
 879 {
 880    vfmt->Color3f = choose_Color3f;
 881    vfmt->Color3fv = choose_Color3fv;
 882    vfmt->Color4f = choose_Color4f;
 883    vfmt->Color4fv = choose_Color4fv;
 884    vfmt->SecondaryColor3fEXT = choose_SecondaryColor3fEXT;
 885    vfmt->SecondaryColor3fvEXT = choose_SecondaryColor3fvEXT;
 886    vfmt->MultiTexCoord1fARB = choose_MultiTexCoord1fARB;
 887    vfmt->MultiTexCoord1fvARB = choose_MultiTexCoord1fvARB;
 888    vfmt->MultiTexCoord2fARB = choose_MultiTexCoord2fARB;
 889    vfmt->MultiTexCoord2fvARB = choose_MultiTexCoord2fvARB;
 890    vfmt->MultiTexCoord3fARB = choose_MultiTexCoord3fARB;
 891    vfmt->MultiTexCoord3fvARB = choose_MultiTexCoord3fvARB;
 892    vfmt->Normal3f = choose_Normal3f;
 893    vfmt->Normal3fv = choose_Normal3fv;
 894    vfmt->TexCoord1f = choose_TexCoord1f;
 895    vfmt->TexCoord1fv = choose_TexCoord1fv;
 896    vfmt->TexCoord2f = choose_TexCoord2f;
 897    vfmt->TexCoord2fv = choose_TexCoord2fv;
 898    vfmt->TexCoord3f = choose_TexCoord3f;
 899    vfmt->TexCoord3fv = choose_TexCoord3fv;
 900    vfmt->Vertex2f = choose_Vertex2f;
 901    vfmt->Vertex2fv = choose_Vertex2fv;
 902    vfmt->Vertex3f = choose_Vertex3f;
 903    vfmt->Vertex3fv = choose_Vertex3fv;
 904
 905    /* TODO: restore ubyte colors to vtxfmt.
 906     */
 907 #if 0
 908    vfmt->Color3ub = choose_Color3ub;
 909    vfmt->Color3ubv = choose_Color3ubv;
 910    vfmt->Color4ub = choose_Color4ub;
 911    vfmt->Color4ubv = choose_Color4ubv;
 912    vfmt->SecondaryColor3ubEXT = choose_SecondaryColor3ubEXT;
 913    vfmt->SecondaryColor3ubvEXT = choose_SecondaryColor3ubvEXT;
 914 #endif
 915 }
 916
 917
 918 static struct dynfn *codegen_noop( GLcontext *ctx, const int *key )
 919 {
 920    (void) ctx; (void) key;
 921    return 0;
 922 }
 923
 924 void r200InitCodegen( struct dfn_generators *gen, GLboolean useCodegen )
 925 {
 926    gen->Vertex3f = codegen_noop;
 927    gen->Vertex3fv = codegen_noop;
 928    gen->Color4ub = codegen_noop;
 929    gen->Color4ubv = codegen_noop;
 930    gen->Normal3f = codegen_noop;
 931    gen->Normal3fv = codegen_noop;
 932
 933    gen->TexCoord3f = codegen_noop;
 934    gen->TexCoord3fv = codegen_noop;
 935    gen->TexCoord2f = codegen_noop;
 936    gen->TexCoord2fv = codegen_noop;
 937    gen->TexCoord1f = codegen_noop;
 938    gen->TexCoord1fv = codegen_noop;
 939
 940    gen->MultiTexCoord3fARB = codegen_noop;
 941    gen->MultiTexCoord3fvARB = codegen_noop;
 942    gen->MultiTexCoord2fARB = codegen_noop;
 943    gen->MultiTexCoord2fvARB = codegen_noop;
 944    gen->MultiTexCoord1fARB = codegen_noop;
 945    gen->MultiTexCoord1fvARB = codegen_noop;
 946
 947    gen->Vertex2f = codegen_noop;
 948    gen->Vertex2fv = codegen_noop;
 949    gen->Color3ub = codegen_noop;
 950    gen->Color3ubv = codegen_noop;
 951    gen->Color4f = codegen_noop;
 952    gen->Color4fv = codegen_noop;
 953    gen->Color3f = codegen_noop;
 954    gen->Color3fv = codegen_noop;
 955    gen->SecondaryColor3fEXT = codegen_noop;
 956    gen->SecondaryColor3fvEXT = codegen_noop;
 957    gen->SecondaryColor3ubEXT = codegen_noop;
 958    gen->SecondaryColor3ubvEXT = codegen_noop;
 959
 960    if (useCodegen) {
 961 #if defined(USE_X86_ASM)
 962       r200InitX86Codegen( gen );
 963 #endif
 964
 965 #if defined(USE_SSE_ASM)
 966       r200InitSSECodegen( gen );
 967 #endif
 968    }
 969 }