src/mesa/main/api_loopback.c

   1 /* $Id: api_loopback.c,v 1.11 2001/12/04 23:43:31 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.5
   6  *
   7  * Copyright (C) 1999-2001  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
  31 #include "glheader.h"
  32 #include "glapitable.h"
  33 #include "macros.h"
  34 #include "colormac.h"
  35 #include "api_loopback.h"
  36
  37 /* KW: A set of functions to convert unusual Color/Normal/Vertex/etc
  38  * calls to a smaller set of driver-provided formats.  Currently just
  39  * go back to dispatch to find these (eg. call glNormal3f directly),
  40  * hence 'loopback'.
  41  *
  42  * The driver must supply all of the remaining entry points, which are
  43  * listed in dd.h.  The easiest way for a driver to do this is to
  44  * install the supplied software t&l module.
  45  */
  46 #define DRIVER(x) gl##x
  47 #define COLORUBV(v)                 DRIVER(Color4ubv)(v)
  48 #define COLORF(r,g,b,a)             DRIVER(Color4f)(r,g,b,a)
  49 #define FOGCOORDF(x)                DRIVER(FogCoordfEXT)(x)
  50 #define VERTEX2(x,y)                DRIVER(Vertex2f)(x,y)
  51 #define VERTEX3(x,y,z)              DRIVER(Vertex3f)(x,y,z)
  52 #define VERTEX4(x,y,z,w)            DRIVER(Vertex4f)(x,y,z,w)
  53 #define NORMAL(x,y,z)               DRIVER(Normal3f)(x,y,z)
  54 #define TEXCOORD1(s)                DRIVER(TexCoord1f)(s)
  55 #define TEXCOORD2(s,t)              DRIVER(TexCoord2f)(s,t)
  56 #define TEXCOORD3(s,t,u)            DRIVER(TexCoord3f)(s,t,u)
  57 #define TEXCOORD4(s,t,u,v)          DRIVER(TexCoord4f)(s,t,u,v)
  58 #define INDEX(c)                    DRIVER(Indexi)(c)
  59 #define MULTI_TEXCOORD1(z,s)        DRIVER(MultiTexCoord1fARB)(z,s)
  60 #define MULTI_TEXCOORD2(z,s,t)      DRIVER(MultiTexCoord2fARB)(z,s,t)
  61 #define MULTI_TEXCOORD3(z,s,t,u)    DRIVER(MultiTexCoord3fARB)(z,s,t,u)
  62 #define MULTI_TEXCOORD4(z,s,t,u,v)  DRIVER(MultiTexCoord4fARB)(z,s,t,u,v)
  63 #define EVALCOORD1(x)               DRIVER(EvalCoord1f)(x)
  64 #define EVALCOORD2(x,y)             DRIVER(EvalCoord2f)(x,y)
  65 #define MATERIALFV(a,b,c)           DRIVER(Materialfv)(a,b,c)
  66 #define RECTF(a,b,c,d)              DRIVER(Rectf)(a,b,c,d)
  67 #define SECONDARYCOLORUB(a,b,c)     DRIVER(SecondaryColor3ubEXT)(a,b,c)
  68 #define SECONDARYCOLORF(a,b,c)      DRIVER(SecondaryColor3fEXT)(a,b,c)
  69
  70
  71 static void
  72 loopback_Color3b( GLbyte red, GLbyte green, GLbyte blue )
  73 {
  74    GLubyte col[4];
  75    col[0] = BYTE_TO_UBYTE(red);
  76    col[1] = BYTE_TO_UBYTE(green);
  77    col[2] = BYTE_TO_UBYTE(blue);
  78    col[3] = 255;
  79    COLORUBV(col);
  80 }
  81
  82 static void
  83 loopback_Color3d( GLdouble red, GLdouble green, GLdouble blue )
  84 {
  85    GLubyte col[4];
  86    GLfloat r = (GLfloat) red;
  87    GLfloat g = (GLfloat) green;
  88    GLfloat b = (GLfloat) blue;
  89    UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
  90    UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
  91    UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
  92    col[3] = 255;
  93    COLORUBV( col );
  94 }
  95
  96 static void
  97 loopback_Color3i( GLint red, GLint green, GLint blue )
  98 {
  99    GLubyte col[4];
 100    col[0] = INT_TO_UBYTE(red);
 101    col[1] = INT_TO_UBYTE(green);
 102    col[2] = INT_TO_UBYTE(blue);
 103    col[3] = 255;
 104    COLORUBV(col);
 105 }
 106
 107 static void
 108 loopback_Color3s( GLshort red, GLshort green, GLshort blue )
 109 {
 110    GLubyte col[4];
 111    col[0] = SHORT_TO_UBYTE(red);
 112    col[1] = SHORT_TO_UBYTE(green);
 113    col[2] = SHORT_TO_UBYTE(blue);
 114    col[3] = 255;
 115    COLORUBV(col);
 116 }
 117
 118 static void
 119 loopback_Color3ui( GLuint red, GLuint green, GLuint blue )
 120 {
 121    GLubyte col[4];
 122    col[0] = UINT_TO_UBYTE(red);
 123    col[1] = UINT_TO_UBYTE(green);
 124    col[2] = UINT_TO_UBYTE(blue);
 125    col[3] = 255;
 126    COLORUBV(col);
 127 }
 128
 129 static void
 130 loopback_Color3us( GLushort red, GLushort green, GLushort blue )
 131 {
 132    GLubyte col[4];
 133    col[0] = USHORT_TO_UBYTE(red);
 134    col[1] = USHORT_TO_UBYTE(green);
 135    col[2] = USHORT_TO_UBYTE(blue);
 136    col[3] = 255;
 137    COLORUBV(col);
 138 }
 139
 140 static void
 141 loopback_Color4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
 142 {
 143    GLubyte col[4];
 144    col[0] = BYTE_TO_UBYTE(red);
 145    col[1] = BYTE_TO_UBYTE(green);
 146    col[2] = BYTE_TO_UBYTE(blue);
 147    col[3] = 255;
 148    COLORUBV(col);
 149 }
 150
 151 static void
 152 loopback_Color4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
 153 {
 154    GLubyte col[4];
 155    GLfloat r = (GLfloat) red;
 156    GLfloat g = (GLfloat) green;
 157    GLfloat b = (GLfloat) blue;
 158    GLfloat a = (GLfloat) alpha;
 159    UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
 160    UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
 161    UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
 162    UNCLAMPED_FLOAT_TO_UBYTE(col[3], a);
 163    COLORUBV( col );
 164 }
 165
 166 static void
 167 loopback_Color4i( GLint red, GLint green, GLint blue, GLint alpha )
 168 {
 169    GLubyte col[4];
 170    col[0] = INT_TO_UBYTE(red);
 171    col[1] = INT_TO_UBYTE(green);
 172    col[2] = INT_TO_UBYTE(blue);
 173    col[3] = INT_TO_UBYTE(alpha);
 174    COLORUBV(col);
 175 }
 176
 177 static void
 178 loopback_Color4s( GLshort red, GLshort green, GLshort blue,
 179                         GLshort alpha )
 180 {
 181    GLubyte col[4];
 182    col[0] = SHORT_TO_UBYTE(red);
 183    col[1] = SHORT_TO_UBYTE(green);
 184    col[2] = SHORT_TO_UBYTE(blue);
 185    col[3] = SHORT_TO_UBYTE(alpha);
 186    COLORUBV(col);
 187 }
 188
 189 static void
 190 loopback_Color4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
 191 {
 192    GLubyte col[4];
 193    col[0] = UINT_TO_UBYTE(red);
 194    col[1] = UINT_TO_UBYTE(green);
 195    col[2] = UINT_TO_UBYTE(blue);
 196    col[3] = UINT_TO_UBYTE(alpha);
 197    COLORUBV(col);
 198 }
 199
 200 static void
 201 loopback_Color4us( GLushort red, GLushort green, GLushort blue,
 202                          GLushort alpha )
 203 {
 204    GLubyte col[4];
 205    col[0] = USHORT_TO_UBYTE(red);
 206    col[1] = USHORT_TO_UBYTE(green);
 207    col[2] = USHORT_TO_UBYTE(blue);
 208    col[3] = USHORT_TO_UBYTE(alpha);
 209    COLORUBV(col);
 210 }
 211
 212 static void
 213 loopback_Color3bv( const GLbyte *v )
 214 {
 215    GLubyte col[4];
 216    col[0] = BYTE_TO_UBYTE(v[0]);
 217    col[1] = BYTE_TO_UBYTE(v[1]);
 218    col[2] = BYTE_TO_UBYTE(v[2]);
 219    col[3] = 255;
 220    COLORUBV(col);
 221 }
 222
 223 static void
 224 loopback_Color3dv( const GLdouble *v )
 225 {
 226    GLubyte col[4];
 227    GLfloat r = (GLfloat) v[0];
 228    GLfloat g = (GLfloat) v[1];
 229    GLfloat b = (GLfloat) v[2];
 230    UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
 231    UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
 232    UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
 233    col[3] = 255;
 234    COLORUBV( col );
 235 }
 236
 237 static void
 238 loopback_Color3iv( const GLint *v )
 239 {
 240    GLubyte col[4];
 241    col[0] = INT_TO_UBYTE(v[0]);
 242    col[1] = INT_TO_UBYTE(v[1]);
 243    col[2] = INT_TO_UBYTE(v[2]);
 244    col[3] = 255;
 245    COLORUBV(col);
 246 }
 247
 248 static void
 249 loopback_Color3sv( const GLshort *v )
 250 {
 251    GLubyte col[4];
 252    col[0] = SHORT_TO_UBYTE(v[0]);
 253    col[1] = SHORT_TO_UBYTE(v[1]);
 254    col[2] = SHORT_TO_UBYTE(v[2]);
 255    col[3] = 255;
 256    COLORUBV(col);
 257 }
 258
 259 static void
 260 loopback_Color3uiv( const GLuint *v )
 261 {
 262    GLubyte col[4];
 263    col[0] = UINT_TO_UBYTE(v[0]);
 264    col[1] = UINT_TO_UBYTE(v[1]);
 265    col[2] = UINT_TO_UBYTE(v[2]);
 266    col[3] = 255;
 267    COLORUBV(col);
 268 }
 269
 270 static void
 271 loopback_Color3usv( const GLushort *v )
 272 {
 273    GLubyte col[4];
 274    col[0] = USHORT_TO_UBYTE(v[0]);
 275    col[1] = USHORT_TO_UBYTE(v[1]);
 276    col[2] = USHORT_TO_UBYTE(v[2]);
 277    col[3] = 255;
 278    COLORUBV(col);
 279
 280 }
 281
 282 static void
 283 loopback_Color4bv( const GLbyte *v )
 284 {
 285    GLubyte col[4];
 286    col[0] = BYTE_TO_UBYTE(v[0]);
 287    col[1] = BYTE_TO_UBYTE(v[1]);
 288    col[2] = BYTE_TO_UBYTE(v[2]);
 289    col[3] = BYTE_TO_UBYTE(v[3]);
 290    COLORUBV(col);
 291 }
 292
 293 static void
 294 loopback_Color4dv( const GLdouble *v )
 295 {
 296    GLubyte col[4];
 297    GLfloat r = (GLfloat) v[0];
 298    GLfloat g = (GLfloat) v[1];
 299    GLfloat b = (GLfloat) v[2];
 300    GLfloat a = (GLfloat) v[3];
 301    UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
 302    UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
 303    UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
 304    UNCLAMPED_FLOAT_TO_UBYTE(col[3], a);
 305    COLORUBV( col );
 306 }
 307
 308 static void
 309 loopback_Color4iv( const GLint *v )
 310 {
 311    GLubyte col[4];
 312    col[0] = INT_TO_UBYTE(v[0]);
 313    col[1] = INT_TO_UBYTE(v[1]);
 314    col[2] = INT_TO_UBYTE(v[2]);
 315    col[3] = INT_TO_UBYTE(v[3]);
 316    COLORUBV(col);
 317 }
 318
 319 static void
 320 loopback_Color4sv( const GLshort *v)
 321 {
 322    GLubyte col[4];
 323    col[0] = SHORT_TO_UBYTE(v[0]);
 324    col[1] = SHORT_TO_UBYTE(v[1]);
 325    col[2] = SHORT_TO_UBYTE(v[2]);
 326    col[3] = SHORT_TO_UBYTE(v[3]);
 327    COLORUBV(col);
 328 }
 329
 330 static void
 331 loopback_Color4uiv( const GLuint *v)
 332 {
 333    GLubyte col[4];
 334    col[0] = UINT_TO_UBYTE(v[0]);
 335    col[1] = UINT_TO_UBYTE(v[1]);
 336    col[2] = UINT_TO_UBYTE(v[2]);
 337    col[3] = UINT_TO_UBYTE(v[3]);
 338    COLORUBV(col);
 339 }
 340
 341 static void
 342 loopback_Color4usv( const GLushort *v)
 343 {
 344    GLubyte col[4];
 345    col[0] = USHORT_TO_UBYTE(v[0]);
 346    col[1] = USHORT_TO_UBYTE(v[1]);
 347    col[2] = USHORT_TO_UBYTE(v[2]);
 348    col[3] = USHORT_TO_UBYTE(v[3]);
 349    COLORUBV(col);
 350 }
 351
 352 static void
 353 loopback_Color3b_f( GLbyte red, GLbyte green, GLbyte blue )
 354 {
 355    COLORF( BYTE_TO_FLOAT(red),
 356            BYTE_TO_FLOAT(green),
 357            BYTE_TO_FLOAT(blue),
 358            1.0 );
 359 }
 360
 361 static void
 362 loopback_Color3d_f( GLdouble red, GLdouble green, GLdouble blue )
 363 {
 364    COLORF( (GLfloat) red, (GLfloat) green, (GLfloat) blue, 1.0 );
 365 }
 366
 367 static void
 368 loopback_Color3i_f( GLint red, GLint green, GLint blue )
 369 {
 370    COLORF( INT_TO_FLOAT(red), INT_TO_FLOAT(green),
 371            INT_TO_FLOAT(blue), 1.0);
 372 }
 373
 374 static void
 375 loopback_Color3s_f( GLshort red, GLshort green, GLshort blue )
 376 {
 377    COLORF( SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
 378            SHORT_TO_FLOAT(blue), 1.0);
 379 }
 380
 381 static void
 382 loopback_Color3ui_f( GLuint red, GLuint green, GLuint blue )
 383 {
 384    COLORF( UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
 385            UINT_TO_FLOAT(blue), 1.0 );
 386 }
 387
 388 static void
 389 loopback_Color3us_f( GLushort red, GLushort green, GLushort blue )
 390 {
 391    COLORF( USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
 392            USHORT_TO_FLOAT(blue), 1.0 );
 393 }
 394
 395
 396 static void
 397 loopback_Color3bv_f( const GLbyte *v )
 398 {
 399    COLORF( BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
 400            BYTE_TO_FLOAT(v[2]), 1.0 );
 401 }
 402
 403 static void
 404 loopback_Color3dv_f( const GLdouble *v )
 405 {
 406    COLORF( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0 );
 407 }
 408
 409 static void
 410 loopback_Color3iv_f( const GLint *v )
 411 {
 412    COLORF( INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
 413            INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
 414 }
 415
 416 static void
 417 loopback_Color3sv_f( const GLshort *v )
 418 {
 419    COLORF( SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
 420            SHORT_TO_FLOAT(v[2]), 1.0 );
 421 }
 422
 423 static void
 424 loopback_Color3uiv_f( const GLuint *v )
 425 {
 426    COLORF( UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
 427            UINT_TO_FLOAT(v[2]), 1.0 );
 428 }
 429
 430 static void
 431 loopback_Color3usv_f( const GLushort *v )
 432 {
 433    COLORF( USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
 434            USHORT_TO_FLOAT(v[2]), 1.0 );
 435 }
 436
 437
 438 static void
 439 loopback_Color4b_f( GLbyte red, GLbyte green, GLbyte blue,
 440                               GLbyte alpha )
 441 {
 442    COLORF( BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
 443            BYTE_TO_FLOAT(blue), BYTE_TO_FLOAT(alpha) );
 444 }
 445
 446 static void
 447 loopback_Color4d_f( GLdouble red, GLdouble green, GLdouble blue,
 448                               GLdouble alpha )
 449 {
 450    COLORF( (GLfloat) red, (GLfloat) green, (GLfloat) blue, (GLfloat) alpha );
 451 }
 452
 453 static void
 454 loopback_Color4i_f( GLint red, GLint green, GLint blue, GLint alpha )
 455 {
 456    COLORF( INT_TO_FLOAT(red), INT_TO_FLOAT(green),
 457            INT_TO_FLOAT(blue), INT_TO_FLOAT(alpha) );
 458 }
 459
 460 static void
 461 loopback_Color4s_f( GLshort red, GLshort green, GLshort blue,
 462                               GLshort alpha )
 463 {
 464    COLORF( SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
 465            SHORT_TO_FLOAT(blue), SHORT_TO_FLOAT(alpha) );
 466 }
 467
 468 static void
 469 loopback_Color4ui_f( GLuint red, GLuint green, GLuint blue, GLuint alpha )
 470 {
 471    COLORF( UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
 472            UINT_TO_FLOAT(blue), UINT_TO_FLOAT(alpha) );
 473 }
 474
 475 static void
 476 loopback_Color4us_f( GLushort red, GLushort green, GLushort blue, GLushort alpha )
 477 {
 478    COLORF( USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
 479            USHORT_TO_FLOAT(blue), USHORT_TO_FLOAT(alpha) );
 480 }
 481
 482
 483 static void
 484 loopback_Color4iv_f( const GLint *v )
 485 {
 486    COLORF( INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
 487            INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
 488 }
 489
 490
 491 static void
 492 loopback_Color4bv_f( const GLbyte *v )
 493 {
 494    COLORF( BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
 495            BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]) );
 496 }
 497
 498 static void
 499 loopback_Color4dv_f( const GLdouble *v )
 500 {
 501    COLORF( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3] );
 502 }
 503
 504
 505 static void
 506 loopback_Color4sv_f( const GLshort *v)
 507 {
 508    COLORF( SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
 509            SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]) );
 510 }
 511
 512
 513 static void
 514 loopback_Color4uiv_f( const GLuint *v)
 515 {
 516    COLORF( UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
 517            UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]) );
 518 }
 519
 520 static void
 521 loopback_Color4usv_f( const GLushort *v)
 522 {
 523    COLORF( USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
 524            USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]) );
 525 }
 526
 527 static void
 528 loopback_FogCoorddEXT( GLdouble d )
 529 {
 530    FOGCOORDF( (GLfloat) d );
 531 }
 532
 533 static void
 534 loopback_FogCoorddvEXT( const GLdouble *v )
 535 {
 536    FOGCOORDF( (GLfloat) *v );
 537 }
 538
 539
 540 static void
 541 loopback_Indexd( GLdouble c )
 542 {
 543    INDEX( (GLint) c );
 544 }
 545
 546 static void
 547 loopback_Indexf( GLfloat c )
 548 {
 549    INDEX( (GLuint) (GLint) c );
 550 }
 551
 552 static void
 553 loopback_Indexs( GLshort c )
 554 {
 555    INDEX( (GLint) c );
 556 }
 557
 558 static void
 559 loopback_Indexub( GLubyte c )
 560 {
 561    INDEX( (GLint) c );
 562 }
 563
 564 static void
 565 loopback_Indexdv( const GLdouble *c )
 566 {
 567    INDEX( (GLint) (GLint) *c );
 568 }
 569
 570 static void
 571 loopback_Indexfv( const GLfloat *c )
 572 {
 573    INDEX( (GLint) (GLint) *c );
 574 }
 575
 576 static void
 577 loopback_Indexiv( const GLint *c )
 578 {
 579    INDEX( *c );
 580 }
 581
 582 static void
 583 loopback_Indexsv( const GLshort *c )
 584 {
 585    INDEX( (GLint) *c );
 586 }
 587
 588 static void
 589 loopback_Indexubv( const GLubyte *c )
 590 {
 591    INDEX( (GLint) *c );
 592 }
 593
 594 static void
 595 loopback_Normal3b( GLbyte nx, GLbyte ny, GLbyte nz )
 596 {
 597    NORMAL( BYTE_TO_FLOAT(nx), BYTE_TO_FLOAT(ny), BYTE_TO_FLOAT(nz) );
 598 }
 599
 600 static void
 601 loopback_Normal3d( GLdouble nx, GLdouble ny, GLdouble nz )
 602 {
 603    NORMAL((GLfloat) nx, (GLfloat) ny, (GLfloat) nz);
 604 }
 605
 606 static void
 607 loopback_Normal3i( GLint nx, GLint ny, GLint nz )
 608 {
 609    NORMAL( INT_TO_FLOAT(nx), INT_TO_FLOAT(ny), INT_TO_FLOAT(nz) );
 610 }
 611
 612 static void
 613 loopback_Normal3s( GLshort nx, GLshort ny, GLshort nz )
 614 {
 615    NORMAL( SHORT_TO_FLOAT(nx), SHORT_TO_FLOAT(ny), SHORT_TO_FLOAT(nz) );
 616 }
 617
 618 static void
 619 loopback_Normal3bv( const GLbyte *v )
 620 {
 621    NORMAL( BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]) );
 622 }
 623
 624 static void
 625 loopback_Normal3dv( const GLdouble *v )
 626 {
 627    NORMAL( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
 628 }
 629
 630 static void
 631 loopback_Normal3iv( const GLint *v )
 632 {
 633    NORMAL( INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]) );
 634 }
 635
 636 static void
 637 loopback_Normal3sv( const GLshort *v )
 638 {
 639    NORMAL( SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]) );
 640 }
 641
 642 static void
 643 loopback_TexCoord1d( GLdouble s )
 644 {
 645    TEXCOORD1((GLfloat) s);
 646 }
 647
 648 static void
 649 loopback_TexCoord1i( GLint s )
 650 {
 651    TEXCOORD1((GLfloat) s);
 652 }
 653
 654 static void
 655 loopback_TexCoord1s( GLshort s )
 656 {
 657    TEXCOORD1((GLfloat) s);
 658 }
 659
 660 static void
 661 loopback_TexCoord2d( GLdouble s, GLdouble t )
 662 {
 663    TEXCOORD2((GLfloat) s,(GLfloat) t);
 664 }
 665
 666 static void
 667 loopback_TexCoord2s( GLshort s, GLshort t )
 668 {
 669    TEXCOORD2((GLfloat) s,(GLfloat) t);
 670 }
 671
 672 static void
 673 loopback_TexCoord2i( GLint s, GLint t )
 674 {
 675    TEXCOORD2((GLfloat) s,(GLfloat) t);
 676 }
 677
 678 static void
 679 loopback_TexCoord3d( GLdouble s, GLdouble t, GLdouble r )
 680 {
 681    TEXCOORD3((GLfloat) s,(GLfloat) t,(GLfloat) r);
 682 }
 683
 684 static void
 685 loopback_TexCoord3i( GLint s, GLint t, GLint r )
 686 {
 687    TEXCOORD3((GLfloat) s,(GLfloat) t,(GLfloat) r);
 688 }
 689
 690 static void
 691 loopback_TexCoord3s( GLshort s, GLshort t, GLshort r )
 692 {
 693    TEXCOORD3((GLfloat) s,(GLfloat) t,(GLfloat) r);
 694 }
 695
 696 static void
 697 loopback_TexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
 698 {
 699    TEXCOORD4((GLfloat) s,(GLfloat) t,(GLfloat) r,(GLfloat) q);
 700 }
 701
 702 static void
 703 loopback_TexCoord4i( GLint s, GLint t, GLint r, GLint q )
 704 {
 705    TEXCOORD4((GLfloat) s,(GLfloat) t,(GLfloat) r,(GLfloat) q);
 706 }
 707
 708 static void
 709 loopback_TexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
 710 {
 711    TEXCOORD4((GLfloat) s,(GLfloat) t,(GLfloat) r,(GLfloat) q);
 712 }
 713
 714 static void
 715 loopback_TexCoord1dv( const GLdouble *v )
 716 {
 717    TEXCOORD1((GLfloat) v[0]);
 718 }
 719
 720 static void
 721 loopback_TexCoord1iv( const GLint *v )
 722 {
 723    TEXCOORD1((GLfloat) v[0]);
 724 }
 725
 726 static void
 727 loopback_TexCoord1sv( const GLshort *v )
 728 {
 729    TEXCOORD1((GLfloat) v[0]);
 730 }
 731
 732 static void
 733 loopback_TexCoord2dv( const GLdouble *v )
 734 {
 735    TEXCOORD2((GLfloat) v[0],(GLfloat) v[1]);
 736 }
 737
 738 static void
 739 loopback_TexCoord2iv( const GLint *v )
 740 {
 741    TEXCOORD2((GLfloat) v[0],(GLfloat) v[1]);
 742 }
 743
 744 static void
 745 loopback_TexCoord2sv( const GLshort *v )
 746 {
 747    TEXCOORD2((GLfloat) v[0],(GLfloat) v[1]);
 748 }
 749
 750 static void
 751 loopback_TexCoord3dv( const GLdouble *v )
 752 {
 753    TEXCOORD2((GLfloat) v[0],(GLfloat) v[1]);
 754 }
 755
 756 static void
 757 loopback_TexCoord3iv( const GLint *v )
 758 {
 759    TEXCOORD3((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2]);
 760 }
 761
 762 static void
 763 loopback_TexCoord3sv( const GLshort *v )
 764 {
 765    TEXCOORD3((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2]);
 766 }
 767
 768 static void
 769 loopback_TexCoord4dv( const GLdouble *v )
 770 {
 771    TEXCOORD4((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2],(GLfloat) v[3]);
 772 }
 773
 774 static void
 775 loopback_TexCoord4iv( const GLint *v )
 776 {
 777    TEXCOORD4((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2],(GLfloat) v[3]);
 778 }
 779
 780 static void
 781 loopback_TexCoord4sv( const GLshort *v )
 782 {
 783    TEXCOORD4((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2],(GLfloat) v[3]);
 784 }
 785
 786 static void
 787 loopback_Vertex2d( GLdouble x, GLdouble y )
 788 {
 789    VERTEX2( (GLfloat) x, (GLfloat) y );
 790 }
 791
 792 static void
 793 loopback_Vertex2i( GLint x, GLint y )
 794 {
 795    VERTEX2( (GLfloat) x, (GLfloat) y );
 796 }
 797
 798 static void
 799 loopback_Vertex2s( GLshort x, GLshort y )
 800 {
 801    VERTEX2( (GLfloat) x, (GLfloat) y );
 802 }
 803
 804 static void
 805 loopback_Vertex3d( GLdouble x, GLdouble y, GLdouble z )
 806 {
 807    VERTEX3( (GLfloat) x, (GLfloat) y, (GLfloat) z );
 808 }
 809
 810 static void
 811 loopback_Vertex3i( GLint x, GLint y, GLint z )
 812 {
 813    VERTEX3( (GLfloat) x, (GLfloat) y, (GLfloat) z );
 814 }
 815
 816 static void
 817 loopback_Vertex3s( GLshort x, GLshort y, GLshort z )
 818 {
 819    VERTEX3( (GLfloat) x, (GLfloat) y, (GLfloat) z );
 820 }
 821
 822 static void
 823 loopback_Vertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
 824 {
 825    VERTEX4( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
 826 }
 827
 828 static void
 829 loopback_Vertex4i( GLint x, GLint y, GLint z, GLint w )
 830 {
 831    VERTEX4( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
 832 }
 833
 834 static void
 835 loopback_Vertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
 836 {
 837    VERTEX4( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
 838 }
 839
 840 static void
 841 loopback_Vertex2dv( const GLdouble *v )
 842 {
 843    VERTEX2( (GLfloat) v[0], (GLfloat) v[1] );
 844 }
 845
 846 static void
 847 loopback_Vertex2iv( const GLint *v )
 848 {
 849    VERTEX2( (GLfloat) v[0], (GLfloat) v[1] );
 850 }
 851
 852 static void
 853 loopback_Vertex2sv( const GLshort *v )
 854 {
 855    VERTEX2( (GLfloat) v[0], (GLfloat) v[1] );
 856 }
 857
 858 static void
 859 loopback_Vertex3dv( const GLdouble *v )
 860 {
 861    VERTEX3( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
 862 }
 863
 864 static void
 865 loopback_Vertex3iv( const GLint *v )
 866 {
 867    VERTEX3( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
 868 }
 869
 870 static void
 871 loopback_Vertex3sv( const GLshort *v )
 872 {
 873    VERTEX3( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
 874 }
 875
 876 static void
 877 loopback_Vertex4dv( const GLdouble *v )
 878 {
 879    VERTEX4( (GLfloat) v[0], (GLfloat) v[1],
 880             (GLfloat) v[2], (GLfloat) v[3] );
 881 }
 882
 883 static void
 884 loopback_Vertex4iv( const GLint *v )
 885 {
 886    VERTEX4( (GLfloat) v[0], (GLfloat) v[1],
 887             (GLfloat) v[2], (GLfloat) v[3] );
 888 }
 889
 890 static void
 891 loopback_Vertex4sv( const GLshort *v )
 892 {
 893    VERTEX4( (GLfloat) v[0], (GLfloat) v[1],
 894             (GLfloat) v[2], (GLfloat) v[3] );
 895 }
 896
 897 static void
 898 loopback_MultiTexCoord1dARB(GLenum target, GLdouble s)
 899 {
 900    MULTI_TEXCOORD1( target, (GLfloat) s );
 901 }
 902
 903 static void
 904 loopback_MultiTexCoord1dvARB(GLenum target, const GLdouble *v)
 905 {
 906    MULTI_TEXCOORD1( target, (GLfloat) v[0] );
 907 }
 908
 909 static void
 910 loopback_MultiTexCoord1iARB(GLenum target, GLint s)
 911 {
 912    MULTI_TEXCOORD1( target, (GLfloat) s );
 913 }
 914
 915 static void
 916 loopback_MultiTexCoord1ivARB(GLenum target, const GLint *v)
 917 {
 918    MULTI_TEXCOORD1( target, (GLfloat) v[0] );
 919 }
 920
 921 static void
 922 loopback_MultiTexCoord1sARB(GLenum target, GLshort s)
 923 {
 924    MULTI_TEXCOORD1( target, (GLfloat) s );
 925 }
 926
 927 static void
 928 loopback_MultiTexCoord1svARB(GLenum target, const GLshort *v)
 929 {
 930    MULTI_TEXCOORD1( target, (GLfloat) v[0] );
 931 }
 932
 933 static void
 934 loopback_MultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
 935 {
 936    MULTI_TEXCOORD2( target, (GLfloat) s, (GLfloat) t );
 937 }
 938
 939 static void
 940 loopback_MultiTexCoord2dvARB(GLenum target, const GLdouble *v)
 941 {
 942    MULTI_TEXCOORD2( target, (GLfloat) v[0], (GLfloat) v[1] );
 943 }
 944
 945 static void
 946 loopback_MultiTexCoord2iARB(GLenum target, GLint s, GLint t)
 947 {
 948    MULTI_TEXCOORD2( target, (GLfloat) s, (GLfloat) t );
 949 }
 950
 951 static void
 952 loopback_MultiTexCoord2ivARB(GLenum target, const GLint *v)
 953 {
 954    MULTI_TEXCOORD2( target, (GLfloat) v[0], (GLfloat) v[1] );
 955 }
 956
 957 static void
 958 loopback_MultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
 959 {
 960    MULTI_TEXCOORD2( target, (GLfloat) s, (GLfloat) t );
 961 }
 962
 963 static void
 964 loopback_MultiTexCoord2svARB(GLenum target, const GLshort *v)
 965 {
 966    MULTI_TEXCOORD2( target, (GLfloat) v[0], (GLfloat) v[1] );
 967 }
 968
 969 static void
 970 loopback_MultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 971 {
 972    MULTI_TEXCOORD3( target, (GLfloat) s, (GLfloat) t, (GLfloat) r );
 973 }
 974
 975 static void
 976 loopback_MultiTexCoord3dvARB(GLenum target, const GLdouble *v)
 977 {
 978    MULTI_TEXCOORD3( target, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
 979 }
 980
 981 static void
 982 loopback_MultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
 983 {
 984    MULTI_TEXCOORD3( target, (GLfloat) s, (GLfloat) t, (GLfloat) r );
 985 }
 986
 987 static void
 988 loopback_MultiTexCoord3ivARB(GLenum target, const GLint *v)
 989 {
 990    MULTI_TEXCOORD3( target, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
 991 }
 992
 993 static void
 994 loopback_MultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
 995 {
 996    MULTI_TEXCOORD3( target, (GLfloat) s, (GLfloat) t, (GLfloat) r );
 997 }
 998
 999 static void
1000 loopback_MultiTexCoord3svARB(GLenum target, const GLshort *v)
1001 {
1002    MULTI_TEXCOORD3( target, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
1003 }
1004
1005 static void
1006 loopback_MultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1007 {
1008    MULTI_TEXCOORD4( target, (GLfloat) s, (GLfloat) t,
1009                     (GLfloat) r, (GLfloat) q );
1010 }
1011
1012 static void
1013 loopback_MultiTexCoord4dvARB(GLenum target, const GLdouble *v)
1014 {
1015    MULTI_TEXCOORD4( target, (GLfloat) v[0], (GLfloat) v[1],
1016                     (GLfloat) v[2], (GLfloat) v[3] );
1017 }
1018
1019 static void
1020 loopback_MultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
1021 {
1022    MULTI_TEXCOORD4( target, (GLfloat) s, (GLfloat) t,
1023                     (GLfloat) r, (GLfloat) q );
1024 }
1025
1026 static void
1027 loopback_MultiTexCoord4ivARB(GLenum target, const GLint *v)
1028 {
1029    MULTI_TEXCOORD4( target, (GLfloat) v[0], (GLfloat) v[1],
1030                     (GLfloat) v[2], (GLfloat) v[3] );
1031 }
1032
1033 static void
1034 loopback_MultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
1035 {
1036    MULTI_TEXCOORD4( target, (GLfloat) s, (GLfloat) t,
1037                     (GLfloat) r, (GLfloat) q );
1038 }
1039
1040 static void
1041 loopback_MultiTexCoord4svARB(GLenum target, const GLshort *v)
1042 {
1043    MULTI_TEXCOORD4( target, (GLfloat) v[0], (GLfloat) v[1],
1044                     (GLfloat) v[2], (GLfloat) v[3] );
1045 }
1046
1047 static void
1048 loopback_EvalCoord2dv( const GLdouble *u )
1049 {
1050    EVALCOORD2( (GLfloat) u[0], (GLfloat) u[1] );
1051 }
1052
1053 static void
1054 loopback_EvalCoord2fv( const GLfloat *u )
1055 {
1056    EVALCOORD2( u[0], u[1] );
1057 }
1058
1059 static void
1060 loopback_EvalCoord2d( GLdouble u, GLdouble v )
1061 {
1062    EVALCOORD2( (GLfloat) u, (GLfloat) v );
1063 }
1064
1065 static void
1066 loopback_EvalCoord1dv( const GLdouble *u )
1067 {
1068    EVALCOORD1( (GLfloat) *u );
1069 }
1070
1071 static void
1072 loopback_EvalCoord1fv( const GLfloat *u )
1073 {
1074    EVALCOORD1( (GLfloat) *u );
1075 }
1076
1077 static void
1078 loopback_EvalCoord1d( GLdouble u )
1079 {
1080    EVALCOORD1( (GLfloat) u );
1081 }
1082
1083 static void
1084 loopback_Materialf( GLenum face, GLenum pname, GLfloat param )
1085 {
1086    GLfloat fparam[4];
1087    fparam[0] = param;
1088    MATERIALFV( face, pname, fparam );
1089 }
1090
1091 static void
1092 loopback_Materiali(GLenum face, GLenum pname, GLint param )
1093 {
1094    GLfloat p = (GLfloat) param;
1095    MATERIALFV(face, pname, &p);
1096 }
1097
1098 static void
1099 loopback_Materialiv(GLenum face, GLenum pname, const GLint *params )
1100 {
1101    GLfloat fparam[4];
1102    switch (pname) {
1103    case GL_AMBIENT:
1104    case GL_DIFFUSE:
1105    case GL_SPECULAR:
1106    case GL_EMISSION:
1107    case GL_AMBIENT_AND_DIFFUSE:
1108       fparam[0] = INT_TO_FLOAT( params[0] );
1109       fparam[1] = INT_TO_FLOAT( params[1] );
1110       fparam[2] = INT_TO_FLOAT( params[2] );
1111       fparam[3] = INT_TO_FLOAT( params[3] );
1112       break;
1113    case GL_SHININESS:
1114       fparam[0] = (GLfloat) params[0];
1115       break;
1116    case GL_COLOR_INDEXES:
1117       fparam[0] = (GLfloat) params[0];
1118       fparam[1] = (GLfloat) params[1];
1119       fparam[2] = (GLfloat) params[2];
1120       break;
1121    default:
1122       ;
1123    }
1124    MATERIALFV(face, pname, fparam);
1125 }
1126
1127
1128 static void
1129 loopback_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1130 {
1131    RECTF((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
1132 }
1133
1134 static void
1135 loopback_Rectdv(const GLdouble *v1, const GLdouble *v2)
1136 {
1137    RECTF((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
1138 }
1139
1140 static void
1141 loopback_Rectfv(const GLfloat *v1, const GLfloat *v2)
1142 {
1143    RECTF(v1[0], v1[1], v2[0], v2[1]);
1144 }
1145
1146 static void
1147 loopback_Recti(GLint x1, GLint y1, GLint x2, GLint y2)
1148 {
1149    RECTF((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
1150 }
1151
1152 static void
1153 loopback_Rectiv(const GLint *v1, const GLint *v2)
1154 {
1155    RECTF((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
1156 }
1157
1158 static void
1159 loopback_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1160 {
1161    RECTF((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
1162 }
1163
1164 static void
1165 loopback_Rectsv(const GLshort *v1, const GLshort *v2)
1166 {
1167    RECTF((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
1168 }
1169
1170 static void
1171 loopback_SecondaryColor3bEXT( GLbyte red, GLbyte green, GLbyte blue )
1172 {
1173    SECONDARYCOLORUB( BYTE_TO_UBYTE(red),
1174                      BYTE_TO_UBYTE(green),
1175                      BYTE_TO_UBYTE(blue) );
1176 }
1177
1178 static void
1179 loopback_SecondaryColor3dEXT( GLdouble red, GLdouble green, GLdouble blue )
1180 {
1181    GLubyte col[3];
1182    GLfloat r = (GLfloat) red;
1183    GLfloat g = (GLfloat) green;
1184    GLfloat b = (GLfloat) blue;
1185    UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
1186    UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
1187    UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
1188    SECONDARYCOLORUB( col[0], col[1], col[2] );
1189 }
1190
1191 static void
1192 loopback_SecondaryColor3iEXT( GLint red, GLint green, GLint blue )
1193 {
1194    SECONDARYCOLORUB( INT_TO_UBYTE(red),
1195                      INT_TO_UBYTE(green),
1196                      INT_TO_UBYTE(blue));
1197 }
1198
1199 static void
1200 loopback_SecondaryColor3sEXT( GLshort red, GLshort green, GLshort blue )
1201 {
1202    SECONDARYCOLORUB(SHORT_TO_UBYTE(red),
1203                     SHORT_TO_UBYTE(green),
1204                     SHORT_TO_UBYTE(blue));
1205 }
1206
1207 static void
1208 loopback_SecondaryColor3uiEXT( GLuint red, GLuint green, GLuint blue )
1209 {
1210    SECONDARYCOLORUB(UINT_TO_UBYTE(red),
1211                     UINT_TO_UBYTE(green),
1212                     UINT_TO_UBYTE(blue));
1213 }
1214
1215 static void
1216 loopback_SecondaryColor3usEXT( GLushort red, GLushort green, GLushort blue )
1217 {
1218    SECONDARYCOLORUB(USHORT_TO_UBYTE(red),
1219                     USHORT_TO_UBYTE(green),
1220                     USHORT_TO_UBYTE(blue));
1221 }
1222
1223 static void
1224 loopback_SecondaryColor3bvEXT( const GLbyte *v )
1225 {
1226    const GLfloat r = BYTE_TO_FLOAT(v[0]);
1227    const GLfloat g = BYTE_TO_FLOAT(v[1]);
1228    const GLfloat b = BYTE_TO_FLOAT(v[2]);
1229    SECONDARYCOLORF(r, g, b);
1230 }
1231
1232 static void
1233 loopback_SecondaryColor3dvEXT( const GLdouble *v )
1234 {
1235    GLubyte col[3];
1236    GLfloat r = (GLfloat) v[0];
1237    GLfloat g = (GLfloat) v[1];
1238    GLfloat b = (GLfloat) v[2];
1239    UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
1240    UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
1241    UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
1242    SECONDARYCOLORUB( col[0], col[1], col[2] );
1243 }
1244
1245 static void
1246 loopback_SecondaryColor3ivEXT( const GLint *v )
1247 {
1248    SECONDARYCOLORUB(INT_TO_UBYTE(v[0]),
1249                     INT_TO_UBYTE(v[1]),
1250                     INT_TO_UBYTE(v[2]));
1251 }
1252
1253 static void
1254 loopback_SecondaryColor3svEXT( const GLshort *v )
1255 {
1256    SECONDARYCOLORUB(SHORT_TO_UBYTE(v[0]),
1257                     SHORT_TO_UBYTE(v[1]),
1258                     SHORT_TO_UBYTE(v[2]));
1259 }
1260
1261 static void
1262 loopback_SecondaryColor3uivEXT( const GLuint *v )
1263 {
1264    SECONDARYCOLORUB(UINT_TO_UBYTE(v[0]),
1265                     UINT_TO_UBYTE(v[1]),
1266                     UINT_TO_UBYTE(v[2]));
1267 }
1268
1269 static void
1270 loopback_SecondaryColor3usvEXT( const GLushort *v )
1271 {
1272    SECONDARYCOLORUB(USHORT_TO_UBYTE(v[0]),
1273                     USHORT_TO_UBYTE(v[1]),
1274                     USHORT_TO_UBYTE(v[2]));
1275 }
1276
1277
1278 static void
1279 loopback_SecondaryColor3bEXT_f( GLbyte red, GLbyte green, GLbyte blue )
1280 {
1281    SECONDARYCOLORF( BYTE_TO_FLOAT(red),
1282                     BYTE_TO_FLOAT(green),
1283                     BYTE_TO_FLOAT(blue) );
1284 }
1285
1286 static void
1287 loopback_SecondaryColor3dEXT_f( GLdouble red, GLdouble green, GLdouble blue )
1288 {
1289    SECONDARYCOLORF( (GLfloat) red, (GLfloat) green, (GLfloat) blue );
1290 }
1291
1292 static void
1293 loopback_SecondaryColor3iEXT_f( GLint red, GLint green, GLint blue )
1294 {
1295    SECONDARYCOLORF( INT_TO_FLOAT(red),
1296                     INT_TO_FLOAT(green),
1297                     INT_TO_FLOAT(blue));
1298 }
1299
1300 static void
1301 loopback_SecondaryColor3sEXT_f( GLshort red, GLshort green, GLshort blue )
1302 {
1303    SECONDARYCOLORF(SHORT_TO_FLOAT(red),
1304                    SHORT_TO_FLOAT(green),
1305                    SHORT_TO_FLOAT(blue));
1306 }
1307
1308 static void
1309 loopback_SecondaryColor3uiEXT_f( GLuint red, GLuint green, GLuint blue )
1310 {
1311    SECONDARYCOLORF(UINT_TO_FLOAT(red),
1312                    UINT_TO_FLOAT(green),
1313                    UINT_TO_FLOAT(blue));
1314 }
1315
1316 static void
1317 loopback_SecondaryColor3usEXT_f( GLushort red, GLushort green, GLushort blue )
1318 {
1319    SECONDARYCOLORF(USHORT_TO_FLOAT(red),
1320                    USHORT_TO_FLOAT(green),
1321                    USHORT_TO_FLOAT(blue));
1322 }
1323
1324 static void
1325 loopback_SecondaryColor3bvEXT_f( const GLbyte *v )
1326 {
1327    SECONDARYCOLORF(BYTE_TO_FLOAT(v[0]),
1328                    BYTE_TO_FLOAT(v[1]),
1329                    BYTE_TO_FLOAT(v[2]));
1330 }
1331
1332 static void
1333 loopback_SecondaryColor3dvEXT_f( const GLdouble *v )
1334 {
1335    SECONDARYCOLORF( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
1336 }
1337 static void
1338 loopback_SecondaryColor3ivEXT_f( const GLint *v )
1339 {
1340    SECONDARYCOLORF(INT_TO_FLOAT(v[0]),
1341                    INT_TO_FLOAT(v[1]),
1342                    INT_TO_FLOAT(v[2]));
1343 }
1344
1345 static void
1346 loopback_SecondaryColor3svEXT_f( const GLshort *v )
1347 {
1348    SECONDARYCOLORF(SHORT_TO_FLOAT(v[0]),
1349                    SHORT_TO_FLOAT(v[1]),
1350                    SHORT_TO_FLOAT(v[2]));
1351 }
1352
1353 static void
1354 loopback_SecondaryColor3uivEXT_f( const GLuint *v )
1355 {
1356    SECONDARYCOLORF(UINT_TO_FLOAT(v[0]),
1357                    UINT_TO_FLOAT(v[1]),
1358                    UINT_TO_FLOAT(v[2]));
1359 }
1360
1361 static void
1362 loopback_SecondaryColor3usvEXT_f( const GLushort *v )
1363 {
1364    SECONDARYCOLORF(USHORT_TO_FLOAT(v[0]),
1365                    USHORT_TO_FLOAT(v[1]),
1366                    USHORT_TO_FLOAT(v[2]));
1367 }
1368
1369
1370
1371 void
1372 _mesa_loopback_prefer_float( struct _glapi_table *dest,
1373                              GLboolean prefer_float_colors )
1374 {
1375    if (!prefer_float_colors) {
1376       dest->Color3b = loopback_Color3b;
1377       dest->Color3d = loopback_Color3d;
1378       dest->Color3i = loopback_Color3i;
1379       dest->Color3s = loopback_Color3s;
1380       dest->Color3ui = loopback_Color3ui;
1381       dest->Color3us = loopback_Color3us;
1382       dest->Color4b = loopback_Color4b;
1383       dest->Color4d = loopback_Color4d;
1384       dest->Color4i = loopback_Color4i;
1385       dest->Color4s = loopback_Color4s;
1386       dest->Color4ui = loopback_Color4ui;
1387       dest->Color4us = loopback_Color4us;
1388       dest->Color3bv = loopback_Color3bv;
1389       dest->Color3dv = loopback_Color3dv;
1390       dest->Color3iv = loopback_Color3iv;
1391       dest->Color3sv = loopback_Color3sv;
1392       dest->Color3uiv = loopback_Color3uiv;
1393       dest->Color3usv = loopback_Color3usv;
1394       dest->Color4bv = loopback_Color4bv;
1395       dest->Color4dv = loopback_Color4dv;
1396       dest->Color4iv = loopback_Color4iv;
1397       dest->Color4sv = loopback_Color4sv;
1398       dest->Color4uiv = loopback_Color4uiv;
1399       dest->Color4usv = loopback_Color4usv;
1400       dest->SecondaryColor3bEXT = loopback_SecondaryColor3bEXT;
1401       dest->SecondaryColor3dEXT = loopback_SecondaryColor3dEXT;
1402       dest->SecondaryColor3iEXT = loopback_SecondaryColor3iEXT;
1403       dest->SecondaryColor3sEXT = loopback_SecondaryColor3sEXT;
1404       dest->SecondaryColor3uiEXT = loopback_SecondaryColor3uiEXT;
1405       dest->SecondaryColor3usEXT = loopback_SecondaryColor3usEXT;
1406       dest->SecondaryColor3bvEXT = loopback_SecondaryColor3bvEXT;
1407       dest->SecondaryColor3dvEXT = loopback_SecondaryColor3dvEXT;
1408       dest->SecondaryColor3ivEXT = loopback_SecondaryColor3ivEXT;
1409       dest->SecondaryColor3svEXT = loopback_SecondaryColor3svEXT;
1410       dest->SecondaryColor3uivEXT = loopback_SecondaryColor3uivEXT;
1411       dest->SecondaryColor3usvEXT = loopback_SecondaryColor3usvEXT;
1412    }
1413    else {
1414       dest->Color3b = loopback_Color3b_f;
1415       dest->Color3d = loopback_Color3d_f;
1416       dest->Color3i = loopback_Color3i_f;
1417       dest->Color3s = loopback_Color3s_f;
1418       dest->Color3ui = loopback_Color3ui_f;
1419       dest->Color3us = loopback_Color3us_f;
1420       dest->Color4b = loopback_Color4b_f;
1421       dest->Color4d = loopback_Color4d_f;
1422       dest->Color4i = loopback_Color4i_f;
1423       dest->Color4s = loopback_Color4s_f;
1424       dest->Color4ui = loopback_Color4ui_f;
1425       dest->Color4us = loopback_Color4us_f;
1426       dest->Color3bv = loopback_Color3bv_f;
1427       dest->Color3dv = loopback_Color3dv_f;
1428       dest->Color3iv = loopback_Color3iv_f;
1429       dest->Color3sv = loopback_Color3sv_f;
1430       dest->Color3uiv = loopback_Color3uiv_f;
1431       dest->Color3usv = loopback_Color3usv_f;
1432       dest->Color4bv = loopback_Color4bv_f;
1433       dest->Color4dv = loopback_Color4dv_f;
1434       dest->Color4iv = loopback_Color4iv_f;
1435       dest->Color4sv = loopback_Color4sv_f;
1436       dest->Color4uiv = loopback_Color4uiv_f;
1437       dest->Color4usv = loopback_Color4usv_f;
1438       dest->SecondaryColor3bEXT = loopback_SecondaryColor3bEXT_f;
1439       dest->SecondaryColor3dEXT = loopback_SecondaryColor3dEXT_f;
1440       dest->SecondaryColor3iEXT = loopback_SecondaryColor3iEXT_f;
1441       dest->SecondaryColor3sEXT = loopback_SecondaryColor3sEXT_f;
1442       dest->SecondaryColor3uiEXT = loopback_SecondaryColor3uiEXT_f;
1443       dest->SecondaryColor3usEXT = loopback_SecondaryColor3usEXT_f;
1444       dest->SecondaryColor3bvEXT = loopback_SecondaryColor3bvEXT_f;
1445       dest->SecondaryColor3dvEXT = loopback_SecondaryColor3dvEXT_f;
1446       dest->SecondaryColor3ivEXT = loopback_SecondaryColor3ivEXT_f;
1447       dest->SecondaryColor3svEXT = loopback_SecondaryColor3svEXT_f;
1448       dest->SecondaryColor3uivEXT = loopback_SecondaryColor3uivEXT_f;
1449       dest->SecondaryColor3usvEXT = loopback_SecondaryColor3usvEXT_f;
1450    }
1451 }
1452
1453 /* Passing prefer_float_colors as true will mean that all colors
1454  * *except* Color{34}ub{v} are passed as floats.  Setting it false will
1455  * mean all colors *except* Color{34}f{v} are passed as ubytes.
1456  *
1457  * This code never registers handlers for any of the entry points
1458  * listed in vtxfmt.h.
1459  */
1460 void
1461 _mesa_loopback_init_api_table( struct _glapi_table *dest,
1462                                GLboolean prefer_float_colors )
1463 {
1464    _mesa_loopback_prefer_float( dest, prefer_float_colors );
1465
1466    dest->Indexd = loopback_Indexd;
1467    dest->Indexf = loopback_Indexf;
1468    dest->Indexs = loopback_Indexs;
1469    dest->Indexub = loopback_Indexub;
1470    dest->Indexdv = loopback_Indexdv;
1471    dest->Indexfv = loopback_Indexfv;
1472    dest->Indexiv = loopback_Indexiv;
1473    dest->Indexsv = loopback_Indexsv;
1474    dest->Indexubv = loopback_Indexubv;
1475    dest->Normal3b = loopback_Normal3b;
1476    dest->Normal3d = loopback_Normal3d;
1477    dest->Normal3i = loopback_Normal3i;
1478    dest->Normal3s = loopback_Normal3s;
1479    dest->Normal3bv = loopback_Normal3bv;
1480    dest->Normal3dv = loopback_Normal3dv;
1481    dest->Normal3iv = loopback_Normal3iv;
1482    dest->Normal3sv = loopback_Normal3sv;
1483    dest->TexCoord1d = loopback_TexCoord1d;
1484    dest->TexCoord1i = loopback_TexCoord1i;
1485    dest->TexCoord1s = loopback_TexCoord1s;
1486    dest->TexCoord2d = loopback_TexCoord2d;
1487    dest->TexCoord2s = loopback_TexCoord2s;
1488    dest->TexCoord2i = loopback_TexCoord2i;
1489    dest->TexCoord3d = loopback_TexCoord3d;
1490    dest->TexCoord3i = loopback_TexCoord3i;
1491    dest->TexCoord3s = loopback_TexCoord3s;
1492    dest->TexCoord4d = loopback_TexCoord4d;
1493    dest->TexCoord4i = loopback_TexCoord4i;
1494    dest->TexCoord4s = loopback_TexCoord4s;
1495    dest->TexCoord1dv = loopback_TexCoord1dv;
1496    dest->TexCoord1iv = loopback_TexCoord1iv;
1497    dest->TexCoord1sv = loopback_TexCoord1sv;
1498    dest->TexCoord2dv = loopback_TexCoord2dv;
1499    dest->TexCoord2iv = loopback_TexCoord2iv;
1500    dest->TexCoord2sv = loopback_TexCoord2sv;
1501    dest->TexCoord3dv = loopback_TexCoord3dv;
1502    dest->TexCoord3iv = loopback_TexCoord3iv;
1503    dest->TexCoord3sv = loopback_TexCoord3sv;
1504    dest->TexCoord4dv = loopback_TexCoord4dv;
1505    dest->TexCoord4iv = loopback_TexCoord4iv;
1506    dest->TexCoord4sv = loopback_TexCoord4sv;
1507    dest->Vertex2d = loopback_Vertex2d;
1508    dest->Vertex2i = loopback_Vertex2i;
1509    dest->Vertex2s = loopback_Vertex2s;
1510    dest->Vertex3d = loopback_Vertex3d;
1511    dest->Vertex3i = loopback_Vertex3i;
1512    dest->Vertex3s = loopback_Vertex3s;
1513    dest->Vertex4d = loopback_Vertex4d;
1514    dest->Vertex4i = loopback_Vertex4i;
1515    dest->Vertex4s = loopback_Vertex4s;
1516    dest->Vertex2dv = loopback_Vertex2dv;
1517    dest->Vertex2iv = loopback_Vertex2iv;
1518    dest->Vertex2sv = loopback_Vertex2sv;
1519    dest->Vertex3dv = loopback_Vertex3dv;
1520    dest->Vertex3iv = loopback_Vertex3iv;
1521    dest->Vertex3sv = loopback_Vertex3sv;
1522    dest->Vertex4dv = loopback_Vertex4dv;
1523    dest->Vertex4iv = loopback_Vertex4iv;
1524    dest->Vertex4sv = loopback_Vertex4sv;
1525    dest->MultiTexCoord1dARB = loopback_MultiTexCoord1dARB;
1526    dest->MultiTexCoord1dvARB = loopback_MultiTexCoord1dvARB;
1527    dest->MultiTexCoord1iARB = loopback_MultiTexCoord1iARB;
1528    dest->MultiTexCoord1ivARB = loopback_MultiTexCoord1ivARB;
1529    dest->MultiTexCoord1sARB = loopback_MultiTexCoord1sARB;
1530    dest->MultiTexCoord1svARB = loopback_MultiTexCoord1svARB;
1531    dest->MultiTexCoord2dARB = loopback_MultiTexCoord2dARB;
1532    dest->MultiTexCoord2dvARB = loopback_MultiTexCoord2dvARB;
1533    dest->MultiTexCoord2iARB = loopback_MultiTexCoord2iARB;
1534    dest->MultiTexCoord2ivARB = loopback_MultiTexCoord2ivARB;
1535    dest->MultiTexCoord2sARB = loopback_MultiTexCoord2sARB;
1536    dest->MultiTexCoord2svARB = loopback_MultiTexCoord2svARB;
1537    dest->MultiTexCoord3dARB = loopback_MultiTexCoord3dARB;
1538    dest->MultiTexCoord3dvARB = loopback_MultiTexCoord3dvARB;
1539    dest->MultiTexCoord3iARB = loopback_MultiTexCoord3iARB;
1540    dest->MultiTexCoord3ivARB = loopback_MultiTexCoord3ivARB;
1541    dest->MultiTexCoord3sARB = loopback_MultiTexCoord3sARB;
1542    dest->MultiTexCoord3svARB = loopback_MultiTexCoord3svARB;
1543    dest->MultiTexCoord4dARB = loopback_MultiTexCoord4dARB;
1544    dest->MultiTexCoord4dvARB = loopback_MultiTexCoord4dvARB;
1545    dest->MultiTexCoord4iARB = loopback_MultiTexCoord4iARB;
1546    dest->MultiTexCoord4ivARB = loopback_MultiTexCoord4ivARB;
1547    dest->MultiTexCoord4sARB = loopback_MultiTexCoord4sARB;
1548    dest->MultiTexCoord4svARB = loopback_MultiTexCoord4svARB;
1549    dest->EvalCoord2dv = loopback_EvalCoord2dv;
1550    dest->EvalCoord2fv = loopback_EvalCoord2fv;
1551    dest->EvalCoord2d = loopback_EvalCoord2d;
1552    dest->EvalCoord1dv = loopback_EvalCoord1dv;
1553    dest->EvalCoord1fv = loopback_EvalCoord1fv;
1554    dest->EvalCoord1d = loopback_EvalCoord1d;
1555    dest->Materialf = loopback_Materialf;
1556    dest->Materiali = loopback_Materiali;
1557    dest->Materialiv = loopback_Materialiv;
1558    dest->Rectd = loopback_Rectd;
1559    dest->Rectdv = loopback_Rectdv;
1560    dest->Rectfv = loopback_Rectfv;
1561    dest->Recti = loopback_Recti;
1562    dest->Rectiv = loopback_Rectiv;
1563    dest->Rects = loopback_Rects;
1564    dest->Rectsv = loopback_Rectsv;
1565    dest->FogCoorddEXT = loopback_FogCoorddEXT;
1566    dest->FogCoorddvEXT = loopback_FogCoorddvEXT;
1567 }