src/mesa/drivers/glide/fxg.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  5.0.1
   4  *
   5  * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /*
  26  * Mesa/FX device driver. Interface to Glide3.
  27  *
  28  *  Copyright (c) 2003 - Daniel Borca
  29  *  Email : dborca@users.sourceforge.net
  30  *  Web   : http://www.geocities.com/dborca
  31  */
  32
  33 #ifdef FX
  34
  35
  36 #include <stdio.h>
  37 #include <stdarg.h>
  38 #include <assert.h>
  39
  40 #define DEBUG_TRAP_internal
  41 #include "fxg.h"
  42
  43
  44
  45 /****************************************************************************\
  46 * logging                                                                    *
  47 \****************************************************************************/
  48 #if DEBUG_TRAP
  49 #define TRAP_LOG trap_printf
  50 #ifdef __GNUC__
  51 __attribute__ ((format(printf, 1, 2)))
  52 #endif /* __GNUC__ */
  53 int trap_printf (const char *format, ...)
  54 {
  55  va_list arg;
  56  int n;
  57  FILE *trap_file;
  58  va_start(arg, format);
  59  trap_file = fopen("trap.log", "a");
  60  if (trap_file == NULL) {
  61     trap_file = stderr;
  62  }
  63  n = vfprintf(trap_file, format, arg);
  64  fclose(trap_file);
  65  va_end(arg);
  66  return n;
  67 }
  68 #else  /* DEBUG_TRAP */
  69 #ifdef __GNUC__
  70 #define TRAP_LOG(format, ...) do {} while (0)
  71 #else  /* __GNUC__ */
  72 #define TRAP_LOG              0 && (unsigned long)
  73 #endif /* __GNUC__ */
  74 #endif /* DEBUG_TRAP */
  75
  76
  77
  78 #if DEBUG_TRAP
  79 /****************************************************************************\
  80 * helpers                                                                    *
  81 \****************************************************************************/
  82
  83 #define GOT "\t"
  84
  85 const char *TRP_BOOL (FxBool b)
  86 {
  87  return b ? "FXTRUE" : "FXFALSE";
  88 }
  89
  90 #define TRAP_CASE_STRING(name) case name: return #name
  91 #define TRAP_NODEFAULT default: assert(0)
  92
  93 const char *TRP_PARAM (FxU32 mode)
  94 {
  95  switch (mode) {
  96         TRAP_CASE_STRING(GR_PARAM_DISABLE);
  97         TRAP_CASE_STRING(GR_PARAM_ENABLE);
  98         TRAP_NODEFAULT;
  99  }
 100 }
 101
 102 const char *TRP_VTX (FxU32 param)
 103 {
 104  switch (param) {
 105         TRAP_CASE_STRING(GR_PARAM_XY);
 106         TRAP_CASE_STRING(GR_PARAM_Z);
 107         TRAP_CASE_STRING(GR_PARAM_W);
 108         TRAP_CASE_STRING(GR_PARAM_Q);
 109         TRAP_CASE_STRING(GR_PARAM_FOG_EXT);
 110         TRAP_CASE_STRING(GR_PARAM_A);
 111         TRAP_CASE_STRING(GR_PARAM_RGB);
 112         TRAP_CASE_STRING(GR_PARAM_PARGB);
 113         TRAP_CASE_STRING(GR_PARAM_ST0);
 114         TRAP_CASE_STRING(GR_PARAM_ST1);
 115         TRAP_CASE_STRING(GR_PARAM_ST2);
 116         TRAP_CASE_STRING(GR_PARAM_Q0);
 117         TRAP_CASE_STRING(GR_PARAM_Q1);
 118         TRAP_CASE_STRING(GR_PARAM_Q2);
 119         TRAP_NODEFAULT;
 120  }
 121 }
 122
 123 const char *TRP_ARRAY (FxU32 mode)
 124 {
 125  switch (mode) {
 126         TRAP_CASE_STRING(GR_POINTS);
 127         TRAP_CASE_STRING(GR_LINE_STRIP);
 128         TRAP_CASE_STRING(GR_LINES);
 129         TRAP_CASE_STRING(GR_POLYGON);
 130         TRAP_CASE_STRING(GR_TRIANGLE_STRIP);
 131         TRAP_CASE_STRING(GR_TRIANGLE_FAN);
 132         TRAP_CASE_STRING(GR_TRIANGLES);
 133         TRAP_CASE_STRING(GR_TRIANGLE_STRIP_CONTINUE);
 134         TRAP_CASE_STRING(GR_TRIANGLE_FAN_CONTINUE);
 135         TRAP_NODEFAULT;
 136  }
 137 }
 138
 139 const char *TRP_BUFFER (GrBuffer_t buffer)
 140 {
 141  switch (buffer) {
 142         TRAP_CASE_STRING(GR_BUFFER_FRONTBUFFER);
 143         TRAP_CASE_STRING(GR_BUFFER_BACKBUFFER);
 144         TRAP_CASE_STRING(GR_BUFFER_AUXBUFFER);
 145         TRAP_CASE_STRING(GR_BUFFER_DEPTHBUFFER);
 146         TRAP_CASE_STRING(GR_BUFFER_ALPHABUFFER);
 147         TRAP_CASE_STRING(GR_BUFFER_TRIPLEBUFFER);
 148         TRAP_CASE_STRING(GR_BUFFER_TEXTUREBUFFER_EXT);
 149         TRAP_CASE_STRING(GR_BUFFER_TEXTUREAUXBUFFER_EXT);
 150         TRAP_NODEFAULT;
 151  }
 152 }
 153
 154 const char *TRP_ORIGIN (GrOriginLocation_t origin_location)
 155 {
 156  switch (origin_location) {
 157         TRAP_CASE_STRING(GR_ORIGIN_UPPER_LEFT);
 158         TRAP_CASE_STRING(GR_ORIGIN_LOWER_LEFT);
 159         TRAP_CASE_STRING(GR_ORIGIN_ANY);
 160         TRAP_NODEFAULT;
 161  }
 162 }
 163
 164 const char *TRP_REFRESH (GrScreenRefresh_t refresh_rate)
 165 {
 166  switch (refresh_rate) {
 167         TRAP_CASE_STRING(GR_REFRESH_60Hz);
 168         TRAP_CASE_STRING(GR_REFRESH_70Hz);
 169         TRAP_CASE_STRING(GR_REFRESH_72Hz);
 170         TRAP_CASE_STRING(GR_REFRESH_75Hz);
 171         TRAP_CASE_STRING(GR_REFRESH_80Hz);
 172         TRAP_CASE_STRING(GR_REFRESH_90Hz);
 173         TRAP_CASE_STRING(GR_REFRESH_100Hz);
 174         TRAP_CASE_STRING(GR_REFRESH_85Hz);
 175         TRAP_CASE_STRING(GR_REFRESH_120Hz);
 176         TRAP_CASE_STRING(GR_REFRESH_NONE);
 177         TRAP_NODEFAULT;
 178  }
 179 }
 180
 181 const char *TRP_COLFMT (GrColorFormat_t color_format)
 182 {
 183  switch (color_format) {
 184         TRAP_CASE_STRING(GR_COLORFORMAT_ARGB);
 185         TRAP_CASE_STRING(GR_COLORFORMAT_ABGR);
 186         TRAP_CASE_STRING(GR_COLORFORMAT_RGBA);
 187         TRAP_CASE_STRING(GR_COLORFORMAT_BGRA);
 188         TRAP_NODEFAULT;
 189  }
 190 }
 191
 192 const char *TRP_RESOLUTION (GrScreenResolution_t screen_resolution)
 193 {
 194  switch (screen_resolution) {
 195         TRAP_CASE_STRING(GR_RESOLUTION_320x200);
 196         TRAP_CASE_STRING(GR_RESOLUTION_320x240);
 197         TRAP_CASE_STRING(GR_RESOLUTION_400x256);
 198         TRAP_CASE_STRING(GR_RESOLUTION_512x384);
 199         TRAP_CASE_STRING(GR_RESOLUTION_640x200);
 200         TRAP_CASE_STRING(GR_RESOLUTION_640x350);
 201         TRAP_CASE_STRING(GR_RESOLUTION_640x400);
 202         TRAP_CASE_STRING(GR_RESOLUTION_640x480);
 203         TRAP_CASE_STRING(GR_RESOLUTION_800x600);
 204         TRAP_CASE_STRING(GR_RESOLUTION_960x720);
 205         TRAP_CASE_STRING(GR_RESOLUTION_856x480);
 206         TRAP_CASE_STRING(GR_RESOLUTION_512x256);
 207         TRAP_CASE_STRING(GR_RESOLUTION_1024x768);
 208         TRAP_CASE_STRING(GR_RESOLUTION_1280x1024);
 209         TRAP_CASE_STRING(GR_RESOLUTION_1600x1200);
 210         TRAP_CASE_STRING(GR_RESOLUTION_400x300);
 211         TRAP_CASE_STRING(GR_RESOLUTION_1152x864);
 212         TRAP_CASE_STRING(GR_RESOLUTION_1280x960);
 213         TRAP_CASE_STRING(GR_RESOLUTION_1600x1024);
 214         TRAP_CASE_STRING(GR_RESOLUTION_1792x1344);
 215         TRAP_CASE_STRING(GR_RESOLUTION_1856x1392);
 216         TRAP_CASE_STRING(GR_RESOLUTION_1920x1440);
 217         TRAP_CASE_STRING(GR_RESOLUTION_2048x1536);
 218         TRAP_CASE_STRING(GR_RESOLUTION_2048x2048);
 219         TRAP_CASE_STRING(GR_RESOLUTION_NONE);
 220         TRAP_NODEFAULT;
 221  }
 222 }
 223
 224 const char *TRP_BLEND (GrAlphaBlendFnc_t func)
 225 {
 226  switch (func) {
 227         TRAP_CASE_STRING(GR_BLEND_ZERO);
 228         TRAP_CASE_STRING(GR_BLEND_SRC_ALPHA);
 229         TRAP_CASE_STRING(GR_BLEND_SRC_COLOR);
 230         /*TRAP_CASE_STRING(GR_BLEND_DST_COLOR); ==GR_BLEND_SRC_COLOR*/
 231         TRAP_CASE_STRING(GR_BLEND_DST_ALPHA);
 232         TRAP_CASE_STRING(GR_BLEND_ONE);
 233         TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SRC_ALPHA);
 234         TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SRC_COLOR);
 235         /*TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_DST_COLOR); ==GR_BLEND_ONE_MINUS_SRC_COLOR*/
 236         TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_DST_ALPHA);
 237         TRAP_CASE_STRING(GR_BLEND_RESERVED_8);
 238         TRAP_CASE_STRING(GR_BLEND_RESERVED_9);
 239         TRAP_CASE_STRING(GR_BLEND_RESERVED_A);
 240         TRAP_CASE_STRING(GR_BLEND_RESERVED_B);
 241         TRAP_CASE_STRING(GR_BLEND_RESERVED_C);
 242         TRAP_CASE_STRING(GR_BLEND_RESERVED_D);
 243         TRAP_CASE_STRING(GR_BLEND_RESERVED_E);
 244         TRAP_CASE_STRING(GR_BLEND_ALPHA_SATURATE);
 245         /*TRAP_CASE_STRING(GR_BLEND_PREFOG_COLOR); ==GR_BLEND_ALPHA_SATURATE*/
 246         TRAP_NODEFAULT;
 247  }
 248 }
 249
 250 const char *TRP_CMBFUNC (GrCombineFunction_t cfunc)
 251 {
 252  switch (cfunc) {
 253         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_ZERO);
 254         /*TRAP_CASE_STRING(GR_COMBINE_FUNCTION_NONE); ==GR_COMBINE_FUNCTION_ZERO*/
 255         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_LOCAL);
 256         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_LOCAL_ALPHA);
 257         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER);
 258         /*TRAP_CASE_STRING(GR_COMBINE_FUNCTION_BLEND_OTHER); ==GR_COMBINE_FUNCTION_SCALE_OTHER*/
 259         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL);
 260         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL_ALPHA);
 261         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL);
 262         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL);
 263         /*TRAP_CASE_STRING(GR_COMBINE_FUNCTION_BLEND); ==GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL*/
 264         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL_ALPHA);
 265         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL);
 266         /*TRAP_CASE_STRING(GR_COMBINE_FUNCTION_BLEND_LOCAL); ==GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL*/
 267         TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL_ALPHA);
 268         TRAP_NODEFAULT;
 269  }
 270 }
 271
 272 const char *TRP_CMBFACT (GrCombineFactor_t cfactor)
 273 {
 274  switch (cfactor) {
 275         TRAP_CASE_STRING(GR_COMBINE_FACTOR_ZERO);
 276         /*TRAP_CASE_STRING(GR_COMBINE_FACTOR_NONE); ==GR_COMBINE_FACTOR_ZERO*/
 277         TRAP_CASE_STRING(GR_COMBINE_FACTOR_LOCAL);
 278         TRAP_CASE_STRING(GR_COMBINE_FACTOR_OTHER_ALPHA);
 279         TRAP_CASE_STRING(GR_COMBINE_FACTOR_LOCAL_ALPHA);
 280         TRAP_CASE_STRING(GR_COMBINE_FACTOR_TEXTURE_ALPHA);
 281         TRAP_CASE_STRING(GR_COMBINE_FACTOR_TEXTURE_RGB);
 282         /*TRAP_CASE_STRING(GR_COMBINE_FACTOR_DETAIL_FACTOR); ==GR_COMBINE_FACTOR_TEXTURE_ALPHA*/
 283         /*TRAP_CASE_STRING(GR_COMBINE_FACTOR_LOD_FRACTION); ==GR_COMBINE_FACTOR_TEXTURE_RGB ???*/
 284         TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE);
 285         TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_LOCAL);
 286         TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_OTHER_ALPHA);
 287         TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_LOCAL_ALPHA);
 288         TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_TEXTURE_ALPHA);
 289         /*TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_DETAIL_FACTOR); ==GR_COMBINE_FACTOR_ONE_MINUS_TEXTURE_ALPHA*/
 290         TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_LOD_FRACTION);
 291         TRAP_NODEFAULT;
 292  }
 293 }
 294
 295 const char *TRP_CMBLOCAL (GrCombineLocal_t clocal)
 296 {
 297  switch (clocal) {
 298         TRAP_CASE_STRING(GR_COMBINE_LOCAL_ITERATED);
 299         TRAP_CASE_STRING(GR_COMBINE_LOCAL_CONSTANT);
 300         /*TRAP_CASE_STRING(GR_COMBINE_LOCAL_NONE); ==GR_COMBINE_LOCAL_CONSTANT*/
 301         TRAP_CASE_STRING(GR_COMBINE_LOCAL_DEPTH);
 302         TRAP_NODEFAULT;
 303  }
 304 }
 305
 306 const char *TRP_CMBOTHER (GrCombineOther_t cother)
 307 {
 308  switch (cother) {
 309         TRAP_CASE_STRING(GR_COMBINE_OTHER_ITERATED);
 310         TRAP_CASE_STRING(GR_COMBINE_OTHER_TEXTURE);
 311         TRAP_CASE_STRING(GR_COMBINE_OTHER_CONSTANT);
 312         /*TRAP_CASE_STRING(GR_COMBINE_OTHER_NONE); ==GR_COMBINE_OTHER_CONSTANT*/
 313         TRAP_NODEFAULT;
 314  }
 315 }
 316
 317 const char *TRP_CMPFUNC (GrCmpFnc_t function)
 318 {
 319  switch (function) {
 320         TRAP_CASE_STRING(GR_CMP_NEVER);
 321         TRAP_CASE_STRING(GR_CMP_LESS);
 322         TRAP_CASE_STRING(GR_CMP_EQUAL);
 323         TRAP_CASE_STRING(GR_CMP_LEQUAL);
 324         TRAP_CASE_STRING(GR_CMP_GREATER);
 325         TRAP_CASE_STRING(GR_CMP_NOTEQUAL);
 326         TRAP_CASE_STRING(GR_CMP_GEQUAL);
 327         TRAP_CASE_STRING(GR_CMP_ALWAYS);
 328         TRAP_NODEFAULT;
 329  }
 330 }
 331
 332 const char *TRP_CKMODE (GrChromakeyMode_t mode)
 333 {
 334  switch (mode) {
 335         TRAP_CASE_STRING(GR_CHROMAKEY_DISABLE);
 336         TRAP_CASE_STRING(GR_CHROMAKEY_ENABLE);
 337         TRAP_NODEFAULT;
 338  }
 339 }
 340
 341 const char *TRP_CULLMODE (GrCullMode_t mode)
 342 {
 343  switch (mode) {
 344         TRAP_CASE_STRING(GR_CULL_DISABLE);
 345         TRAP_CASE_STRING(GR_CULL_NEGATIVE);
 346         TRAP_CASE_STRING(GR_CULL_POSITIVE);
 347         TRAP_NODEFAULT;
 348  }
 349 }
 350
 351 const char *TRP_DEPTHMODE (GrDepthBufferMode_t mode)
 352 {
 353  switch (mode) {
 354         TRAP_CASE_STRING(GR_DEPTHBUFFER_DISABLE);
 355         TRAP_CASE_STRING(GR_DEPTHBUFFER_ZBUFFER);
 356         TRAP_CASE_STRING(GR_DEPTHBUFFER_WBUFFER);
 357         TRAP_CASE_STRING(GR_DEPTHBUFFER_ZBUFFER_COMPARE_TO_BIAS);
 358         TRAP_CASE_STRING(GR_DEPTHBUFFER_WBUFFER_COMPARE_TO_BIAS);
 359         TRAP_NODEFAULT;
 360  }
 361 }
 362
 363 const char *TRP_DITHERMODE (GrDitherMode_t mode)
 364 {
 365  switch (mode) {
 366         TRAP_CASE_STRING(GR_DITHER_DISABLE);
 367         TRAP_CASE_STRING(GR_DITHER_2x2);
 368         TRAP_CASE_STRING(GR_DITHER_4x4);
 369         TRAP_NODEFAULT;
 370  }
 371 }
 372
 373 const char *TRP_FOGMODE (GrFogMode_t mode)
 374 {
 375  switch (mode) {
 376         TRAP_CASE_STRING(GR_FOG_DISABLE);
 377         TRAP_CASE_STRING(GR_FOG_WITH_TABLE_ON_FOGCOORD_EXT);
 378         TRAP_CASE_STRING(GR_FOG_WITH_TABLE_ON_Q);
 379         /*TRAP_CASE_STRING(GR_FOG_WITH_TABLE_ON_W); ==GR_FOG_WITH_TABLE_ON_Q*/
 380         TRAP_CASE_STRING(GR_FOG_WITH_ITERATED_Z);
 381         TRAP_CASE_STRING(GR_FOG_WITH_ITERATED_ALPHA_EXT);
 382         TRAP_CASE_STRING(GR_FOG_MULT2);
 383         TRAP_CASE_STRING(GR_FOG_ADD2);
 384         TRAP_NODEFAULT;
 385  }
 386 }
 387
 388 const char *TRP_GETNAME (FxU32 pname)
 389 {
 390  switch (pname) {
 391         TRAP_CASE_STRING(GR_BITS_DEPTH);
 392         TRAP_CASE_STRING(GR_BITS_RGBA);
 393         TRAP_CASE_STRING(GR_FIFO_FULLNESS);
 394         TRAP_CASE_STRING(GR_FOG_TABLE_ENTRIES);
 395         TRAP_CASE_STRING(GR_GAMMA_TABLE_ENTRIES);
 396         TRAP_CASE_STRING(GR_GLIDE_STATE_SIZE);
 397         TRAP_CASE_STRING(GR_GLIDE_VERTEXLAYOUT_SIZE);
 398         TRAP_CASE_STRING(GR_IS_BUSY);
 399         TRAP_CASE_STRING(GR_LFB_PIXEL_PIPE);
 400         TRAP_CASE_STRING(GR_MAX_TEXTURE_SIZE);
 401         TRAP_CASE_STRING(GR_MAX_TEXTURE_ASPECT_RATIO);
 402         TRAP_CASE_STRING(GR_MEMORY_FB);
 403         TRAP_CASE_STRING(GR_MEMORY_TMU);
 404         TRAP_CASE_STRING(GR_MEMORY_UMA);
 405         TRAP_CASE_STRING(GR_NUM_BOARDS);
 406         TRAP_CASE_STRING(GR_NON_POWER_OF_TWO_TEXTURES);
 407         TRAP_CASE_STRING(GR_NUM_FB);
 408         TRAP_CASE_STRING(GR_NUM_SWAP_HISTORY_BUFFER);
 409         TRAP_CASE_STRING(GR_NUM_TMU);
 410         TRAP_CASE_STRING(GR_PENDING_BUFFERSWAPS);
 411         TRAP_CASE_STRING(GR_REVISION_FB);
 412         TRAP_CASE_STRING(GR_REVISION_TMU);
 413         TRAP_CASE_STRING(GR_STATS_LINES);
 414         TRAP_CASE_STRING(GR_STATS_PIXELS_AFUNC_FAIL);
 415         TRAP_CASE_STRING(GR_STATS_PIXELS_CHROMA_FAIL);
 416         TRAP_CASE_STRING(GR_STATS_PIXELS_DEPTHFUNC_FAIL);
 417         TRAP_CASE_STRING(GR_STATS_PIXELS_IN);
 418         TRAP_CASE_STRING(GR_STATS_PIXELS_OUT);
 419         TRAP_CASE_STRING(GR_STATS_PIXELS);
 420         TRAP_CASE_STRING(GR_STATS_POINTS);
 421         TRAP_CASE_STRING(GR_STATS_TRIANGLES_IN);
 422         TRAP_CASE_STRING(GR_STATS_TRIANGLES_OUT);
 423         TRAP_CASE_STRING(GR_STATS_TRIANGLES);
 424         TRAP_CASE_STRING(GR_SWAP_HISTORY);
 425         TRAP_CASE_STRING(GR_SUPPORTS_PASSTHRU);
 426         TRAP_CASE_STRING(GR_TEXTURE_ALIGN);
 427         TRAP_CASE_STRING(GR_VIDEO_POSITION);
 428         TRAP_CASE_STRING(GR_VIEWPORT);
 429         TRAP_CASE_STRING(GR_WDEPTH_MIN_MAX);
 430         TRAP_CASE_STRING(GR_ZDEPTH_MIN_MAX);
 431         TRAP_CASE_STRING(GR_VERTEX_PARAMETER);
 432         TRAP_CASE_STRING(GR_BITS_GAMMA);
 433         TRAP_CASE_STRING(GR_GET_RESERVED_1);
 434         TRAP_NODEFAULT;
 435  }
 436 }
 437
 438 const char *TRP_GETSTRING (FxU32 pname)
 439 {
 440  switch (pname) {
 441         TRAP_CASE_STRING(GR_EXTENSION);
 442         TRAP_CASE_STRING(GR_HARDWARE);
 443         TRAP_CASE_STRING(GR_RENDERER);
 444         TRAP_CASE_STRING(GR_VENDOR);
 445         TRAP_CASE_STRING(GR_VERSION);
 446         TRAP_NODEFAULT;
 447  }
 448 }
 449
 450 const char *TRP_ENABLE (GrEnableMode_t mode)
 451 {
 452  switch (mode) {
 453         TRAP_CASE_STRING(GR_AA_ORDERED);
 454         TRAP_CASE_STRING(GR_ALLOW_MIPMAP_DITHER);
 455         TRAP_CASE_STRING(GR_PASSTHRU);
 456         TRAP_CASE_STRING(GR_SHAMELESS_PLUG);
 457         TRAP_CASE_STRING(GR_VIDEO_SMOOTHING);
 458         TRAP_CASE_STRING(GR_TEXTURE_UMA_EXT);
 459         TRAP_CASE_STRING(GR_STENCIL_MODE_EXT);
 460         TRAP_CASE_STRING(GR_OPENGL_MODE_EXT);
 461         TRAP_NODEFAULT;
 462  }
 463 }
 464
 465 const char *TRP_COORD (GrCoordinateSpaceMode_t mode)
 466 {
 467  switch (mode) {
 468         TRAP_CASE_STRING(GR_WINDOW_COORDS);
 469         TRAP_CASE_STRING(GR_CLIP_COORDS);
 470         TRAP_NODEFAULT;
 471  }
 472 }
 473
 474 const char *TRP_STIPPLEMODE (GrStippleMode_t mode)
 475 {
 476  switch (mode) {
 477         TRAP_CASE_STRING(GR_STIPPLE_DISABLE);
 478         TRAP_CASE_STRING(GR_STIPPLE_PATTERN);
 479         TRAP_CASE_STRING(GR_STIPPLE_ROTATE);
 480         TRAP_NODEFAULT;
 481  }
 482 }
 483
 484 const char *TRP_LODLEVEL (GrLOD_t lod)
 485 {
 486  switch (lod) {
 487         TRAP_CASE_STRING(GR_LOD_LOG2_2048);
 488         TRAP_CASE_STRING(GR_LOD_LOG2_1024);
 489         TRAP_CASE_STRING(GR_LOD_LOG2_512);
 490         TRAP_CASE_STRING(GR_LOD_LOG2_256);
 491         TRAP_CASE_STRING(GR_LOD_LOG2_128);
 492         TRAP_CASE_STRING(GR_LOD_LOG2_64);
 493         TRAP_CASE_STRING(GR_LOD_LOG2_32);
 494         TRAP_CASE_STRING(GR_LOD_LOG2_16);
 495         TRAP_CASE_STRING(GR_LOD_LOG2_8);
 496         TRAP_CASE_STRING(GR_LOD_LOG2_4);
 497         TRAP_CASE_STRING(GR_LOD_LOG2_2);
 498         TRAP_CASE_STRING(GR_LOD_LOG2_1);
 499         TRAP_NODEFAULT;
 500  }
 501 }
 502
 503 const char *TRP_ASPECTRATIO (GrAspectRatio_t aspect)
 504 {
 505  switch (aspect) {
 506         TRAP_CASE_STRING(GR_ASPECT_LOG2_8x1);
 507         TRAP_CASE_STRING(GR_ASPECT_LOG2_4x1);
 508         TRAP_CASE_STRING(GR_ASPECT_LOG2_2x1);
 509         TRAP_CASE_STRING(GR_ASPECT_LOG2_1x1);
 510         TRAP_CASE_STRING(GR_ASPECT_LOG2_1x2);
 511         TRAP_CASE_STRING(GR_ASPECT_LOG2_1x4);
 512         TRAP_CASE_STRING(GR_ASPECT_LOG2_1x8);
 513         TRAP_NODEFAULT;
 514  }
 515 }
 516
 517 const char *TRP_TEXFMT (GrTextureFormat_t fmt)
 518 {
 519  switch (fmt) {
 520         TRAP_CASE_STRING(GR_TEXFMT_8BIT);
 521         /*TRAP_CASE_STRING(GR_TEXFMT_RGB_332); ==GR_TEXFMT_8BIT*/
 522         TRAP_CASE_STRING(GR_TEXFMT_YIQ_422);
 523         TRAP_CASE_STRING(GR_TEXFMT_ALPHA_8);
 524         TRAP_CASE_STRING(GR_TEXFMT_INTENSITY_8);
 525         TRAP_CASE_STRING(GR_TEXFMT_ALPHA_INTENSITY_44);
 526         TRAP_CASE_STRING(GR_TEXFMT_P_8);
 527         TRAP_CASE_STRING(GR_TEXFMT_RSVD0);
 528         /*TRAP_CASE_STRING(GR_TEXFMT_P_8_6666); ==GR_TEXFMT_RSVD0*/
 529         /*TRAP_CASE_STRING(GR_TEXFMT_P_8_6666_EXT); ==GR_TEXFMT_RSVD0*/
 530         TRAP_CASE_STRING(GR_TEXFMT_RSVD1);
 531         TRAP_CASE_STRING(GR_TEXFMT_16BIT);
 532         /*TRAP_CASE_STRING(GR_TEXFMT_ARGB_8332); ==GR_TEXFMT_16BIT*/
 533         TRAP_CASE_STRING(GR_TEXFMT_AYIQ_8422);
 534         TRAP_CASE_STRING(GR_TEXFMT_RGB_565);
 535         TRAP_CASE_STRING(GR_TEXFMT_ARGB_1555);
 536         TRAP_CASE_STRING(GR_TEXFMT_ARGB_4444);
 537         TRAP_CASE_STRING(GR_TEXFMT_ALPHA_INTENSITY_88);
 538         TRAP_CASE_STRING(GR_TEXFMT_AP_88);
 539         TRAP_CASE_STRING(GR_TEXFMT_RSVD2);
 540         /*TRAP_CASE_STRING(GR_TEXFMT_RSVD4); ==GR_TEXFMT_RSVD2*/
 541         TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_FXT1);
 542         TRAP_CASE_STRING(GR_TEXFMT_ARGB_8888);
 543         TRAP_CASE_STRING(GR_TEXFMT_YUYV_422);
 544         TRAP_CASE_STRING(GR_TEXFMT_UYVY_422);
 545         TRAP_CASE_STRING(GR_TEXFMT_AYUV_444);
 546         TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT1);
 547         TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT2);
 548         TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT3);
 549         TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT4);
 550         TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT5);
 551         TRAP_CASE_STRING(GR_TEXTFMT_RGB_888);
 552         TRAP_NODEFAULT;
 553  }
 554 }
 555
 556 const char *TRP_EVENODD (FxU32 evenOdd)
 557 {
 558  switch (evenOdd) {
 559         TRAP_CASE_STRING(GR_MIPMAPLEVELMASK_EVEN);
 560         TRAP_CASE_STRING(GR_MIPMAPLEVELMASK_ODD);
 561         TRAP_CASE_STRING(GR_MIPMAPLEVELMASK_BOTH);
 562         TRAP_NODEFAULT;
 563  }
 564 }
 565
 566 const char *TRP_NCC (GrNCCTable_t table)
 567 {
 568  switch (table) {
 569         TRAP_CASE_STRING(GR_NCCTABLE_NCC0);
 570         TRAP_CASE_STRING(GR_NCCTABLE_NCC1);
 571         TRAP_NODEFAULT;
 572  }
 573 }
 574
 575 const char *TRP_CLAMPMODE (GrTextureClampMode_t clampmode)
 576 {
 577  switch (clampmode) {
 578         TRAP_CASE_STRING(GR_TEXTURECLAMP_WRAP);
 579         TRAP_CASE_STRING(GR_TEXTURECLAMP_CLAMP);
 580         TRAP_CASE_STRING(GR_TEXTURECLAMP_MIRROR_EXT);
 581         TRAP_NODEFAULT;
 582  }
 583 }
 584
 585 const char *TRP_TEXFILTER (GrTextureFilterMode_t filter_mode)
 586 {
 587  switch (filter_mode) {
 588         TRAP_CASE_STRING(GR_TEXTUREFILTER_POINT_SAMPLED);
 589         TRAP_CASE_STRING(GR_TEXTUREFILTER_BILINEAR);
 590         TRAP_NODEFAULT;
 591  }
 592 }
 593
 594 const char *TRP_TABLE (GrTexTable_t type)
 595 {
 596  switch (type) {
 597         TRAP_CASE_STRING(GR_TEXTABLE_NCC0);
 598         TRAP_CASE_STRING(GR_TEXTABLE_NCC1);
 599         TRAP_CASE_STRING(GR_TEXTABLE_PALETTE);
 600         TRAP_CASE_STRING(GR_TEXTABLE_PALETTE_6666_EXT);
 601         TRAP_NODEFAULT;
 602  }
 603 }
 604
 605 const char *TRP_MIPMODE (GrMipMapMode_t mode)
 606 {
 607  switch (mode) {
 608         TRAP_CASE_STRING(GR_MIPMAP_DISABLE);
 609         TRAP_CASE_STRING(GR_MIPMAP_NEAREST);
 610         TRAP_CASE_STRING(GR_MIPMAP_NEAREST_DITHER);
 611         TRAP_NODEFAULT;
 612  }
 613 }
 614
 615 const char *TRP_TEXBASERANGE (GrTexBaseRange_t range)
 616 {
 617  switch (range) {
 618         TRAP_CASE_STRING(GR_TEXBASE_2048);
 619         TRAP_CASE_STRING(GR_TEXBASE_1024);
 620         TRAP_CASE_STRING(GR_TEXBASE_512);
 621         TRAP_CASE_STRING(GR_TEXBASE_256_TO_1);
 622         TRAP_CASE_STRING(GR_TEXBASE_256);
 623         TRAP_CASE_STRING(GR_TEXBASE_128);
 624         TRAP_CASE_STRING(GR_TEXBASE_64);
 625         TRAP_CASE_STRING(GR_TEXBASE_32_TO_1);
 626         TRAP_NODEFAULT;
 627  }
 628 }
 629
 630 const char *TRP_LOCKTYPE (GrLock_t type)
 631 {
 632  switch (type) {
 633         TRAP_CASE_STRING(GR_LFB_READ_ONLY);
 634         TRAP_CASE_STRING(GR_LFB_WRITE_ONLY);
 635         /*TRAP_CASE_STRING(GR_LFB_IDLE); ==GR_LFB_READ_ONLY*/
 636         TRAP_CASE_STRING(GR_LFB_NOIDLE);
 637         TRAP_CASE_STRING(GR_LFB_WRITE_ONLY_EXPLICIT_EXT);
 638         TRAP_NODEFAULT;
 639  }
 640 }
 641
 642 const char *TRP_WRITEMODE (GrLfbWriteMode_t writeMode)
 643 {
 644  switch (writeMode) {
 645         TRAP_CASE_STRING(GR_LFBWRITEMODE_565);
 646         TRAP_CASE_STRING(GR_LFBWRITEMODE_555);
 647         TRAP_CASE_STRING(GR_LFBWRITEMODE_1555);
 648         TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED1);
 649         TRAP_CASE_STRING(GR_LFBWRITEMODE_888);
 650         TRAP_CASE_STRING(GR_LFBWRITEMODE_8888);
 651         TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED2);
 652         TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED3);
 653         TRAP_CASE_STRING(GR_LFBWRITEMODE_Z32);
 654         TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED5);
 655         TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED6);
 656         TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED7);
 657         TRAP_CASE_STRING(GR_LFBWRITEMODE_565_DEPTH);
 658         TRAP_CASE_STRING(GR_LFBWRITEMODE_555_DEPTH);
 659         TRAP_CASE_STRING(GR_LFBWRITEMODE_1555_DEPTH);
 660         TRAP_CASE_STRING(GR_LFBWRITEMODE_ZA16);
 661         TRAP_CASE_STRING(GR_LFBWRITEMODE_ANY);
 662         TRAP_NODEFAULT;
 663  }
 664 }
 665
 666 const char *TRP_SRCFMT (GrLfbSrcFmt_t src_format)
 667 {
 668  switch (src_format) {
 669         TRAP_CASE_STRING(GR_LFB_SRC_FMT_565);
 670         TRAP_CASE_STRING(GR_LFB_SRC_FMT_555);
 671         TRAP_CASE_STRING(GR_LFB_SRC_FMT_1555);
 672         TRAP_CASE_STRING(GR_LFB_SRC_FMT_888);
 673         TRAP_CASE_STRING(GR_LFB_SRC_FMT_8888);
 674         TRAP_CASE_STRING(GR_LFB_SRC_FMT_565_DEPTH);
 675         TRAP_CASE_STRING(GR_LFB_SRC_FMT_555_DEPTH);
 676         TRAP_CASE_STRING(GR_LFB_SRC_FMT_1555_DEPTH);
 677         TRAP_CASE_STRING(GR_LFB_SRC_FMT_ZA16);
 678         TRAP_CASE_STRING(GR_LFB_SRC_FMT_RLE16);
 679         TRAP_CASE_STRING(GR_LFBWRITEMODE_Z32); /*???*/
 680         TRAP_NODEFAULT;
 681  }
 682 }
 683
 684 const char *TRP_CRMODE (GrChromaRangeMode_t mode)
 685 {
 686  switch (mode) {
 687         TRAP_CASE_STRING(GR_CHROMARANGE_DISABLE_EXT);
 688         /*TRAP_CASE_STRING(GR_CHROMARANGE_RGB_ALL_EXT); ==GR_CHROMARANGE_DISABLE_EXT*/
 689         TRAP_CASE_STRING(GR_CHROMARANGE_ENABLE_EXT);
 690         TRAP_NODEFAULT;
 691  }
 692 }
 693
 694 const char *TRP_PIXFMT (GrPixelFormat_t pixelformat)
 695 {
 696  switch (pixelformat) {
 697         TRAP_CASE_STRING(GR_PIXFMT_I_8);
 698         TRAP_CASE_STRING(GR_PIXFMT_AI_88);
 699         TRAP_CASE_STRING(GR_PIXFMT_RGB_565);
 700         TRAP_CASE_STRING(GR_PIXFMT_ARGB_1555);
 701         TRAP_CASE_STRING(GR_PIXFMT_ARGB_8888);
 702         TRAP_CASE_STRING(GR_PIXFMT_AA_2_RGB_565);
 703         TRAP_CASE_STRING(GR_PIXFMT_AA_2_ARGB_1555);
 704         TRAP_CASE_STRING(GR_PIXFMT_AA_2_ARGB_8888);
 705         TRAP_CASE_STRING(GR_PIXFMT_AA_4_RGB_565);
 706         TRAP_CASE_STRING(GR_PIXFMT_AA_4_ARGB_1555);
 707         TRAP_CASE_STRING(GR_PIXFMT_AA_4_ARGB_8888);
 708         TRAP_CASE_STRING(GR_PIXFMT_AA_8_RGB_565);
 709         TRAP_CASE_STRING(GR_PIXFMT_AA_8_ARGB_1555);
 710         TRAP_CASE_STRING(GR_PIXFMT_AA_8_ARGB_8888);
 711         TRAP_NODEFAULT;
 712  }
 713 }
 714
 715 const char *TRP_STENCILOP (GrStencilOp_t op)
 716 {
 717  switch (op) {
 718         TRAP_CASE_STRING(GR_STENCILOP_KEEP);
 719         TRAP_CASE_STRING(GR_STENCILOP_ZERO);
 720         TRAP_CASE_STRING(GR_STENCILOP_REPLACE);
 721         TRAP_CASE_STRING(GR_STENCILOP_INCR_CLAMP);
 722         TRAP_CASE_STRING(GR_STENCILOP_DECR_CLAMP);
 723         TRAP_CASE_STRING(GR_STENCILOP_INVERT);
 724         TRAP_CASE_STRING(GR_STENCILOP_INCR_WRAP);
 725         TRAP_CASE_STRING(GR_STENCILOP_DECR_WRAP);
 726         TRAP_NODEFAULT;
 727  }
 728 }
 729
 730 const char *TRP_BLENDOP (GrAlphaBlendOp_t op)
 731 {
 732  switch (op) {
 733         TRAP_CASE_STRING(GR_BLEND_OP_ADD);
 734         TRAP_CASE_STRING(GR_BLEND_OP_SUB);
 735         TRAP_CASE_STRING(GR_BLEND_OP_REVSUB);
 736         TRAP_CASE_STRING(GR_BLEND_SAME_COLOR_EXT);
 737         TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SAME_COLOR_EXT);
 738         TRAP_NODEFAULT;
 739  }
 740 }
 741
 742 const char *TRP_CU (GrCCUColor_t a)
 743 {
 744  switch (a) {
 745         TRAP_CASE_STRING(GR_CMBX_ZERO);
 746         TRAP_CASE_STRING(GR_CMBX_TEXTURE_ALPHA);
 747         TRAP_CASE_STRING(GR_CMBX_ALOCAL);
 748         TRAP_CASE_STRING(GR_CMBX_AOTHER);
 749         TRAP_CASE_STRING(GR_CMBX_B);
 750         TRAP_CASE_STRING(GR_CMBX_CONSTANT_ALPHA);
 751         TRAP_CASE_STRING(GR_CMBX_CONSTANT_COLOR);
 752         TRAP_CASE_STRING(GR_CMBX_DETAIL_FACTOR);
 753         TRAP_CASE_STRING(GR_CMBX_ITALPHA);
 754         TRAP_CASE_STRING(GR_CMBX_ITRGB);
 755         TRAP_CASE_STRING(GR_CMBX_LOCAL_TEXTURE_ALPHA);
 756         TRAP_CASE_STRING(GR_CMBX_LOCAL_TEXTURE_RGB);
 757         TRAP_CASE_STRING(GR_CMBX_LOD_FRAC);
 758         TRAP_CASE_STRING(GR_CMBX_OTHER_TEXTURE_ALPHA);
 759         TRAP_CASE_STRING(GR_CMBX_OTHER_TEXTURE_RGB);
 760         TRAP_CASE_STRING(GR_CMBX_TEXTURE_RGB);
 761         TRAP_CASE_STRING(GR_CMBX_TMU_CALPHA);
 762         TRAP_CASE_STRING(GR_CMBX_TMU_CCOLOR);
 763         TRAP_NODEFAULT;
 764  }
 765 }
 766
 767 const char *TRP_CMBMODE (GrCombineMode_t a_mode)
 768 {
 769  switch (a_mode) {
 770         TRAP_CASE_STRING(GR_FUNC_MODE_ZERO);
 771         TRAP_CASE_STRING(GR_FUNC_MODE_X);
 772         TRAP_CASE_STRING(GR_FUNC_MODE_ONE_MINUS_X);
 773         TRAP_CASE_STRING(GR_FUNC_MODE_NEGATIVE_X);
 774         TRAP_CASE_STRING(GR_FUNC_MODE_X_MINUS_HALF);
 775         TRAP_NODEFAULT;
 776  }
 777 }
 778
 779 const char *TRP_TMU (GrChipID_t tmu)
 780 {
 781  switch (tmu) {
 782         TRAP_CASE_STRING(GR_TMU0);
 783         TRAP_CASE_STRING(GR_TMU1);
 784         TRAP_NODEFAULT;
 785  }
 786 }
 787
 788
 789
 790 /****************************************************************************\
 791 * REAL POINTERS                                                              *
 792 \****************************************************************************/
 793
 794 /*
 795 ** glide extensions
 796 */
 797 char * (FX_CALL *real_grGetRegistryOrEnvironmentStringExt) (char *theEntry);
 798 void (FX_CALL *real_grGetGammaTableExt) (FxU32 nentries, FxU32 *red, FxU32 *green, FxU32 *blue);
 799 void (FX_CALL *real_grChromaRangeModeExt) (GrChromakeyMode_t mode);
 800 void (FX_CALL *real_grChromaRangeExt) (GrColor_t color, GrColor_t range, GrChromaRangeMode_t match_mode);
 801 void (FX_CALL *real_grTexChromaModeExt) (GrChipID_t tmu, GrChromakeyMode_t mode);
 802 void (FX_CALL *real_grTexChromaRangeExt) (GrChipID_t tmu, GrColor_t min, GrColor_t max, GrTexChromakeyMode_t mode);
 803
 804 /* tbext */
 805 void (FX_CALL *real_grTextureBufferExt) (GrChipID_t tmu, FxU32 startAddress, GrLOD_t thisLOD, GrLOD_t largeLOD, GrAspectRatio_t aspectRatio, GrTextureFormat_t format, FxU32 odd_even_mask);
 806 void (FX_CALL *real_grTextureAuxBufferExt) (GrChipID_t tmu, FxU32 startAddress, GrLOD_t thisLOD, GrLOD_t largeLOD, GrAspectRatio_t aspectRatio, GrTextureFormat_t format, FxU32 odd_even_mask);
 807 void (FX_CALL *real_grAuxBufferExt) (GrBuffer_t buffer);
 808
 809 /* napalm */
 810 GrContext_t (FX_CALL *real_grSstWinOpenExt) (FxU32 hWnd, GrScreenResolution_t resolution, GrScreenRefresh_t refresh, GrColorFormat_t format, GrOriginLocation_t origin, GrPixelFormat_t pixelformat, int nColBuffers, int nAuxBuffers);
 811 void (FX_CALL *real_grStencilFuncExt) (GrCmpFnc_t fnc, GrStencil_t ref, GrStencil_t mask);
 812 void (FX_CALL *real_grStencilMaskExt) (GrStencil_t value);
 813 void (FX_CALL *real_grStencilOpExt) (GrStencilOp_t stencil_fail, GrStencilOp_t depth_fail, GrStencilOp_t depth_pass);
 814 void (FX_CALL *real_grLfbConstantStencilExt) (GrStencil_t value);
 815 void (FX_CALL *real_grBufferClearExt) (GrColor_t color, GrAlpha_t alpha, FxU32 depth, GrStencil_t stencil);
 816 void (FX_CALL *real_grColorCombineExt) (GrCCUColor_t a, GrCombineMode_t a_mode, GrCCUColor_t b, GrCombineMode_t b_mode, GrCCUColor_t c, FxBool c_invert, GrCCUColor_t d, FxBool d_invert, FxU32 shift, FxBool invert);
 817 void (FX_CALL *real_grAlphaCombineExt) (GrACUColor_t a, GrCombineMode_t a_mode, GrACUColor_t b, GrCombineMode_t b_mode, GrACUColor_t c, FxBool c_invert, GrACUColor_t d, FxBool d_invert, FxU32 shift, FxBool invert);
 818 void (FX_CALL *real_grTexColorCombineExt) (GrChipID_t tmu, GrTCCUColor_t a, GrCombineMode_t a_mode, GrTCCUColor_t b, GrCombineMode_t b_mode, GrTCCUColor_t c, FxBool c_invert, GrTCCUColor_t d, FxBool d_invert, FxU32 shift, FxBool invert);
 819 void (FX_CALL *real_grTexAlphaCombineExt) (GrChipID_t tmu, GrTACUColor_t a, GrCombineMode_t a_mode, GrTACUColor_t b, GrCombineMode_t b_mode, GrTACUColor_t c, FxBool c_invert, GrTACUColor_t d, FxBool d_invert, FxU32 shift, FxBool invert);
 820 void (FX_CALL *real_grConstantColorValueExt) (GrChipID_t tmu, GrColor_t value);
 821 void (FX_CALL *real_grColorMaskExt) (FxBool r, FxBool g, FxBool b, FxBool a);
 822 void (FX_CALL *real_grAlphaBlendFunctionExt) (GrAlphaBlendFnc_t rgb_sf, GrAlphaBlendFnc_t rgb_df, GrAlphaBlendOp_t rgb_op, GrAlphaBlendFnc_t alpha_sf, GrAlphaBlendFnc_t alpha_df, GrAlphaBlendOp_t alpha_op);
 823 void (FX_CALL *real_grTBufferWriteMaskExt) (FxU32 tmask);
 824
 825
 826
 827 /****************************************************************************\
 828 * DEBUG HOOKS                                                                *
 829 \****************************************************************************/
 830
 831 /*
 832 ** rendering functions
 833 */
 834 void FX_CALL trap_grDrawPoint (const void *pt)
 835 {
 836 #define FN_NAME "grDrawPoint"
 837  TRAP_LOG("%s(%p)\n", FN_NAME, pt);
 838  grDrawPoint(pt);
 839 #undef FN_NAME
 840 }
 841
 842 void FX_CALL trap_grDrawLine (const void *v1,
 843                               const void *v2)
 844 {
 845 #define FN_NAME "grDrawLine"
 846  TRAP_LOG("%s(%p, %p)\n", FN_NAME, v1, v2);
 847  grDrawLine(v1, v2);
 848 #undef FN_NAME
 849 }
 850
 851 void FX_CALL trap_grDrawTriangle (const void *a,
 852                                   const void *b,
 853                                   const void *c)
 854 {
 855 #define FN_NAME "grDrawTriangle"
 856  TRAP_LOG("%s(%p, %p, %p)\n", FN_NAME, a, b, c);
 857  grDrawTriangle(a, b, c);
 858 #undef FN_NAME
 859 }
 860
 861 void FX_CALL trap_grVertexLayout (FxU32 param,
 862                                   FxI32 offset,
 863                                   FxU32 mode)
 864 {
 865 #define FN_NAME "grVertexLayout"
 866  TRAP_LOG("%s(%s, %ld, %s)\n", FN_NAME, TRP_VTX(param), offset, TRP_PARAM(mode));
 867  grVertexLayout(param, offset, mode);
 868 #undef FN_NAME
 869 }
 870
 871 void FX_CALL trap_grDrawVertexArray (FxU32 mode,
 872                                      FxU32 Count,
 873                                      void  *pointers)
 874 {
 875 #define FN_NAME "grDrawVertexArray"
 876  TRAP_LOG("%s(%s, %lu, %p)\n", FN_NAME, TRP_ARRAY(mode), Count, pointers);
 877  grDrawVertexArray(mode, Count, pointers);
 878 #undef FN_NAME
 879 }
 880
 881 void FX_CALL trap_grDrawVertexArrayContiguous (FxU32 mode,
 882                                                FxU32 Count,
 883                                                void  *pointers,
 884                                                FxU32 stride)
 885 {
 886 #define FN_NAME "grDrawVertexArrayContiguous"
 887  TRAP_LOG("%s(%s, %lu, %p, %lu)\n", FN_NAME, TRP_ARRAY(mode), Count, pointers, stride);
 888  grDrawVertexArrayContiguous(mode, Count, pointers, stride);
 889 #undef FN_NAME
 890 }
 891
 892 /*
 893 **  Antialiasing Functions
 894 */
 895 void FX_CALL trap_grAADrawTriangle (const void *a,
 896                                     const void *b,
 897                                     const void *c,
 898                                     FxBool     ab_antialias,
 899                                     FxBool     bc_antialias,
 900                                     FxBool     ca_antialias)
 901 {
 902 #define FN_NAME "grAADrawTriangle"
 903  TRAP_LOG("%s(%p, %p, %p, %s, %s, %s)\n", FN_NAME, a, b, c, TRP_BOOL(ab_antialias), TRP_BOOL(bc_antialias), TRP_BOOL(ca_antialias));
 904  grAADrawTriangle(a, b, c, ab_antialias, bc_antialias, ca_antialias);
 905 #undef FN_NAME
 906 }
 907
 908 /*
 909 ** buffer management
 910 */
 911 void FX_CALL trap_grBufferClear (GrColor_t color,
 912                                  GrAlpha_t alpha,
 913                                  FxU32     depth)
 914 {
 915 #define FN_NAME "grBufferClear"
 916  TRAP_LOG("%s(%08lx, %02x, %08lx)\n", FN_NAME, color, alpha, depth);
 917  grBufferClear(color, alpha, depth);
 918 #undef FN_NAME
 919 }
 920
 921 void FX_CALL trap_grBufferSwap (FxU32 swap_interval)
 922 {
 923 #define FN_NAME "grBufferSwap"
 924  TRAP_LOG("%s(%lu)\n", FN_NAME, swap_interval);
 925  grBufferSwap(swap_interval);
 926 #undef FN_NAME
 927 }
 928
 929 void FX_CALL trap_grRenderBuffer (GrBuffer_t buffer)
 930 {
 931 #define FN_NAME "grRenderBuffer"
 932  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BUFFER(buffer));
 933  grRenderBuffer(buffer);
 934 #undef FN_NAME
 935 }
 936
 937 /*
 938 ** error management
 939 */
 940 void FX_CALL trap_grErrorSetCallback (GrErrorCallbackFnc_t fnc)
 941 {
 942 #define FN_NAME "grErrorSetCallback"
 943  TRAP_LOG("%s(%p)\n", FN_NAME, (void *)fnc);
 944  grErrorSetCallback(fnc);
 945 #undef FN_NAME
 946 }
 947
 948 /*
 949 ** SST routines
 950 */
 951 void FX_CALL trap_grFinish (void)
 952 {
 953 #define FN_NAME "grFinish"
 954  TRAP_LOG("%s()\n", FN_NAME);
 955  grFinish();
 956 #undef FN_NAME
 957 }
 958
 959 void FX_CALL trap_grFlush (void)
 960 {
 961 #define FN_NAME "grFlush"
 962  TRAP_LOG("%s()\n", FN_NAME);
 963  grFlush();
 964 #undef FN_NAME
 965 }
 966
 967 GrContext_t FX_CALL trap_grSstWinOpen (FxU32                hWnd,
 968                                        GrScreenResolution_t screen_resolution,
 969                                        GrScreenRefresh_t    refresh_rate,
 970                                        GrColorFormat_t      color_format,
 971                                        GrOriginLocation_t   origin_location,
 972                                        int                  nColBuffers,
 973                                        int                  nAuxBuffers)
 974 {
 975 #define FN_NAME "grSstWinOpen"
 976  GrContext_t rv;
 977  TRAP_LOG("%s(%08lx, %s, %s, %s, %s, %d, %d)\n", FN_NAME, hWnd, TRP_RESOLUTION(screen_resolution), TRP_REFRESH(refresh_rate), TRP_COLFMT(color_format), TRP_ORIGIN(origin_location), nColBuffers, nAuxBuffers);
 978  rv = grSstWinOpen(hWnd, screen_resolution, refresh_rate, color_format, origin_location, nColBuffers, nAuxBuffers);
 979  TRAP_LOG(GOT "%p\n", (void *)rv);
 980  return rv;
 981 #undef FN_NAME
 982 }
 983
 984 FxBool FX_CALL trap_grSstWinClose (GrContext_t context)
 985 {
 986 #define FN_NAME "grSstWinClose"
 987  FxBool rv;
 988  TRAP_LOG("%s(%p)\n", FN_NAME, (void *)context);
 989  rv = grSstWinClose(context);
 990  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
 991  return rv;
 992 #undef FN_NAME
 993 }
 994
 995 void FX_CALL trap_grSetNumPendingBuffers (FxI32 NumPendingBuffers)
 996 {
 997 #define FN_NAME "grSetNumPendingBuffers"
 998  TRAP_LOG("%s(%ld)\n", FN_NAME, NumPendingBuffers);
 999  grSetNumPendingBuffers(NumPendingBuffers);
1000 #undef FN_NAME
1001 }
1002
1003 FxBool FX_CALL trap_grSelectContext (GrContext_t context)
1004 {
1005 #define FN_NAME "grSelectContext"
1006  FxBool rv;
1007  TRAP_LOG("%s(%p)\n", FN_NAME, (void *)context);
1008  rv = grSelectContext(context);
1009  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1010  return rv;
1011 #undef FN_NAME
1012 }
1013
1014 void FX_CALL trap_grSstOrigin (GrOriginLocation_t origin)
1015 {
1016 #define FN_NAME "grSstOrigin"
1017  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_ORIGIN(origin));
1018  grSstOrigin(origin);
1019 #undef FN_NAME
1020 }
1021
1022 void FX_CALL trap_grSstSelect (int which_sst)
1023 {
1024 #define FN_NAME "grSstSelect"
1025  TRAP_LOG("%s(%d)\n", FN_NAME, which_sst);
1026  grSstSelect(which_sst);
1027 #undef FN_NAME
1028 }
1029
1030 /*
1031 ** Glide configuration and special effect maintenance functions
1032 */
1033 void FX_CALL trap_grAlphaBlendFunction (GrAlphaBlendFnc_t rgb_sf,
1034                                         GrAlphaBlendFnc_t rgb_df,
1035                                         GrAlphaBlendFnc_t alpha_sf,
1036                                         GrAlphaBlendFnc_t alpha_df)
1037 {
1038 #define FN_NAME "grAlphaBlendFunction"
1039  TRAP_LOG("%s(%s, %s, %s, %s)\n", FN_NAME, TRP_BLEND(rgb_sf), TRP_BLEND(rgb_df), TRP_BLEND(alpha_sf), TRP_BLEND(alpha_df));
1040  grAlphaBlendFunction(rgb_sf, rgb_df, alpha_sf, alpha_df);
1041 #undef FN_NAME
1042 }
1043
1044 void FX_CALL trap_grAlphaCombine (GrCombineFunction_t function,
1045                                   GrCombineFactor_t   factor,
1046                                   GrCombineLocal_t    local,
1047                                   GrCombineOther_t    other,
1048                                   FxBool              invert)
1049 {
1050 #define FN_NAME "grAlphaCombine"
1051  TRAP_LOG("%s(%s, %s, %s, %s, %s)\n", FN_NAME, TRP_CMBFUNC(function), TRP_CMBFACT(factor), TRP_CMBLOCAL(local), TRP_CMBOTHER(other), TRP_BOOL(invert));
1052  grAlphaCombine(function, factor, local, other, invert);
1053 #undef FN_NAME
1054 }
1055
1056 void FX_CALL trap_grAlphaControlsITRGBLighting (FxBool enable)
1057 {
1058 #define FN_NAME "grAlphaControlsITRGBLighting"
1059  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BOOL(enable));
1060  grAlphaControlsITRGBLighting(enable);
1061 #undef FN_NAME
1062 }
1063
1064 void FX_CALL trap_grAlphaTestFunction (GrCmpFnc_t function)
1065 {
1066 #define FN_NAME "grAlphaTestFunction"
1067  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CMPFUNC(function));
1068  grAlphaTestFunction(function);
1069 #undef FN_NAME
1070 }
1071
1072 void FX_CALL trap_grAlphaTestReferenceValue (GrAlpha_t value)
1073 {
1074 #define FN_NAME "grAlphaTestReferenceValue"
1075  TRAP_LOG("%s(%02x)\n", FN_NAME, value);
1076  grAlphaTestReferenceValue(value);
1077 #undef FN_NAME
1078 }
1079
1080 void FX_CALL trap_grChromakeyMode (GrChromakeyMode_t mode)
1081 {
1082 #define FN_NAME "grChromakeyMode"
1083  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CKMODE(mode));
1084  grChromakeyMode(mode);
1085 #undef FN_NAME
1086 }
1087
1088 void FX_CALL trap_grChromakeyValue (GrColor_t value)
1089 {
1090 #define FN_NAME "grChromakeyValue"
1091  TRAP_LOG("%s(%08lx)\n", FN_NAME, value);
1092  grChromakeyValue(value);
1093 #undef FN_NAME
1094 }
1095
1096 void FX_CALL trap_grClipWindow (FxU32 minx,
1097                                 FxU32 miny,
1098                                 FxU32 maxx,
1099                                 FxU32 maxy)
1100 {
1101 #define FN_NAME "grClipWindow"
1102  TRAP_LOG("%s(%lu, %lu, %lu, %lu)\n", FN_NAME, minx, miny, maxx, maxy);
1103  grClipWindow(minx, miny, maxx, maxy);
1104 #undef FN_NAME
1105 }
1106
1107 void FX_CALL trap_grColorCombine (GrCombineFunction_t function,
1108                                   GrCombineFactor_t   factor,
1109                                   GrCombineLocal_t    local,
1110                                   GrCombineOther_t    other,
1111                                   FxBool              invert)
1112 {
1113 #define FN_NAME "grColorCombine"
1114  TRAP_LOG("%s(%s, %s, %s, %s, %s)\n", FN_NAME, TRP_CMBFUNC(function), TRP_CMBFACT(factor), TRP_CMBLOCAL(local), TRP_CMBOTHER(other), TRP_BOOL(invert));
1115  grColorCombine(function, factor, local, other, invert);
1116 #undef FN_NAME
1117 }
1118
1119 void FX_CALL trap_grColorMask (FxBool rgb,
1120                                FxBool a)
1121 {
1122 #define FN_NAME "grColorMask"
1123  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_BOOL(rgb), TRP_BOOL(a));
1124  grColorMask(rgb, a);
1125 #undef FN_NAME
1126 }
1127
1128 void FX_CALL trap_grCullMode (GrCullMode_t mode)
1129 {
1130 #define FN_NAME "grCullMode"
1131  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CULLMODE(mode));
1132  grCullMode(mode);
1133 #undef FN_NAME
1134 }
1135
1136 void FX_CALL trap_grConstantColorValue (GrColor_t value)
1137 {
1138 #define FN_NAME "grConstantColorValue"
1139  TRAP_LOG("%s(%08lx)\n", FN_NAME, value);
1140  grConstantColorValue(value);
1141 #undef FN_NAME
1142 }
1143
1144 void FX_CALL trap_grDepthBiasLevel (FxI32 level)
1145 {
1146 #define FN_NAME "grDepthBiasLevel"
1147  TRAP_LOG("%s(%ld)\n", FN_NAME, level);
1148  grDepthBiasLevel(level);
1149 #undef FN_NAME
1150 }
1151
1152 void FX_CALL trap_grDepthBufferFunction (GrCmpFnc_t function)
1153 {
1154 #define FN_NAME "grDepthBufferFunction"
1155  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CMPFUNC(function));
1156  grDepthBufferFunction(function);
1157 #undef FN_NAME
1158 }
1159
1160 void FX_CALL trap_grDepthBufferMode (GrDepthBufferMode_t mode)
1161 {
1162 #define FN_NAME "grDepthBufferMode"
1163  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_DEPTHMODE(mode));
1164  grDepthBufferMode(mode);
1165 #undef FN_NAME
1166 }
1167
1168 void FX_CALL trap_grDepthMask (FxBool mask)
1169 {
1170 #define FN_NAME "grDepthMask"
1171  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BOOL(mask));
1172  grDepthMask(mask);
1173 #undef FN_NAME
1174 }
1175
1176 void FX_CALL trap_grDisableAllEffects (void)
1177 {
1178 #define FN_NAME "grDisableAllEffects"
1179  TRAP_LOG("%s()\n", FN_NAME);
1180  grDisableAllEffects();
1181 #undef FN_NAME
1182 }
1183
1184 void FX_CALL trap_grDitherMode (GrDitherMode_t mode)
1185 {
1186 #define FN_NAME "grDitherMode"
1187  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_DITHERMODE(mode));
1188  grDitherMode(mode);
1189 #undef FN_NAME
1190 }
1191
1192 void FX_CALL trap_grFogColorValue (GrColor_t fogcolor)
1193 {
1194 #define FN_NAME "grFogColorValue"
1195  TRAP_LOG("%s(%08lx)\n", FN_NAME, fogcolor);
1196  grFogColorValue(fogcolor);
1197 #undef FN_NAME
1198 }
1199
1200 void FX_CALL trap_grFogMode (GrFogMode_t mode)
1201 {
1202 #define FN_NAME "grFogMode"
1203  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_FOGMODE(mode));
1204  grFogMode(mode);
1205 #undef FN_NAME
1206 }
1207
1208 void FX_CALL trap_grFogTable (const GrFog_t ft[])
1209 {
1210 #define FN_NAME "grFogTable"
1211  TRAP_LOG("%s(%p)\n", FN_NAME, ft);
1212  grFogTable(ft);
1213 #undef FN_NAME
1214 }
1215
1216 void FX_CALL trap_grLoadGammaTable (FxU32 nentries,
1217                                     FxU32 *red,
1218                                     FxU32 *green,
1219                                     FxU32 *blue)
1220 {
1221 #define FN_NAME "grLoadGammaTable"
1222  TRAP_LOG("%s(%lu, %p, %p, %p)\n", FN_NAME, nentries, (void *)red, (void *)green, (void *)blue);
1223  grLoadGammaTable(nentries, red, green, blue);
1224 #undef FN_NAME
1225 }
1226
1227 void FX_CALL trap_grSplash (float x,
1228                             float y,
1229                             float width,
1230                             float height,
1231                             FxU32 frame)
1232 {
1233 #define FN_NAME "grSplash"
1234  TRAP_LOG("%s(%f, %f, %f, %f, %lu)\n", FN_NAME, x, y, width, height, frame);
1235  grSplash(x, y, width, height, frame);
1236 #undef FN_NAME
1237 }
1238
1239 FxU32 FX_CALL trap_grGet (FxU32 pname,
1240                           FxU32 plength,
1241                           FxI32 *params)
1242 {
1243 #define FN_NAME "grGet"
1244  FxU32 rv, i;
1245  TRAP_LOG("%s(%s, %lu, %p)\n", FN_NAME, TRP_GETNAME(pname), plength, (void *)params);
1246  rv = grGet(pname, plength, params);
1247  TRAP_LOG(GOT "[");
1248  for (i = 0; i < (rv/sizeof(FxI32)); i++) {
1249      TRAP_LOG("%s%ld", i ? ", " : "", params[i]);
1250  }
1251  TRAP_LOG("]\n");
1252  return rv;
1253 #undef FN_NAME
1254 }
1255
1256 const char *FX_CALL trap_grGetString (FxU32 pname)
1257 {
1258 #define FN_NAME "grGetString"
1259  const char *rv;
1260  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_GETSTRING(pname));
1261  rv = grGetString(pname);
1262  if (rv) {
1263     TRAP_LOG(GOT "\"%s\"\n", rv);
1264  } else {
1265     TRAP_LOG(GOT "NULL\n");
1266  }
1267  return rv;
1268 #undef FN_NAME
1269 }
1270
1271 FxI32 FX_CALL trap_grQueryResolutions (const GrResolution *resTemplate,
1272                                        GrResolution       *output)
1273 {
1274 #define FN_NAME "grQueryResolutions"
1275  FxI32 rv;
1276  TRAP_LOG("%s(%p, %p)\n", FN_NAME, (void *)resTemplate, (void *)output);
1277  rv = grQueryResolutions(resTemplate, output);
1278  TRAP_LOG(GOT "%ld\n", rv);
1279  return rv;
1280 #undef FN_NAME
1281 }
1282
1283 FxBool FX_CALL trap_grReset (FxU32 what)
1284 {
1285 #define FN_NAME "grReset"
1286  FxBool rv;
1287  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_GETNAME(what));
1288  rv = grReset(what);
1289  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1290  return rv;
1291 #undef FN_NAME
1292 }
1293
1294 GrProc FX_CALL trap_grGetProcAddress (char *procName)
1295 {
1296 #define FN_NAME "grGetProcAddress"
1297  GrProc rv;
1298  TRAP_LOG("%s(%s)\n", FN_NAME, procName);
1299  rv = grGetProcAddress(procName);
1300  TRAP_LOG(GOT "%p\n", (void *)rv);
1301  return rv;
1302 #undef FN_NAME
1303 }
1304
1305 void FX_CALL trap_grEnable (GrEnableMode_t mode)
1306 {
1307 #define FN_NAME "grEnable"
1308  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_ENABLE(mode));
1309  grEnable(mode);
1310 #undef FN_NAME
1311 }
1312
1313 void FX_CALL trap_grDisable (GrEnableMode_t mode)
1314 {
1315 #define FN_NAME "grDisable"
1316  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_ENABLE(mode));
1317  grDisable(mode);
1318 #undef FN_NAME
1319 }
1320
1321 void FX_CALL trap_grCoordinateSpace (GrCoordinateSpaceMode_t mode)
1322 {
1323 #define FN_NAME "grCoordinateSpace"
1324  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_COORD(mode));
1325  grCoordinateSpace(mode);
1326 #undef FN_NAME
1327 }
1328
1329 void FX_CALL trap_grDepthRange (FxFloat n,
1330                                 FxFloat f)
1331 {
1332 #define FN_NAME "grDepthRange"
1333  TRAP_LOG("%s(%f, %f)\n", FN_NAME, n, f);
1334  grDepthRange(n, f);
1335 #undef FN_NAME
1336 }
1337
1338 void FX_CALL trap_grStippleMode (GrStippleMode_t mode)
1339 {
1340 #define FN_NAME "grStippleMode"
1341  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_STIPPLEMODE(mode));
1342  grStippleMode(mode);
1343 #undef FN_NAME
1344 }
1345
1346 void FX_CALL trap_grStipplePattern (GrStipplePattern_t mode)
1347 {
1348 #define FN_NAME "grStipplePattern"
1349  TRAP_LOG("%s(%08lx)\n", FN_NAME, mode);
1350  grStipplePattern(mode);
1351 #undef FN_NAME
1352 }
1353
1354 void FX_CALL trap_grViewport (FxI32 x,
1355                               FxI32 y,
1356                               FxI32 width,
1357                               FxI32 height)
1358 {
1359 #define FN_NAME "grViewport"
1360  TRAP_LOG("%s(%ld, %ld, %ld, %ld)\n", FN_NAME, x, y, width, height);
1361  grViewport(x, y, width, height);
1362 #undef FN_NAME
1363 }
1364
1365 /*
1366 ** texture mapping control functions
1367 */
1368 FxU32 FX_CALL trap_grTexCalcMemRequired (GrLOD_t           lodmin,
1369                                          GrLOD_t           lodmax,
1370                                          GrAspectRatio_t   aspect,
1371                                          GrTextureFormat_t fmt)
1372 {
1373 #define FN_NAME "grTexCalcMemRequired"
1374  FxU32 rv;
1375  TRAP_LOG("%s(%s, %s, %s, %s)\n", FN_NAME, TRP_LODLEVEL(lodmin), TRP_LODLEVEL(lodmax), TRP_ASPECTRATIO(aspect), TRP_TEXFMT(fmt));
1376  rv = grTexCalcMemRequired(lodmin, lodmax, aspect, fmt);
1377  TRAP_LOG(GOT "%lu\n", rv);
1378  return rv;
1379 #undef FN_NAME
1380 }
1381
1382 FxU32 FX_CALL trap_grTexTextureMemRequired (FxU32     evenOdd,
1383                                             GrTexInfo *info)
1384 {
1385 #define FN_NAME "grTexTextureMemRequired"
1386  FxU32 rv;
1387  TRAP_LOG("%s(%s, %p)\n", FN_NAME, TRP_EVENODD(evenOdd), (void *)info);
1388  rv = grTexTextureMemRequired(evenOdd, info);
1389  TRAP_LOG(GOT "%lu\n", rv);
1390  return rv;
1391 #undef FN_NAME
1392 }
1393
1394 FxU32 FX_CALL trap_grTexMinAddress (GrChipID_t tmu)
1395 {
1396 #define FN_NAME "grTexMinAddress"
1397  FxU32 rv;
1398  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_TMU(tmu));
1399  rv = grTexMinAddress(tmu);
1400  TRAP_LOG(GOT "%lu\n", rv);
1401  return rv;
1402 #undef FN_NAME
1403 }
1404
1405 FxU32 FX_CALL trap_grTexMaxAddress (GrChipID_t tmu)
1406 {
1407 #define FN_NAME "grTexMaxAddress"
1408  FxU32 rv;
1409  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_TMU(tmu));
1410  rv = grTexMaxAddress(tmu);
1411  TRAP_LOG(GOT "%lu\n", rv);
1412  return rv;
1413 #undef FN_NAME
1414 }
1415
1416 void FX_CALL trap_grTexNCCTable (GrNCCTable_t table)
1417 {
1418 #define FN_NAME "grTexNCCTable"
1419  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_NCC(table));
1420  grTexNCCTable(table);
1421 #undef FN_NAME
1422 }
1423
1424 void FX_CALL trap_grTexSource (GrChipID_t tmu,
1425                                FxU32      startAddress,
1426                                FxU32      evenOdd,
1427                                GrTexInfo  *info)
1428 {
1429 #define FN_NAME "grTexSource"
1430  TRAP_LOG("%s(%s, %08lx, %s, %p)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_EVENODD(evenOdd), (void *)info);
1431  grTexSource(tmu, startAddress, evenOdd, info);
1432 #undef FN_NAME
1433 }
1434
1435 void FX_CALL trap_grTexClampMode (GrChipID_t           tmu,
1436                                   GrTextureClampMode_t s_clampmode,
1437                                   GrTextureClampMode_t t_clampmode)
1438 {
1439 #define FN_NAME "grTexClampMode"
1440  TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_CLAMPMODE(s_clampmode), TRP_CLAMPMODE(t_clampmode));
1441  grTexClampMode(tmu, s_clampmode, t_clampmode);
1442 #undef FN_NAME
1443 }
1444
1445 void FX_CALL trap_grTexCombine (GrChipID_t          tmu,
1446                                 GrCombineFunction_t rgb_function,
1447                                 GrCombineFactor_t   rgb_factor,
1448                                 GrCombineFunction_t alpha_function,
1449                                 GrCombineFactor_t   alpha_factor,
1450                                 FxBool              rgb_invert,
1451                                 FxBool              alpha_invert)
1452 {
1453 #define FN_NAME "grTexCombine"
1454  TRAP_LOG("%s(%s, %s, %s, %s, %s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_CMBFUNC(rgb_function), TRP_CMBFACT(rgb_factor), TRP_CMBFUNC(alpha_function), TRP_CMBFACT(alpha_factor), TRP_BOOL(rgb_invert), TRP_BOOL(alpha_invert));
1455  grTexCombine(tmu, rgb_function, rgb_factor, alpha_function, alpha_factor, rgb_invert, alpha_invert);
1456 #undef FN_NAME
1457 }
1458
1459 void FX_CALL trap_grTexDetailControl (GrChipID_t tmu,
1460                                       int        lod_bias,
1461                                       FxU8       detail_scale,
1462                                       float      detail_max)
1463 {
1464 #define FN_NAME "grTexDetailControl"
1465  TRAP_LOG("%s(%s, %u, %d, %f)\n", FN_NAME, TRP_TMU(tmu), lod_bias, detail_scale, detail_max);
1466  grTexDetailControl(tmu, lod_bias, detail_scale, detail_max);
1467 #undef FN_NAME
1468 }
1469
1470 void FX_CALL trap_grTexFilterMode (GrChipID_t            tmu,
1471                                    GrTextureFilterMode_t minfilter_mode,
1472                                    GrTextureFilterMode_t magfilter_mode)
1473 {
1474 #define FN_NAME "grTexFilterMode"
1475  TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_TEXFILTER(minfilter_mode), TRP_TEXFILTER(magfilter_mode));
1476  grTexFilterMode(tmu, minfilter_mode, magfilter_mode);
1477 #undef FN_NAME
1478 }
1479
1480 void FX_CALL trap_grTexLodBiasValue (GrChipID_t tmu,
1481                                      float      bias)
1482 {
1483 #define FN_NAME "grTexLodBiasValue"
1484  TRAP_LOG("%s(%s, %f)\n", FN_NAME, TRP_TMU(tmu), bias);
1485  grTexLodBiasValue(tmu, bias);
1486 #undef FN_NAME
1487 }
1488
1489 void FX_CALL trap_grTexDownloadMipMap (GrChipID_t tmu,
1490                                        FxU32      startAddress,
1491                                        FxU32      evenOdd,
1492                                        GrTexInfo  *info)
1493 {
1494 #define FN_NAME "grTexDownloadMipMap"
1495  TRAP_LOG("%s(%s, %08lx, %s, %p)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_EVENODD(evenOdd), (void *)info);
1496  grTexDownloadMipMap(tmu, startAddress, evenOdd, info);
1497 #undef FN_NAME
1498 }
1499
1500 void FX_CALL trap_grTexDownloadMipMapLevel (GrChipID_t        tmu,
1501                                             FxU32             startAddress,
1502                                             GrLOD_t           thisLod,
1503                                             GrLOD_t           largeLod,
1504                                             GrAspectRatio_t   aspectRatio,
1505                                             GrTextureFormat_t format,
1506                                             FxU32             evenOdd,
1507                                             void              *data)
1508 {
1509 #define FN_NAME "grTexDownloadMipMapLevel"
1510  TRAP_LOG("%s(%s, %08lx, %s, %s, %s, %s, %s, %p)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_LODLEVEL(thisLod), TRP_LODLEVEL(largeLod), TRP_ASPECTRATIO(aspectRatio), TRP_TEXFMT(format), TRP_EVENODD(evenOdd), data);
1511  grTexDownloadMipMapLevel(tmu, startAddress, thisLod, largeLod, aspectRatio, format, evenOdd, data);
1512 #undef FN_NAME
1513 }
1514
1515 FxBool FX_CALL trap_grTexDownloadMipMapLevelPartial (GrChipID_t        tmu,
1516                                                      FxU32             startAddress,
1517                                                      GrLOD_t           thisLod,
1518                                                      GrLOD_t           largeLod,
1519                                                      GrAspectRatio_t   aspectRatio,
1520                                                      GrTextureFormat_t format,
1521                                                      FxU32             evenOdd,
1522                                                      void              *data,
1523                                                      int               start,
1524                                                      int               end)
1525 {
1526 #define FN_NAME "grTexDownloadMipMapLevelPartial"
1527  FxBool rv;
1528  TRAP_LOG("%s(%s, %08lx, %s, %s, %s, %s, %s, %p, %d, %d)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_LODLEVEL(thisLod), TRP_LODLEVEL(largeLod), TRP_ASPECTRATIO(aspectRatio), TRP_TEXFMT(format), TRP_EVENODD(evenOdd), data, start, end);
1529  rv = grTexDownloadMipMapLevelPartial(tmu, startAddress, thisLod, largeLod, aspectRatio, format, evenOdd, data, start, end);
1530  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1531  return rv;
1532 #undef FN_NAME
1533 }
1534
1535 void FX_CALL trap_grTexDownloadTable (GrTexTable_t type,
1536                                       void         *data)
1537 {
1538 #define FN_NAME "grTexDownloadTable"
1539  TRAP_LOG("%s(%s, %p)\n", FN_NAME, TRP_TABLE(type), data);
1540  grTexDownloadTable(type, data);
1541 #undef FN_NAME
1542 }
1543
1544 void FX_CALL trap_grTexDownloadTablePartial (GrTexTable_t type,
1545                                              void         *data,
1546                                              int          start,
1547                                              int          end)
1548 {
1549 #define FN_NAME "grTexDownloadTablePartial"
1550  TRAP_LOG("%s(%s, %p, %d, %d)\n", FN_NAME, TRP_TABLE(type), data, start, end);
1551  grTexDownloadTablePartial(type, data, start, end);
1552 #undef FN_NAME
1553 }
1554
1555 void FX_CALL trap_grTexMipMapMode (GrChipID_t     tmu,
1556                                    GrMipMapMode_t mode,
1557                                    FxBool         lodBlend)
1558 {
1559 #define FN_NAME "grTexMipMapMode"
1560  TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_MIPMODE(mode), TRP_BOOL(lodBlend));
1561  grTexMipMapMode(tmu, mode, lodBlend);
1562 #undef FN_NAME
1563 }
1564
1565 void FX_CALL trap_grTexMultibase (GrChipID_t tmu,
1566                                   FxBool     enable)
1567 {
1568 #define FN_NAME "grTexMultibase"
1569  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_BOOL(enable));
1570  grTexMultibase(tmu, enable);
1571 #undef FN_NAME
1572 }
1573
1574 void FX_CALL trap_grTexMultibaseAddress (GrChipID_t       tmu,
1575                                          GrTexBaseRange_t range,
1576                                          FxU32            startAddress,
1577                                          FxU32            evenOdd,
1578                                          GrTexInfo        *info)
1579 {
1580 #define FN_NAME "grTexMultibaseAddress"
1581  TRAP_LOG("%s(%s, %s, %08lx, %s, %p)\n", FN_NAME, TRP_TMU(tmu), TRP_TEXBASERANGE(range), startAddress, TRP_EVENODD(evenOdd), (void *)info);
1582  grTexMultibaseAddress(tmu, range, startAddress, evenOdd, info);
1583 #undef FN_NAME
1584 }
1585
1586 /*
1587 ** linear frame buffer functions
1588 */
1589 FxBool FX_CALL trap_grLfbLock (GrLock_t           type,
1590                                GrBuffer_t         buffer,
1591                                GrLfbWriteMode_t   writeMode,
1592                                GrOriginLocation_t origin,
1593                                FxBool             pixelPipeline,
1594                                GrLfbInfo_t        *info)
1595 {
1596 #define FN_NAME "grLfbLock"
1597  FxBool rv;
1598  TRAP_LOG("%s(%s, %s, %s, %s, %s, %p)\n", FN_NAME, TRP_LOCKTYPE(type), TRP_BUFFER(buffer), TRP_WRITEMODE(writeMode), TRP_ORIGIN(origin), TRP_BOOL(pixelPipeline), (void *)info);
1599  rv = grLfbLock(type, buffer, writeMode, origin, pixelPipeline, info);
1600  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1601  return rv;
1602 #undef FN_NAME
1603 }
1604
1605 FxBool FX_CALL trap_grLfbUnlock (GrLock_t   type,
1606                                  GrBuffer_t buffer)
1607 {
1608 #define FN_NAME "grLfbUnlock"
1609  FxBool rv;
1610  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_LOCKTYPE(type), TRP_BUFFER(buffer));
1611  rv = grLfbUnlock(type, buffer);
1612  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1613  return rv;
1614 #undef FN_NAME
1615 }
1616
1617 void FX_CALL trap_grLfbConstantAlpha (GrAlpha_t alpha)
1618 {
1619 #define FN_NAME "grLfbConstantAlpha"
1620  TRAP_LOG("%s(%02x)\n", FN_NAME, alpha);
1621  grLfbConstantAlpha(alpha);
1622 #undef FN_NAME
1623 }
1624
1625 void FX_CALL trap_grLfbConstantDepth (FxU32 depth)
1626 {
1627 #define FN_NAME "grLfbConstantDepth"
1628  TRAP_LOG("%s(%08lx)\n", FN_NAME, depth);
1629  grLfbConstantDepth(depth);
1630 #undef FN_NAME
1631 }
1632
1633 void FX_CALL trap_grLfbWriteColorSwizzle (FxBool swizzleBytes,
1634                                           FxBool swapWords)
1635 {
1636 #define FN_NAME "grLfbWriteColorSwizzle"
1637  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_BOOL(swizzleBytes), TRP_BOOL(swapWords));
1638  grLfbWriteColorSwizzle(swizzleBytes, swapWords);
1639 #undef FN_NAME
1640 }
1641
1642 void FX_CALL trap_grLfbWriteColorFormat (GrColorFormat_t colorFormat)
1643 {
1644 #define FN_NAME "grLfbWriteColorFormat"
1645  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_COLFMT(colorFormat));
1646  grLfbWriteColorFormat(colorFormat);
1647 #undef FN_NAME
1648 }
1649
1650 FxBool FX_CALL trap_grLfbWriteRegion (GrBuffer_t    dst_buffer,
1651                                       FxU32         dst_x,
1652                                       FxU32         dst_y,
1653                                       GrLfbSrcFmt_t src_format,
1654                                       FxU32         src_width,
1655                                       FxU32         src_height,
1656                                       FxBool        pixelPipeline,
1657                                       FxI32         src_stride,
1658                                       void          *src_data)
1659 {
1660 #define FN_NAME "grLfbWriteRegion"
1661  FxBool rv;
1662  TRAP_LOG("%s(%s, %lu, %lu, %s, %lu, %lu, %s, %ld, %p)\n", FN_NAME, TRP_BUFFER(dst_buffer), dst_x, dst_y, TRP_SRCFMT(src_format), src_width, src_height, TRP_BOOL(pixelPipeline), src_stride, src_data);
1663  rv = grLfbWriteRegion(dst_buffer, dst_x, dst_y, src_format, src_width, src_height, pixelPipeline, src_stride, src_data);
1664  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1665  return rv;
1666 #undef FN_NAME
1667 }
1668
1669 FxBool FX_CALL trap_grLfbReadRegion (GrBuffer_t src_buffer,
1670                                      FxU32      src_x,
1671                                      FxU32      src_y,
1672                                      FxU32      src_width,
1673                                      FxU32      src_height,
1674                                      FxU32      dst_stride,
1675                                      void       *dst_data)
1676 {
1677 #define FN_NAME "grLfbReadRegion"
1678  FxBool rv;
1679  TRAP_LOG("%s(%s, %lu, %lu, %lu, %lu, %ld, %p)\n", FN_NAME, TRP_BUFFER(src_buffer), src_x, src_y, src_width, src_height, dst_stride, dst_data);
1680  rv = grLfbReadRegion(src_buffer, src_x, src_y, src_width, src_height, dst_stride, dst_data);
1681  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1682  return rv;
1683 #undef FN_NAME
1684 }
1685
1686 /*
1687 ** glide management functions
1688 */
1689 void FX_CALL trap_grGlideInit (void)
1690 {
1691 #define FN_NAME "grGlideInit"
1692  TRAP_LOG("%s()\n", FN_NAME);
1693  grGlideInit();
1694 #undef FN_NAME
1695 }
1696
1697 void FX_CALL trap_grGlideShutdown (void)
1698 {
1699 #define FN_NAME "grGlideShutdown"
1700  TRAP_LOG("%s()\n", FN_NAME);
1701  grGlideShutdown();
1702 #undef FN_NAME
1703 }
1704
1705 void FX_CALL trap_grGlideGetState (void *state)
1706 {
1707 #define FN_NAME "grGlideGetState"
1708  TRAP_LOG("%s(%p)\n", FN_NAME, state);
1709  grGlideGetState(state);
1710 #undef FN_NAME
1711 }
1712
1713 void FX_CALL trap_grGlideSetState (const void *state)
1714 {
1715 #define FN_NAME "grGlideSetState"
1716  TRAP_LOG("%s(%p)\n", FN_NAME, state);
1717  grGlideSetState(state);
1718 #undef FN_NAME
1719 }
1720
1721 void FX_CALL trap_grGlideGetVertexLayout (void *layout)
1722 {
1723 #define FN_NAME "grGlideGetVertexLayout"
1724  TRAP_LOG("%s(%p)\n", FN_NAME, layout);
1725  grGlideGetVertexLayout(layout);
1726 #undef FN_NAME
1727 }
1728
1729 void FX_CALL trap_grGlideSetVertexLayout (const void *layout)
1730 {
1731 #define FN_NAME "grGlideSetVertexLayout"
1732  TRAP_LOG("%s(%p)\n", FN_NAME, layout);
1733  grGlideSetVertexLayout(layout);
1734 #undef FN_NAME
1735 }
1736
1737 /*
1738 ** glide utility functions
1739 */
1740 void FX_CALL trap_guGammaCorrectionRGB (FxFloat red,
1741                                         FxFloat green,
1742                                         FxFloat blue)
1743 {
1744 #define FN_NAME "guGammaCorrectionRGB"
1745  TRAP_LOG("%s(%f, %f, %f)\n", FN_NAME, red, green, blue);
1746  guGammaCorrectionRGB(red, green, blue);
1747 #undef FN_NAME
1748 }
1749
1750 float FX_CALL trap_guFogTableIndexToW (int i)
1751 {
1752 #define FN_NAME "guFogTableIndexToW"
1753  float rv;
1754  TRAP_LOG("%s(%d)\n", FN_NAME, i);
1755  rv = guFogTableIndexToW(i);
1756  TRAP_LOG(GOT "%f\n", rv);
1757  return rv;
1758 #undef FN_NAME
1759 }
1760
1761 void FX_CALL trap_guFogGenerateExp (GrFog_t *fogtable,
1762                                     float   density)
1763 {
1764 #define FN_NAME "guFogGenerateExp"
1765  TRAP_LOG("%s(%p, %f)\n", FN_NAME, fogtable, density);
1766  guFogGenerateExp(fogtable, density);
1767 #undef FN_NAME
1768 }
1769
1770 void FX_CALL trap_guFogGenerateExp2 (GrFog_t *fogtable,
1771                                      float   density)
1772 {
1773 #define FN_NAME "guFogGenerateExp2"
1774  TRAP_LOG("%s(%p, %f)\n", FN_NAME, fogtable, density);
1775  guFogGenerateExp2(fogtable, density);
1776 #undef FN_NAME
1777 }
1778
1779 void FX_CALL trap_guFogGenerateLinear (GrFog_t *fogtable,
1780                                        float   nearZ,
1781                                        float   farZ)
1782 {
1783 #define FN_NAME "guFogGenerateLinear"
1784  TRAP_LOG("%s(%p, %f, %f)\n", FN_NAME, fogtable, nearZ, farZ);
1785  guFogGenerateLinear(fogtable, nearZ, farZ);
1786 #undef FN_NAME
1787 }
1788
1789 /*
1790 ** glide extensions
1791 */
1792 char *FX_CALL trap_grGetRegistryOrEnvironmentStringExt (char *theEntry)
1793 {
1794 #define FN_NAME "grGetRegistryOrEnvironmentStringExt"
1795  char *rv;
1796  TRAP_LOG("%s(\"%s\")\n", FN_NAME, theEntry);
1797  assert(real_grGetRegistryOrEnvironmentStringExt);
1798  rv = (*real_grGetRegistryOrEnvironmentStringExt)(theEntry);
1799  if (rv) {
1800     TRAP_LOG(GOT "\"%s\"\n", rv);
1801  } else {
1802     TRAP_LOG(GOT "NULL\n");
1803  }
1804  return rv;
1805 #undef FN_NAME
1806 }
1807
1808 void FX_CALL trap_grGetGammaTableExt (FxU32 nentries,
1809                                       FxU32 *red,
1810                                       FxU32 *green,
1811                                       FxU32 *blue)
1812 {
1813 #define FN_NAME "grGetGammaTableExt"
1814  TRAP_LOG("%s(%lu, %p, %p, %p)\n", FN_NAME, nentries, (void *)red, (void *)green, (void *)blue);
1815  assert(real_grGetGammaTableExt);
1816  (*real_grGetGammaTableExt)(nentries, red, green, blue);
1817 #undef FN_NAME
1818 }
1819
1820 void FX_CALL trap_grChromaRangeModeExt (GrChromakeyMode_t mode)
1821 {
1822 #define FN_NAME "grChromaRangeModeExt"
1823  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CKMODE(mode));
1824  assert(real_grChromaRangeModeExt);
1825  (*real_grChromaRangeModeExt)(mode);
1826 #undef FN_NAME
1827 }
1828
1829 void FX_CALL trap_grChromaRangeExt (GrColor_t           color,
1830                                     GrColor_t           range,
1831                                     GrChromaRangeMode_t match_mode)
1832 {
1833 #define FN_NAME "grChromaRangeExt"
1834  TRAP_LOG("%s(%08lx, %08lx, %s)\n", FN_NAME, color, range, TRP_CRMODE(match_mode));
1835  assert(real_grChromaRangeExt);
1836  (*real_grChromaRangeExt)(color, range, match_mode);
1837 #undef FN_NAME
1838 }
1839
1840 void FX_CALL trap_grTexChromaModeExt (GrChipID_t        tmu,
1841                                       GrChromakeyMode_t mode)
1842 {
1843 #define FN_NAME "grTexChromaModeExt"
1844  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_CKMODE(mode));
1845  assert(real_grTexChromaModeExt);
1846  (*real_grTexChromaModeExt)(tmu, mode);
1847 #undef FN_NAME
1848 }
1849
1850 void FX_CALL trap_grTexChromaRangeExt (GrChipID_t           tmu,
1851                                        GrColor_t            min,
1852                                        GrColor_t            max,
1853                                        GrTexChromakeyMode_t mode)
1854 {
1855 #define FN_NAME "grTexChromaRangeExt"
1856  TRAP_LOG("%s(%s, %08lx, %08lx, %s)\n", FN_NAME, TRP_TMU(tmu), min, max, TRP_CRMODE(mode));
1857  assert(real_grTexChromaRangeExt);
1858  (*real_grTexChromaRangeExt)(tmu, min, max, mode);
1859 #undef FN_NAME
1860 }
1861
1862         /* tbext */
1863 void FX_CALL trap_grTextureBufferExt (GrChipID_t        tmu,
1864                                       FxU32             startAddress,
1865                                       GrLOD_t           thisLOD,
1866                                       GrLOD_t           largeLOD,
1867                                       GrAspectRatio_t   aspectRatio,
1868                                       GrTextureFormat_t format,
1869                                       FxU32             odd_even_mask)
1870 {
1871 #define FN_NAME "grTextureBufferExt"
1872  TRAP_LOG("%s(%s, %08lx, %s, %s, %s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_LODLEVEL(thisLOD), TRP_LODLEVEL(largeLOD), TRP_ASPECTRATIO(aspectRatio), TRP_TEXFMT(format), TRP_EVENODD(odd_even_mask));
1873  assert(real_grTextureBufferExt);
1874  (*real_grTextureBufferExt)(tmu, startAddress, thisLOD, largeLOD, aspectRatio, format, odd_even_mask);
1875 #undef FN_NAME
1876 }
1877
1878 void FX_CALL trap_grTextureAuxBufferExt (GrChipID_t        tmu,
1879                                          FxU32             startAddress,
1880                                          GrLOD_t           thisLOD,
1881                                          GrLOD_t           largeLOD,
1882                                          GrAspectRatio_t   aspectRatio,
1883                                          GrTextureFormat_t format,
1884                                          FxU32             odd_even_mask)
1885 {
1886 #define FN_NAME "grTextureAuxBufferExt"
1887  TRAP_LOG("%s(%s, %08lx, %s, %s, %s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_LODLEVEL(thisLOD), TRP_LODLEVEL(largeLOD), TRP_ASPECTRATIO(aspectRatio), TRP_TEXFMT(format), TRP_EVENODD(odd_even_mask));
1888  assert(real_grTextureAuxBufferExt);
1889  (*real_grTextureAuxBufferExt)(tmu, startAddress, thisLOD, largeLOD, aspectRatio, format, odd_even_mask);
1890 #undef FN_NAME
1891 }
1892
1893 void FX_CALL trap_grAuxBufferExt (GrBuffer_t buffer)
1894 {
1895 #define FN_NAME "grAuxBufferExt"
1896  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BUFFER(buffer));
1897  assert(real_grAuxBufferExt);
1898  (*real_grAuxBufferExt)(buffer);
1899 #undef FN_NAME
1900 }
1901
1902         /* napalm */
1903 GrContext_t FX_CALL trap_grSstWinOpenExt (FxU32                hWnd,
1904                                           GrScreenResolution_t resolution,
1905                                           GrScreenRefresh_t    refresh,
1906                                           GrColorFormat_t      format,
1907                                           GrOriginLocation_t   origin,
1908                                           GrPixelFormat_t      pixelformat,
1909                                           int                  nColBuffers,
1910                                           int                  nAuxBuffers)
1911 {
1912 #define FN_NAME "grSstWinOpenExt"
1913  GrContext_t rv;
1914  TRAP_LOG("%s(%08lx, %s, %s, %s, %s, %s, %d, %d)\n", FN_NAME, hWnd, TRP_RESOLUTION(resolution), TRP_REFRESH(refresh), TRP_COLFMT(format), TRP_ORIGIN(origin), TRP_PIXFMT(pixelformat), nColBuffers, nAuxBuffers);
1915  assert(real_grSstWinOpenExt);
1916  rv = (*real_grSstWinOpenExt)(hWnd, resolution, refresh, format, origin, pixelformat, nColBuffers, nAuxBuffers);
1917  TRAP_LOG(GOT "%p\n", (void *)rv);
1918  return rv;
1919 #undef FN_NAME
1920 }
1921
1922 void FX_CALL trap_grStencilFuncExt (GrCmpFnc_t  fnc,
1923                                     GrStencil_t ref,
1924                                     GrStencil_t mask)
1925 {
1926 #define FN_NAME "grStencilFuncExt"
1927  TRAP_LOG("%s(%s, %02x, %02x)\n", FN_NAME, TRP_CMPFUNC(fnc), ref, mask);
1928  assert(real_grStencilFuncExt);
1929  (*real_grStencilFuncExt)(fnc, ref, mask);
1930 #undef FN_NAME
1931 }
1932
1933 void FX_CALL trap_grStencilMaskExt (GrStencil_t value)
1934 {
1935 #define FN_NAME "grStencilMaskExt"
1936  TRAP_LOG("%s(%02x)\n", FN_NAME, value);
1937  assert(real_grStencilMaskExt);
1938  (*real_grStencilMaskExt)(value);
1939 #undef FN_NAME
1940 }
1941
1942 void FX_CALL trap_grStencilOpExt (GrStencilOp_t stencil_fail,
1943                                   GrStencilOp_t depth_fail,
1944                                   GrStencilOp_t depth_pass)
1945 {
1946 #define FN_NAME "grStencilOpExt"
1947  TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_STENCILOP(stencil_fail), TRP_STENCILOP(depth_fail), TRP_STENCILOP(depth_pass));
1948  assert(real_grStencilOpExt);
1949  (*real_grStencilOpExt)(stencil_fail, depth_fail, depth_pass);
1950 #undef FN_NAME
1951 }
1952
1953 void FX_CALL trap_grLfbConstantStencilExt (GrStencil_t value)
1954 {
1955 #define FN_NAME "grLfbConstantStencilExt"
1956  TRAP_LOG("%s(%02x)\n", FN_NAME, value);
1957  assert(real_grLfbConstantStencilExt);
1958  (*real_grLfbConstantStencilExt)(value);
1959 #undef FN_NAME
1960 }
1961
1962 void FX_CALL trap_grBufferClearExt (GrColor_t   color,
1963                                     GrAlpha_t   alpha,
1964                                     FxU32       depth,
1965                                     GrStencil_t stencil)
1966 {
1967 #define FN_NAME "grBufferClearExt"
1968  TRAP_LOG("%s(%08lx, %02x, %08lx, %02x)\n", FN_NAME, color, alpha, depth, stencil);
1969  assert(real_grBufferClearExt);
1970  (*real_grBufferClearExt)(color, alpha, depth, stencil);
1971 #undef FN_NAME
1972 }
1973
1974 void FX_CALL trap_grColorCombineExt (GrCCUColor_t    a,
1975                                      GrCombineMode_t a_mode,
1976                                      GrCCUColor_t    b,
1977                                      GrCombineMode_t b_mode,
1978                                      GrCCUColor_t    c,
1979                                      FxBool          c_invert,
1980                                      GrCCUColor_t    d,
1981                                      FxBool          d_invert,
1982                                      FxU32           shift,
1983                                      FxBool          invert)
1984 {
1985 #define FN_NAME "grColorCombineExt"
1986  TRAP_LOG("%s(%s, %s, %s, %s, %s, %s, %s, %s, %lu, %s)\n", FN_NAME, TRP_CU(a), TRP_CMBMODE(a_mode), TRP_CU(b), TRP_CMBMODE(b_mode), TRP_CU(c), TRP_BOOL(c_invert), TRP_CU(d), TRP_BOOL(d_invert), shift, TRP_BOOL(invert));
1987  assert(real_grColorCombineExt);
1988  (*real_grColorCombineExt)(a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
1989 #undef FN_NAME
1990 }
1991
1992 void FX_CALL trap_grAlphaCombineExt (GrACUColor_t    a,
1993                                      GrCombineMode_t a_mode,
1994                                      GrACUColor_t    b,
1995                                      GrCombineMode_t b_mode,
1996                                      GrACUColor_t    c,
1997                                      FxBool          c_invert,
1998                                      GrACUColor_t    d,
1999                                      FxBool          d_invert,
2000                                      FxU32           shift,
2001                                      FxBool          invert)
2002 {
2003 #define FN_NAME "grAlphaCombineExt"
2004  TRAP_LOG("%s(%s, %s, %s, %s, %s, %s, %s, %s, %lu, %s)\n", FN_NAME, TRP_CU(a), TRP_CMBMODE(a_mode), TRP_CU(b), TRP_CMBMODE(b_mode), TRP_CU(c), TRP_BOOL(c_invert), TRP_CU(d), TRP_BOOL(d_invert), shift, TRP_BOOL(invert));
2005  assert(real_grAlphaCombineExt);
2006  (*real_grAlphaCombineExt)(a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
2007 #undef FN_NAME
2008 }
2009
2010 void FX_CALL trap_grTexColorCombineExt (GrChipID_t      tmu,
2011                                         GrTCCUColor_t   a,
2012                                         GrCombineMode_t a_mode,
2013                                         GrTCCUColor_t   b,
2014                                         GrCombineMode_t b_mode,
2015                                         GrTCCUColor_t   c,
2016                                         FxBool          c_invert,
2017                                         GrTCCUColor_t   d,
2018                                         FxBool          d_invert,
2019                                         FxU32           shift,
2020                                         FxBool          invert)
2021 {
2022 #define FN_NAME "grTexColorCombineExt"
2023  TRAP_LOG("%s(%s, %s, %s, %s, %s, %s, %s, %s, %s, %lu, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_CU(a), TRP_CMBMODE(a_mode), TRP_CU(b), TRP_CMBMODE(b_mode), TRP_CU(c), TRP_BOOL(c_invert), TRP_CU(d), TRP_BOOL(d_invert), shift, TRP_BOOL(invert));
2024  assert(real_grTexColorCombineExt);
2025  (*real_grTexColorCombineExt)(tmu, a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
2026 #undef FN_NAME
2027 }
2028
2029 void FX_CALL trap_grTexAlphaCombineExt (GrChipID_t      tmu,
2030                                         GrTACUColor_t   a,
2031                                         GrCombineMode_t a_mode,
2032                                         GrTACUColor_t   b,
2033                                         GrCombineMode_t b_mode,
2034                                         GrTACUColor_t   c,
2035                                         FxBool          c_invert,
2036                                         GrTACUColor_t   d,
2037                                         FxBool          d_invert,
2038                                         FxU32           shift,
2039                                         FxBool          invert)
2040 {
2041 #define FN_NAME "grTexAlphaCombineExt"
2042  TRAP_LOG("%s(%s, %s, %s, %s, %s, %s, %s, %s, %s, %lu, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_CU(a), TRP_CMBMODE(a_mode), TRP_CU(b), TRP_CMBMODE(b_mode), TRP_CU(c), TRP_BOOL(c_invert), TRP_CU(d), TRP_BOOL(d_invert), shift, TRP_BOOL(invert));
2043  assert(real_grTexAlphaCombineExt);
2044  (*real_grTexAlphaCombineExt)(tmu, a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
2045 #undef FN_NAME
2046 }
2047
2048 void FX_CALL trap_grConstantColorValueExt (GrChipID_t tmu,
2049                                            GrColor_t  value)
2050 {
2051 #define FN_NAME "grConstantColorValueExt"
2052  TRAP_LOG("%s(%s, %08lx)\n", FN_NAME, TRP_TMU(tmu), value);
2053  assert(real_grConstantColorValueExt);
2054  (*real_grConstantColorValueExt)(tmu, value);
2055 #undef FN_NAME
2056 }
2057
2058 void FX_CALL trap_grColorMaskExt (FxBool r,
2059                                   FxBool g,
2060                                   FxBool b,
2061                                   FxBool a)
2062 {
2063 #define FN_NAME "grColorMaskExt"
2064  TRAP_LOG("%s(%s, %s, %s, %s)\n", FN_NAME, TRP_BOOL(r), TRP_BOOL(g), TRP_BOOL(b), TRP_BOOL(a));
2065  assert(real_grColorMaskExt);
2066  (*real_grColorMaskExt)(r, g, b, a);
2067 #undef FN_NAME
2068 }
2069
2070 void FX_CALL trap_grAlphaBlendFunctionExt (GrAlphaBlendFnc_t rgb_sf,
2071                                            GrAlphaBlendFnc_t rgb_df,
2072                                            GrAlphaBlendOp_t  rgb_op,
2073                                            GrAlphaBlendFnc_t alpha_sf,
2074                                            GrAlphaBlendFnc_t alpha_df,
2075                                            GrAlphaBlendOp_t  alpha_op)
2076 {
2077 #define FN_NAME "grAlphaBlendFunctionExt"
2078  TRAP_LOG("%s(%s, %s, %s, %s, %s, %s)\n", FN_NAME, TRP_BLEND(rgb_sf), TRP_BLEND(rgb_df), TRP_BLENDOP(rgb_op), TRP_BLEND(alpha_sf), TRP_BLEND(alpha_df), TRP_BLENDOP(alpha_op));
2079  assert(real_grAlphaBlendFunctionExt);
2080  (*real_grAlphaBlendFunctionExt)(rgb_sf, rgb_df, rgb_op, alpha_sf, alpha_df, alpha_op);
2081 #undef FN_NAME
2082 }
2083
2084 void FX_CALL trap_grTBufferWriteMaskExt (FxU32 tmask)
2085 {
2086 #define FN_NAME "grTBufferWriteMaskExt"
2087  TRAP_LOG("%s(%08lx)\n", FN_NAME, tmask);
2088  assert(real_grTBufferWriteMaskExt);
2089  (*real_grTBufferWriteMaskExt)(tmask);
2090 #undef FN_NAME
2091 }
2092 #endif
2093
2094
2095
2096 /****************************************************************************\
2097 * interface
2098 \****************************************************************************/
2099 void tdfx_hook_glide (struct tdfx_glide *Glide)
2100 {
2101 #if DEBUG_TRAP
2102 #define GET_EXT_ADDR(name)  *(GrProc *)&real_##name = grGetProcAddress(#name), Glide->name = trap_##name
2103 #else  /* DEBUG_TRAP */
2104 #define GET_EXT_ADDR(name)  *(GrProc *)&Glide->name = grGetProcAddress(#name)
2105 #endif /* DEBUG_TRAP */
2106
2107  /*
2108  ** glide extensions
2109  */
2110  GET_EXT_ADDR(grGetRegistryOrEnvironmentStringExt);
2111  GET_EXT_ADDR(grGetGammaTableExt);
2112  GET_EXT_ADDR(grChromaRangeModeExt);
2113  GET_EXT_ADDR(grChromaRangeExt);
2114  GET_EXT_ADDR(grTexChromaModeExt);
2115  GET_EXT_ADDR(grTexChromaRangeExt);
2116  /* tbext */
2117  GET_EXT_ADDR(grTextureBufferExt);
2118  GET_EXT_ADDR(grTextureAuxBufferExt);
2119  GET_EXT_ADDR(grAuxBufferExt);
2120  /* napalm */
2121  GET_EXT_ADDR(grSstWinOpenExt);
2122  GET_EXT_ADDR(grStencilFuncExt);
2123  GET_EXT_ADDR(grStencilMaskExt);
2124  GET_EXT_ADDR(grStencilOpExt);
2125  GET_EXT_ADDR(grLfbConstantStencilExt);
2126  GET_EXT_ADDR(grBufferClearExt);
2127  GET_EXT_ADDR(grColorCombineExt);
2128  GET_EXT_ADDR(grAlphaCombineExt);
2129  GET_EXT_ADDR(grTexColorCombineExt);
2130  GET_EXT_ADDR(grTexAlphaCombineExt);
2131  GET_EXT_ADDR(grConstantColorValueExt);
2132  GET_EXT_ADDR(grColorMaskExt);
2133  GET_EXT_ADDR(grAlphaBlendFunctionExt);
2134  GET_EXT_ADDR(grTBufferWriteMaskExt);
2135
2136 #undef GET_EXT_ADDR
2137 }
2138
2139 #endif /* FX */