updates from Daniel Borca

1 files changed, 2135 insertions, 0 deletions

diff --git a/src/mesa/drivers/glide/fxg.c b/src/mesa/drivers/glide/fxg.c
new file mode 100644
index 00000000000..3d00e080b17
--- /dev/null
+++ b/src/mesa/drivers/glide/fxg.c
@@ -0,0 +1,2135 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  5.0.1
+ * 
+ * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * Mesa/FX device driver. Interface to Glide3.
+ *
+ *  Copyright (c) 2003 - Daniel Borca
+ *  Email : [email protected]
+ *  Web   : http://www.geocities.com/dborca
+ */
+
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+
+#define DEBUG_TRAP_internal
+#include "fxg.h"
+
+
+
+/****************************************************************************\
+* logging                                                                    *
+\****************************************************************************/
+#if DEBUG_TRAP
+#define TRAP_LOG trap_printf
+#ifdef __GNUC__
+__attribute__ ((format(printf, 1, 2)))
+#endif /* __GNUC__ */
+int trap_printf (const char *format, ...)
+{
+ va_list arg;
+ int n;
+ FILE *trap_file;
+ va_start(arg, format);
+ trap_file = fopen("trap.log", "a");
+ if (trap_file == NULL) {
+    trap_file = stderr;
+ }
+ n = vfprintf(trap_file, format, arg);
+ fclose(trap_file);
+ va_end(arg);
+ return n;
+}
+#else  /* DEBUG_TRAP */
+#ifdef __GNUC__
+#define TRAP_LOG(format, ...) do {} while (0)
+#else  /* __GNUC__ */
+#define TRAP_LOG              0 && (unsigned long)
+#endif /* __GNUC__ */
+#endif /* DEBUG_TRAP */
+
+
+
+#if DEBUG_TRAP
+/****************************************************************************\
+* helpers                                                                    *
+\****************************************************************************/
+
+#define GOT "\t"
+
+const char *TRP_BOOL (FxBool b)
+{
+ return b ? "FXTRUE" : "FXFALSE";
+}
+
+#define TRAP_CASE_STRING(name) case name: return #name
+#define TRAP_NODEFAULT default: assert(0)
+
+const char *TRP_PARAM (FxU32 mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_PARAM_DISABLE);
+        TRAP_CASE_STRING(GR_PARAM_ENABLE);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_VTX (FxU32 param)
+{
+ switch (param) {
+        TRAP_CASE_STRING(GR_PARAM_XY);
+        TRAP_CASE_STRING(GR_PARAM_Z);
+        TRAP_CASE_STRING(GR_PARAM_W);
+        TRAP_CASE_STRING(GR_PARAM_Q);
+        TRAP_CASE_STRING(GR_PARAM_FOG_EXT);
+        TRAP_CASE_STRING(GR_PARAM_A);
+        TRAP_CASE_STRING(GR_PARAM_RGB);
+        TRAP_CASE_STRING(GR_PARAM_PARGB);
+        TRAP_CASE_STRING(GR_PARAM_ST0);
+        TRAP_CASE_STRING(GR_PARAM_ST1);
+        TRAP_CASE_STRING(GR_PARAM_ST2);
+        TRAP_CASE_STRING(GR_PARAM_Q0);
+        TRAP_CASE_STRING(GR_PARAM_Q1);
+        TRAP_CASE_STRING(GR_PARAM_Q2);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_ARRAY (FxU32 mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_POINTS);
+        TRAP_CASE_STRING(GR_LINE_STRIP);
+        TRAP_CASE_STRING(GR_LINES);
+        TRAP_CASE_STRING(GR_POLYGON);
+        TRAP_CASE_STRING(GR_TRIANGLE_STRIP);
+        TRAP_CASE_STRING(GR_TRIANGLE_FAN);
+        TRAP_CASE_STRING(GR_TRIANGLES);
+        TRAP_CASE_STRING(GR_TRIANGLE_STRIP_CONTINUE);
+        TRAP_CASE_STRING(GR_TRIANGLE_FAN_CONTINUE);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_BUFFER (GrBuffer_t buffer)
+{
+ switch (buffer) {
+        TRAP_CASE_STRING(GR_BUFFER_FRONTBUFFER);
+        TRAP_CASE_STRING(GR_BUFFER_BACKBUFFER);
+        TRAP_CASE_STRING(GR_BUFFER_AUXBUFFER);
+        TRAP_CASE_STRING(GR_BUFFER_DEPTHBUFFER);
+        TRAP_CASE_STRING(GR_BUFFER_ALPHABUFFER);
+        TRAP_CASE_STRING(GR_BUFFER_TRIPLEBUFFER);
+        TRAP_CASE_STRING(GR_BUFFER_TEXTUREBUFFER_EXT);
+        TRAP_CASE_STRING(GR_BUFFER_TEXTUREAUXBUFFER_EXT);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_ORIGIN (GrOriginLocation_t origin_location)
+{
+ switch (origin_location) {
+        TRAP_CASE_STRING(GR_ORIGIN_UPPER_LEFT);
+        TRAP_CASE_STRING(GR_ORIGIN_LOWER_LEFT);
+        TRAP_CASE_STRING(GR_ORIGIN_ANY);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_REFRESH (GrScreenRefresh_t refresh_rate)
+{
+ switch (refresh_rate) {
+        TRAP_CASE_STRING(GR_REFRESH_60Hz);
+        TRAP_CASE_STRING(GR_REFRESH_70Hz);
+        TRAP_CASE_STRING(GR_REFRESH_72Hz);
+        TRAP_CASE_STRING(GR_REFRESH_75Hz);
+        TRAP_CASE_STRING(GR_REFRESH_80Hz);
+        TRAP_CASE_STRING(GR_REFRESH_90Hz);
+        TRAP_CASE_STRING(GR_REFRESH_100Hz);
+        TRAP_CASE_STRING(GR_REFRESH_85Hz);
+        TRAP_CASE_STRING(GR_REFRESH_120Hz);
+        TRAP_CASE_STRING(GR_REFRESH_NONE);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_COLFMT (GrColorFormat_t color_format)
+{
+ switch (color_format) {
+        TRAP_CASE_STRING(GR_COLORFORMAT_ARGB);
+        TRAP_CASE_STRING(GR_COLORFORMAT_ABGR);
+        TRAP_CASE_STRING(GR_COLORFORMAT_RGBA);
+        TRAP_CASE_STRING(GR_COLORFORMAT_BGRA);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_RESOLUTION (GrScreenResolution_t screen_resolution)
+{
+ switch (screen_resolution) {
+        TRAP_CASE_STRING(GR_RESOLUTION_320x200);
+        TRAP_CASE_STRING(GR_RESOLUTION_320x240);
+        TRAP_CASE_STRING(GR_RESOLUTION_400x256);
+        TRAP_CASE_STRING(GR_RESOLUTION_512x384);
+        TRAP_CASE_STRING(GR_RESOLUTION_640x200);
+        TRAP_CASE_STRING(GR_RESOLUTION_640x350);
+        TRAP_CASE_STRING(GR_RESOLUTION_640x400);
+        TRAP_CASE_STRING(GR_RESOLUTION_640x480);
+        TRAP_CASE_STRING(GR_RESOLUTION_800x600);
+        TRAP_CASE_STRING(GR_RESOLUTION_960x720);
+        TRAP_CASE_STRING(GR_RESOLUTION_856x480);
+        TRAP_CASE_STRING(GR_RESOLUTION_512x256);
+        TRAP_CASE_STRING(GR_RESOLUTION_1024x768);
+        TRAP_CASE_STRING(GR_RESOLUTION_1280x1024);
+        TRAP_CASE_STRING(GR_RESOLUTION_1600x1200);
+        TRAP_CASE_STRING(GR_RESOLUTION_400x300);
+        TRAP_CASE_STRING(GR_RESOLUTION_1152x864);
+        TRAP_CASE_STRING(GR_RESOLUTION_1280x960);
+        TRAP_CASE_STRING(GR_RESOLUTION_1600x1024);
+        TRAP_CASE_STRING(GR_RESOLUTION_1792x1344);
+        TRAP_CASE_STRING(GR_RESOLUTION_1856x1392);
+        TRAP_CASE_STRING(GR_RESOLUTION_1920x1440);
+        TRAP_CASE_STRING(GR_RESOLUTION_2048x1536);
+        TRAP_CASE_STRING(GR_RESOLUTION_2048x2048);
+        TRAP_CASE_STRING(GR_RESOLUTION_NONE);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_BLEND (GrAlphaBlendFnc_t func)
+{
+ switch (func) {
+        TRAP_CASE_STRING(GR_BLEND_ZERO);
+        TRAP_CASE_STRING(GR_BLEND_SRC_ALPHA);
+        TRAP_CASE_STRING(GR_BLEND_SRC_COLOR);
+        /*TRAP_CASE_STRING(GR_BLEND_DST_COLOR); ==GR_BLEND_SRC_COLOR*/
+        TRAP_CASE_STRING(GR_BLEND_DST_ALPHA);
+        TRAP_CASE_STRING(GR_BLEND_ONE);
+        TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SRC_ALPHA);
+        TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SRC_COLOR);
+        /*TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_DST_COLOR); ==GR_BLEND_ONE_MINUS_SRC_COLOR*/
+        TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_DST_ALPHA);
+        TRAP_CASE_STRING(GR_BLEND_RESERVED_8);
+        TRAP_CASE_STRING(GR_BLEND_RESERVED_9);
+        TRAP_CASE_STRING(GR_BLEND_RESERVED_A);
+        TRAP_CASE_STRING(GR_BLEND_RESERVED_B);
+        TRAP_CASE_STRING(GR_BLEND_RESERVED_C);
+        TRAP_CASE_STRING(GR_BLEND_RESERVED_D);
+        TRAP_CASE_STRING(GR_BLEND_RESERVED_E);
+        TRAP_CASE_STRING(GR_BLEND_ALPHA_SATURATE);
+        /*TRAP_CASE_STRING(GR_BLEND_PREFOG_COLOR); ==GR_BLEND_ALPHA_SATURATE*/
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CMBFUNC (GrCombineFunction_t cfunc)
+{
+ switch (cfunc) {
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_ZERO);
+        /*TRAP_CASE_STRING(GR_COMBINE_FUNCTION_NONE); ==GR_COMBINE_FUNCTION_ZERO*/
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_LOCAL);
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_LOCAL_ALPHA);
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER);
+        /*TRAP_CASE_STRING(GR_COMBINE_FUNCTION_BLEND_OTHER); ==GR_COMBINE_FUNCTION_SCALE_OTHER*/
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL);
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL_ALPHA);
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL);
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL);
+        /*TRAP_CASE_STRING(GR_COMBINE_FUNCTION_BLEND); ==GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL*/
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL_ALPHA);
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL);
+        /*TRAP_CASE_STRING(GR_COMBINE_FUNCTION_BLEND_LOCAL); ==GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL*/
+        TRAP_CASE_STRING(GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL_ALPHA);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CMBFACT (GrCombineFactor_t cfactor)
+{
+ switch (cfactor) {
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_ZERO);
+        /*TRAP_CASE_STRING(GR_COMBINE_FACTOR_NONE); ==GR_COMBINE_FACTOR_ZERO*/
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_LOCAL);
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_OTHER_ALPHA);
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_LOCAL_ALPHA);
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_TEXTURE_ALPHA);
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_TEXTURE_RGB);
+        /*TRAP_CASE_STRING(GR_COMBINE_FACTOR_DETAIL_FACTOR); ==GR_COMBINE_FACTOR_TEXTURE_ALPHA*/
+        /*TRAP_CASE_STRING(GR_COMBINE_FACTOR_LOD_FRACTION); ==GR_COMBINE_FACTOR_TEXTURE_RGB ???*/
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE);
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_LOCAL);
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_OTHER_ALPHA);
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_LOCAL_ALPHA);
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_TEXTURE_ALPHA);
+        /*TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_DETAIL_FACTOR); ==GR_COMBINE_FACTOR_ONE_MINUS_TEXTURE_ALPHA*/
+        TRAP_CASE_STRING(GR_COMBINE_FACTOR_ONE_MINUS_LOD_FRACTION);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CMBLOCAL (GrCombineLocal_t clocal)
+{
+ switch (clocal) {
+        TRAP_CASE_STRING(GR_COMBINE_LOCAL_ITERATED);
+        TRAP_CASE_STRING(GR_COMBINE_LOCAL_CONSTANT);
+        /*TRAP_CASE_STRING(GR_COMBINE_LOCAL_NONE); ==GR_COMBINE_LOCAL_CONSTANT*/
+        TRAP_CASE_STRING(GR_COMBINE_LOCAL_DEPTH);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CMBOTHER (GrCombineOther_t cother)
+{
+ switch (cother) {
+        TRAP_CASE_STRING(GR_COMBINE_OTHER_ITERATED);
+        TRAP_CASE_STRING(GR_COMBINE_OTHER_TEXTURE);
+        TRAP_CASE_STRING(GR_COMBINE_OTHER_CONSTANT);
+        /*TRAP_CASE_STRING(GR_COMBINE_OTHER_NONE); ==GR_COMBINE_OTHER_CONSTANT*/
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CMPFUNC (GrCmpFnc_t function)
+{
+ switch (function) {
+        TRAP_CASE_STRING(GR_CMP_NEVER);
+        TRAP_CASE_STRING(GR_CMP_LESS);
+        TRAP_CASE_STRING(GR_CMP_EQUAL);
+        TRAP_CASE_STRING(GR_CMP_LEQUAL);
+        TRAP_CASE_STRING(GR_CMP_GREATER);
+        TRAP_CASE_STRING(GR_CMP_NOTEQUAL);
+        TRAP_CASE_STRING(GR_CMP_GEQUAL);
+        TRAP_CASE_STRING(GR_CMP_ALWAYS);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CKMODE (GrChromakeyMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_CHROMAKEY_DISABLE);
+        TRAP_CASE_STRING(GR_CHROMAKEY_ENABLE);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CULLMODE (GrCullMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_CULL_DISABLE);
+        TRAP_CASE_STRING(GR_CULL_NEGATIVE);
+        TRAP_CASE_STRING(GR_CULL_POSITIVE);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_DEPTHMODE (GrDepthBufferMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_DEPTHBUFFER_DISABLE);
+        TRAP_CASE_STRING(GR_DEPTHBUFFER_ZBUFFER);
+        TRAP_CASE_STRING(GR_DEPTHBUFFER_WBUFFER);
+        TRAP_CASE_STRING(GR_DEPTHBUFFER_ZBUFFER_COMPARE_TO_BIAS);
+        TRAP_CASE_STRING(GR_DEPTHBUFFER_WBUFFER_COMPARE_TO_BIAS);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_DITHERMODE (GrDitherMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_DITHER_DISABLE);
+        TRAP_CASE_STRING(GR_DITHER_2x2);
+        TRAP_CASE_STRING(GR_DITHER_4x4);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_FOGMODE (GrFogMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_FOG_DISABLE);
+        TRAP_CASE_STRING(GR_FOG_WITH_TABLE_ON_FOGCOORD_EXT);
+        TRAP_CASE_STRING(GR_FOG_WITH_TABLE_ON_Q);
+        /*TRAP_CASE_STRING(GR_FOG_WITH_TABLE_ON_W); ==GR_FOG_WITH_TABLE_ON_Q*/
+        TRAP_CASE_STRING(GR_FOG_WITH_ITERATED_Z);
+        TRAP_CASE_STRING(GR_FOG_WITH_ITERATED_ALPHA_EXT);
+        TRAP_CASE_STRING(GR_FOG_MULT2);
+        TRAP_CASE_STRING(GR_FOG_ADD2);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_GETNAME (FxU32 pname)
+{
+ switch (pname) {
+        TRAP_CASE_STRING(GR_BITS_DEPTH);
+        TRAP_CASE_STRING(GR_BITS_RGBA);
+        TRAP_CASE_STRING(GR_FIFO_FULLNESS);
+        TRAP_CASE_STRING(GR_FOG_TABLE_ENTRIES);
+        TRAP_CASE_STRING(GR_GAMMA_TABLE_ENTRIES);
+        TRAP_CASE_STRING(GR_GLIDE_STATE_SIZE);
+        TRAP_CASE_STRING(GR_GLIDE_VERTEXLAYOUT_SIZE);
+        TRAP_CASE_STRING(GR_IS_BUSY);
+        TRAP_CASE_STRING(GR_LFB_PIXEL_PIPE);
+        TRAP_CASE_STRING(GR_MAX_TEXTURE_SIZE);
+        TRAP_CASE_STRING(GR_MAX_TEXTURE_ASPECT_RATIO);
+        TRAP_CASE_STRING(GR_MEMORY_FB);
+        TRAP_CASE_STRING(GR_MEMORY_TMU);
+        TRAP_CASE_STRING(GR_MEMORY_UMA);
+        TRAP_CASE_STRING(GR_NUM_BOARDS);
+        TRAP_CASE_STRING(GR_NON_POWER_OF_TWO_TEXTURES);
+        TRAP_CASE_STRING(GR_NUM_FB);
+        TRAP_CASE_STRING(GR_NUM_SWAP_HISTORY_BUFFER);
+        TRAP_CASE_STRING(GR_NUM_TMU);
+        TRAP_CASE_STRING(GR_PENDING_BUFFERSWAPS);
+        TRAP_CASE_STRING(GR_REVISION_FB);
+        TRAP_CASE_STRING(GR_REVISION_TMU);
+        TRAP_CASE_STRING(GR_STATS_LINES);
+        TRAP_CASE_STRING(GR_STATS_PIXELS_AFUNC_FAIL);
+        TRAP_CASE_STRING(GR_STATS_PIXELS_CHROMA_FAIL);
+        TRAP_CASE_STRING(GR_STATS_PIXELS_DEPTHFUNC_FAIL);
+        TRAP_CASE_STRING(GR_STATS_PIXELS_IN);
+        TRAP_CASE_STRING(GR_STATS_PIXELS_OUT);
+        TRAP_CASE_STRING(GR_STATS_PIXELS);
+        TRAP_CASE_STRING(GR_STATS_POINTS);
+        TRAP_CASE_STRING(GR_STATS_TRIANGLES_IN);
+        TRAP_CASE_STRING(GR_STATS_TRIANGLES_OUT);
+        TRAP_CASE_STRING(GR_STATS_TRIANGLES);
+        TRAP_CASE_STRING(GR_SWAP_HISTORY);
+        TRAP_CASE_STRING(GR_SUPPORTS_PASSTHRU);
+        TRAP_CASE_STRING(GR_TEXTURE_ALIGN);
+        TRAP_CASE_STRING(GR_VIDEO_POSITION);
+        TRAP_CASE_STRING(GR_VIEWPORT);
+        TRAP_CASE_STRING(GR_WDEPTH_MIN_MAX);
+        TRAP_CASE_STRING(GR_ZDEPTH_MIN_MAX);
+        TRAP_CASE_STRING(GR_VERTEX_PARAMETER);
+        TRAP_CASE_STRING(GR_BITS_GAMMA);
+        TRAP_CASE_STRING(GR_GET_RESERVED_1);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_GETSTRING (FxU32 pname)
+{
+ switch (pname) {
+        TRAP_CASE_STRING(GR_EXTENSION);
+        TRAP_CASE_STRING(GR_HARDWARE);
+        TRAP_CASE_STRING(GR_RENDERER);
+        TRAP_CASE_STRING(GR_VENDOR);
+        TRAP_CASE_STRING(GR_VERSION);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_ENABLE (GrEnableMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_AA_ORDERED);
+        TRAP_CASE_STRING(GR_ALLOW_MIPMAP_DITHER);
+        TRAP_CASE_STRING(GR_PASSTHRU);
+        TRAP_CASE_STRING(GR_SHAMELESS_PLUG);
+        TRAP_CASE_STRING(GR_VIDEO_SMOOTHING);
+        TRAP_CASE_STRING(GR_TEXTURE_UMA_EXT);
+        TRAP_CASE_STRING(GR_STENCIL_MODE_EXT);
+        TRAP_CASE_STRING(GR_OPENGL_MODE_EXT);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_COORD (GrCoordinateSpaceMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_WINDOW_COORDS);
+        TRAP_CASE_STRING(GR_CLIP_COORDS);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_STIPPLEMODE (GrStippleMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_STIPPLE_DISABLE);
+        TRAP_CASE_STRING(GR_STIPPLE_PATTERN);
+        TRAP_CASE_STRING(GR_STIPPLE_ROTATE);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_LODLEVEL (GrLOD_t lod)
+{
+ switch (lod) {
+        TRAP_CASE_STRING(GR_LOD_LOG2_2048);
+        TRAP_CASE_STRING(GR_LOD_LOG2_1024);
+        TRAP_CASE_STRING(GR_LOD_LOG2_512);
+        TRAP_CASE_STRING(GR_LOD_LOG2_256);
+        TRAP_CASE_STRING(GR_LOD_LOG2_128);
+        TRAP_CASE_STRING(GR_LOD_LOG2_64);
+        TRAP_CASE_STRING(GR_LOD_LOG2_32);
+        TRAP_CASE_STRING(GR_LOD_LOG2_16);
+        TRAP_CASE_STRING(GR_LOD_LOG2_8);
+        TRAP_CASE_STRING(GR_LOD_LOG2_4);
+        TRAP_CASE_STRING(GR_LOD_LOG2_2);
+        TRAP_CASE_STRING(GR_LOD_LOG2_1);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_ASPECTRATIO (GrAspectRatio_t aspect)
+{
+ switch (aspect) {
+        TRAP_CASE_STRING(GR_ASPECT_LOG2_8x1);
+        TRAP_CASE_STRING(GR_ASPECT_LOG2_4x1);
+        TRAP_CASE_STRING(GR_ASPECT_LOG2_2x1);
+        TRAP_CASE_STRING(GR_ASPECT_LOG2_1x1);
+        TRAP_CASE_STRING(GR_ASPECT_LOG2_1x2);
+        TRAP_CASE_STRING(GR_ASPECT_LOG2_1x4);
+        TRAP_CASE_STRING(GR_ASPECT_LOG2_1x8);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_TEXFMT (GrTextureFormat_t fmt)
+{
+ switch (fmt) {
+        TRAP_CASE_STRING(GR_TEXFMT_8BIT);
+        /*TRAP_CASE_STRING(GR_TEXFMT_RGB_332); ==GR_TEXFMT_8BIT*/
+        TRAP_CASE_STRING(GR_TEXFMT_YIQ_422);
+        TRAP_CASE_STRING(GR_TEXFMT_ALPHA_8);
+        TRAP_CASE_STRING(GR_TEXFMT_INTENSITY_8);
+        TRAP_CASE_STRING(GR_TEXFMT_ALPHA_INTENSITY_44);
+        TRAP_CASE_STRING(GR_TEXFMT_P_8);
+        TRAP_CASE_STRING(GR_TEXFMT_RSVD0);
+        /*TRAP_CASE_STRING(GR_TEXFMT_P_8_6666); ==GR_TEXFMT_RSVD0*/
+        /*TRAP_CASE_STRING(GR_TEXFMT_P_8_6666_EXT); ==GR_TEXFMT_RSVD0*/
+        TRAP_CASE_STRING(GR_TEXFMT_RSVD1);
+        TRAP_CASE_STRING(GR_TEXFMT_16BIT);
+        /*TRAP_CASE_STRING(GR_TEXFMT_ARGB_8332); ==GR_TEXFMT_16BIT*/
+        TRAP_CASE_STRING(GR_TEXFMT_AYIQ_8422);
+        TRAP_CASE_STRING(GR_TEXFMT_RGB_565);
+        TRAP_CASE_STRING(GR_TEXFMT_ARGB_1555);
+        TRAP_CASE_STRING(GR_TEXFMT_ARGB_4444);
+        TRAP_CASE_STRING(GR_TEXFMT_ALPHA_INTENSITY_88);
+        TRAP_CASE_STRING(GR_TEXFMT_AP_88);
+        TRAP_CASE_STRING(GR_TEXFMT_RSVD2);
+        /*TRAP_CASE_STRING(GR_TEXFMT_RSVD4); ==GR_TEXFMT_RSVD2*/
+        TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_FXT1);
+        TRAP_CASE_STRING(GR_TEXFMT_ARGB_8888);
+        TRAP_CASE_STRING(GR_TEXFMT_YUYV_422);
+        TRAP_CASE_STRING(GR_TEXFMT_UYVY_422);
+        TRAP_CASE_STRING(GR_TEXFMT_AYUV_444);
+        TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT1);
+        TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT2);
+        TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT3);
+        TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT4);
+        TRAP_CASE_STRING(GR_TEXFMT_ARGB_CMP_DXT5);
+        TRAP_CASE_STRING(GR_TEXTFMT_RGB_888);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_EVENODD (FxU32 evenOdd)
+{
+ switch (evenOdd) {
+        TRAP_CASE_STRING(GR_MIPMAPLEVELMASK_EVEN);
+        TRAP_CASE_STRING(GR_MIPMAPLEVELMASK_ODD);
+        TRAP_CASE_STRING(GR_MIPMAPLEVELMASK_BOTH);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_NCC (GrNCCTable_t table)
+{
+ switch (table) {
+        TRAP_CASE_STRING(GR_NCCTABLE_NCC0);
+        TRAP_CASE_STRING(GR_NCCTABLE_NCC1);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CLAMPMODE (GrTextureClampMode_t clampmode)
+{
+ switch (clampmode) {
+        TRAP_CASE_STRING(GR_TEXTURECLAMP_WRAP);
+        TRAP_CASE_STRING(GR_TEXTURECLAMP_CLAMP);
+        TRAP_CASE_STRING(GR_TEXTURECLAMP_MIRROR_EXT);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_TEXFILTER (GrTextureFilterMode_t filter_mode)
+{
+ switch (filter_mode) {
+        TRAP_CASE_STRING(GR_TEXTUREFILTER_POINT_SAMPLED);
+        TRAP_CASE_STRING(GR_TEXTUREFILTER_BILINEAR);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_TABLE (GrTexTable_t type)
+{
+ switch (type) {
+        TRAP_CASE_STRING(GR_TEXTABLE_NCC0);
+        TRAP_CASE_STRING(GR_TEXTABLE_NCC1);
+        TRAP_CASE_STRING(GR_TEXTABLE_PALETTE);
+        TRAP_CASE_STRING(GR_TEXTABLE_PALETTE_6666_EXT);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_MIPMODE (GrMipMapMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_MIPMAP_DISABLE);
+        TRAP_CASE_STRING(GR_MIPMAP_NEAREST);
+        TRAP_CASE_STRING(GR_MIPMAP_NEAREST_DITHER);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_TEXBASERANGE (GrTexBaseRange_t range)
+{
+ switch (range) {
+        TRAP_CASE_STRING(GR_TEXBASE_2048);
+        TRAP_CASE_STRING(GR_TEXBASE_1024);
+        TRAP_CASE_STRING(GR_TEXBASE_512);
+        TRAP_CASE_STRING(GR_TEXBASE_256_TO_1);
+        TRAP_CASE_STRING(GR_TEXBASE_256);
+        TRAP_CASE_STRING(GR_TEXBASE_128);
+        TRAP_CASE_STRING(GR_TEXBASE_64);
+        TRAP_CASE_STRING(GR_TEXBASE_32_TO_1);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_LOCKTYPE (GrLock_t type)
+{
+ switch (type) {
+        TRAP_CASE_STRING(GR_LFB_READ_ONLY);
+        TRAP_CASE_STRING(GR_LFB_WRITE_ONLY);
+        /*TRAP_CASE_STRING(GR_LFB_IDLE); ==GR_LFB_READ_ONLY*/
+        TRAP_CASE_STRING(GR_LFB_NOIDLE);
+        TRAP_CASE_STRING(GR_LFB_WRITE_ONLY_EXPLICIT_EXT);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_WRITEMODE (GrLfbWriteMode_t writeMode)
+{
+ switch (writeMode) {
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_565);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_555);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_1555);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED1);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_888);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_8888);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED2);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED3);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_Z32);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED5);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED6);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_RESERVED7);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_565_DEPTH);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_555_DEPTH);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_1555_DEPTH);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_ZA16);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_ANY);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_SRCFMT (GrLfbSrcFmt_t src_format)
+{
+ switch (src_format) {
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_565);
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_555);
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_1555);
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_888);
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_8888);
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_565_DEPTH);
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_555_DEPTH);
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_1555_DEPTH);
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_ZA16);
+        TRAP_CASE_STRING(GR_LFB_SRC_FMT_RLE16);
+        TRAP_CASE_STRING(GR_LFBWRITEMODE_Z32); /*???*/
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CRMODE (GrChromaRangeMode_t mode)
+{
+ switch (mode) {
+        TRAP_CASE_STRING(GR_CHROMARANGE_DISABLE_EXT);
+        /*TRAP_CASE_STRING(GR_CHROMARANGE_RGB_ALL_EXT); ==GR_CHROMARANGE_DISABLE_EXT*/
+        TRAP_CASE_STRING(GR_CHROMARANGE_ENABLE_EXT);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_PIXFMT (GrPixelFormat_t pixelformat)
+{
+ switch (pixelformat) {
+        TRAP_CASE_STRING(GR_PIXFMT_I_8);
+        TRAP_CASE_STRING(GR_PIXFMT_AI_88);
+        TRAP_CASE_STRING(GR_PIXFMT_RGB_565);
+        TRAP_CASE_STRING(GR_PIXFMT_ARGB_1555);
+        TRAP_CASE_STRING(GR_PIXFMT_ARGB_8888);
+        TRAP_CASE_STRING(GR_PIXFMT_AA_2_RGB_565);
+        TRAP_CASE_STRING(GR_PIXFMT_AA_2_ARGB_1555);
+        TRAP_CASE_STRING(GR_PIXFMT_AA_2_ARGB_8888);
+        TRAP_CASE_STRING(GR_PIXFMT_AA_4_RGB_565);
+        TRAP_CASE_STRING(GR_PIXFMT_AA_4_ARGB_1555);
+        TRAP_CASE_STRING(GR_PIXFMT_AA_4_ARGB_8888);
+        TRAP_CASE_STRING(GR_PIXFMT_AA_8_RGB_565);
+        TRAP_CASE_STRING(GR_PIXFMT_AA_8_ARGB_1555);
+        TRAP_CASE_STRING(GR_PIXFMT_AA_8_ARGB_8888);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_STENCILOP (GrStencilOp_t op)
+{
+ switch (op) {
+        TRAP_CASE_STRING(GR_STENCILOP_KEEP);
+        TRAP_CASE_STRING(GR_STENCILOP_ZERO);
+        TRAP_CASE_STRING(GR_STENCILOP_REPLACE);
+        TRAP_CASE_STRING(GR_STENCILOP_INCR_CLAMP);
+        TRAP_CASE_STRING(GR_STENCILOP_DECR_CLAMP);
+        TRAP_CASE_STRING(GR_STENCILOP_INVERT);
+        TRAP_CASE_STRING(GR_STENCILOP_INCR_WRAP);
+        TRAP_CASE_STRING(GR_STENCILOP_DECR_WRAP);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_BLENDOP (GrAlphaBlendOp_t op)
+{
+ switch (op) {
+        TRAP_CASE_STRING(GR_BLEND_OP_ADD);
+        TRAP_CASE_STRING(GR_BLEND_OP_SUB);
+        TRAP_CASE_STRING(GR_BLEND_OP_REVSUB);
+        TRAP_CASE_STRING(GR_BLEND_SAME_COLOR_EXT);
+        TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SAME_COLOR_EXT);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CU (GrCCUColor_t a)
+{
+ switch (a) {
+        TRAP_CASE_STRING(GR_CMBX_ZERO);
+        TRAP_CASE_STRING(GR_CMBX_TEXTURE_ALPHA);
+        TRAP_CASE_STRING(GR_CMBX_ALOCAL);
+        TRAP_CASE_STRING(GR_CMBX_AOTHER);
+        TRAP_CASE_STRING(GR_CMBX_B);
+        TRAP_CASE_STRING(GR_CMBX_CONSTANT_ALPHA);
+        TRAP_CASE_STRING(GR_CMBX_CONSTANT_COLOR);
+        TRAP_CASE_STRING(GR_CMBX_DETAIL_FACTOR);
+        TRAP_CASE_STRING(GR_CMBX_ITALPHA);
+        TRAP_CASE_STRING(GR_CMBX_ITRGB);
+        TRAP_CASE_STRING(GR_CMBX_LOCAL_TEXTURE_ALPHA);
+        TRAP_CASE_STRING(GR_CMBX_LOCAL_TEXTURE_RGB);
+        TRAP_CASE_STRING(GR_CMBX_LOD_FRAC);
+        TRAP_CASE_STRING(GR_CMBX_OTHER_TEXTURE_ALPHA);
+        TRAP_CASE_STRING(GR_CMBX_OTHER_TEXTURE_RGB);
+        TRAP_CASE_STRING(GR_CMBX_TEXTURE_RGB);
+        TRAP_CASE_STRING(GR_CMBX_TMU_CALPHA);
+        TRAP_CASE_STRING(GR_CMBX_TMU_CCOLOR);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_CMBMODE (GrCombineMode_t a_mode)
+{
+ switch (a_mode) {
+        TRAP_CASE_STRING(GR_FUNC_MODE_ZERO);
+        TRAP_CASE_STRING(GR_FUNC_MODE_X);
+        TRAP_CASE_STRING(GR_FUNC_MODE_ONE_MINUS_X);
+        TRAP_CASE_STRING(GR_FUNC_MODE_NEGATIVE_X);
+        TRAP_CASE_STRING(GR_FUNC_MODE_X_MINUS_HALF);
+        TRAP_NODEFAULT;
+ }
+}
+
+const char *TRP_TMU (GrChipID_t tmu)
+{
+ switch (tmu) {
+        TRAP_CASE_STRING(GR_TMU0);
+        TRAP_CASE_STRING(GR_TMU1);
+        TRAP_NODEFAULT;
+ }
+}
+
+
+
+/****************************************************************************\
+* REAL POINTERS                                                              *
+\****************************************************************************/
+
+/*
+** glide extensions
+*/
+char * (FX_CALL *real_grGetRegistryOrEnvironmentStringExt) (char *theEntry);
+void (FX_CALL *real_grGetGammaTableExt) (FxU32 nentries, FxU32 *red, FxU32 *green, FxU32 *blue);
+void (FX_CALL *real_grChromaRangeModeExt) (GrChromakeyMode_t mode);
+void (FX_CALL *real_grChromaRangeExt) (GrColor_t color, GrColor_t range, GrChromaRangeMode_t match_mode);
+void (FX_CALL *real_grTexChromaModeExt) (GrChipID_t tmu, GrChromakeyMode_t mode);
+void (FX_CALL *real_grTexChromaRangeExt) (GrChipID_t tmu, GrColor_t min, GrColor_t max, GrTexChromakeyMode_t mode);
+
+/* tbext */
+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);
+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);
+void (FX_CALL *real_grAuxBufferExt) (GrBuffer_t buffer);
+
+/* napalm */
+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);
+void (FX_CALL *real_grStencilFuncExt) (GrCmpFnc_t fnc, GrStencil_t ref, GrStencil_t mask);
+void (FX_CALL *real_grStencilMaskExt) (GrStencil_t value);
+void (FX_CALL *real_grStencilOpExt) (GrStencilOp_t stencil_fail, GrStencilOp_t depth_fail, GrStencilOp_t depth_pass);
+void (FX_CALL *real_grLfbConstantStencilExt) (GrStencil_t value);
+void (FX_CALL *real_grBufferClearExt) (GrColor_t color, GrAlpha_t alpha, FxU32 depth, GrStencil_t stencil);
+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);
+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);
+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);
+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);
+void (FX_CALL *real_grConstantColorValueExt) (GrChipID_t tmu, GrColor_t value);
+void (FX_CALL *real_grColorMaskExt) (FxBool r, FxBool g, FxBool b, FxBool a);
+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);
+void (FX_CALL *real_grTBufferWriteMaskExt) (FxU32 tmask);
+
+
+
+/****************************************************************************\
+* DEBUG HOOKS                                                                *
+\****************************************************************************/
+
+/*
+** rendering functions
+*/
+void FX_CALL trap_grDrawPoint (const void *pt)
+{
+#define FN_NAME "grDrawPoint"
+ TRAP_LOG("%s(%p)\n", FN_NAME, pt);
+ grDrawPoint(pt);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDrawLine (const void *v1,
+                              const void *v2)
+{
+#define FN_NAME "grDrawLine"
+ TRAP_LOG("%s(%p, %p)\n", FN_NAME, v1, v2);
+ grDrawLine(v1, v2);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDrawTriangle (const void *a,
+                                  const void *b,
+                                  const void *c)
+{
+#define FN_NAME "grDrawTriangle"
+ TRAP_LOG("%s(%p, %p, %p)\n", FN_NAME, a, b, c);
+ grDrawTriangle(a, b, c);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grVertexLayout (FxU32 param,
+                                  FxI32 offset,
+                                  FxU32 mode)
+{
+#define FN_NAME "grVertexLayout"
+ TRAP_LOG("%s(%s, %ld, %s)\n", FN_NAME, TRP_VTX(param), offset, TRP_PARAM(mode));
+ grVertexLayout(param, offset, mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDrawVertexArray (FxU32 mode,
+                                     FxU32 Count,
+                                     void  *pointers)
+{
+#define FN_NAME "grDrawVertexArray"
+ TRAP_LOG("%s(%s, %lu, %p)\n", FN_NAME, TRP_ARRAY(mode), Count, pointers);
+ grDrawVertexArray(mode, Count, pointers);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDrawVertexArrayContiguous (FxU32 mode,
+                                               FxU32 Count,
+                                               void  *pointers,
+                                               FxU32 stride)
+{
+#define FN_NAME "grDrawVertexArrayContiguous"
+ TRAP_LOG("%s(%s, %lu, %p, %lu)\n", FN_NAME, TRP_ARRAY(mode), Count, pointers, stride);
+ grDrawVertexArrayContiguous(mode, Count, pointers, stride);
+#undef FN_NAME
+}
+
+/*
+**  Antialiasing Functions
+*/
+void FX_CALL trap_grAADrawTriangle (const void *a,
+                                    const void *b,
+                                    const void *c,
+                                    FxBool     ab_antialias,
+                                    FxBool     bc_antialias,
+                                    FxBool     ca_antialias)
+{
+#define FN_NAME "grAADrawTriangle"
+ 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));
+ grAADrawTriangle(a, b, c, ab_antialias, bc_antialias, ca_antialias);
+#undef FN_NAME
+}
+
+/*
+** buffer management
+*/
+void FX_CALL trap_grBufferClear (GrColor_t color,
+                                 GrAlpha_t alpha,
+                                 FxU32     depth)
+{
+#define FN_NAME "grBufferClear"
+ TRAP_LOG("%s(%08lx, %02x, %08lx)\n", FN_NAME, color, alpha, depth);
+ grBufferClear(color, alpha, depth);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grBufferSwap (FxU32 swap_interval)
+{
+#define FN_NAME "grBufferSwap"
+ TRAP_LOG("%s(%lu)\n", FN_NAME, swap_interval);
+ grBufferSwap(swap_interval);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grRenderBuffer (GrBuffer_t buffer)
+{
+#define FN_NAME "grRenderBuffer"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BUFFER(buffer));
+ grRenderBuffer(buffer);
+#undef FN_NAME
+}
+
+/*
+** error management
+*/
+void FX_CALL trap_grErrorSetCallback (GrErrorCallbackFnc_t fnc)
+{
+#define FN_NAME "grErrorSetCallback"
+ TRAP_LOG("%s(%p)\n", FN_NAME, (void *)fnc);
+ grErrorSetCallback(fnc);
+#undef FN_NAME
+}
+
+/*
+** SST routines
+*/
+void FX_CALL trap_grFinish (void)
+{
+#define FN_NAME "grFinish"
+ TRAP_LOG("%s()\n", FN_NAME);
+ grFinish();
+#undef FN_NAME
+}
+
+void FX_CALL trap_grFlush (void)
+{
+#define FN_NAME "grFlush"
+ TRAP_LOG("%s()\n", FN_NAME);
+ grFlush();
+#undef FN_NAME
+}
+
+GrContext_t FX_CALL trap_grSstWinOpen (FxU32                hWnd,
+                                       GrScreenResolution_t screen_resolution,
+                                       GrScreenRefresh_t    refresh_rate,
+                                       GrColorFormat_t      color_format,
+                                       GrOriginLocation_t   origin_location,
+                                       int                  nColBuffers,
+                                       int                  nAuxBuffers)
+{
+#define FN_NAME "grSstWinOpen"
+ GrContext_t rv;
+ 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);
+ rv = grSstWinOpen(hWnd, screen_resolution, refresh_rate, color_format, origin_location, nColBuffers, nAuxBuffers);
+ TRAP_LOG(GOT "%p\n", (void *)rv);
+ return rv;
+#undef FN_NAME
+}
+
+FxBool FX_CALL trap_grSstWinClose (GrContext_t context)
+{
+#define FN_NAME "grSstWinClose"
+ FxBool rv;
+ TRAP_LOG("%s(%p)\n", FN_NAME, (void *)context);
+ rv = grSstWinClose(context);
+ TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
+ return rv;
+#undef FN_NAME
+}
+
+void FX_CALL trap_grSetNumPendingBuffers (FxI32 NumPendingBuffers)
+{
+#define FN_NAME "grSetNumPendingBuffers"
+ TRAP_LOG("%s(%ld)\n", FN_NAME, NumPendingBuffers);
+ grSetNumPendingBuffers(NumPendingBuffers);
+#undef FN_NAME
+}
+
+FxBool FX_CALL trap_grSelectContext (GrContext_t context)
+{
+#define FN_NAME "grSelectContext"
+ FxBool rv;
+ TRAP_LOG("%s(%p)\n", FN_NAME, (void *)context);
+ rv = grSelectContext(context);
+ TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
+ return rv;
+#undef FN_NAME
+}
+
+void FX_CALL trap_grSstOrigin (GrOriginLocation_t origin)
+{
+#define FN_NAME "grSstOrigin"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_ORIGIN(origin));
+ grSstOrigin(origin);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grSstSelect (int which_sst)
+{
+#define FN_NAME "grSstSelect"
+ TRAP_LOG("%s(%d)\n", FN_NAME, which_sst);
+ grSstSelect(which_sst);
+#undef FN_NAME
+}
+
+/*
+** Glide configuration and special effect maintenance functions
+*/
+void FX_CALL trap_grAlphaBlendFunction (GrAlphaBlendFnc_t rgb_sf,
+                                        GrAlphaBlendFnc_t rgb_df,
+                                        GrAlphaBlendFnc_t alpha_sf,
+                                        GrAlphaBlendFnc_t alpha_df)
+{
+#define FN_NAME "grAlphaBlendFunction"
+ 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));
+ grAlphaBlendFunction(rgb_sf, rgb_df, alpha_sf, alpha_df);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grAlphaCombine (GrCombineFunction_t function,
+                                  GrCombineFactor_t   factor,
+                                  GrCombineLocal_t    local,
+                                  GrCombineOther_t    other,
+                                  FxBool              invert)
+{
+#define FN_NAME "grAlphaCombine"
+ 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));
+ grAlphaCombine(function, factor, local, other, invert);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grAlphaControlsITRGBLighting (FxBool enable)
+{
+#define FN_NAME "grAlphaControlsITRGBLighting"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BOOL(enable));
+ grAlphaControlsITRGBLighting(enable);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grAlphaTestFunction (GrCmpFnc_t function)
+{
+#define FN_NAME "grAlphaTestFunction"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CMPFUNC(function));
+ grAlphaTestFunction(function);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grAlphaTestReferenceValue (GrAlpha_t value)
+{
+#define FN_NAME "grAlphaTestReferenceValue"
+ TRAP_LOG("%s(%02x)\n", FN_NAME, value);
+ grAlphaTestReferenceValue(value);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grChromakeyMode (GrChromakeyMode_t mode)
+{
+#define FN_NAME "grChromakeyMode"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CKMODE(mode));
+ grChromakeyMode(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grChromakeyValue (GrColor_t value)
+{
+#define FN_NAME "grChromakeyValue"
+ TRAP_LOG("%s(%08lx)\n", FN_NAME, value);
+ grChromakeyValue(value);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grClipWindow (FxU32 minx,
+                                FxU32 miny,
+                                FxU32 maxx,
+                                FxU32 maxy)
+{
+#define FN_NAME "grClipWindow"
+ TRAP_LOG("%s(%lu, %lu, %lu, %lu)\n", FN_NAME, minx, miny, maxx, maxy);
+ grClipWindow(minx, miny, maxx, maxy);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grColorCombine (GrCombineFunction_t function,
+                                  GrCombineFactor_t   factor,
+                                  GrCombineLocal_t    local,
+                                  GrCombineOther_t    other,
+                                  FxBool              invert)
+{
+#define FN_NAME "grColorCombine"
+ 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));
+ grColorCombine(function, factor, local, other, invert);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grColorMask (FxBool rgb,
+                               FxBool a)
+{
+#define FN_NAME "grColorMask"
+ TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_BOOL(rgb), TRP_BOOL(a));
+ grColorMask(rgb, a);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grCullMode (GrCullMode_t mode)
+{
+#define FN_NAME "grCullMode"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CULLMODE(mode));
+ grCullMode(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grConstantColorValue (GrColor_t value)
+{
+#define FN_NAME "grConstantColorValue"
+ TRAP_LOG("%s(%08lx)\n", FN_NAME, value);
+ grConstantColorValue(value);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDepthBiasLevel (FxI32 level)
+{
+#define FN_NAME "grDepthBiasLevel"
+ TRAP_LOG("%s(%ld)\n", FN_NAME, level);
+ grDepthBiasLevel(level);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDepthBufferFunction (GrCmpFnc_t function)
+{
+#define FN_NAME "grDepthBufferFunction"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CMPFUNC(function));
+ grDepthBufferFunction(function);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDepthBufferMode (GrDepthBufferMode_t mode)
+{
+#define FN_NAME "grDepthBufferMode"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_DEPTHMODE(mode));
+ grDepthBufferMode(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDepthMask (FxBool mask)
+{
+#define FN_NAME "grDepthMask"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BOOL(mask));
+ grDepthMask(mask);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDisableAllEffects (void)
+{
+#define FN_NAME "grDisableAllEffects"
+ TRAP_LOG("%s()\n", FN_NAME);
+ grDisableAllEffects();
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDitherMode (GrDitherMode_t mode)
+{
+#define FN_NAME "grDitherMode"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_DITHERMODE(mode));
+ grDitherMode(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grFogColorValue (GrColor_t fogcolor)
+{
+#define FN_NAME "grFogColorValue"
+ TRAP_LOG("%s(%08lx)\n", FN_NAME, fogcolor);
+ grFogColorValue(fogcolor);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grFogMode (GrFogMode_t mode)
+{
+#define FN_NAME "grFogMode"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_FOGMODE(mode));
+ grFogMode(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grFogTable (const GrFog_t ft[])
+{
+#define FN_NAME "grFogTable"
+ TRAP_LOG("%s(%p)\n", FN_NAME, ft);
+ grFogTable(ft);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grLoadGammaTable (FxU32 nentries,
+                                    FxU32 *red,
+                                    FxU32 *green,
+                                    FxU32 *blue)
+{
+#define FN_NAME "grLoadGammaTable"
+ TRAP_LOG("%s(%lu, %p, %p, %p)\n", FN_NAME, nentries, (void *)red, (void *)green, (void *)blue);
+ grLoadGammaTable(nentries, red, green, blue);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grSplash (float x,
+                            float y,
+                            float width,
+                            float height,
+                            FxU32 frame)
+{
+#define FN_NAME "grSplash"
+ TRAP_LOG("%s(%f, %f, %f, %f, %lu)\n", FN_NAME, x, y, width, height, frame);
+ grSplash(x, y, width, height, frame);
+#undef FN_NAME
+}
+
+FxU32 FX_CALL trap_grGet (FxU32 pname,
+                          FxU32 plength,
+                          FxI32 *params)
+{
+#define FN_NAME "grGet"
+ FxU32 rv, i;
+ TRAP_LOG("%s(%s, %lu, %p)\n", FN_NAME, TRP_GETNAME(pname), plength, (void *)params);
+ rv = grGet(pname, plength, params);
+ TRAP_LOG(GOT "[");
+ for (i = 0; i < (rv/sizeof(FxI32)); i++) {
+     TRAP_LOG("%s%ld", i ? ", " : "", params[i]);
+ }
+ TRAP_LOG("]\n");
+ return rv;
+#undef FN_NAME
+}
+
+const char *FX_CALL trap_grGetString (FxU32 pname)
+{
+#define FN_NAME "grGetString"
+ const char *rv;
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_GETSTRING(pname));
+ rv = grGetString(pname);
+ if (rv) {
+    TRAP_LOG(GOT "\"%s\"\n", rv);
+ } else {
+    TRAP_LOG(GOT "NULL\n");
+ }
+ return rv;
+#undef FN_NAME
+}
+
+FxI32 FX_CALL trap_grQueryResolutions (const GrResolution *resTemplate,
+                                       GrResolution       *output)
+{
+#define FN_NAME "grQueryResolutions"
+ FxI32 rv;
+ TRAP_LOG("%s(%p, %p)\n", FN_NAME, (void *)resTemplate, (void *)output);
+ rv = grQueryResolutions(resTemplate, output);
+ TRAP_LOG(GOT "%ld\n", rv);
+ return rv;
+#undef FN_NAME
+}
+
+FxBool FX_CALL trap_grReset (FxU32 what)
+{
+#define FN_NAME "grReset"
+ FxBool rv;
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_GETNAME(what));
+ rv = grReset(what);
+ TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
+ return rv;
+#undef FN_NAME
+}
+
+GrProc FX_CALL trap_grGetProcAddress (char *procName)
+{
+#define FN_NAME "grGetProcAddress"
+ GrProc rv;
+ TRAP_LOG("%s(%s)\n", FN_NAME, procName);
+ rv = grGetProcAddress(procName);
+ TRAP_LOG(GOT "%p\n", (void *)rv);
+ return rv;
+#undef FN_NAME
+}
+
+void FX_CALL trap_grEnable (GrEnableMode_t mode)
+{
+#define FN_NAME "grEnable"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_ENABLE(mode));
+ grEnable(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDisable (GrEnableMode_t mode)
+{
+#define FN_NAME "grDisable"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_ENABLE(mode));
+ grDisable(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grCoordinateSpace (GrCoordinateSpaceMode_t mode)
+{
+#define FN_NAME "grCoordinateSpace"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_COORD(mode));
+ grCoordinateSpace(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grDepthRange (FxFloat n,
+                                FxFloat f)
+{
+#define FN_NAME "grDepthRange"
+ TRAP_LOG("%s(%f, %f)\n", FN_NAME, n, f);
+ grDepthRange(n, f);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grStippleMode (GrStippleMode_t mode)
+{
+#define FN_NAME "grStippleMode"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_STIPPLEMODE(mode));
+ grStippleMode(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grStipplePattern (GrStipplePattern_t mode)
+{
+#define FN_NAME "grStipplePattern"
+ TRAP_LOG("%s(%08lx)\n", FN_NAME, mode);
+ grStipplePattern(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grViewport (FxI32 x,
+                              FxI32 y,
+                              FxI32 width,
+                              FxI32 height)
+{
+#define FN_NAME "grViewport"
+ TRAP_LOG("%s(%ld, %ld, %ld, %ld)\n", FN_NAME, x, y, width, height);
+ grViewport(x, y, width, height);
+#undef FN_NAME
+}
+
+/*
+** texture mapping control functions
+*/
+FxU32 FX_CALL trap_grTexCalcMemRequired (GrLOD_t           lodmin,
+                                         GrLOD_t           lodmax,
+                                         GrAspectRatio_t   aspect,
+                                         GrTextureFormat_t fmt)
+{
+#define FN_NAME "grTexCalcMemRequired"
+ FxU32 rv;
+ TRAP_LOG("%s(%s, %s, %s, %s)\n", FN_NAME, TRP_LODLEVEL(lodmin), TRP_LODLEVEL(lodmax), TRP_ASPECTRATIO(aspect), TRP_TEXFMT(fmt));
+ rv = grTexCalcMemRequired(lodmin, lodmax, aspect, fmt);
+ TRAP_LOG(GOT "%lu\n", rv);
+ return rv;
+#undef FN_NAME
+}
+
+FxU32 FX_CALL trap_grTexTextureMemRequired (FxU32     evenOdd,
+                                            GrTexInfo *info)
+{
+#define FN_NAME "grTexTextureMemRequired"
+ FxU32 rv;
+ TRAP_LOG("%s(%s, %p)\n", FN_NAME, TRP_EVENODD(evenOdd), (void *)info);
+ rv = grTexTextureMemRequired(evenOdd, info);
+ TRAP_LOG(GOT "%lu\n", rv);
+ return rv;
+#undef FN_NAME
+}
+
+FxU32 FX_CALL trap_grTexMinAddress (GrChipID_t tmu)
+{
+#define FN_NAME "grTexMinAddress"
+ FxU32 rv;
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_TMU(tmu));
+ rv = grTexMinAddress(tmu);
+ TRAP_LOG(GOT "%lu\n", rv);
+ return rv;
+#undef FN_NAME
+}
+
+FxU32 FX_CALL trap_grTexMaxAddress (GrChipID_t tmu)
+{
+#define FN_NAME "grTexMaxAddress"
+ FxU32 rv;
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_TMU(tmu));
+ rv = grTexMaxAddress(tmu);
+ TRAP_LOG(GOT "%lu\n", rv);
+ return rv;
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexNCCTable (GrNCCTable_t table)
+{
+#define FN_NAME "grTexNCCTable"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_NCC(table));
+ grTexNCCTable(table);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexSource (GrChipID_t tmu,
+                               FxU32      startAddress,
+                               FxU32      evenOdd,
+                               GrTexInfo  *info)
+{
+#define FN_NAME "grTexSource"
+ TRAP_LOG("%s(%s, %08lx, %s, %p)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_EVENODD(evenOdd), (void *)info);
+ grTexSource(tmu, startAddress, evenOdd, info);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexClampMode (GrChipID_t           tmu,
+                                  GrTextureClampMode_t s_clampmode,
+                                  GrTextureClampMode_t t_clampmode)
+{
+#define FN_NAME "grTexClampMode"
+ TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_CLAMPMODE(s_clampmode), TRP_CLAMPMODE(t_clampmode));
+ grTexClampMode(tmu, s_clampmode, t_clampmode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexCombine (GrChipID_t          tmu,
+                                GrCombineFunction_t rgb_function,
+                                GrCombineFactor_t   rgb_factor,
+                                GrCombineFunction_t alpha_function,
+                                GrCombineFactor_t   alpha_factor,
+                                FxBool              rgb_invert,
+                                FxBool              alpha_invert)
+{
+#define FN_NAME "grTexCombine"
+ 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));
+ grTexCombine(tmu, rgb_function, rgb_factor, alpha_function, alpha_factor, rgb_invert, alpha_invert);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexDetailControl (GrChipID_t tmu,
+                                      int        lod_bias,
+                                      FxU8       detail_scale,
+                                      float      detail_max)
+{
+#define FN_NAME "grTexDetailControl"
+ TRAP_LOG("%s(%s, %u, %d, %f)\n", FN_NAME, TRP_TMU(tmu), lod_bias, detail_scale, detail_max);
+ grTexDetailControl(tmu, lod_bias, detail_scale, detail_max);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexFilterMode (GrChipID_t            tmu,
+                                   GrTextureFilterMode_t minfilter_mode,
+                                   GrTextureFilterMode_t magfilter_mode)
+{
+#define FN_NAME "grTexFilterMode"
+ TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_TEXFILTER(minfilter_mode), TRP_TEXFILTER(magfilter_mode));
+ grTexFilterMode(tmu, minfilter_mode, magfilter_mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexLodBiasValue (GrChipID_t tmu,
+                                     float      bias)
+{
+#define FN_NAME "grTexLodBiasValue"
+ TRAP_LOG("%s(%s, %f)\n", FN_NAME, TRP_TMU(tmu), bias);
+ grTexLodBiasValue(tmu, bias);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexDownloadMipMap (GrChipID_t tmu,
+                                       FxU32      startAddress,
+                                       FxU32      evenOdd,
+                                       GrTexInfo  *info)
+{
+#define FN_NAME "grTexDownloadMipMap"
+ TRAP_LOG("%s(%s, %08lx, %s, %p)\n", FN_NAME, TRP_TMU(tmu), startAddress, TRP_EVENODD(evenOdd), (void *)info);
+ grTexDownloadMipMap(tmu, startAddress, evenOdd, info);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexDownloadMipMapLevel (GrChipID_t        tmu,
+                                            FxU32             startAddress,
+                                            GrLOD_t           thisLod,
+                                            GrLOD_t           largeLod,
+                                            GrAspectRatio_t   aspectRatio,
+                                            GrTextureFormat_t format,
+                                            FxU32             evenOdd,
+                                            void              *data)
+{
+#define FN_NAME "grTexDownloadMipMapLevel"
+ 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);
+ grTexDownloadMipMapLevel(tmu, startAddress, thisLod, largeLod, aspectRatio, format, evenOdd, data);
+#undef FN_NAME
+}
+
+FxBool FX_CALL trap_grTexDownloadMipMapLevelPartial (GrChipID_t        tmu,
+                                                     FxU32             startAddress,
+                                                     GrLOD_t           thisLod,
+                                                     GrLOD_t           largeLod,
+                                                     GrAspectRatio_t   aspectRatio,
+                                                     GrTextureFormat_t format,
+                                                     FxU32             evenOdd,
+                                                     void              *data,
+                                                     int               start,
+                                                     int               end)
+{
+#define FN_NAME "grTexDownloadMipMapLevelPartial"
+ FxBool rv;
+ 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);
+ rv = grTexDownloadMipMapLevelPartial(tmu, startAddress, thisLod, largeLod, aspectRatio, format, evenOdd, data, start, end);
+ TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
+ return rv;
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexDownloadTable (GrTexTable_t type,
+                                      void         *data)
+{
+#define FN_NAME "grTexDownloadTable"
+ TRAP_LOG("%s(%s, %p)\n", FN_NAME, TRP_TABLE(type), data);
+ grTexDownloadTable(type, data);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexDownloadTablePartial (GrTexTable_t type,
+                                             void         *data,
+                                             int          start,
+                                             int          end)
+{
+#define FN_NAME "grTexDownloadTablePartial"
+ TRAP_LOG("%s(%s, %p, %d, %d)\n", FN_NAME, TRP_TABLE(type), data, start, end);
+ grTexDownloadTablePartial(type, data, start, end);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexMipMapMode (GrChipID_t     tmu,
+                                   GrMipMapMode_t mode,
+                                   FxBool         lodBlend)
+{
+#define FN_NAME "grTexMipMapMode"
+ TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_MIPMODE(mode), TRP_BOOL(lodBlend));
+ grTexMipMapMode(tmu, mode, lodBlend);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexMultibase (GrChipID_t tmu,
+                                  FxBool     enable)
+{
+#define FN_NAME "grTexMultibase"
+ TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_BOOL(enable));
+ grTexMultibase(tmu, enable);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexMultibaseAddress (GrChipID_t       tmu,
+                                         GrTexBaseRange_t range,
+                                         FxU32            startAddress,
+                                         FxU32            evenOdd,
+                                         GrTexInfo        *info)
+{
+#define FN_NAME "grTexMultibaseAddress"
+ TRAP_LOG("%s(%s, %s, %08lx, %s, %p)\n", FN_NAME, TRP_TMU(tmu), TRP_TEXBASERANGE(range), startAddress, TRP_EVENODD(evenOdd), (void *)info);
+ grTexMultibaseAddress(tmu, range, startAddress, evenOdd, info);
+#undef FN_NAME
+}
+
+/*
+** linear frame buffer functions
+*/
+FxBool FX_CALL trap_grLfbLock (GrLock_t           type,
+                               GrBuffer_t         buffer,
+                               GrLfbWriteMode_t   writeMode,
+                               GrOriginLocation_t origin,
+                               FxBool             pixelPipeline,
+                               GrLfbInfo_t        *info)
+{
+#define FN_NAME "grLfbLock"
+ FxBool rv;
+ 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);
+ rv = grLfbLock(type, buffer, writeMode, origin, pixelPipeline, info);
+ TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
+ return rv;
+#undef FN_NAME
+}
+
+FxBool FX_CALL trap_grLfbUnlock (GrLock_t   type,
+                                 GrBuffer_t buffer)
+{
+#define FN_NAME "grLfbUnlock"
+ FxBool rv;
+ TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_LOCKTYPE(type), TRP_BUFFER(buffer));
+ rv = grLfbUnlock(type, buffer);
+ TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
+ return rv;
+#undef FN_NAME
+}
+
+void FX_CALL trap_grLfbConstantAlpha (GrAlpha_t alpha)
+{
+#define FN_NAME "grLfbConstantAlpha"
+ TRAP_LOG("%s(%02x)\n", FN_NAME, alpha);
+ grLfbConstantAlpha(alpha);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grLfbConstantDepth (FxU32 depth)
+{
+#define FN_NAME "grLfbConstantDepth"
+ TRAP_LOG("%s(%08lx)\n", FN_NAME, depth);
+ grLfbConstantDepth(depth);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grLfbWriteColorSwizzle (FxBool swizzleBytes,
+                                          FxBool swapWords)
+{
+#define FN_NAME "grLfbWriteColorSwizzle"
+ TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_BOOL(swizzleBytes), TRP_BOOL(swapWords));
+ grLfbWriteColorSwizzle(swizzleBytes, swapWords);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grLfbWriteColorFormat (GrColorFormat_t colorFormat)
+{
+#define FN_NAME "grLfbWriteColorFormat"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_COLFMT(colorFormat));
+ grLfbWriteColorFormat(colorFormat);
+#undef FN_NAME
+}
+
+FxBool FX_CALL trap_grLfbWriteRegion (GrBuffer_t    dst_buffer,
+                                      FxU32         dst_x,
+                                      FxU32         dst_y,
+                                      GrLfbSrcFmt_t src_format,
+                                      FxU32         src_width,
+                                      FxU32         src_height,
+                                      FxBool        pixelPipeline,
+                                      FxI32         src_stride,
+                                      void          *src_data)
+{
+#define FN_NAME "grLfbWriteRegion"
+ FxBool rv;
+ 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);
+ rv = grLfbWriteRegion(dst_buffer, dst_x, dst_y, src_format, src_width, src_height, pixelPipeline, src_stride, src_data);
+ TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
+ return rv;
+#undef FN_NAME
+}
+
+FxBool FX_CALL trap_grLfbReadRegion (GrBuffer_t src_buffer,
+                                     FxU32      src_x,
+                                     FxU32      src_y,
+                                     FxU32      src_width,
+                                     FxU32      src_height,
+                                     FxU32      dst_stride,
+                                     void       *dst_data)
+{
+#define FN_NAME "grLfbReadRegion"
+ FxBool rv;
+ 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);
+ rv = grLfbReadRegion(src_buffer, src_x, src_y, src_width, src_height, dst_stride, dst_data);
+ TRAP_LOG(GOT "%s\n", TRP_BOOL(rv));
+ return rv;
+#undef FN_NAME
+}
+
+/*
+** glide management functions
+*/
+void FX_CALL trap_grGlideInit (void)
+{
+#define FN_NAME "grGlideInit"
+ TRAP_LOG("%s()\n", FN_NAME);
+ grGlideInit();
+#undef FN_NAME
+}
+
+void FX_CALL trap_grGlideShutdown (void)
+{
+#define FN_NAME "grGlideShutdown"
+ TRAP_LOG("%s()\n", FN_NAME);
+ grGlideShutdown();
+#undef FN_NAME
+}
+
+void FX_CALL trap_grGlideGetState (void *state)
+{
+#define FN_NAME "grGlideGetState"
+ TRAP_LOG("%s(%p)\n", FN_NAME, state);
+ grGlideGetState(state);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grGlideSetState (const void *state)
+{
+#define FN_NAME "grGlideSetState"
+ TRAP_LOG("%s(%p)\n", FN_NAME, state);
+ grGlideSetState(state);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grGlideGetVertexLayout (void *layout)
+{
+#define FN_NAME "grGlideGetVertexLayout"
+ TRAP_LOG("%s(%p)\n", FN_NAME, layout);
+ grGlideGetVertexLayout(layout);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grGlideSetVertexLayout (const void *layout)
+{
+#define FN_NAME "grGlideSetVertexLayout"
+ TRAP_LOG("%s(%p)\n", FN_NAME, layout);
+ grGlideSetVertexLayout(layout);
+#undef FN_NAME
+}
+
+/*
+** glide utility functions
+*/
+void FX_CALL trap_guGammaCorrectionRGB (FxFloat red,
+                                        FxFloat green,
+                                        FxFloat blue)
+{
+#define FN_NAME "guGammaCorrectionRGB"
+ TRAP_LOG("%s(%f, %f, %f)\n", FN_NAME, red, green, blue);
+ guGammaCorrectionRGB(red, green, blue);
+#undef FN_NAME
+}
+
+float FX_CALL trap_guFogTableIndexToW (int i)
+{
+#define FN_NAME "guFogTableIndexToW"
+ float rv;
+ TRAP_LOG("%s(%d)\n", FN_NAME, i);
+ rv = guFogTableIndexToW(i);
+ TRAP_LOG(GOT "%f\n", rv);
+ return rv;
+#undef FN_NAME
+}
+
+void FX_CALL trap_guFogGenerateExp (GrFog_t *fogtable,
+                                    float   density)
+{
+#define FN_NAME "guFogGenerateExp"
+ TRAP_LOG("%s(%p, %f)\n", FN_NAME, fogtable, density);
+ guFogGenerateExp(fogtable, density);
+#undef FN_NAME
+}
+
+void FX_CALL trap_guFogGenerateExp2 (GrFog_t *fogtable,
+                                     float   density)
+{
+#define FN_NAME "guFogGenerateExp2"
+ TRAP_LOG("%s(%p, %f)\n", FN_NAME, fogtable, density);
+ guFogGenerateExp2(fogtable, density);
+#undef FN_NAME
+}
+
+void FX_CALL trap_guFogGenerateLinear (GrFog_t *fogtable,
+                                       float   nearZ,
+                                       float   farZ)
+{
+#define FN_NAME "guFogGenerateLinear"
+ TRAP_LOG("%s(%p, %f, %f)\n", FN_NAME, fogtable, nearZ, farZ);
+ guFogGenerateLinear(fogtable, nearZ, farZ);
+#undef FN_NAME
+}
+
+/*
+** glide extensions
+*/
+char *FX_CALL trap_grGetRegistryOrEnvironmentStringExt (char *theEntry)
+{
+#define FN_NAME "grGetRegistryOrEnvironmentStringExt"
+ char *rv;
+ TRAP_LOG("%s(\"%s\")\n", FN_NAME, theEntry);
+ assert(real_grGetRegistryOrEnvironmentStringExt);
+ rv = (*real_grGetRegistryOrEnvironmentStringExt)(theEntry);
+ if (rv) {
+    TRAP_LOG(GOT "\"%s\"\n", rv);
+ } else {
+    TRAP_LOG(GOT "NULL\n");
+ }
+ return rv;
+#undef FN_NAME
+}
+
+void FX_CALL trap_grGetGammaTableExt (FxU32 nentries,
+                                      FxU32 *red,
+                                      FxU32 *green,
+                                      FxU32 *blue)
+{
+#define FN_NAME "grGetGammaTableExt"
+ TRAP_LOG("%s(%lu, %p, %p, %p)\n", FN_NAME, nentries, (void *)red, (void *)green, (void *)blue);
+ assert(real_grGetGammaTableExt);
+ (*real_grGetGammaTableExt)(nentries, red, green, blue);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grChromaRangeModeExt (GrChromakeyMode_t mode)
+{
+#define FN_NAME "grChromaRangeModeExt"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_CKMODE(mode));
+ assert(real_grChromaRangeModeExt);
+ (*real_grChromaRangeModeExt)(mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grChromaRangeExt (GrColor_t           color,
+                                    GrColor_t           range,
+                                    GrChromaRangeMode_t match_mode)
+{
+#define FN_NAME "grChromaRangeExt"
+ TRAP_LOG("%s(%08lx, %08lx, %s)\n", FN_NAME, color, range, TRP_CRMODE(match_mode));
+ assert(real_grChromaRangeExt);
+ (*real_grChromaRangeExt)(color, range, match_mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexChromaModeExt (GrChipID_t        tmu,
+                                      GrChromakeyMode_t mode)
+{
+#define FN_NAME "grTexChromaModeExt"
+ TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_CKMODE(mode));
+ assert(real_grTexChromaModeExt);
+ (*real_grTexChromaModeExt)(tmu, mode);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTexChromaRangeExt (GrChipID_t           tmu,
+                                       GrColor_t            min,
+                                       GrColor_t            max,
+                                       GrTexChromakeyMode_t mode)
+{
+#define FN_NAME "grTexChromaRangeExt"
+ TRAP_LOG("%s(%s, %08lx, %08lx, %s)\n", FN_NAME, TRP_TMU(tmu), min, max, TRP_CRMODE(mode));
+ assert(real_grTexChromaRangeExt);
+ (*real_grTexChromaRangeExt)(tmu, min, max, mode);
+#undef FN_NAME
+}
+
+        /* tbext */
+void FX_CALL trap_grTextureBufferExt (GrChipID_t        tmu,
+                                      FxU32             startAddress,
+                                      GrLOD_t           thisLOD,
+                                      GrLOD_t           largeLOD,
+                                      GrAspectRatio_t   aspectRatio,
+                                      GrTextureFormat_t format,
+                                      FxU32             odd_even_mask)
+{
+#define FN_NAME "grTextureBufferExt"
+ 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));
+ assert(real_grTextureBufferExt);
+ (*real_grTextureBufferExt)(tmu, startAddress, thisLOD, largeLOD, aspectRatio, format, odd_even_mask);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTextureAuxBufferExt (GrChipID_t        tmu,
+                                         FxU32             startAddress,
+                                         GrLOD_t           thisLOD,
+                                         GrLOD_t           largeLOD,
+                                         GrAspectRatio_t   aspectRatio,
+                                         GrTextureFormat_t format,
+                                         FxU32             odd_even_mask)
+{
+#define FN_NAME "grTextureAuxBufferExt"
+ 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));
+ assert(real_grTextureAuxBufferExt);
+ (*real_grTextureAuxBufferExt)(tmu, startAddress, thisLOD, largeLOD, aspectRatio, format, odd_even_mask);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grAuxBufferExt (GrBuffer_t buffer)
+{
+#define FN_NAME "grAuxBufferExt"
+ TRAP_LOG("%s(%s)\n", FN_NAME, TRP_BUFFER(buffer));
+ assert(real_grAuxBufferExt);
+ (*real_grAuxBufferExt)(buffer);
+#undef FN_NAME
+}
+
+        /* napalm */
+GrContext_t FX_CALL trap_grSstWinOpenExt (FxU32                hWnd,
+                                          GrScreenResolution_t resolution,
+                                          GrScreenRefresh_t    refresh,
+                                          GrColorFormat_t      format,
+                                          GrOriginLocation_t   origin,
+                                          GrPixelFormat_t      pixelformat,
+                                          int                  nColBuffers,
+                                          int                  nAuxBuffers)
+{
+#define FN_NAME "grSstWinOpenExt"
+ GrContext_t rv;
+ 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);
+ assert(real_grSstWinOpenExt);
+ rv = (*real_grSstWinOpenExt)(hWnd, resolution, refresh, format, origin, pixelformat, nColBuffers, nAuxBuffers);
+ TRAP_LOG(GOT "%p\n", (void *)rv);
+ return rv;
+#undef FN_NAME
+}
+
+void FX_CALL trap_grStencilFuncExt (GrCmpFnc_t  fnc,
+                                    GrStencil_t ref,
+                                    GrStencil_t mask)
+{
+#define FN_NAME "grStencilFuncExt"
+ TRAP_LOG("%s(%s, %02x, %02x)\n", FN_NAME, TRP_CMPFUNC(fnc), ref, mask);
+ assert(real_grStencilFuncExt);
+ (*real_grStencilFuncExt)(fnc, ref, mask);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grStencilMaskExt (GrStencil_t value)
+{
+#define FN_NAME "grStencilMaskExt"
+ TRAP_LOG("%s(%02x)\n", FN_NAME, value);
+ assert(real_grStencilMaskExt);
+ (*real_grStencilMaskExt)(value);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grStencilOpExt (GrStencilOp_t stencil_fail,
+                                  GrStencilOp_t depth_fail,
+                                  GrStencilOp_t depth_pass)
+{
+#define FN_NAME "grStencilOpExt"
+ TRAP_LOG("%s(%s, %s, %s)\n", FN_NAME, TRP_STENCILOP(stencil_fail), TRP_STENCILOP(depth_fail), TRP_STENCILOP(depth_pass));
+ assert(real_grStencilOpExt);
+ (*real_grStencilOpExt)(stencil_fail, depth_fail, depth_pass);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grLfbConstantStencilExt (GrStencil_t value)
+{
+#define FN_NAME "grLfbConstantStencilExt"
+ TRAP_LOG("%s(%02x)\n", FN_NAME, value);
+ assert(real_grLfbConstantStencilExt);
+ (*real_grLfbConstantStencilExt)(value);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grBufferClearExt (GrColor_t   color,
+                                    GrAlpha_t   alpha,
+                                    FxU32       depth,
+                                    GrStencil_t stencil)
+{
+#define FN_NAME "grBufferClearExt"
+ TRAP_LOG("%s(%08lx, %02x, %08lx, %02x)\n", FN_NAME, color, alpha, depth, stencil);
+ assert(real_grBufferClearExt);
+ (*real_grBufferClearExt)(color, alpha, depth, stencil);
+#undef FN_NAME
+}
+
+void FX_CALL trap_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)
+{
+#define FN_NAME "grColorCombineExt"
+ 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));
+ assert(real_grColorCombineExt);
+ (*real_grColorCombineExt)(a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
+#undef FN_NAME
+}
+
+void FX_CALL trap_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)
+{
+#define FN_NAME "grAlphaCombineExt"
+ 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));
+ assert(real_grAlphaCombineExt);
+ (*real_grAlphaCombineExt)(a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
+#undef FN_NAME
+}
+
+void FX_CALL trap_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)
+{
+#define FN_NAME "grTexColorCombineExt"
+ 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));
+ assert(real_grTexColorCombineExt);
+ (*real_grTexColorCombineExt)(tmu, a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
+#undef FN_NAME
+}
+
+void FX_CALL trap_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)
+{
+#define FN_NAME "grTexAlphaCombineExt"
+ 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));
+ assert(real_grTexAlphaCombineExt);
+ (*real_grTexAlphaCombineExt)(tmu, a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grConstantColorValueExt (GrChipID_t tmu,
+                                           GrColor_t  value)
+{
+#define FN_NAME "grConstantColorValueExt"
+ TRAP_LOG("%s(%s, %08lx)\n", FN_NAME, TRP_TMU(tmu), value);
+ assert(real_grConstantColorValueExt);
+ (*real_grConstantColorValueExt)(tmu, value);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grColorMaskExt (FxBool r,
+                                  FxBool g,
+                                  FxBool b,
+                                  FxBool a)
+{
+#define FN_NAME "grColorMaskExt"
+ TRAP_LOG("%s(%s, %s, %s, %s)\n", FN_NAME, TRP_BOOL(r), TRP_BOOL(g), TRP_BOOL(b), TRP_BOOL(a));
+ assert(real_grColorMaskExt);
+ (*real_grColorMaskExt)(r, g, b, a);
+#undef FN_NAME
+}
+
+void FX_CALL trap_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)
+{
+#define FN_NAME "grAlphaBlendFunctionExt"
+ 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));
+ assert(real_grAlphaBlendFunctionExt);
+ (*real_grAlphaBlendFunctionExt)(rgb_sf, rgb_df, rgb_op, alpha_sf, alpha_df, alpha_op);
+#undef FN_NAME
+}
+
+void FX_CALL trap_grTBufferWriteMaskExt (FxU32 tmask)
+{
+#define FN_NAME "grTBufferWriteMaskExt"
+ TRAP_LOG("%s(%08lx)\n", FN_NAME, tmask);
+ assert(real_grTBufferWriteMaskExt);
+ (*real_grTBufferWriteMaskExt)(tmask);
+#undef FN_NAME
+}
+#endif
+
+
+
+/****************************************************************************\
+* interface
+\****************************************************************************/
+void tdfx_hook_glide (struct tdfx_glide *Glide)
+{
+#if DEBUG_TRAP
+#define GET_EXT_ADDR(name)  *(GrProc *)&real_##name = grGetProcAddress(#name), Glide->name = trap_##name
+#else  /* DEBUG_TRAP */
+#define GET_EXT_ADDR(name)  *(GrProc *)&Glide->name = grGetProcAddress(#name)
+#endif /* DEBUG_TRAP */
+
+ /*
+ ** glide extensions
+ */
+ GET_EXT_ADDR(grGetRegistryOrEnvironmentStringExt);
+ GET_EXT_ADDR(grGetGammaTableExt);
+ GET_EXT_ADDR(grChromaRangeModeExt);
+ GET_EXT_ADDR(grChromaRangeExt);
+ GET_EXT_ADDR(grTexChromaModeExt);
+ GET_EXT_ADDR(grTexChromaRangeExt);
+ /* tbext */
+ GET_EXT_ADDR(grTextureBufferExt);
+ GET_EXT_ADDR(grTextureAuxBufferExt);
+ GET_EXT_ADDR(grAuxBufferExt);
+ /* napalm */
+ GET_EXT_ADDR(grSstWinOpenExt);
+ GET_EXT_ADDR(grStencilFuncExt);
+ GET_EXT_ADDR(grStencilMaskExt);
+ GET_EXT_ADDR(grStencilOpExt);
+ GET_EXT_ADDR(grLfbConstantStencilExt);
+ GET_EXT_ADDR(grBufferClearExt);
+ GET_EXT_ADDR(grColorCombineExt);
+ GET_EXT_ADDR(grAlphaCombineExt);
+ GET_EXT_ADDR(grTexColorCombineExt);
+ GET_EXT_ADDR(grTexAlphaCombineExt);
+ GET_EXT_ADDR(grConstantColorValueExt);
+ GET_EXT_ADDR(grColorMaskExt);
+ GET_EXT_ADDR(grAlphaBlendFunctionExt);
+ GET_EXT_ADDR(grTBufferWriteMaskExt);
+
+#undef GET_EXT_ADDR
+}