fxg.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

#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);
#u