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
  34 #include <stdio.h>
  35 #include <stdarg.h>
  36 #include <assert.h>
  37
  38 #define DEBUG_TRAP_internal
  39 #include "fxg.h"
  40
  41
  42
  43 /****************************************************************************\
  44 * logging                                                                    *
  45 \****************************************************************************/
  46 #if DEBUG_TRAP
  47 #define TRAP_LOG trap_printf
  48 #ifdef __GNUC__
  49 __attribute__ ((format(printf, 1, 2)))
  50 #endif /* __GNUC__ */
  51 int trap_printf (const char *format, ...)
  52 {
  53  va_list arg;
  54  int n;
  55  FILE *trap_file;
  56  va_start(arg, format);
  57  trap_file = fopen("trap.log", "a");
  58  if (trap_file == NULL) {
  59     trap_file = stderr;
  60  }
  61  n = vfprintf(trap_file, format, arg);
  62  fclose(trap_file);
  63  va_end(arg);
  64  return n;
  65 }
  66 #else  /* DEBUG_TRAP */
  67 #ifdef __GNUC__
  68 #define TRAP_LOG(format, ...) do {} while (0)
  69 #else  /* __GNUC__ */
  70 #define TRAP_LOG              0 && (unsigned long)
  71 #endif /* __GNUC__ */
  72 #endif /* DEBUG_TRAP */
  73
  74
  75
  76 #if DEBUG_TRAP
  77 /****************************************************************************\
  78 * helpers                                                                    *
  79 \****************************************************************************/
  80
  81 #define GOT "\t"
  82
  83 const char *TRP_BOOL (FxBool b)
  84 {
  85  return b ? "FXTRUE" : "FXFALSE";
  86 }
  87
  88 #define TRAP_CASE_STRING(name) case name: return #name
  89 #define TRAP_NODEFAULT default: assert(0)
  90
  91 const char *TRP_PARAM (FxU32 mode)
  92 {
  93  switch (mode) {
  94         TRAP_CASE_STRING(GR_PARAM_DISABLE);
  95         TRAP_CASE_STRING(GR_PARAM_ENABLE);
  96         TRAP_NODEFAULT;
  97  }
  98 }
  99
 100 const char *TRP_VTX (FxU32 param)
 101 {
 102  switch (param) {
 103         TRAP_CASE_STRING(GR_PARAM_XY);
 104         TRAP_CASE_STRING(GR_PARAM_Z);
 105         TRAP_CASE_STRING(GR_PARAM_W);
 106         TRAP_CASE_STRING(GR_PARAM_Q);
 107         TRAP_CASE_STRING(GR_PARAM_FOG_EXT);
 108         TRAP_CASE_STRING(GR_PARAM_A);
 109         TRAP_CASE_STRING(GR_PARAM_RGB);
 110         TRAP_CASE_STRING(GR_PARAM_PARGB);
 111         TRAP_CASE_STRING(GR_PARAM_ST0);
 112         TRAP_CASE_STRING(GR_PARAM_ST1);
 113         TRAP_CASE_STRING(GR_PARAM_ST2);
 114         TRAP_CASE_STRING(GR_PARAM_Q0);
 115         TRAP_CASE_STRING(GR_PARAM_Q1);
 116         TRAP_CASE_STRING(GR_PARAM_Q2);
 117         TRAP_NODEFAULT;
 118  }
 119 }
 120
 121 const char *TRP_ARRAY (FxU32 mode)
 122 {
 123  switch (mode) {
 124         TRAP_CASE_STRING(GR_POINTS);
 125         TRAP_CASE_STRING(GR_LINE_STRIP);
 126         TRAP_CASE_STRING(GR_LINES);
 127         TRAP_CASE_STRING(GR_POLYGON);
 128         TRAP_CASE_STRING(GR_TRIANGLE_STRIP);
 129         TRAP_CASE_STRING(GR_TRIANGLE_FAN);
 130         TRAP_CASE_STRING(GR_TRIANGLES);
 131         TRAP_CASE_STRING(GR_TRIANGLE_STRIP_CONTINUE);
 132         TRAP_CASE_STRING(GR_TRIANGLE_FAN_CONTINUE);
 133         TRAP_NODEFAULT;
 134  }
 135 }
 136
 137 const char *TRP_BUFFER (GrBuffer_t buffer)
 138 {
 139  switch (buffer) {
 140         TRAP_CASE_STRING(GR_BUFFER_FRONTBUFFER);
 141         TRAP_CASE_STRING(GR_BUFFER_BACKBUFFER);
 142         TRAP_CASE_STRING(GR_BUFFER_AUXBUFFER);
 143         TRAP_CASE_STRING(GR_BUFFER_DEPTHBUFFER);
 144         TRAP_CASE_STRING(GR_BUFFER_ALPHABUFFER);
 145         TRAP_CASE_STRING(GR_BUFFER_TRIPLEBUFFER);
 146         TRAP_CASE_STRING(GR_BUFFER_TEXTUREBUFFER_EXT);
 147         TRAP_CASE_STRING(GR_BUFFER_TEXTUREAUXBUFFER_EXT);
 148         TRAP_NODEFAULT;
 149  }
 150 }
 151
 152 const char *TRP_ORIGIN (GrOriginLocation_t origin_location)
 153 {
 154  switch (origin_location) {
 155         TRAP_CASE_STRING(GR_ORIGIN_UPPER_LEFT);
 156         TRAP_CASE_STRING(GR_ORIGIN_LOWER_LEFT);
 157         TRAP_CASE_STRING(GR_ORIGIN_ANY);
 158         TRAP_NODEFAULT;
 159  }
 160 }
 161
 162 const char *TRP_REFRESH (GrScreenRefresh_t refresh_rate)
 163 {
 164  switch (refresh_rate) {
 165         TRAP_CASE_STRING(GR_REFRESH_60Hz);
 166         TRAP_CASE_STRING(GR_REFRESH_70Hz);
 167         TRAP_CASE_STRING(GR_REFRESH_72Hz);
 168         TRAP_CASE_STRING(GR_REFRESH_75Hz);
 169         TRAP_CASE_STRING(GR_REFRESH_80Hz);
 170         TRAP_CASE_STRING(GR_REFRESH_90Hz);
 171         TRAP_CASE_STRING(GR_REFRESH_100Hz);
 172         TRAP_CASE_STRING(GR_REFRESH_85Hz);
 173         TRAP_CASE_STRING(GR_REFRESH_120Hz);
 174         TRAP_CASE_STRING(GR_REFRESH_NONE);
 175         TRAP_NODEFAULT;
 176  }
 177 }
 178
 179 const char *TRP_COLFMT (GrColorFormat_t color_format)
 180 {
 181  switch (color_format) {
 182         TRAP_CASE_STRING(GR_COLORFORMAT_ARGB);
 183         TRAP_CASE_STRING(GR_COLORFORMAT_ABGR);
 184         TRAP_CASE_STRING(GR_COLORFORMAT_RGBA);
 185         TRAP_CASE_STRING(GR_COLORFORMAT_BGRA);
 186         TRAP_NODEFAULT;
 187  }
 188 }
 189
 190 const char *TRP_RESOLUTION (GrScreenResolution_t screen_resolution)
 191 {
 192  switch (screen_resolution) {
 193         TRAP_CASE_STRING(GR_RESOLUTION_320x200);
 194         TRAP_CASE_STRING(GR_RESOLUTION_320x240);
 195         TRAP_CASE_STRING(GR_RESOLUTION_400x256);
 196         TRAP_CASE_STRING(GR_RESOLUTION_512x384);
 197         TRAP_CASE_STRING(GR_RESOLUTION_640x200);
 198         TRAP_CASE_STRING(GR_RESOLUTION_640x350);
 199         TRAP_CASE_STRING(GR_RESOLUTION_640x400);
 200         TRAP_CASE_STRING(GR_RESOLUTION_640x480);
 201         TRAP_CASE_STRING(GR_RESOLUTION_800x600);
 202         TRAP_CASE_STRING(GR_RESOLUTION_960x720);
 203         TRAP_CASE_STRING(GR_RESOLUTION_856x480);
 204         TRAP_CASE_STRING(GR_RESOLUTION_512x256);
 205         TRAP_CASE_STRING(GR_RESOLUTION_1024x768);
 206         TRAP_CASE_STRING(GR_RESOLUTION_1280x1024);
 207         TRAP_CASE_STRING(GR_RESOLUTION_1600x1200);
 208         TRAP_CASE_STRING(GR_RESOLUTION_400x300);
 209         TRAP_CASE_STRING(GR_RESOLUTION_1152x864);
 210         TRAP_CASE_STRING(GR_RESOLUTION_1280x960);
 211         TRAP_CASE_STRING(GR_RESOLUTION_1600x1024);
 212         TRAP_CASE_STRING(GR_RESOLUTION_1792x1344);
 213         TRAP_CASE_STRING(GR_RESOLUTION_1856x1392);
 214         TRAP_CASE_STRING(GR_RESOLUTION_1920x1440);
 215         TRAP_CASE_STRING(GR_RESOLUTION_2048x1536);
 216         TRAP_CASE_STRING(GR_RESOLUTION_2048x2048);
 217         TRAP_CASE_STRING(GR_RESOLUTION_NONE);
 218         TRAP_NODEFAULT;
 219  }
 220 }
 221
 222 const char *TRP_BLEND (GrAlphaBlendFnc_t func)
 223 {
 224  switch (func) {
 225         TRAP_CASE_STRING(GR_BLEND_ZERO);
 226         TRAP_CASE_STRING(GR_BLEND_SRC_ALPHA);
 227         TRAP_CASE_STRING(GR_BLEND_SRC_COLOR);
 228         /*TRAP_CASE_STRING(GR_BLEND_DST_COLOR); ==GR_BLEND_SRC_COLOR*/
 229         TRAP_CASE_STRING(GR_BLEND_DST_ALPHA);
 230         TRAP_CASE_STRING(GR_BLEND_ONE);
 231         TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SRC_ALPHA);
 232         TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SRC_COLOR);
 233         /*TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_DST_COLOR); ==GR_BLEND_ONE_MINUS_SRC_COLOR*/
 234         TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_DST_ALPHA);
 235         TRAP_CASE_STRING(GR_BLEND_RESERVED_8);
 236         TRAP_CASE_STRING(GR_BLEND_RESERVED_9);
 237         TRAP_CASE_STRING(GR_BLEND_RESERVED_A);
 238         TRAP_CASE_STRING(GR_BLEND_RESERVED_B);
 239         TRAP_CASE_STRING(GR_BLEND_RESERVED_C);
 240         TRAP_CASE_STRING(GR_BLEND_RESERVED_D);
 241         TRAP_CASE_STRING(GR_BLEND_RESERVED_E);
 242         TRAP_CASE_STRING(GR_BLEND_ALPHA_SATURATE);
 243         /*TRAP_CASE_STRING(GR_BLEND_PREFOG_COLOR); ==GR_BLEND_ALPHA_SATURATE*/
 244         TRAP_CASE_STRING(GR_BLEND_SAME_COLOR_EXT);
 245         TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SAME_COLOR_EXT);
 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_NODEFAULT;
 737  }
 738 }
 739
 740 const char *TRP_CU (GrCCUColor_t a)
 741 {
 742  switch (a) {
 743         TRAP_CASE_STRING(GR_CMBX_ZERO);
 744         TRAP_CASE_STRING(GR_CMBX_TEXTURE_ALPHA);
 745         TRAP_CASE_STRING(GR_CMBX_ALOCAL);
 746         TRAP_CASE_STRING(GR_CMBX_AOTHER);
 747         TRAP_CASE_STRING(GR_CMBX_B);
 748         TRAP_CASE_STRING(GR_CMBX_CONSTANT_ALPHA);
 749         TRAP_CASE_STRING(GR_CMBX_CONSTANT_COLOR);
 750         TRAP_CASE_STRING(GR_CMBX_DETAIL_FACTOR);
 751         TRAP_CASE_STRING(GR_CMBX_ITALPHA);
 752         TRAP_CASE_STRING(GR_CMBX_ITRGB);
 753         TRAP_CASE_STRING(GR_CMBX_LOCAL_TEXTURE_ALPHA);
 754         TRAP_CASE_STRING(GR_CMBX_LOCAL_TEXTURE_RGB);
 755         TRAP_CASE_STRING(GR_CMBX_LOD_FRAC);
 756         TRAP_CASE_STRING(GR_CMBX_OTHER_TEXTURE_ALPHA);
 757         TRAP_CASE_STRING(GR_CMBX_OTHER_TEXTURE_RGB);
 758         TRAP_CASE_STRING(GR_CMBX_TEXTURE_RGB);
 759         TRAP_CASE_STRING(GR_CMBX_TMU_CALPHA);
 760         TRAP_CASE_STRING(GR_CMBX_TMU_CCOLOR);
 761         TRAP_NODEFAULT;
 762  }
 763 }
 764
 765 const char *TRP_CMBMODE (GrCombineMode_t a_mode)
 766 {
 767  switch (a_mode) {
 768         TRAP_CASE_STRING(GR_FUNC_MODE_ZERO);
 769         TRAP_CASE_STRING(GR_FUNC_MODE_X);
 770         TRAP_CASE_STRING(GR_FUNC_MODE_ONE_MINUS_X);
 771         TRAP_CASE_STRING(GR_FUNC_MODE_NEGATIVE_X);
 772         TRAP_CASE_STRING(GR_FUNC_MODE_X_MINUS_HALF);
 773         TRAP_NODEFAULT;
 774  }
 775 }
 776
 777 const char *TRP_TMU (GrChipID_t tmu)
 778 {
 779  switch (tmu) {
 780         TRAP_CASE_STRING(GR_TMU0);
 781         TRAP_CASE_STRING(GR_TMU1);
 782         TRAP_NODEFAULT;
 783  }
 784 }
 785
 786
 787
 788 /****************************************************************************\
 789 * REAL POINTERS                                                              *
 790 \****************************************************************************/
 791
 792 /*
 793 ** glide extensions
 794 */
 795 char * (FX_CALL *real_grGetRegistryOrEnvironmentStringExt) (char *theEntry);
 796 void (FX_CALL *real_grGetGammaTableExt) (FxU32 nentries, FxU32 *red, FxU32 *green, FxU32 *blue);
 797 void (FX_CALL *real_grChromaRangeModeExt) (GrChromakeyMode_t mode);
 798 void (FX_CALL *real_grChromaRangeExt) (GrColor_t color, GrColor_t range, GrChromaRangeMode_t match_mode);
 799 void (FX_CALL *real_grTexChromaModeExt) (GrChipID_t tmu, GrChromakeyMode_t mode);
 800 void (FX_CALL *real_grTexChromaRangeExt) (GrChipID_t tmu, GrColor_t min, GrColor_t max, GrTexChromakeyMode_t mode);
 801
 802 /* tbext */
 803 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);
 804 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);
 805 void (FX_CALL *real_grAuxBufferExt) (GrBuffer_t buffer);
 806
 807 /* napalm */
 808 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);
 809 void (FX_CALL *real_grStencilFuncExt) (GrCmpFnc_t fnc, GrStencil_t ref, GrStencil_t mask);
 810 void (FX_CALL *real_grStencilMaskExt) (GrStencil_t value);
 811 void (FX_CALL *real_grStencilOpExt) (GrStencilOp_t stencil_fail, GrStencilOp_t depth_fail, GrStencilOp_t depth_pass);
 812 void (FX_CALL *real_grLfbConstantStencilExt) (GrStencil_t value);
 813 void (FX_CALL *real_grBufferClearExt) (GrColor_t color, GrAlpha_t alpha, FxU32 depth, GrStencil_t stencil);
 814 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);
 815 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);
 816 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);
 817 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);
 818 void (FX_CALL *real_grConstantColorValueExt) (GrChipID_t tmu, GrColor_t value);
 819 void (FX_CALL *real_grColorMaskExt) (FxBool r, FxBool g, FxBool b, FxBool a);
 820 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);
 821 void (FX_CALL *real_grTBufferWriteMaskExt) (FxU32 tmask);
 822
 823
 824
 825 /****************************************************************************\
 826 * DEBUG HOOKS                                                                *
 827 \****************************************************************************/
 828
 829 /*
 830 ** rendering functions
 831 */
 832 void FX_CALL trap_grDrawPoint (const void *pt)
 833 {
 834 #define FN_NAME "grDrawPoint"
 835  TRAP_LOG("%s(%p)\n", FN_NAME, pt);
 836  grDrawPoint(pt);
 837 #undef FN_NAME
 838 }
 839
 840 void FX_CALL trap_grDrawLine (const void *v1,
 841                               const void *v2)
 842 {
 843 #define FN_NAME "grDrawLine"
 844  TRAP_LOG("%s(%p, %p)\n", FN_NAME, v1, v2);
 845  grDrawLine(v1, v2);
 846 #undef FN_NAME
 847 }
 848
 849 void FX_CALL trap_grDrawTriangle (const void *a,
 850                                   const void *b,
 851                                   const void *c)
 852 {
 853 #define FN_NAME "grDrawTriangle"
 854  TRAP_LOG("%s(%p, %p, %p)\n", FN_NAME, a, b, c);
 855  grDrawTriangle(a, b, c);
 856 #undef FN_NAME
 857 }
 858
 859 void FX_CALL trap_grVertexLayout (FxU32 param,
 860                                   FxI32 offset,
 861                                   FxU32 mode)
 862 {
 863 #define FN_NAME "grVertexLayout"
 864  TRAP_LOG("%s(%s, %ld, %s)\n", FN_NAME, TRP_VTX(param), offset, TRP_PARAM(mode));
 865  grVertexLayout(param, offset, mode);
 866 #undef FN_NAME
 867 }
 868
 869 void FX_CALL trap_grDrawVertexArray (FxU32 mode,
 870                                      FxU32 Count,
 871                                      void  *pointers)
 872 {
 873 #define FN_NAME "grDrawVertexArray"
 874  TRAP_LOG("%s(%s, %lu, %p)\n", FN_NAME, TRP_ARRAY(mode), Count, pointers);
 875  grDrawVertexArray(mode, Count, pointers);
 876 #undef FN_NAME
 877 }
 878
 879 void FX_CALL trap_grDrawVertexArrayContiguous (FxU32 mode,
 880                                                FxU32 Count,
 881                                                void  *pointers,
 882                                                FxU32 stride)
 883 {
 884 #define FN_NAME "grDrawVertexArrayContiguous"
 885  TRAP_LOG("%s(%s, %lu, %p, %lu)\n", FN_NAME, TRP_ARRAY(mode), Count, pointers, stride);
 886  grDrawVertexArrayContiguous(mode, Count, pointers, stride);
 887 #undef FN_NAME
 888 }
 889
 890 /*
 891 **  Antialiasing Functions
 892 */
 893 void FX_CALL trap_grAADrawTriangle (const void *a,
 894                                     const void *b,
 895                                     const void *c,
 896                                     FxBool     ab_antialias,
 897                                     FxBool     bc_antialias,
 898                                     FxBool     ca_antialias)
 899 {
 900 #define FN_NAME "grAADrawTriangle"
 901  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));
 902  grAADrawTriangle(a, b, c, ab_antialias, bc_antialias, ca_antialias);
 903 #undef FN_NAME
 904 }
 905
 906 /*
 907 ** buffer management
 908 */
 909 void FX_CALL trap_grBufferClear (GrColor_t color,
 910                                  GrAlpha_t alpha,
 911                                  FxU32     depth)
 912 {
 913 #define FN_NAME "grBufferClear"
 914  TRAP_LOG("%s(%08lx, %02x, %08lx)\n", FN_NAME, color, alpha, depth);
 915  grBufferClear(color, alpha, depth);
 916 #undef FN_NAME
 917 }
 918
 919 void FX_CALL trap_grBufferSwap (FxU32 swap_interval)
 920 {
 921 #define FN_NAME "grBufferSwap"
 922  TRAP_LOG("%s(%lu)\n", FN_NAME, swap_interval);
 923  grBufferSwap(swap_interval);
 924 #undef FN_NAME
 925 }
 926
 927 void FX_CALL trap_grRenderBuffer (GrBuffer_t buffer)
 928 {
 929 #define FN_NAME "grRenderBuffer"
 930  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BUFFER(buffer));
 931  grRenderBuffer(buffer);
 932 #undef FN_NAME
 933 }
 934
 935 /*
 936 ** error management
 937 */
 938 void FX_CALL trap_grErrorSetCallback (GrErrorCallbackFnc_t fnc)
 939 {
 940 #define FN_NAME "grErrorSetCallback"
 941  TRAP_LOG("%s(%p)\n", FN_NAME, (void *)fnc);
 942  grErrorSetCallback(fnc);
 943 #undef FN_NAME
 944 }
 945
 946 /*
 947 ** SST routines
 948 */
 949 void FX_CALL trap_grFinish (void)
 950 {
 951 #define FN_NAME "grFinish"
 952  TRAP_LOG("%s()\n", FN_NAME);
 953  grFinish();
 954 #undef FN_NAME
 955 }
 956
 957 void FX_CALL trap_grFlush (void)
 958 {
 959 #define FN_NAME "grFlush"
 960  TRAP_LOG("%s()\n", FN_NAME);
 961  grFlush();
 962 #undef FN_NAME
 963 }
 964
 965 GrContext_t FX_CALL trap_grSstWinOpen (FxU32                hWnd,
 966                                        GrScreenResolution_t screen_resolution,
 967                                        GrScreenRefresh_t    refresh_rate,
 968                                        GrColorFormat_t      color_format,
 969                                        GrOriginLocation_t   origin_location,
 970                                        int                  nColBuffers,
 971                                        int                  nAuxBuffers)
 972 {
 973 #define FN_NAME "grSstWinOpen"
 974  GrContext_t rv;
 975  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);
 976  rv = grSstWinOpen(hWnd, screen_resolution, refresh_rate, color_format, origin_location, nColBuffers, nAuxBuffers);
 977  TRAP_LOG(GOT "%p\n", (void *)rv);
 978  return rv;
 979 #undef FN_NAME
 980 }
 981
 982 FxBool FX_CALL trap_grSstWinClose (GrContext_t context)
 983 {
 984 #define FN_NAME "grSstWinClose"
 985  FxBool rv;
 986  TRAP_LOG("%s(%p)\n", FN_NAME, (void *)context);
 987  rv = grSstWinClose(context);
 988  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
 989  return rv;
 990 #undef FN_NAME
 991 }
 992
 993 void FX_CALL trap_grSetNumPendingBuffers (FxI32 NumPendingBuffers)
 994 {
 995 #define FN_NAME "grSetNumPendingBuffers"
 996  TRAP_LOG("%s(%ld)\n", FN_NAME, NumPendingBuffers);
 997  grSetNumPendingBuffers(NumPendingBuffers);
 998 #undef FN_NAME
 999 }
