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