/*
 * 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 : dborca@users.sourceforge.net
 *  Web   : http://www.geocities.com/dborca
 */


#ifdef FX

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <assert.h>

#define FX_TRAP_GLIDE_internal
#include "fxg.h"


/****************************************************************************\
* logging                                                                    *
\****************************************************************************/
#if FX_TRAP_GLIDE
#define TRAP_LOG trp_printf
#ifdef __GNUC__
__attribute__ ((format(printf, 1, 2)))
#endif /* __GNUC__ */
int trp_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  /* FX_TRAP_GLIDE */
#ifdef __GNUC__
#define TRAP_LOG(format, ...) do {} while (0)
#else  /* __GNUC__ */
#define TRAP_LOG              0 && (unsigned long)
#endif /* __GNUC__ */
#endif /* FX_TRAP_GLIDE */


#if FX_TRAP_GLIDE
/****************************************************************************\
* 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_SAME_COLOR_EXT);
        /*TRAP_CASE_STRING(GR_BLEND_RESERVED_8); ==GR_BLEND_SAME_COLOR_EXT*/
        TRAP_CASE_STRING(GR_BLEND_ONE_MINUS_SAME_COLOR_EXT);
        /*TRAP_CASE_STRING(GR_BLEND_RESERVED_9); ==GR_BLEND_ONE_MINUS_SAME_COLOR_EXT*/
        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_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;
 }
}

const char *TRP_TXDITHER (FxU32 dither)
{
 switch (dither) {
        TRAP_CASE_STRING(TX_DITHER_NONE);
        TRAP_CASE_STRING(TX_DITHER_4x4);
        TRAP_CASE_STRING(TX_DITHER_ERR);
        TRAP_NODEFAULT;
 }
}

const char *TRP_TXCOMPRESS (FxU32 compress)
{
 switch (compress) {
        TRAP_CASE_STRING(TX_COMPRESSION_STATISTICAL);
        TRAP_CASE_STRING(TX_COMPRESSION_HEURISTIC);
        TRAP_NODEFAULT;
 }
}


/****************************************************************************\
* REAL POINTERS                                                              *
\****************************************************************************/

/*
** glide extensions
*/
void (FX_CALL *real_grSetNumPendingBuffers) (FxI32 NumPendingBuffers);
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);

/* pointcast */
void (FX_CALL *real_grTexDownloadTableExt) (GrChipID_t tmu, GrTexTable_t type, void *data);
void (FX_CALL *real_grTexDownloadTablePartialExt) (GrChipID_t tmu, GrTexTable_t type, void *data, int start, int end);
void (FX_CALL *real_grTexNCCTableExt) (GrChipID_t tmu, GrNCCTable_t table);

/* 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);

/*
** texus
*/
void (FX_CALL *real_txImgQuantize) (char *dst, char *src, int w, int h, FxU32 format, FxU32 dither);
void (FX_CALL *real_txMipQuantize) (TxMip *pxMip, TxMip *txMip, int fmt, FxU32 d, FxU32 comp);
void (FX_CALL *real_txPalToNcc) (GuNccTable *ncc_table, const FxU32 *pal);


/****************************************************************************\
* 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
}

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); /* some Glide libs don't have it; not used anyway */
#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); /* some Glide libs don't have it; not used anyway */
#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
*/
void FX_CALL trap_grSetNumPendingBuffers (FxI32 NumPendingBuffers)
{
#define FN_NAME "grSetNumPendingBuffers"
 TRAP_LOG("%s(%ld)\n", FN_NAME, NumPendingBuffers);
 assert(real_grSetNumPendingBuffers);
 (*real_grSetNumPendingBuffers)(NumPendingBuffers);
#undef FN_NAME
}

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
}

        /* pointcast */
void FX_CALL trap_grTexDownloadTableExt (GrChipID_t   tmu,
                                         GrTexTable_t type,
                                         void         *data)
{
#define FN_NAME "grTexDownloadTableExt"
 TRAP_LOG("%s(%s, %s, %p)\n", FN_NAME, TRP_TMU(tmu), TRP_TABLE(type), data);
 assert(real_grTexDownloadTableExt);
 (*real_grTexDownloadTableExt)(tmu, type, data);
#undef FN_NAME
}

void FX_CALL trap_grTexDownloadTablePartialExt (GrChipID_t   tmu,
                                                GrTexTable_t type,
                                                void         *data,
                                                int          start,
                                                int          end)
{
#define FN_NAME "grTexDownloadTablePartialExt"
 TRAP_LOG("%s(%s, %s, %p, %d, %d)\n", FN_NAME, TRP_TMU(tmu), TRP_TABLE(type), data, start, end);
 assert(real_grTexDownloadTablePartialExt);
 (*real_grTexDownloadTablePartialExt)(tmu, type, data, start, end);
#undef FN_NAME
}

void FX_CALL trap_grTexNCCTableExt (GrChipID_t   tmu,
                                    GrNCCTable_t table)
{
#define FN_NAME "grTexNCCTableExt"
 TRAP_LOG("%s(%s, %s)\n", FN_NAME, TRP_TMU(tmu), TRP_NCC(table));
 assert(real_grTexNCCTableExt);
 (*real_grTexNCCTableExt)(tmu, table);
#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
}