1000
1001 FxBool FX_CALL trap_grSelectContext (GrContext_t context)
1002 {
1003 #define FN_NAME "grSelectContext"
1004  FxBool rv;
1005  TRAP_LOG("%s(%p)\n", FN_NAME, (void *)context);
1006  rv = grSelectContext(context);
1007  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1008  return rv;
1009 #undef FN_NAME
1010 }
1011
1012 void FX_CALL trap_grSstOrigin (GrOriginLocation_t origin)
1013 {
1014 #define FN_NAME "grSstOrigin"
1015  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_ORIGIN(origin));
1016  grSstOrigin(origin);
1017 #undef FN_NAME
1018 }
1019
1020 void FX_CALL trap_grSstSelect (int which_sst)
1021 {
1022 #define FN_NAME "grSstSelect"
1023  TRAP_LOG("%s(%d)\n", FN_NAME, which_sst);
1024  grSstSelect(which_sst);
1025 #undef FN_NAME
1026 }
1027
1028 /*
1029 ** Glide configuration and special effect maintenance functions
1030 */
1031 void FX_CALL trap_grAlphaBlendFunction (GrAlphaBlendFnc_t rgb_sf,
1032                                         GrAlphaBlendFnc_t rgb_df,
1033                                         GrAlphaBlendFnc_t alpha_sf,
1034                                         GrAlphaBlendFnc_t alpha_df)
1035 {
1036 #define FN_NAME "grAlphaBlendFunction"
1037  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));
1038  grAlphaBlendFunction(rgb_sf, rgb_df, alpha_sf, alpha_df);
1039 #undef FN_NAME
1040 }
1041
1042 void FX_CALL trap_grAlphaCombine (GrCombineFunction_t function,
1043                                   GrCombineFactor_t   factor,
1044                                   GrCombineLocal_t    local,
1045                                   GrCombineOther_t    other,
1046                                   FxBool              invert)
1047 {
1048 #define FN_NAME "grAlphaCombine"
1049  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));
1050  grAlphaCombine(function, factor, local, other, invert);
1051 #undef FN_NAME
1052 }
1053
1054 void FX_CALL trap_grAlphaControlsITRGBLighting (FxBool enable)
1055 {
1056 #define FN_NAME "grAlphaControlsITRGBLighting"
1057  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BOOL(enable));
1058  grAlphaControlsITRGBLighting(enable);
1059 #undef FN_NAME
1060 }
1061
1062 void FX_CALL trap_grAlphaTestFunction (GrCmpFnc_t function)
1063 {
1064 #define FN_NAME "grAlphaTestFunction"
1065  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CMPFUNC(function));
1066  grAlphaTestFunction(function);
1067 #undef FN_NAME
1068 }
1069
1070 void FX_CALL trap_grAlphaTestReferenceValue (GrAlpha_t value)
1071 {
1072 #define FN_NAME "grAlphaTestReferenceValue"
1073  TRAP_LOG("%s(%02x)\n", FN_NAME, value);
1074  grAlphaTestReferenceValue(value);
1075 #undef FN_NAME
1076 }
1077
1078 void FX_CALL trap_grChromakeyMode (GrChromakeyMode_t mode)
1079 {
1080 #define FN_NAME "grChromakeyMode"
1081  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CKMODE(mode));
1082  grChromakeyMode(mode);
1083 #undef FN_NAME
1084 }
1085
1086 void FX_CALL trap_grChromakeyValue (GrColor_t value)
1087 {
1088 #define FN_NAME "grChromakeyValue"
1089  TRAP_LOG("%s(%08lx)\n", FN_NAME, value);
1090  grChromakeyValue(value);
1091 #undef FN_NAME
1092 }
1093
1094 void FX_CALL trap_grClipWindow (FxU32 minx,
1095                                 FxU32 miny,
1096                                 FxU32 maxx,
1097                                 FxU32 maxy)
1098 {
1099 #define FN_NAME "grClipWindow"
1100  TRAP_LOG("%s(%lu, %lu, %lu, %lu)\n", FN_NAME, minx, miny, maxx, maxy);
1101  grClipWindow(minx, miny, maxx, maxy);
1102 #undef FN_NAME
1103 }
1104
1105 void FX_CALL trap_grColorCombine (GrCombineFunction_t function,
1106                                   GrCombineFactor_t   factor,
1107                                   GrCombineLocal_t    local,
1108                                   GrCombineOther_t    other,
1109                                   FxBool              invert)
1110 {
1111 #define FN_NAME "grColorCombine"
1112  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));
1113  grColorCombine(function, factor, local, other, invert);
1114 #undef FN_NAME
1115 }
1116
1117 void FX_CALL trap_grColorMask (FxBool rgb,
1118                                FxBool a)
1119 {
1120 #define FN_NAME "grColorMask"
1121  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_BOOL(rgb), TRP_BOOL(a));
1122  grColorMask(rgb, a);
1123 #undef FN_NAME
1124 }
1125
1126 void FX_CALL trap_grCullMode (GrCullMode_t mode)
1127 {
1128 #define FN_NAME "grCullMode"
1129  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CULLMODE(mode));
1130  grCullMode(mode);
1131 #undef FN_NAME
1132 }
1133
1134 void FX_CALL trap_grConstantColorValue (GrColor_t value)
1135 {
1136 #define FN_NAME "grConstantColorValue"
1137  TRAP_LOG("%s(%08lx)\n", FN_NAME, value);
1138  grConstantColorValue(value);
1139 #undef FN_NAME
1140 }
1141
1142 void FX_CALL trap_grDepthBiasLevel (FxI32 level)
1143 {
1144 #define FN_NAME "grDepthBiasLevel"
1145  TRAP_LOG("%s(%ld)\n", FN_NAME, level);
1146  grDepthBiasLevel(level);
1147 #undef FN_NAME
1148 }
1149
1150 void FX_CALL trap_grDepthBufferFunction (GrCmpFnc_t function)
1151 {
1152 #define FN_NAME "grDepthBufferFunction"
1153  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CMPFUNC(function));
1154  grDepthBufferFunction(function);
1155 #undef FN_NAME
1156 }
1157
1158 void FX_CALL trap_grDepthBufferMode (GrDepthBufferMode_t mode)
1159 {
1160 #define FN_NAME "grDepthBufferMode"
1161  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_DEPTHMODE(mode));
1162  grDepthBufferMode(mode);
1163 #undef FN_NAME
1164 }
1165
1166 void FX_CALL trap_grDepthMask (FxBool mask)
1167 {
1168 #define FN_NAME "grDepthMask"
1169  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BOOL(mask));
1170  grDepthMask(mask);
1171 #undef FN_NAME
1172 }
1173
1174 void FX_CALL trap_grDisableAllEffects (void)
1175 {
1176 #define FN_NAME "grDisableAllEffects"
1177  TRAP_LOG("%s()\n", FN_NAME);
1178  grDisableAllEffects();
1179 #undef FN_NAME
1180 }
1181
1182 void FX_CALL trap_grDitherMode (GrDitherMode_t mode)
1183 {
1184 #define FN_NAME "grDitherMode"
1185  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_DITHERMODE(mode));
1186  grDitherMode(mode);
1187 #undef FN_NAME
1188 }
1189
1190 void FX_CALL trap_grFogColorValue (GrColor_t fogcolor)
1191 {
1192 #define FN_NAME "grFogColorValue"
1193  TRAP_LOG("%s(%08lx)\n", FN_NAME, fogcolor);
1194  grFogColorValue(fogcolor);
1195 #undef FN_NAME
1196 }
1197
1198 void FX_CALL trap_grFogMode (GrFogMode_t mode)
1199 {
1200 #define FN_NAME "grFogMode"
1201  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_FOGMODE(mode));
1202  grFogMode(mode);
1203 #undef FN_NAME
1204 }
1205
1206 void FX_CALL trap_grFogTable (const GrFog_t ft[])
1207 {
1208 #define FN_NAME "grFogTable"
1209  TRAP_LOG("%s(%p)\n", FN_NAME, ft);
1210  grFogTable(ft);
1211 #undef FN_NAME
1212 }
1213
1214 void FX_CALL trap_grLoadGammaTable (FxU32 nentries,
1215                                     FxU32 *red,
1216                                     FxU32 *green,
1217                                     FxU32 *blue)
1218 {
1219 #define FN_NAME "grLoadGammaTable"
1220  TRAP_LOG("%s(%lu, %p, %p, %p)\n", FN_NAME, nentries, (void *)red, (void *)green, (void *)blue);
1221  grLoadGammaTable(nentries, red, green, blue);
1222 #undef FN_NAME
1223 }
1224
1225 void FX_CALL trap_grSplash (float x,
1226                             float y,
1227                             float width,
1228                             float height,
1229                             FxU32 frame)
1230 {
1231 #define FN_NAME "grSplash"
1232  TRAP_LOG("%s(%f, %f, %f, %f, %lu)\n", FN_NAME, x, y, width, height, frame);
1233  grSplash(x, y, width, height, frame);
1234 #undef FN_NAME
1235 }
1236
1237 FxU32 FX_CALL trap_grGet (FxU32 pname,
1238                           FxU32 plength,
1239                           FxI32 *params)
1240 {
1241 #define FN_NAME "grGet"
1242  FxU32 rv, i;
1243  TRAP_LOG("%s(%s, %lu, %p)\n", FN_NAME, TRP_GETNAME(pname), plength, (void *)params);
1244  rv = grGet(pname, plength, params);
1245  TRAP_LOG(GOT "[");
1246  for (i = 0; i < (rv/sizeof(FxI32)); i++) {
1247      TRAP_LOG("%s%ld", i ? ", " : "", params[i]);
1248  }
1249  TRAP_LOG("]\n");
1250  return rv;
1251 #undef FN_NAME
1252 }
1253
1254 const char *FX_CALL trap_grGetString (FxU32 pname)
1255 {
1256 #define FN_NAME "grGetString"
1257  const char *rv;
1258  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_GETSTRING(pname));
1259  rv = grGetString(pname);
1260  if (rv) {
1261     TRAP_LOG(GOT "\"%s\"\n", rv);
1262  } else {
1263     TRAP_LOG(GOT "NULL\n");
1264  }
1265  return rv;
1266 #undef FN_NAME
1267 }
1268
1269 FxI32 FX_CALL trap_grQueryResolutions (const GrResolution *resTemplate,
1270                                        GrResolution       *output)
1271 {
1272 #define FN_NAME "grQueryResolutions"
1273  FxI32 rv;
1274  TRAP_LOG("%s(%p, %p)\n", FN_NAME, (void *)resTemplate, (void *)output);
1275  rv = grQueryResolutions(resTemplate, output);
1276  TRAP_LOG(GOT "%ld\n", rv);
1277  return rv;
1278 #undef FN_NAME
1279 }
1280
1281 FxBool FX_CALL trap_grReset (FxU32 what)
1282 {
1283 #define FN_NAME "grReset"
1284  FxBool rv;
1285  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_GETNAME(what));
1286  rv = grReset(what);
1287  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1288  return rv;
1289 #undef FN_NAME
1290 }
1291
1292 GrProc FX_CALL trap_grGetProcAddress (char *procName)
1293 {
1294 #define FN_NAME "grGetProcAddress"
1295  GrProc rv;
1296  TRAP_LOG("%s(%s)\n", FN_NAME, procName);
1297  rv = grGetProcAddress(procName);
1298  TRAP_LOG(GOT "%p\n", (void *)rv);
1299  return rv;
1300 #undef FN_NAME
1301 }
1302
1303 void FX_CALL trap_grEnable (GrEnableMode_t mode)
1304 {
1305 #define FN_NAME "grEnable"
1306  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_ENABLE(mode));
1307  grEnable(mode);
1308 #undef FN_NAME
1309 }
1310
1311 void FX_CALL trap_grDisable (GrEnableMode_t mode)
1312 {
1313 #define FN_NAME "grDisable"
1314  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_ENABLE(mode));
1315  grDisable(mode);
1316 #undef FN_NAME
1317 }
1318
1319 void FX_CALL trap_grCoordinateSpace (GrCoordinateSpaceMode_t mode)
1320 {
1321 #define FN_NAME "grCoordinateSpace"
1322  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_COORD(mode));
1323  grCoordinateSpace(mode);
1324 #undef FN_NAME
1325 }
1326
1327 void FX_CALL trap_grDepthRange (FxFloat n,
1328                                 FxFloat f)
1329 {
1330 #define FN_NAME "grDepthRange"
1331  TRAP_LOG("%s(%f, %f)\n", FN_NAME, n, f);
1332  grDepthRange(n, f);
1333 #undef FN_NAME
1334 }
1335
1336 void FX_CALL trap_grStippleMode (GrStippleMode_t mode)
1337 {
1338 #define FN_NAME "grStippleMode"
1339  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_STIPPLEMODE(mode));
1340  grStippleMode(mode);
1341 #undef FN_NAME
1342 }
1343
1344 void FX_CALL trap_grStipplePattern (GrStipplePattern_t mode)
1345 {
1346 #define FN_NAME "grStipplePattern"
1347  TRAP_LOG("%s(%08lx)\n", FN_NAME, mode);
1348  grStipplePattern(mode);
1349 #undef FN_NAME
1350 }
1351
1352 void FX_CALL trap_grViewport (FxI32 x,
1353                               FxI32 y,
1354                               FxI32 width,
1355                               FxI32 height)
1356 {
1357 #define FN_NAME "grViewport"
1358  TRAP_LOG("%s(%ld, %ld, %ld, %ld)\n", FN_NAME, x, y, width, height);
1359  grViewport(x, y, width, height);
1360 #undef FN_NAME
1361 }
1362
1363 /*
1364 ** texture mapping control functions
1365 */
1366 FxU32 FX_CALL trap_grTexCalcMemRequired (GrLOD_t           lodmin,
1367                                          GrLOD_t           lodmax,
1368                                          GrAspectRatio_t   aspect,
1369                                          GrTextureFormat_t fmt)
1370 {
1371 #define FN_NAME "grTexCalcMemRequired"
1372  FxU32 rv;
1373  TRAP_LOG("%s(%s, %s, %s, %s)\n", FN_NAME, TRP_LODLEVEL(lodmin), TRP_LODLEVEL(lodmax), TRP_ASPECTRATIO(aspect), TRP_TEXFMT(fmt));
1374  rv = grTexCalcMemRequired(lodmin, lodmax, aspect, fmt);
1375  TRAP_LOG(GOT "%lu\n", rv);
1376  return rv;
1377 #undef FN_NAME
1378 }
1379
1380 FxU32 FX_CALL trap_grTexTextureMemRequired (FxU32     evenOdd,
1381                                             GrTexInfo *info)
1382 {
1383 #define FN_NAME "grTexTextureMemRequired"
1384  FxU32 rv;
1385  TRAP_LOG("%s(%s, %p)\n", FN_NAME, TRP_EVENODD(evenOdd), (void *)info);
1386  rv = grTexTextureMemRequired(evenOdd, info);
1387  TRAP_LOG(GOT "%lu\n", rv);
1388  return rv;
1389 #undef FN_NAME
1390 }
1391
1392 FxU32 FX_CALL trap_grTexMinAddress (GrChipID_t tmu)
1393 {
1394 #define FN_NAME "grTexMinAddress"
1395  FxU32 rv;
1396  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_TMU(tmu));
1397  rv = grTexMinAddress(tmu);
1398  TRAP_LOG(GOT "%lu\n", rv);
1399  return rv;
1400 #undef FN_NAME
1401 }
1402
1403 FxU32 FX_CALL trap_grTexMaxAddress (GrChipID_t tmu)
1404 {
1405 #define FN_NAME "grTexMaxAddress"
1406  FxU32 rv;
1407  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_TMU(tmu));
1408  rv = grTexMaxAddress(tmu);
1409  TRAP_LOG(GOT "%lu\n", rv);
1410  return rv;
1411 #undef FN_NAME
1412 }
1413
1414 void FX_CALL trap_grTexNCCTable (GrNCCTable_t table)
1415 {
1416 #define FN_NAME "grTexNCCTable"
1417  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_NCC(table));
1418  grTexNCCTable(table);
1419 #undef FN_NAME
1420 }
1421
1422 void FX_CALL trap_grTexSource (GrChipID_t tmu,
1423                                FxU32      startAddress,
1424                                FxU32      evenOdd,
1425                                GrTexInfo  *info)
1426 {
1427 #define FN_NAME "grTexSource"
1428  TRAP_LOG("%s(%s, %08lx, %s, %p)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_EVENODD(evenOdd), (void *)info);
1429  grTexSource(tmu, startAddress, evenOdd, info);
1430 #undef FN_NAME
1431 }
1432
1433 void FX_CALL trap_grTexClampMode (GrChipID_t           tmu,
1434                                   GrTextureClampMode_t s_clampmode,
1435                                   GrTextureClampMode_t t_clampmode)
1436 {
1437 #define FN_NAME "grTexClampMode"
1438  TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_CLAMPMODE(s_clampmode), TRP_CLAMPMODE(t_clampmode));
1439  grTexClampMode(tmu, s_clampmode, t_clampmode);
1440 #undef FN_NAME
1441 }
1442
1443 void FX_CALL trap_grTexCombine (GrChipID_t          tmu,
1444                                 GrCombineFunction_t rgb_function,
1445                                 GrCombineFactor_t   rgb_factor,
1446                                 GrCombineFunction_t alpha_function,
1447                                 GrCombineFactor_t   alpha_factor,
1448                                 FxBool              rgb_invert,
1449                                 FxBool              alpha_invert)
1450 {
1451 #define FN_NAME "grTexCombine"
1452  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));
1453  grTexCombine(tmu, rgb_function, rgb_factor, alpha_function, alpha_factor, rgb_invert, alpha_invert);
1454 #undef FN_NAME
1455 }
1456
1457 void FX_CALL trap_grTexDetailControl (GrChipID_t tmu,
1458                                       int        lod_bias,
1459                                       FxU8       detail_scale,
1460                                       float      detail_max)
1461 {
1462 #define FN_NAME "grTexDetailControl"
1463  TRAP_LOG("%s(%s, %u, %d, %f)\n", FN_NAME, TRP_TMU(tmu), lod_bias, detail_scale, detail_max);
1464  grTexDetailControl(tmu, lod_bias, detail_scale, detail_max);
1465 #undef FN_NAME
1466 }
1467
1468 void FX_CALL trap_grTexFilterMode (GrChipID_t            tmu,
1469                                    GrTextureFilterMode_t minfilter_mode,
1470                                    GrTextureFilterMode_t magfilter_mode)
1471 {
1472 #define FN_NAME "grTexFilterMode"
1473  TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_TEXFILTER(minfilter_mode), TRP_TEXFILTER(magfilter_mode));
1474  grTexFilterMode(tmu, minfilter_mode, magfilter_mode);
1475 #undef FN_NAME
1476 }
1477
1478 void FX_CALL trap_grTexLodBiasValue (GrChipID_t tmu,
1479                                      float      bias)
1480 {
1481 #define FN_NAME "grTexLodBiasValue"
1482  TRAP_LOG("%s(%s, %f)\n", FN_NAME, TRP_TMU(tmu), bias);
1483  grTexLodBiasValue(tmu, bias);
1484 #undef FN_NAME
1485 }
1486
1487 void FX_CALL trap_grTexDownloadMipMap (GrChipID_t tmu,
1488                                        FxU32      startAddress,
1489                                        FxU32      evenOdd,
1490                                        GrTexInfo  *info)
1491 {
1492 #define FN_NAME "grTexDownloadMipMap"
1493  TRAP_LOG("%s(%s, %08lx, %s, %p)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_EVENODD(evenOdd), (void *)info);
1494  grTexDownloadMipMap(tmu, startAddress, evenOdd, info);
1495 #undef FN_NAME
1496 }
1497
1498 void FX_CALL trap_grTexDownloadMipMapLevel (GrChipID_t        tmu,
1499                                             FxU32             startAddress,
1500                                             GrLOD_t           thisLod,
1501                                             GrLOD_t           largeLod,
1502                                             GrAspectRatio_t   aspectRatio,
1503                                             GrTextureFormat_t format,
1504                                             FxU32             evenOdd,
1505                                             void              *data)
1506 {
1507 #define FN_NAME "grTexDownloadMipMapLevel"
1508  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);
1509  grTexDownloadMipMapLevel(tmu, startAddress, thisLod, largeLod, aspectRatio, format, evenOdd, data);
1510 #undef FN_NAME
1511 }
1512
1513 FxBool FX_CALL trap_grTexDownloadMipMapLevelPartial (GrChipID_t        tmu,
1514                                                      FxU32             startAddress,
1515                                                      GrLOD_t           thisLod,
1516                                                      GrLOD_t           largeLod,
1517                                                      GrAspectRatio_t   aspectRatio,
1518                                                      GrTextureFormat_t format,
1519                                                      FxU32             evenOdd,
1520                                                      void              *data,
1521                                                      int               start,
1522                                                      int               end)
1523 {
1524 #define FN_NAME "grTexDownloadMipMapLevelPartial"
1525  FxBool rv;
1526  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);
1527  rv = grTexDownloadMipMapLevelPartial(tmu, startAddress, thisLod, largeLod, aspectRatio, format, evenOdd, data, start, end);
1528  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1529  return rv;
1530 #undef FN_NAME
1531 }
1532
1533 void FX_CALL trap_grTexDownloadTable (GrTexTable_t type,
1534                                       void         *data)
1535 {
1536 #define FN_NAME "grTexDownloadTable"
1537  TRAP_LOG("%s(%s, %p)\n", FN_NAME, TRP_TABLE(type), data);
1538  grTexDownloadTable(type, data);
1539 #undef FN_NAME
1540 }
1541
1542 void FX_CALL trap_grTexDownloadTablePartial (GrTexTable_t type,
1543                                              void         *data,
1544                                              int          start,
1545                                              int          end)
1546 {
1547 #define FN_NAME "grTexDownloadTablePartial"
1548  TRAP_LOG("%s(%s, %p, %d, %d)\n", FN_NAME, TRP_TABLE(type), data, start, end);
1549  grTexDownloadTablePartial(type, data, start, end);
1550 #undef FN_NAME
1551 }
1552
1553 void FX_CALL trap_grTexMipMapMode (GrChipID_t     tmu,
1554                                    GrMipMapMode_t mode,
1555                                    FxBool         lodBlend)
1556 {
1557 #define FN_NAME "grTexMipMapMode"
1558  TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_MIPMODE(mode), TRP_BOOL(lodBlend));
1559  grTexMipMapMode(tmu, mode, lodBlend);
1560 #undef FN_NAME
1561 }
1562
1563 void FX_CALL trap_grTexMultibase (GrChipID_t tmu,
1564                                   FxBool     enable)
1565 {
1566 #define FN_NAME "grTexMultibase"
1567  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_BOOL(enable));
1568  grTexMultibase(tmu, enable);
1569 #undef FN_NAME
1570 }
1571
1572 void FX_CALL trap_grTexMultibaseAddress (GrChipID_t       tmu,
1573                                          GrTexBaseRange_t range,
1574                                          FxU32            startAddress,
1575                                          FxU32            evenOdd,
1576                                          GrTexInfo        *info)
1577 {
1578 #define FN_NAME "grTexMultibaseAddress"
1579  TRAP_LOG("%s(%s, %s, %08lx, %s, %p)\n", FN_NAME, TRP_TMU(tmu), TRP_TEXBASERANGE(range), startAddress, TRP_EVENODD(evenOdd), (void *)info);
1580  grTexMultibaseAddress(tmu, range, startAddress, evenOdd, info);
1581 #undef FN_NAME
1582 }
1583
1584 /*
1585 ** linear frame buffer functions
1586 */
1587 FxBool FX_CALL trap_grLfbLock (GrLock_t           type,
1588                                GrBuffer_t         buffer,
1589                                GrLfbWriteMode_t   writeMode,
1590                                GrOriginLocation_t origin,
1591                                FxBool             pixelPipeline,
1592                                GrLfbInfo_t        *info)
1593 {
1594 #define FN_NAME "grLfbLock"
1595  FxBool rv;
1596  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);
1597  rv = grLfbLock(type, buffer, writeMode, origin, pixelPipeline, info);
1598  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1599  return rv;
1600 #undef FN_NAME
1601 }
1602
1603 FxBool FX_CALL trap_grLfbUnlock (GrLock_t   type,
1604                                  GrBuffer_t buffer)
1605 {
1606 #define FN_NAME "grLfbUnlock"
1607  FxBool rv;
1608  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_LOCKTYPE(type), TRP_BUFFER(buffer));
1609  rv = grLfbUnlock(type, buffer);
1610  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1611  return rv;
1612 #undef FN_NAME
1613 }
1614
1615 void FX_CALL trap_grLfbConstantAlpha (GrAlpha_t alpha)
1616 {
1617 #define FN_NAME "grLfbConstantAlpha"
1618  TRAP_LOG("%s(%02x)\n", FN_NAME, alpha);
1619  grLfbConstantAlpha(alpha);
1620 #undef FN_NAME
1621 }
1622
1623 void FX_CALL trap_grLfbConstantDepth (FxU32 depth)
1624 {
1625 #define FN_NAME "grLfbConstantDepth"
1626  TRAP_LOG("%s(%08lx)\n", FN_NAME, depth);
1627  grLfbConstantDepth(depth);
1628 #undef FN_NAME
1629 }
1630
1631 void FX_CALL trap_grLfbWriteColorSwizzle (FxBool swizzleBytes,
1632                                           FxBool swapWords)
1633 {
1634 #define FN_NAME "grLfbWriteColorSwizzle"
1635  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_BOOL(swizzleBytes), TRP_BOOL(swapWords));
1636  grLfbWriteColorSwizzle(swizzleBytes, swapWords);
1637 #undef FN_NAME
1638 }
1639
1640 void FX_CALL trap_grLfbWriteColorFormat (GrColorFormat_t colorFormat)
1641 {
1642 #define FN_NAME "grLfbWriteColorFormat"
1643  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_COLFMT(colorFormat));
1644  grLfbWriteColorFormat(colorFormat);
1645 #undef FN_NAME
1646 }
1647
1648 FxBool FX_CALL trap_grLfbWriteRegion (GrBuffer_t    dst_buffer,
1649                                       FxU32         dst_x,
1650                                       FxU32         dst_y,
1651                                       GrLfbSrcFmt_t src_format,
1652                                       FxU32         src_width,
1653                                       FxU32         src_height,
1654                                       FxBool        pixelPipeline,
1655                                       FxI32         src_stride,
1656                                       void          *src_data)
1657 {
1658 #define FN_NAME "grLfbWriteRegion"
1659  FxBool rv;
1660  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);
1661  rv = grLfbWriteRegion(dst_buffer, dst_x, dst_y, src_format, src_width, src_height, pixelPipeline, src_stride, src_data);
1662  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1663  return rv;
1664 #undef FN_NAME
1665 }
1666
1667 FxBool FX_CALL trap_grLfbReadRegion (GrBuffer_t src_buffer,
1668                                      FxU32      src_x,
1669                                      FxU32      src_y,
1670                                      FxU32      src_width,
1671                                      FxU32      src_height,
1672                                      FxU32      dst_stride,
1673                                      void       *dst_data)
1674 {
1675 #define FN_NAME "grLfbReadRegion"
1676  FxBool rv;
1677  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);
1678  rv = grLfbReadRegion(src_buffer, src_x, src_y, src_width, src_height, dst_stride, dst_data);
1679  TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
1680  return rv;
1681 #undef FN_NAME
1682 }
1683
1684 /*
1685 ** glide management functions
1686 */
1687 void FX_CALL trap_grGlideInit (void)
1688 {
1689 #define FN_NAME "grGlideInit"
1690  TRAP_LOG("%s()\n", FN_NAME);
1691  grGlideInit();
1692 #undef FN_NAME
1693 }
1694
1695 void FX_CALL trap_grGlideShutdown (void)
1696 {
1697 #define FN_NAME "grGlideShutdown"
1698  TRAP_LOG("%s()\n", FN_NAME);
1699  grGlideShutdown();
1700 #undef FN_NAME
1701 }
1702
1703 void FX_CALL trap_grGlideGetState (void *state)
1704 {
1705 #define FN_NAME "grGlideGetState"
1706  TRAP_LOG("%s(%p)\n", FN_NAME, state);
1707  grGlideGetState(state);
1708 #undef FN_NAME
1709 }
1710
1711 void FX_CALL trap_grGlideSetState (const void *state)
1712 {
1713 #define FN_NAME "grGlideSetState"
1714  TRAP_LOG("%s(%p)\n", FN_NAME, state);
1715  grGlideSetState(state);
1716 #undef FN_NAME
1717 }
1718
1719 void FX_CALL trap_grGlideGetVertexLayout (void *layout)
1720 {
1721 #define FN_NAME "grGlideGetVertexLayout"
1722  TRAP_LOG("%s(%p)\n", FN_NAME, layout);
1723  grGlideGetVertexLayout(layout);
1724 #undef FN_NAME
1725 }
1726
1727 void FX_CALL trap_grGlideSetVertexLayout (const void *layout)
1728 {
1729 #define FN_NAME "grGlideSetVertexLayout"
1730  TRAP_LOG("%s(%p)\n", FN_NAME, layout);
1731  grGlideSetVertexLayout(layout);
1732 #undef FN_NAME
1733 }
1734
1735 /*
1736 ** glide utility functions
1737 */
1738 void FX_CALL trap_guGammaCorrectionRGB (FxFloat red,
1739                                         FxFloat green,
1740                                         FxFloat blue)
1741 {
1742 #define FN_NAME "guGammaCorrectionRGB"
1743  TRAP_LOG("%s(%f, %f, %f)\n", FN_NAME, red, green, blue);
1744  guGammaCorrectionRGB(red, green, blue);
1745 #undef FN_NAME
1746 }
1747
1748 float FX_CALL trap_guFogTableIndexToW (int i)
1749 {
1750 #define FN_NAME "guFogTableIndexToW"
1751  float rv;
1752  TRAP_LOG("%s(%d)\n", FN_NAME, i);
1753  rv = guFogTableIndexToW(i);
1754  TRAP_LOG(GOT "%f\n", rv);
1755  return rv;
1756 #undef FN_NAME
1757 }
1758
1759 void FX_CALL trap_guFogGenerateExp (GrFog_t *fogtable,
1760                                     float   density)
1761 {
1762 #define FN_NAME "guFogGenerateExp"
1763  TRAP_LOG("%s(%p, %f)\n", FN_NAME, fogtable, density);
1764  guFogGenerateExp(fogtable, density);
1765 #undef FN_NAME
1766 }
1767
1768 void FX_CALL trap_guFogGenerateExp2 (GrFog_t *fogtable,
1769                                      float   density)
1770 {
1771 #define FN_NAME "guFogGenerateExp2"
1772  TRAP_LOG("%s(%p, %f)\n", FN_NAME, fogtable, density);
1773  guFogGenerateExp2(fogtable, density);
1774 #undef FN_NAME
1775 }
1776
1777 void FX_CALL trap_guFogGenerateLinear (GrFog_t *fogtable,
1778                                        float   nearZ,
1779                                        float   farZ)
1780 {
1781 #define FN_NAME "guFogGenerateLinear"
1782  TRAP_LOG("%s(%p, %f, %f)\n", FN_NAME, fogtable, nearZ, farZ);
1783  guFogGenerateLinear(fogtable, nearZ, farZ);
1784 #undef FN_NAME
1785 }
1786
1787 /*
1788 ** glide extensions
1789 */
1790 char *FX_CALL trap_grGetRegistryOrEnvironmentStringExt (char *theEntry)
1791 {
1792 #define FN_NAME "grGetRegistryOrEnvironmentStringExt"
1793  char *rv;
1794  TRAP_LOG("%s(\"%s\")\n", FN_NAME, theEntry);
1795  assert(real_grGetRegistryOrEnvironmentStringExt);
1796  rv = (*real_grGetRegistryOrEnvironmentStringExt)(theEntry);
1797  if (rv) {
1798     TRAP_LOG(GOT "\"%s\"\n", rv);
1799  } else {
1800     TRAP_LOG(GOT "NULL\n");
1801  }
1802  return rv;
1803 #undef FN_NAME
1804 }
1805
1806 void FX_CALL trap_grGetGammaTableExt (FxU32 nentries,
1807                                       FxU32 *red,
1808                                       FxU32 *green,
1809                                       FxU32 *blue)
1810 {
1811 #define FN_NAME "grGetGammaTableExt"
1812  TRAP_LOG("%s(%lu, %p, %p, %p)\n", FN_NAME, nentries, (void *)red, (void *)green, (void *)blue);
1813  assert(real_grGetGammaTableExt);
1814  (*real_grGetGammaTableExt)(nentries, red, green, blue);
1815 #undef FN_NAME
1816 }
1817
1818 void FX_CALL trap_grChromaRangeModeExt (GrChromakeyMode_t mode)
1819 {
1820 #define FN_NAME "grChromaRangeModeExt"
1821  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CKMODE(mode));
1822  assert(real_grChromaRangeModeExt);
1823  (*real_grChromaRangeModeExt)(mode);
1824 #undef FN_NAME
1825 }
1826
1827 void FX_CALL trap_grChromaRangeExt (GrColor_t           color,
1828                                     GrColor_t           range,
1829                                     GrChromaRangeMode_t match_mode)
1830 {
1831 #define FN_NAME "grChromaRangeExt"
1832  TRAP_LOG("%s(%08lx, %08lx, %s)\n", FN_NAME, color, range, TRP_CRMODE(match_mode));
1833  assert(real_grChromaRangeExt);
1834  (*real_grChromaRangeExt)(color, range, match_mode);
1835 #undef FN_NAME
1836 }
1837
1838 void FX_CALL trap_grTexChromaModeExt (GrChipID_t        tmu,
1839                                       GrChromakeyMode_t mode)
1840 {
1841 #define FN_NAME "grTexChromaModeExt"
1842  TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_CKMODE(mode));
1843  assert(real_grTexChromaModeExt);
1844  (*real_grTexChromaModeExt)(tmu, mode);
1845 #undef FN_NAME
1846 }
1847
1848 void FX_CALL trap_grTexChromaRangeExt (GrChipID_t           tmu,
1849                                        GrColor_t            min,
1850                                        GrColor_t            max,
1851                                        GrTexChromakeyMode_t mode)
1852 {
1853 #define FN_NAME "grTexChromaRangeExt"
1854  TRAP_LOG("%s(%s, %08lx, %08lx, %s)\n", FN_NAME, TRP_TMU(tmu), min, max, TRP_CRMODE(mode));
1855  assert(real_grTexChromaRangeExt);
1856  (*real_grTexChromaRangeExt)(tmu, min, max, mode);
1857 #undef FN_NAME
1858 }
1859
1860         /* tbext */
1861 void FX_CALL trap_grTextureBufferExt (GrChipID_t        tmu,
1862                                       FxU32             startAddress,
1863                                       GrLOD_t           thisLOD,
1864                                       GrLOD_t           largeLOD,
1865                                       GrAspectRatio_t   aspectRatio,
1866                                       GrTextureFormat_t format,
1867                                       FxU32             odd_even_mask)
1868 {
1869 #define FN_NAME "grTextureBufferExt"
1870  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));
1871  assert(real_grTextureBufferExt);
1872  (*real_grTextureBufferExt)(tmu, startAddress, thisLOD, largeLOD, aspectRatio, format, odd_even_mask);
1873 #undef FN_NAME
1874 }
1875
1876 void FX_CALL trap_grTextureAuxBufferExt (GrChipID_t        tmu,
1877                                          FxU32             startAddress,
1878                                          GrLOD_t           thisLOD,
1879                                          GrLOD_t           largeLOD,
1880                                          GrAspectRatio_t   aspectRatio,
1881                                          GrTextureFormat_t format,
1882                                          FxU32             odd_even_mask)
1883 {
1884 #define FN_NAME "grTextureAuxBufferExt"
1885  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));
1886  assert(real_grTextureAuxBufferExt);
1887  (*real_grTextureAuxBufferExt)(tmu, startAddress, thisLOD, largeLOD, aspectRatio, format, odd_even_mask);
1888 #undef FN_NAME
1889 }
1890
1891 void FX_CALL trap_grAuxBufferExt (GrBuffer_t buffer)
1892 {
1893 #define FN_NAME "grAuxBufferExt"
1894  TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BUFFER(buffer));
1895  assert(real_grAuxBufferExt);
1896  (*real_grAuxBufferExt)(buffer);
1897 #undef FN_NAME
1898 }
1899
1900         /* napalm */
1901 GrContext_t FX_CALL trap_grSstWinOpenExt (FxU32                hWnd,
1902                                           GrScreenResolution_t resolution,
1903                                           GrScreenRefresh_t    refresh,
1904                                           GrColorFormat_t      format,
1905                                           GrOriginLocation_t   origin,
1906                                           GrPixelFormat_t      pixelformat,
1907                                           int                  nColBuffers,
1908                                           int                  nAuxBuffers)
1909 {
1910 #define FN_NAME "grSstWinOpenExt"
1911  GrContext_t rv;
1912  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);
1913  assert(real_grSstWinOpenExt);
1914  rv = (*real_grSstWinOpenExt)(hWnd, resolution, refresh, format, origin, pixelformat, nColBuffers, nAuxBuffers);
1915  TRAP_LOG(GOT "%p\n", (void *)rv);
1916  return rv;
1917 #undef FN_NAME
1918 }
1919
1920 void FX_CALL trap_grStencilFuncExt (GrCmpFnc_t  fnc,
1921                                     GrStencil_t ref,
1922                                     GrStencil_t mask)
1923 {
1924 #define FN_NAME "grStencilFuncExt"
1925  TRAP_LOG("%s(%s, %02x, %02x)\n", FN_NAME, TRP_CMPFUNC(fnc), ref, mask);
1926  assert(real_grStencilFuncExt);
1927  (*real_grStencilFuncExt)(fnc, ref, mask);
1928 #undef FN_NAME
1929 }
1930
1931 void FX_CALL trap_grStencilMaskExt (GrStencil_t value)
1932 {
1933 #define FN_NAME "grStencilMaskExt"
1934  TRAP_LOG("%s(%02x)\n", FN_NAME, value);
1935  assert(real_grStencilMaskExt);
1936  (*real_grStencilMaskExt)(value);
1937 #undef FN_NAME
1938 }
1939
1940 void FX_CALL trap_grStencilOpExt (GrStencilOp_t stencil_fail,
1941                                   GrStencilOp_t depth_fail,
1942                                   GrStencilOp_t depth_pass)
1943 {
1944 #define FN_NAME "grStencilOpExt"
1945  TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_STENCILOP(stencil_fail), TRP_STENCILOP(depth_fail), TRP_STENCILOP(depth_pass));
1946  assert(real_grStencilOpExt);
1947  (*real_grStencilOpExt)(stencil_fail, depth_fail, depth_pass);
1948 #undef FN_NAME
1949 }
1950
1951 void FX_CALL trap_grLfbConstantStencilExt (GrStencil_t value)
1952 {
1953 #define FN_NAME "grLfbConstantStencilExt"
1954  TRAP_LOG("%s(%02x)\n", FN_NAME, value);
1955  assert(real_grLfbConstantStencilExt);
1956  (*real_grLfbConstantStencilExt)(value);
1957 #undef FN_NAME
1958 }
1959
1960 void FX_CALL trap_grBufferClearExt (GrColor_t   color,
1961                                     GrAlpha_t   alpha,
1962                                     FxU32       depth,
1963                                     GrStencil_t stencil)
1964 {
1965 #define FN_NAME "grBufferClearExt"
1966  TRAP_LOG("%s(%08lx, %02x, %08lx, %02x)\n", FN_NAME, color, alpha, depth, stencil);
1967  assert(real_grBufferClearExt);
1968  (*real_grBufferClearExt)(color, alpha, depth, stencil);
1969 #undef FN_NAME
1970 }
1971
1972 void FX_CALL trap_grColorCombineExt (GrCCUColor_t    a,
1973                                      GrCombineMode_t a_mode,
1974                                      GrCCUColor_t    b,
1975                                      GrCombineMode_t b_mode,
1976                                      GrCCUColor_t    c,
1977                                      FxBool          c_invert,
1978                                      GrCCUColor_t    d,
1979                                      FxBool          d_invert,
1980                                      FxU32           shift,
1981                                      FxBool          invert)
1982 {
1983 #define FN_NAME "grColorCombineExt"
1984  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));
1985  assert(real_grColorCombineExt);
1986  (*real_grColorCombineExt)(a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
1987 #undef FN_NAME
1988 }
1989
1990 void FX_CALL trap_grAlphaCombineExt (GrACUColor_t    a,
1991                                      GrCombineMode_t a_mode,
1992                                      GrACUColor_t    b,
1993                                      GrCombineMode_t b_mode,
1994                                      GrACUColor_t    c,
1995                                      FxBool          c_invert,
1996                                      GrACUColor_t    d,
1997                                      FxBool          d_invert,
1998                                      FxU32           shift,
1999                                      FxBool          invert)
2000 {
2001 #define FN_NAME "grAlphaCombineExt"
2002  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));
2003  assert(real_grAlphaCombineExt);
2004  (*real_grAlphaCombineExt)(a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
2005 #undef FN_NAME
2006 }
2007
2008 void FX_CALL trap_grTexColorCombineExt (GrChipID_t      tmu,
2009                                         GrTCCUColor_t   a,
2010                                         GrCombineMode_t a_mode,
2011                                         GrTCCUColor_t   b,
2012                                         GrCombineMode_t b_mode,
2013                                         GrTCCUColor_t   c,
2014                                         FxBool          c_invert,
2015                                         GrTCCUColor_t   d,
2016                                         FxBool          d_invert,
2017                                         FxU32           shift,
2018                                         FxBool          invert)
2019 {
2020 #define FN_NAME "grTexColorCombineExt"
2021  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));
2022  assert(real_grTexColorCombineExt);
2023  (*real_grTexColorCombineExt)(tmu, a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
2024 #undef FN_NAME
2025 }
2026
2027 void FX_CALL trap_grTexAlphaCombineExt (GrChipID_t      tmu,
2028                                         GrTACUColor_t   a,
2029                                         GrCombineMode_t a_mode,
2030                                         GrTACUColor_t   b,
2031                                         GrCombineMode_t b_mode,
2032                                         GrTACUColor_t   c,
2033                                         FxBool          c_invert,
2034                                         GrTACUColor_t   d,
2035                                         FxBool          d_invert,
2036                                         FxU32           shift,
2037                                         FxBool          invert)
2038 {
2039 #define FN_NAME "grTexAlphaCombineExt"
2040  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));
2041  assert(real_grTexAlphaCombineExt);
2042  (*real_grTexAlphaCombineExt)(tmu, a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
2043 #undef FN_NAME
2044 }
2045
2046 void FX_CALL trap_grConstantColorValueExt (GrChipID_t tmu,
2047                                            GrColor_t  value)
2048 {
2049 #define FN_NAME "grConstantColorValueExt"
2050  TRAP_LOG("%s(%s, %08lx)\n", FN_NAME, TRP_TMU(tmu), value);
2051  assert(real_grConstantColorValueExt);
2052  (*real_grConstantColorValueExt)(tmu, value);
2053 #undef FN_NAME
2054 }
2055
2056 void FX_CALL trap_grColorMaskExt (FxBool r,
2057                                   FxBool g,
2058                                   FxBool b,
2059                                   FxBool a)
2060 {
2061 #define FN_NAME "grColorMaskExt"
2062  TRAP_LOG("%s(%s, %s, %s, %s)\n", FN_NAME, TRP_BOOL(r), TRP_BOOL(g), TRP_BOOL(b), TRP_BOOL(a));
2063  assert(real_grColorMaskExt);
2064  (*real_grColorMaskExt)(r, g, b, a);
2065 #undef FN_NAME
2066 }
2067
2068 void FX_CALL trap_grAlphaBlendFunctionExt (GrAlphaBlendFnc_t rgb_sf,
2069                                            GrAlphaBlendFnc_t rgb_df,
2070                                            GrAlphaBlendOp_t  rgb_op,
2071                                            GrAlphaBlendFnc_t alpha_sf,
2072                                            GrAlphaBlendFnc_t alpha_df,
2073                                            GrAlphaBlendOp_t  alpha_op)
2074 {
2075 #define FN_NAME "grAlphaBlendFunctionExt"
2076  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));
2077  assert(real_grAlphaBlendFunctionExt);
2078  (*real_grAlphaBlendFunctionExt)(rgb_sf, rgb_df, rgb_op, alpha_sf, alpha_df, alpha_op);
2079 #undef FN_NAME
2080 }
2081
2082 void FX_CALL trap_grTBufferWriteMaskExt (FxU32 tmask)
2083 {
2084 #define FN_NAME "grTBufferWriteMaskExt"
2085  TRAP_LOG("%s(%08lx)\n", FN_NAME, tmask);
2086  assert(real_grTBufferWriteMaskExt);
2087  (*real_grTBufferWriteMaskExt)(tmask);
2088 #undef FN_NAME
2089 }
2090 #endif
2091
2092
2093
2094 /****************************************************************************\
2095 * interface
2096 \****************************************************************************/
2097 void tdfx_hook_glide (struct tdfx_glide *Glide)
2098 {
2099 #if DEBUG_TRAP
2100 #define GET_EXT_ADDR(name)  *(GrProc *)&real_##name = grGetProcAddress(#name), Glide->name = trap_##name
2101 #else  /* DEBUG_TRAP */
2102 #define GET_EXT_ADDR(name)  *(GrProc *)&Glide->name = grGetProcAddress(#name)
2103 #endif /* DEBUG_TRAP */
2104
2105  /*
2106  ** glide extensions
2107  */
2108  GET_EXT_ADDR(grGetRegistryOrEnvironmentStringExt);
2109  GET_EXT_ADDR(grGetGammaTableExt);
2110  GET_EXT_ADDR(grChromaRangeModeExt);
2111  GET_EXT_ADDR(grChromaRangeExt);
2112  GET_EXT_ADDR(grTexChromaModeExt);
2113  GET_EXT_ADDR(grTexChromaRangeExt);
2114  /* tbext */
2115  GET_EXT_ADDR(grTextureBufferExt);
2116  GET_EXT_ADDR(grTextureAuxBufferExt);
2117  GET_EXT_ADDR(grAuxBufferExt);
2118  /* napalm */
2119  GET_EXT_ADDR(grSstWinOpenExt);
2120  GET_EXT_ADDR(grStencilFuncExt);
2121  GET_EXT_ADDR(grStencilMaskExt);
2122  GET_EXT_ADDR(grStencilOpExt);
2123  GET_EXT_ADDR(grLfbConstantStencilExt);
2124  GET_EXT_ADDR(grBufferClearExt);
2125  GET_EXT_ADDR(grColorCombineExt);
2126  GET_EXT_ADDR(grAlphaCombineExt);
2127  GET_EXT_ADDR(grTexColorCombineExt);
2128  GET_EXT_ADDR(grTexAlphaCombineExt);
2129  GET_EXT_ADDR(grConstantColorValueExt);
2130  GET_EXT_ADDR(grColorMaskExt);
2131  GET_EXT_ADDR(grAlphaBlendFunctionExt);
2132  GET_EXT_ADDR(grTBufferWriteMaskExt);
2133
2134 #undef GET_EXT_ADDR
2135 }