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