/*
** texus functions
*/
void FX_CALL trap_txImgQuantize (char  *dst,
                                 char  *src,
                                 int   w,
                                 int   h,
                                 FxU32 format,
                                 FxU32 dither)
{
#define FN_NAME "txImgQuantize"
 TRAP_LOG("%s(%p, %p, %d, %d, %s, %s)\n", FN_NAME, dst, src, w, h, TRP_TEXFMT(format), TRP_TXDITHER(dither));
 assert(real_txImgQuantize);
 (*real_txImgQuantize)(dst, src, w, h, format, dither);
#undef FN_NAME
}

void FX_CALL trap_txMipQuantize (TxMip *pxMip,
                                 TxMip *txMip,
                                 int   fmt,
                                 FxU32 d,
                                 FxU32 comp)
{
#define FN_NAME "txMipQuantize"
 TRAP_LOG("%s(%p, %p, %s, %s, %s)\n", FN_NAME, (void *)pxMip, (void *)txMip, TRP_TEXFMT(fmt), TRP_TXDITHER(d), TRP_TXCOMPRESS(comp));
 assert(real_txMipQuantize);
 (*real_txMipQuantize)(pxMip, txMip, fmt, d, comp);
#undef FN_NAME
}

void FX_CALL trap_txPalToNcc (GuNccTable *ncc_table,
                              const FxU32 *pal)
{
#define FN_NAME "txPalToNcc"
 TRAP_LOG("%s(%p, %p)\n", FN_NAME, (void *)ncc_table, (void *)pal);
 assert(real_txPalToNcc);
 (*real_txPalToNcc)(ncc_table, pal);
#undef FN_NAME
}
#endif


/****************************************************************************\
* housekeeping (fake pointers)                                               *
\****************************************************************************/
char *FX_CALL fake_grGetRegistryOrEnvironmentStringExt (char *theEntry)
{
 return getenv(theEntry);
}

void FX_CALL fake_grTexDownloadTableExt (GrChipID_t   tmu,
                                         GrTexTable_t type,
                                         void         *data)
{
 (void)tmu;
 grTexDownloadTable(type, data);
}

void FX_CALL fake_grTexDownloadTablePartialExt (GrChipID_t   tmu,
                                                GrTexTable_t type,
                                                void         *data,
                                                int          start,
                                                int          end)
{
 (void)tmu;
 grTexDownloadTablePartial(type, data, start, end);
}

void FX_CALL fake_grTexNCCTableExt (GrChipID_t   tmu,
                                    GrNCCTable_t table)
{
 (void)tmu;
 grTexNCCTable(table);
}


/****************************************************************************\
* interface                                                                  *
\****************************************************************************/
void tdfx_hook_glide (struct tdfx_glide *Glide, int pointcast)
{
/* GET_EXT_ADDR: get function pointer
 * GET_EXT_FAKE: get function pointer if possible, else use a fake function
 * GET_EXT_NULL: get function pointer if possible, else leave NULL pointer
 */
#if FX_TRAP_GLIDE
#define GET_EXT_ADDR(name) *(GrProc *)&real_##name = grGetProcAddress(#name), Glide->name = trap_##name
#define GET_EXT_FAKE(name) GET_EXT_ADDR(name); if (real_##name == NULL) real_##name = fake_##name
#define GET_EXT_NULL(name) GET_EXT_ADDR(name); if (real_##name == NULL) Glide->name = NULL
#else  /* FX_TRAP_GLIDE */
#define GET_EXT_ADDR(name) *(GrProc *)&Glide->name = grGetProcAddress(#name)
#define GET_EXT_FAKE(name) GET_EXT_ADDR(name); if (Glide->name == NULL) Glide->name = fake_##name
#define GET_EXT_NULL(name) GET_EXT_ADDR(name)
#endif /* FX_TRAP_GLIDE */

 /*
 ** glide extensions
 */
 GET_EXT_NULL(grSetNumPendingBuffers);
 GET_EXT_FAKE(grGetRegistryOrEnvironmentStringExt);
 GET_EXT_ADDR(grGetGammaTableExt);
 GET_EXT_ADDR(grChromaRangeModeExt);
 GET_EXT_ADDR(grChromaRangeExt);
 GET_EXT_ADDR(grTexChromaModeExt);
 GET_EXT_ADDR(grTexChromaRangeExt);
 /* pointcast */
 if (pointcast) {
    GET_EXT_FAKE(grTexDownloadTableExt);
    GET_EXT_FAKE(grTexDownloadTablePartialExt);
    GET_EXT_FAKE(grTexNCCTableExt);
 } else {
    Glide->grTexDownloadTableExt = fake_grTexDownloadTableExt;
    Glide->grTexDownloadTablePartialExt = fake_grTexDownloadTablePartialExt;
    Glide->grTexNCCTableExt = fake_grTexNCCTableExt;
 }
 /* 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);

 /*
 ** texus
 */
 GET_EXT_NULL(txImgQuantize);
 GET_EXT_NULL(txMipQuantize);
 GET_EXT_NULL(txPalToNcc);

#undef GET_EXT_ADDR
}

#endif /* FX */