void main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
TlTexture baseTexture;
unsigned long baseTextureAddr;
TlTexture lightTexture;
unsigned long lightTextureAddr;
int ftsize = 0;
GrFog_t *fogtable = NULL;
TlVertex3D srcVerts[4];
float distance, dDelta;
FxU32 zrange[2];
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "nr", &match, &remArgs ) ) {
if ( rv == -1 ) {
printf( "Unrecognized command line argument\n" );
printf( "%s %s\n", name, usage );
printf( "Available resolutions:\n%s\n",
tlGetResolutionList() );
return;
}
switch( match ) {
case 'n':
frames = atoi( remArgs[0] );
break;
case 'r':
resolution = tlGetResolutionConstant( remArgs[0],
&scrWidth,
&scrHeight );
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
grSstSelect( 0 );
assert( grSstWinOpen( 0,
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_LOWER_LEFT,
2, 1 ) );
tlConSet( 0.0f, 0.0f, 1.0f, 0.5f,
60, 15, 0xffffff );
/* Set up Render State - decal - bilinear - nearest mipmapping - fogging */
grGet(GR_ZDEPTH_MIN_MAX, 8, zrange);
grGet(GR_FOG_TABLE_ENTRIES, 4, &ftsize);
fogtable = malloc(sizeof(GrFog_t)*ftsize);
assert(fogtable);
grVertexLayout(GR_PARAM_XY, 0, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
grTexMipMapMode( GR_TMU0,
GR_MIPMAP_NEAREST,
FXFALSE );
grTexFilterMode( GR_TMU0,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR );
grFogColorValue( 0x404040 );
guFogGenerateExp( fogtable, .2f );
grFogTable( fogtable );
/* Load texture data into system ram */
assert( tlLoadTexture( "decal1.3df",
&baseTexture.info,
&baseTexture.tableType,
&baseTexture.tableData ) );
assert( tlLoadTexture( "light.3df",
&lightTexture.info,
&lightTexture.tableType,
&lightTexture.tableData ) );
/* Download texture data to TMU */
baseTextureAddr = grTexMinAddress( GR_TMU0 );
grTexDownloadMipMap( GR_TMU0,
baseTextureAddr,
GR_MIPMAPLEVELMASK_BOTH,
&baseTexture.info );
if ( baseTexture.tableType != NO_TABLE ) {
grTexDownloadTable( baseTexture.tableType,
&baseTexture.tableData );
}
lightTextureAddr =
baseTextureAddr +
grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH,
&baseTexture.info );
grTexDownloadMipMap( GR_TMU0,
lightTextureAddr,
GR_MIPMAPLEVELMASK_BOTH,
&lightTexture.info );
if ( lightTexture.tableType != NO_TABLE ) {
grTexDownloadTable( lightTexture.tableType,
&lightTexture.tableData );
}
/* Initialize Source 3D data - Rectangle on X/Z Plane
Centered about Y Axis
0--1 Z+
| | |
2--3 - X+
*/
srcVerts[0].x = -0.5f, srcVerts[0].y = 0.0f, srcVerts[0].z = 0.5f, srcVerts[0].w = 1.0f;
srcVerts[1].x = 0.5f, srcVerts[1].y = 0.0f, srcVerts[1].z = 0.5f, srcVerts[1].w = 1.0f;
srcVerts[2].x = -0.5f, srcVerts[2].y = 0.0f, srcVerts[2].z = -0.5f, srcVerts[2].w = 1.0f;
srcVerts[3].x = 0.5f, srcVerts[3].y = 0.0f, srcVerts[3].z = -0.5f, srcVerts[3].w = 1.0f;
srcVerts[0].s = 0.0f, srcVerts[0].t = 0.0f;
srcVerts[1].s = 1.0f, srcVerts[1].t = 0.0f;
srcVerts[2].s = 0.0f, srcVerts[2].t = 1.0f;
srcVerts[3].s = 1.0f, srcVerts[3].t = 1.0f;
#define RED 0x000000ff
#define BLUE 0x00ff0000
#define MAX_DIST 10.0f
#define MIN_DIST 1.0f
distance = 1.0f;
dDelta = 0.05f;
tlConOutput( "Press any key to quit\n\n" );
while( frames-- && tlOkToRender()) {
GrVertex vtxA, vtxB, vtxC, vtxD;
TlVertex3D xfVerts[4];
TlVertex3D prjVerts[4];
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear( 0x00404040, 0, zrange[1] );
/* 3D Transformations */
/*----
A-B
|\|
C-D
-----*/
vtxA.oow = 1.0f;
vtxB = vtxC = vtxD = vtxA;
distance += dDelta;
if ( distance > MAX_DIST ||
distance < MIN_DIST ) {
dDelta *= -1.0f;
distance += dDelta;
}
tlSetMatrix( tlIdentity() );
tlMultMatrix( tlXRotation( -90.0f ) );
tlMultMatrix( tlTranslation( 0.0f, 0.0f, distance ) );
tlTransformVertices( xfVerts, srcVerts, 4 );
tlProjectVertices( prjVerts, xfVerts, 4 );
vtxA.x = tlScaleX( prjVerts[0].x );
vtxA.y = tlScaleY( prjVerts[0].y );
vtxA.oow = 1.0f / prjVerts[0].w;
vtxB.x = tlScaleX( prjVerts[1].x );
vtxB.y = tlScaleY( prjVerts[1].y );
vtxB.oow = 1.0f / prjVerts[1].w;
vtxC.x = tlScaleX( prjVerts[2].x );
vtxC.y = tlScaleY( prjVerts[2].y );
vtxC.oow = 1.0f / prjVerts[2].w;
vtxD.x = tlScaleX( prjVerts[3].x );
vtxD.y = tlScaleY( prjVerts[3].y );
vtxD.oow = 1.0f / prjVerts[3].w;
vtxA.tmuvtx[0].sow = prjVerts[0].s * 255.0f * vtxA.oow;
vtxA.tmuvtx[0].tow = prjVerts[0].t * 255.0f * vtxA.oow;
vtxB.tmuvtx[0].sow = prjVerts[1].s * 255.0f * vtxB.oow;
vtxB.tmuvtx[0].tow = prjVerts[1].t * 255.0f * vtxB.oow;
vtxC.tmuvtx[0].sow = prjVerts[2].s * 255.0f * vtxC.oow;
vtxC.tmuvtx[0].tow = prjVerts[2].t * 255.0f * vtxC.oow;
vtxD.tmuvtx[0].sow = prjVerts[3].s * 255.0f * vtxD.oow;
vtxD.tmuvtx[0].tow = prjVerts[3].t * 255.0f * vtxD.oow;
/* Render First Pass */
grTexCombine( GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
FXFALSE,
FXFALSE );
grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_ZERO,
GR_BLEND_ONE, GR_BLEND_ZERO );
grTexSource( GR_TMU0,
baseTextureAddr,
GR_MIPMAPLEVELMASK_BOTH,
&baseTexture.info );
grFogMode( GR_FOG_ADD2 | GR_FOG_WITH_TABLE_ON_W );
grDrawTriangle( &vtxA, &vtxB, &vtxD );
grDrawTriangle( &vtxA, &vtxD, &vtxC );
/* Render Second Pass */
grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_PREFOG_COLOR,
GR_BLEND_ZERO, GR_BLEND_ZERO );
grTexSource( GR_TMU0,
lightTextureAddr,
GR_MIPMAPLEVELMASK_BOTH,
&lightTexture.info );
grFogMode( GR_FOG_MULT2 | GR_FOG_WITH_TABLE_ON_W );
grDrawTriangle( &vtxA, &vtxB, &vtxD );
grDrawTriangle( &vtxA, &vtxD, &vtxC );
tlConRender();
grBufferSwap( 1 );
grFinish();
while( tlKbHit() ) {
switch( tlGetCH() ) {
default:
frames = 0;
break;
}
}
}
grGlideShutdown();
free(fogtable);
return;
}
void main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
float
minColor = 10.f, /* Vertex min color */
maxColor = 245.f; /* Vertex max color */
GrVertex
localVerts[VERT_COUNT], /* Vertices in world coordinates */
texVerts[4]; /* Texture vertices for background */
float
alpha = 192.0f, /* Alpha for blending tringle over background */
y_angle = 0.0f; /* rotation amount */
int
firstTime; /* Used for performance calculations */
FxBool
plugging = FXFALSE, /* Show shameless plug */
printPerf = FXFALSE, /* Print performance numbers */
lines = FXFALSE, /* Draw lines instead of triangles */
blend = FXFALSE, /* Blend the triangle over the background */
texturing = FXFALSE, /* Texture the tiangle */
antialias = FXTRUE, /* Antialias the triangle? */
bilinear = FXTRUE, /* Perform bilinear filtering on the texture? */
render = FXTRUE, /* Draw? */
backbuffer = FXTRUE, /* Draw to backbuffer? */
background = FXTRUE; /* Draw background? */
GrOriginLocation_t
origin = GR_ORIGIN_LOWER_LEFT; /* Origin */
FxU32
swapDelay = 1, /* Arg to grBufferSwap */
trisDrawn, /* # triangles drawn */
trisProcessed, /* # triangles through pipeline */
lastFrame, /* Number of last frame we did perf stats */
frameNum = 0L; /* id of each frame drawn */
GrCullMode_t
cullMode = GR_CULL_DISABLE; /* backface culling */
GrContext_t*
curContext;
FxU32 startAddress = 0, bgDecalAddress = 0, triDecalAddress = 0;
GrTexInfo
triDecal, /* Triangle decal texture */
bgDecal; /* Background decal texture */
Gu3dfInfo
bgInfo, /* Info on background texture */
triInfo; /* Info on triangle texture */
GrColorCombineFnc_t
ccFnc = GR_COLORCOMBINE_ITRGB; /* Start of w/ Gouraud shading */
char
*bgFileName = NULL, /* Name of background texture file */
*triFileName = NULL; /* Name of triangle texture file */
int
frameCount = 0;
FxU32 wrange[2];
FxI32 state_size;
void *oldState;
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "nrbtea", &match, &remArgs ) ) {
if ( rv == -1 ) {
printf( "Unrecognized command line argument\n" );
printf( "%s %s\n", name, usage );
printf( "Available resolutions:\n%s\n",
tlGetResolutionList() );
return;
}
switch( match ) {
case 'n':
frames = atoi( remArgs[0] );
break;
case 'r':
resolution = tlGetResolutionConstant( remArgs[0],
&scrWidth,
&scrHeight );
break;
case 'b':
bgFileName = strdup( remArgs[0] );
break;
case 't':
triFileName = strdup( remArgs[0] );
break;
case 'a':
alpha = (float)atof( remArgs[0] );
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
curContext = tlGetRenderContext(0,
tlGethWnd(),
resolution, GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
origin,
2, 1);
if (curContext == NULL) {
printf("Could not allocate glide fullscreen context.\n");
exit(-1);
}
grVertexLayout(GR_PARAM_XY, GR_VERTEX_X_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_RGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_A, GR_VERTEX_A_OFFSET << 2, GR_PARAM_ENABLE);
grGet(GR_WDEPTH_MIN_MAX, 8, (FxI32 *)wrange);
grGet(GR_GLIDE_STATE_SIZE, 4, (FxI32 *)&state_size);
oldState = malloc(state_size);
tlConSet( 0.0f, 0.0f, 1.0f, 1.0f,
80, 40, 0xffffff );
if(frames == -1) {
doHelp();
}
localVerts[0].x = 0.f;
localVerts[0].y = 0.75f;
localVerts[0].z = 0.0f;
localVerts[0].tmuvtx[0].sow = 255.f;
localVerts[0].tmuvtx[0].tow = 255.f;
localVerts[0].oow = 1.f;
localVerts[0].r = maxColor;
localVerts[0].g = minColor;
localVerts[0].b = minColor;
localVerts[0].a = 255.f;
localVerts[1].x = -0.75f;
localVerts[1].y = -0.75f;
localVerts[1].z = 0.0f;
localVerts[1].tmuvtx[0].sow = 0.f;
localVerts[1].tmuvtx[0].tow = 255.f;
localVerts[1].oow = 1.f;
localVerts[1].r = minColor;
localVerts[1].g = maxColor;
localVerts[1].b = minColor;
localVerts[1].a = 255.f;
localVerts[2].x = 0.75f;
localVerts[2].y = -0.75f;
localVerts[2].z = 0.0f;
localVerts[2].tmuvtx[0].sow = 255.f;
localVerts[2].tmuvtx[0].tow = 0.f;
localVerts[2].oow = 1.f;
localVerts[2].r = minColor;
localVerts[2].g = minColor;
localVerts[2].b = maxColor;
localVerts[2].a = 255.f;
texVerts[0].x = 0.f;
texVerts[0].y = 0.f;
texVerts[0].a = 255.f;
texVerts[0].oow = 1.f;
texVerts[0].tmuvtx[0].sow = 0.f * texVerts[0].oow;
texVerts[0].tmuvtx[0].tow = 255.f * texVerts[0].oow;
texVerts[1].x = scrWidth;
texVerts[1].y = 0.f;
texVerts[1].a = 255.f;
texVerts[1].oow = 1.f;
texVerts[1].tmuvtx[0].sow = 255.f * texVerts[1].oow;
texVerts[1].tmuvtx[0].tow = 255.f * texVerts[1].oow;
texVerts[2].x = scrWidth;
texVerts[2].y = scrHeight;
texVerts[2].a = 255.f;
texVerts[2].oow = 1.f;
texVerts[2].tmuvtx[0].sow = 255.f * texVerts[2].oow;
texVerts[2].tmuvtx[0].tow = 0.f * texVerts[2].oow;
texVerts[3].x = 0.f;
texVerts[3].y = scrHeight;
texVerts[3].a = 255.f;
texVerts[3].oow = 1.f;
texVerts[3].tmuvtx[0].sow = 0.f * texVerts[3].oow;
texVerts[3].tmuvtx[0].tow = 0.f * texVerts[3].oow;
if (bgFileName == NULL)
bgFileName = "miro.3df";
if (triFileName == NULL)
triFileName = "matt1.3df";
/* Read in background texture file */
if ( gu3dfGetInfo( bgFileName, &bgInfo ) ) {
bgInfo.data = malloc( bgInfo.mem_required );
if ( bgInfo.data == 0 ) {
fprintf( stderr, "out of memory for texture file %s\n", bgFileName );
grGlideShutdown();
exit( -1 );
}
if ( !gu3dfLoad( bgFileName, &bgInfo ) ) {
fprintf( stderr, "could not load texture file %s\n", bgFileName );
grGlideShutdown();
exit( -1 );
}
bgDecal.smallLodLog2 = bgInfo.header.small_lod;
bgDecal.largeLodLog2 = bgInfo.header.large_lod;
bgDecal.aspectRatioLog2 = bgInfo.header.aspect_ratio;
bgDecal.data = bgInfo.data;
bgDecal.format = bgInfo.header.format;
bgDecalAddress = startAddress;
startAddress += grTexCalcMemRequired ( bgDecal.smallLodLog2, bgDecal.largeLodLog2,
bgDecal.aspectRatioLog2, bgDecal.format );
} else {
fprintf( stderr, "could not get info on %s\n", bgFileName );
grGlideShutdown();
exit( -1 );
}
if ( gu3dfGetInfo( triFileName, &triInfo ) ) {
triInfo.data = malloc( triInfo.mem_required );
if ( triInfo.data == 0 ) {
fprintf( stderr, "out of memory for texture file %s\n", triFileName );
grGlideShutdown();
exit( -1 );
}
if ( !gu3dfLoad( triFileName, &triInfo ) ) {
fprintf( stderr, "could not load texture file %s\n", triFileName );
grGlideShutdown();
exit( -1 );
}
triDecal.smallLodLog2 = triInfo.header.small_lod;
triDecal.largeLodLog2 = triInfo.header.large_lod;
triDecal.aspectRatioLog2 = triInfo.header.aspect_ratio;
triDecal.data = triInfo.data;
triDecal.format = triInfo.header.format;
#if 1
triDecal.largeLodLog2 = GR_LOD_LOG2_64;
triDecal.data = ((FxU8*)triDecal.data +
(sizeof(FxU16) * ((256 * 256) + (128 * 128))));
#endif
triDecalAddress = startAddress;
} else {
fprintf( stderr, "could not get info on %s\n", triFileName );
grGlideShutdown();
exit( -1 );
}
while ( 1 ) {
Matrix rotm;
GrVertex xformedVerts[VERT_COUNT];
int i;
static FxBool
resetStateP = FXTRUE;
MatMakeYRot( rotm, DEG2RAD( y_angle ) );
if (resolution == GR_RESOLUTION_NONE)
tlGetResolutionConstant("0",
&scrWidth,
&scrHeight );
for( i = 0; i < VERT_COUNT; i++ ) {
PointMatMult( &xformedVerts[i], &localVerts[i], rotm );
xformedVerts[i].x = xformedVerts[i].x / ( xformedVerts[i].z + 2.0f );
xformedVerts[i].y = xformedVerts[i].y / ( xformedVerts[i].z + 2.0f );
xformedVerts[i].x *= scrWidth / 2.0f;
xformedVerts[i].y *= scrHeight / 2.0f;
xformedVerts[i].x += scrWidth / 2.0f;
xformedVerts[i].y += scrHeight / 2.0f;
xformedVerts[i].oow = 1.f / ((xformedVerts[i].z + 2) * scrHeight);
xformedVerts[i].tmuvtx[0].sow *= xformedVerts[i].oow;
xformedVerts[i].tmuvtx[0].tow *= xformedVerts[i].oow;
}
curContext = tlCheckRenderContext(0);
if (curContext == NULL) {
resetStateP = FXTRUE;
} else {
if (resetStateP) {
grTexDownloadMipMap( GR_TMU0, bgDecalAddress, GR_MIPMAPLEVELMASK_BOTH, &bgDecal);
grTexDownloadMipMap( GR_TMU0, triDecalAddress, GR_MIPMAPLEVELMASK_BOTH, &triDecal);
grTexMipMapMode(GR_TMU0, GR_MIPMAP_NEAREST, FXTRUE);
grTexClampMode( GR_TMU0, GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP);
grTexFilterMode( GR_TMU0, GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR );
grTexCombine( GR_TMU0, GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_NONE, FXFALSE, FXFALSE );
grRenderBuffer(backbuffer == FXTRUE ? GR_BUFFER_BACKBUFFER : GR_BUFFER_FRONTBUFFER);
/* Set up alpha blending for AA and compositing... */
grAlphaCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_NONE,
FXFALSE );
grAlphaBlendFunction( GR_BLEND_SRC_ALPHA,
GR_BLEND_ONE_MINUS_SRC_ALPHA, GR_BLEND_ONE,
GR_BLEND_ZERO );
grAlphaTestFunction( GR_CMP_ALWAYS );
resetStateP = FXFALSE;
}
switch ( ccFnc ) {
case GR_COLORCOMBINE_ITRGB:
grColorCombine( GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED, GR_COMBINE_OTHER_NONE,
FXFALSE );
break;
case GR_COLORCOMBINE_DECAL_TEXTURE:
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER, GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE, GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
break;
case GR_COLORCOMBINE_TEXTURE_TIMES_ITRGB:
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER, GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_LOCAL_ITERATED, GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
break;
}
/* grLfbBypassMode(GR_LFBBYPASS_ENABLE); */
if (render == FXTRUE) {
++frameNum;
if ((frameNum % NFRAMES) == 0) {
if (printPerf) {
if (!firstTime) {
GrSstPerfStats_t
pStats;
FxU32
lfbWritePixels,
nFrames = frameNum - lastFrame,
fillPixels = nFrames * screenFulls[resolution],
totFail;
lastFrame = frameNum;
grGet(GR_STATS_PIXELS_IN, 4, (FxI32 *)&pStats.pixelsIn);
grGet(GR_STATS_PIXELS_CHROMA_FAIL, 4, (FxI32 *)&pStats.chromaFail);
grGet(GR_STATS_PIXELS_DEPTHFUNC_FAIL, 4, (FxI32 *)&pStats.zFuncFail);
grGet(GR_STATS_PIXELS_AFUNC_FAIL, 4, (FxI32 *)&pStats.aFuncFail);
grGet(GR_STATS_PIXELS_OUT, 4, (FxI32 *)&pStats.pixelsOut);
grGet(GR_STATS_TRIANGLES_IN, 4, (FxI32 *)&trisProcessed);
grGet(GR_STATS_TRIANGLES_OUT, 4, (FxI32 *)&trisDrawn);
totFail = pStats.chromaFail + pStats.zFuncFail +
pStats.aFuncFail;
lfbWritePixels = pStats.pixelsOut - pStats.pixelsIn - fillPixels;
tlConOutput("In the last %d frames:\n", nFrames);
tlConOutput(" Pixels Processed: %d\n",
pStats.pixelsIn);
tlConOutput(" Chroma Failures: %d\n",
pStats.chromaFail);
tlConOutput(" Z Compare Failures: %d\n",
pStats.zFuncFail);
tlConOutput(" Alpha Compare Failures: %d\n",
pStats.aFuncFail);
tlConOutput(" Fast Fill Pixels: %d\n",
fillPixels);
tlConOutput(" LFB Write Pixels: %d\n",
lfbWritePixels);
tlConOutput(" Total Pixels Drawn: %d\n",
pStats.pixelsOut);
tlConOutput(" Triangles Processed %d\n",
trisProcessed);
tlConOutput(" Triangles Drawn %d\n",
trisDrawn);
if (
(pStats.pixelsOut - lfbWritePixels - fillPixels - pStats.pixelsIn) != totFail)
tlConOutput("Error: %d != %d\n",
pStats.pixelsOut - lfbWritePixels - fillPixels,
totFail);
grReset(GR_STATS_PIXELS);
} else {
lastFrame = frameNum;
grReset(GR_STATS_PIXELS);
firstTime = 0;
}
}
}
grBufferClear( 0xffffffff, 0, (FxU16)wrange[1] );
if (background == FXTRUE) {
texVerts[0].x = 0.f;
texVerts[0].y = 0.f;
texVerts[1].x = scrWidth;
texVerts[1].y = 0.f;
texVerts[1].x = scrWidth;
texVerts[1].y = 0.f;
texVerts[2].x = scrWidth;
texVerts[2].y = scrHeight;
texVerts[3].x = 0.f;
texVerts[3].y = scrHeight;
grGlideGetState(oldState);
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
grAlphaBlendFunction(
GR_BLEND_ONE, GR_BLEND_ZERO,
GR_BLEND_ONE, GR_BLEND_ZERO);
grColorCombine(
GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE, FXFALSE
);
grTexSource( GR_TMU0, bgDecalAddress, GR_MIPMAPLEVELMASK_BOTH, &bgDecal );
for (i = 0; i < NTRIS; i++) {
grDrawTriangle(&texVerts[0], &texVerts[1], &texVerts[2]);
grDrawTriangle(&texVerts[2], &texVerts[3], &texVerts[0]);
}
grGlideSetState(oldState);
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
if (texturing == FXTRUE)
grTexSource( GR_TMU0, bgDecalAddress, GR_MIPMAPLEVELMASK_BOTH, &bgDecal );
if (texturing)
grTexSource( GR_TMU0, triDecalAddress, GR_MIPMAPLEVELMASK_BOTH, &triDecal );
if (antialias == FXTRUE) {
grEnable(GR_AA_ORDERED);
if (lines == FXTRUE) {
grDrawLine(&xformedVerts[0], &xformedVerts[1]);
grDrawLine(&xformedVerts[1], &xformedVerts[2]);
grDrawLine(&xformedVerts[2], &xformedVerts[0]);
} else {
grAADrawTriangle(
&xformedVerts[0], &xformedVerts[1],
&xformedVerts[2], FXTRUE, FXTRUE, FXTRUE
);
}
} else {
grDisable(GR_AA_ORDERED);
if (lines == FXTRUE) {
grDrawLine(&xformedVerts[0], &xformedVerts[1]);
grDrawLine(&xformedVerts[1], &xformedVerts[2]);
grDrawLine(&xformedVerts[2], &xformedVerts[0]);
} else {
grDrawTriangle(
&xformedVerts[0], &xformedVerts[1],
&xformedVerts[2]
);
}
}
if (plugging)
grSplash(0.f, (origin == GR_ORIGIN_UPPER_LEFT) ? 4.0f / 5.0f * scrHeight : 0.f,
scrWidth / 5.f, scrHeight / 5.f,
frameNum);
if (backbuffer) {
tlConRender();
grBufferSwap( swapDelay );
}
/* Fix for PRS 8197
Delay between pressing a key and "action" happening when
rendering to the front buffer. The hware seems to buffer up
a number of frames so we call grFinish() to remove this delay. jmccartney 13/04/00
*/
else
grFinish();
if (!grSelectContext(*curContext)) *curContext = 0x00UL;
}
}
if (tlKbHit()) {
char c = (char) tlGetCH();
switch (c) {
case 'a':
case 'A':
if (antialias == FXFALSE) {
tlConOutput("Turning ON Antialiasing\n");
antialias = FXTRUE;
} else {
tlConOutput("Turning OFF Antialiasing\n");
antialias = FXFALSE;
}
break;
case 'B':
case 'b':
if (bilinear == FXFALSE) {
bilinear = FXTRUE;
tlConOutput("Turning ON BiLinear blending\n");
grTexFilterMode ( GR_TMU0, GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR );
} else {
bilinear = FXFALSE;
tlConOutput("Turning OFF BiLinear blending\n");
grTexFilterMode ( GR_TMU0, GR_TEXTUREFILTER_POINT_SAMPLED,
GR_TEXTUREFILTER_POINT_SAMPLED );
}
break;
case 'c':
case 'C':
if (blend == FXTRUE) {
int i;
blend = FXFALSE;
for(i=0;i<VERT_COUNT;i++) localVerts[i].a = 255.0f;
} else {
int i;
blend = FXTRUE;
for(i=0;i<VERT_COUNT;i++) localVerts[i].a = alpha;
}
break;
case 'd':
case 'D':
tlConOutput("vtxa = (%.2f, %.2f), vtxb = (%.2f, %.2f), vtxc = (%.2f, %.2f)\n",
xformedVerts[0].x, xformedVerts[0].y,
xformedVerts[1].x, xformedVerts[1].y,
xformedVerts[2].x, xformedVerts[2].y
);
break;
case 'f':
case 'F':
if (backbuffer == FXTRUE) {
backbuffer = FXFALSE;
grRenderBuffer(GR_BUFFER_FRONTBUFFER);
} else {
backbuffer = FXTRUE;
grRenderBuffer(GR_BUFFER_BACKBUFFER);
}
break;
case 'g':
case 'G':
#if 0
grLfbBegin();
grLfbWriteMode(GR_LFBWRITEMODE_565);
grLfbOrigin(GR_ORIGIN_UPPER_LEFT);
grLfbGetReadPtr(GR_BUFFER_FRONTBUFFER);
tlConOutput("Press a key to get front buffer\n");
while (!tlKbHit());
c = (char) tlGetCH();
guFbReadRegion(0,0,(int)wWidth,(int)scrHeight,scrnImage,(int)wWidth * sizeof(FxU16));
tlConOutput("Press a key to put image in back buffer and swap\n");
while (!tlKbHit());
tlGetCH();
grLfbGetWritePtr(GR_BUFFER_BACKBUFFER);
guFbWriteRegion(0,0,(int)wWidth,(int)scrHeight,scrnImage,(int)wWidth * sizeof(FxU16));
grBufferSwap(swapDelay);
tlConOutput("Press a key to continue...\n");
while (!tlKbHit());
tlGetCH();
grLfbEnd();
#endif
break;
case 'h':
case 'H':
case '?':
doHelp();
break;
case 'i':
case 'I':
if (background == FXTRUE) {
background = FXFALSE;
tlConOutput("Turning off background\n");
} else {
tlConOutput("Turning on background\n");
background = FXTRUE;
}
break;
case 'l':
case 'L':
if (lines == FXTRUE) {
lines = FXFALSE;
tlConOutput("Turning OFF lines\n");
} else {
lines = FXTRUE;
tlConOutput("Turning ON lines\n");
}
break;
case 'm':
case 'M':
if (texturing == FXTRUE) {
ccFnc = GR_COLORCOMBINE_TEXTURE_TIMES_ITRGB;
}
break;
case 'n':
case 'N':
if (printPerf == FXFALSE) {
printPerf = FXTRUE;
firstTime = 1;
grReset(GR_STATS_PIXELS);
grReset(GR_STATS_TRIANGLES);
} else {
printPerf= FXFALSE;
}
break;
case 'o':
case 'O':
if (origin == GR_ORIGIN_LOWER_LEFT)
origin = GR_ORIGIN_UPPER_LEFT;
else
origin = GR_ORIGIN_LOWER_LEFT;
grSstOrigin(origin);
break;
case 'p':
case 'P':
if (render == FXTRUE)
render = FXFALSE;
else
render = FXTRUE;
break;
case 'q':
case 'Q':
case 27:
grGlideShutdown();
exit(0);
break;
case 'r':
case 'R':
tlConOutput("Screen Resolution is %s\n", tlGetResolutionString( resolution ) );
break;
case 'S':
case 's':
if (cullMode == GR_CULL_DISABLE) {
cullMode = GR_CULL_NEGATIVE;
tlConOutput("Turning ON backface culling (hidden Surface removal)\n");
} else {
cullMode = GR_CULL_DISABLE;
tlConOutput("Turning OFF backface culling (hidden Surface removal)\n");
}
grCullMode(cullMode);
break;
case 'T':
case 't':
if (texturing == FXFALSE) {
tlConOutput("Turning ON texturing\n");
ccFnc = GR_COLORCOMBINE_DECAL_TEXTURE;
texturing = FXTRUE;
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
} else {
tlConOutput("Turning OFF texturing\n");
ccFnc = GR_COLORCOMBINE_ITRGB;
texturing = FXFALSE;
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_DISABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_DISABLE);
}
break;
case 'u':
case 'U':
if (plugging == FXTRUE) {
plugging = FXFALSE;
grDisable(GR_SHAMELESS_PLUG);
}
else {
plugging = FXTRUE;
grEnable(GR_SHAMELESS_PLUG);
}
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '0':
{
char str[256];
swapDelay = (int) c - 0x30;
sprintf(str, "Swapdelay = %d\n", swapDelay);
tlConOutput(str);
}
break;
}
}
if (render) {
y_angle += 2.f;
if( y_angle > 360.0f )
y_angle -= 360.0f;
}
frameCount++;
if(frameCount < 0)
frameCount = 0;
if(frames == frameCount)
break;
}
grGlideShutdown();
}
void main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
float clipX, clipY, clipSize, clipSizeDelta, clipPosDelta;
FxU32 zrange[2];
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "nr", &match, &remArgs ) ) {
if ( rv == -1 ) {
printf( "Unrecognized command line argument\n" );
printf( "%s %s\n", name, usage );
printf( "Available resolutions:\n%s\n",
tlGetResolutionList() );
return;
}
switch( match ) {
case 'n':
frames = atoi( remArgs[0] );
break;
case 'r':
resolution = tlGetResolutionConstant( remArgs[0],
&scrWidth,
&scrHeight );
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
grSstSelect( 0 );
assert( grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1 ) );
tlConSet( 0.0f, 0.0f, 1.0f, 0.5f,
60, 15, 0xffffff );
/* Set up Render State - iterated alpha + z buffering */
grGet(GR_ZDEPTH_MIN_MAX, 8, zrange);
grVertexLayout(GR_PARAM_XY, 0, GR_PARAM_ENABLE);
grColorCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_NONE,
FXFALSE );
clipX = 0.2f;
clipY = 0.5f;
clipSize = 0.3f;
clipSizeDelta = 0.005f;
clipPosDelta = 0.01f;
#define CLIPSIZE_MIN 0.05f
#define CLIPSIZE_MAX 0.6f
#define GRAY 0x00808080
#define BLACK 0x00000000
tlConOutput( "+/- - grow/shrink clip rectangle\n" );
tlConOutput( "a/d - clip window left/right \n" );
tlConOutput( "w/s - clip window up/down \n" );
tlConOutput( "Press any other key to quit\n" );
while( frames-- && tlOkToRender()) {
int x, y;
GrVertex vtxA, vtxB, vtxC;
int minx, miny, maxx, maxy;
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grClipWindow( (int)tlScaleX(0.0f),(int)tlScaleY(0.0f),
(int)tlScaleX(1.0f),(int)tlScaleY(1.0f) );
grBufferClear( BLACK, 0, zrange[1] );
/* Set Clipping Rectangle */
minx = (int)tlScaleX(clipX);
miny = (int)tlScaleY(clipY);
if ( (clipX+clipSize)>1.0f )
maxx = (int)tlScaleX( 1.0f );
else
maxx = (int)tlScaleX( clipX + clipSize );
if ( (clipY+clipSize)>1.0f )
maxy = (int)tlScaleY( 1.0f );
else
maxy = (int)tlScaleY( clipY + clipSize );
grClipWindow( minx, miny, maxx, maxy );
/* Draw 10x10 grid of triangles */
for( y = 0; y < 10; y++ ) {
for( x = 0; x < 10; x++ ) {
/*
A
|\
B-C
*/
vtxA.x = vtxB.x = tlScaleX( ((float)x)/10.0f );
vtxA.y = tlScaleY( ((float)y)/10.0f );
vtxB.y = vtxC.y = tlScaleY( (((float)y)/10.0f) + 0.1f );
vtxC.x = tlScaleX( (((float)x)/10.0f) + 0.1f );
grConstantColorValue( GRAY );
grDrawTriangle( &vtxA, &vtxB, &vtxC );
}
}
tlConRender();
grBufferSwap( 1 );
grFinish();
while( tlKbHit() ) {
switch( tlGetCH() ) {
case '+':
if ( clipSize < CLIPSIZE_MAX )
clipSize += clipSizeDelta;
break;
case '-':
if ( clipSize > CLIPSIZE_MIN )
clipSize -= clipSizeDelta;
break;
case 'a':
case 'A':
if ( clipX > 0.0f )
clipX -= clipPosDelta;
if ( clipX < 0.0f ) clipX = 0.0f;
break;
case 'd':
case 'D':
if ( clipX < 1.0f )
clipX += clipPosDelta;
break;
case 'w':
case 'W':
if ( clipY > 0.0f )
clipY -= clipPosDelta;
if ( clipY < 0.0f ) clipY = 0.0f;
break;
case 's':
case 'S':
if ( clipY < 1.0f )
clipY += clipPosDelta;
break;
default:
frames = 0;
break;
}
}
}
grGlideShutdown();
return;
}
void
main(int argc, char **argv)
{
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
FxBool scrgrab = FXFALSE;
char filename[256];
FxU8 subframe = 0;
TlTexture texture;
FxU32 zrange[2];
GrContext_t gc = 0;
FxU32 pixelformat = 0x0003; /* 16 bit 565 */
static FxBool useCCExt = 1;
char textureFile[256];
int bigTex = 0;
FxBool needToLoadNewTexture = FXFALSE;
FxBool umaIsEnabled = FXFALSE;
float
xLeft,
xRight,
yTop,
yBottom;
/* Process Command Line Arguments */
while(rv = tlGetOpt(argc, argv, "nrdxp", &match, &remArgs)) {
if (rv == -1) {
printf("Unrecognized command line argument\n");
printf("%s %s\n", name, usage);
printf("Available resolutions:\n%s\n",
tlGetResolutionList());
return;
}
switch(match) {
case 'n':
frames = atoi(remArgs[0]);
break;
case 'r':
resolution = tlGetResolutionConstant(remArgs[0],
&scrWidth,
&scrHeight);
break;
case 'd':
scrgrab = FXTRUE;
frames = 5;
strcpy(filename, remArgs[0]);
break;
case 'p':
pixelformat = tlGetPixelFormat( remArgs[0] );
break;
}
}
tlSetScreen(scrWidth, scrHeight);
version = grGetString(GR_VERSION);
printf("%s:\n%s\n", name, purpose);
printf("%s\n", version);
printf("Resolution: %s\n", tlGetResolutionString(resolution));
if (frames == -1) {
printf("Press A Key To Begin Test.\n");
tlGetCH();
}
/* Initialize Glide */
grGlideInit();
assert(hwconfig = tlVoodooType());
grGet(GR_ZDEPTH_MIN_MAX, 8, (FxI32 *)zrange);
grSstSelect(0);
tlInitGlideExt(&glideext);
if (!glideext.combineext) {
printf("Could not use COMBINE extension.\n");
useCCExt = 0;
}
if (glideext.canDo32BitTexture) {
printf("Using TEXFMT 32-bit extension.\n");
strcpy(textureFile, "t256x32.3df"); /* 32 bits deep */
} else {
printf("Could not use TEXFMT 32-bit extension.\n");
strcpy(textureFile, "miro.3df"); /* 16 bits deep */
}
if (glideext.umaExt) {
printf("Using TEXUMA extension.\n");
grEnable(GR_TEXTURE_UMA_EXT);
umaIsEnabled = FXTRUE;
} else {
printf("Could not use TEXUMA extension.\n");
grDisable(GR_TEXTURE_UMA_EXT);
umaIsEnabled = FXFALSE;
}
if (glideext.grSstWinOpen) {
gc = glideext.grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
pixelformat,
2, 1);
} else {
gc = grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1);
}
if (!gc) {
printf("Could not allocate glide fullscreen context.\n");
goto __errExit;
}
tlVertexLayout();
tlConSet(0.0f, 0.0f, 1.0f, 0.5f,
60, 15, 0xffffff);
/* Load texture data into system ram */
assert(tlLoadTexture(textureFile,
&texture.info,
&texture.tableType,
&texture.tableData));
/* Download texture data to TMU */
grTexDownloadMipMap(GR_TMU0,
grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
if (texture.tableType != NO_TABLE) {
grTexDownloadTable(texture.tableType,
&texture.tableData);
}
/* Select Texture As Source of all texturing operations */
grTexSource(GR_TMU0,
grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
/* Enable Bilinear Filtering + Mipmapping */
grTexFilterMode(GR_TMU0,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR);
grTexMipMapMode(GR_TMU0,
GR_MIPMAP_NEAREST,
FXFALSE);
xLeft = tlScaleX( 0.2f );
xRight = tlScaleX( 0.8f );
yTop = tlScaleY( 0.2f );
yBottom = tlScaleY( 0.8f );
while(frames-- && tlOkToRender()) {
GrVertex vtxA, vtxB, vtxC, vtxD;
static TextureMode textureMode;
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight);
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear(0x00, 0, zrange[1]);
tlConOutput( "m : change lighting mode\n");
tlConOutput( "e : toggle combine extension\n");
tlConOutput( "b : big textures (if TEXFMT extension is available)\n");
tlConOutput( "u : toggle UMA (if TEXUMA extension is available)\n");
tlConOutput("Press any other key to quit\n");
tlConOutput("Current Texture Mode: %s\n", textureModeNames[textureMode]);
tlConOutput("COMBINE extension %s\n", cmodeName[useCCExt]);
if (needToLoadNewTexture) {
/*
* This is only true if TEXFMT extension is available, which
* implies 2k texture capability. Also, this is only true if
* the user has just hit 'b' for big texture testing.
*/
assert(bigTex <= TEX_MAX);
strcpy(textureFile, texFileNames[bigTex]);
/* Redo all the texture loading stuff. */
/* Load texture data into system ram */
assert(tlLoadTexture(textureFile, &texture.info, &texture.tableType,
&texture.tableData));
/* Download texture data to TMU */
grTexDownloadMipMap(GR_TMU0, grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH, &texture.info);
if (texture.tableType != NO_TABLE) {
grTexDownloadTable(texture.tableType, &texture.tableData);
}
/* Select Texture As Source of all texturing operations */
grTexSource(GR_TMU0, grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH, &texture.info);
needToLoadNewTexture = FXFALSE;
}
if (useCCExt) {
#ifdef FX_GLIDE_NAPALM
glideext.grTexColorCombineExt(GR_TMU0,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_LOCAL_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ZERO, FXFALSE,
GR_CMBX_B, FXFALSE,
0, FXFALSE);
switch(textureMode) {
case DECAL:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_ZERO, FXTRUE,
GR_CMBX_ZERO, FXFALSE,
0, FXFALSE);
break;
case FLATLIT:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_CONSTANT_COLOR, FXFALSE,
GR_CMBX_ZERO, FXFALSE,
0, FXFALSE);
break;
case RGBLIT:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_ITRGB, FXFALSE,
GR_CMBX_ZERO, FXFALSE,
0, FXFALSE);
break;
case WHITELIT:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ITALPHA, GR_FUNC_MODE_ZERO,
GR_CMBX_B, FXFALSE,
GR_CMBX_ZERO, FXFALSE,
0, FXFALSE);
glideext.grAlphaCombineExt(GR_CMBX_ITALPHA, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_ZERO, FXTRUE,
GR_CMBX_ALOCAL, FXFALSE,
0, FXFALSE);
break;
case SPECALPHA:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ITALPHA, GR_FUNC_MODE_ZERO,
GR_CMBX_ITRGB, FXFALSE,
GR_CMBX_B, FXFALSE,
0, FXFALSE);
glideext.grAlphaCombineExt(GR_CMBX_ITALPHA, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_ZERO, FXTRUE,
GR_CMBX_ALOCAL, FXFALSE,
0, FXFALSE);
break;
}
#endif
}
else {
/* Set up Render State - Decal Texture - color combine set in render loop */
grTexCombine(GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_NONE,
GR_COMBINE_FACTOR_NONE,
FXFALSE, FXFALSE);
switch(textureMode) {
case DECAL:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
case FLATLIT:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
case RGBLIT:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
case WHITELIT:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL_ALPHA,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
grAlphaCombine(GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
case SPECALPHA:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL_ALPHA,
GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
grAlphaCombine(GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
}
}
/*----
A-B
|\|
C-D
-----*/
vtxA.oow = 1.0f;
vtxB = vtxC = vtxD = vtxA;
vtxA.x = vtxC.x = xLeft;
vtxB.x = vtxD.x = xRight;
vtxA.y = vtxB.y = yTop;
vtxC.y = vtxD.y = yBottom;
vtxA.tmuvtx[0].sow = vtxC.tmuvtx[0].sow = 0.0f;
vtxB.tmuvtx[0].sow = vtxD.tmuvtx[0].sow = 255.0f;
vtxA.tmuvtx[0].tow = vtxB.tmuvtx[0].tow = 0.0f;
vtxC.tmuvtx[0].tow = vtxD.tmuvtx[0].tow = 255.0f;
vtxA.r = 255.0f, vtxA.g = 0.0f, vtxA.b = 0.0f, vtxA.a = 255.0f;
vtxB.r = 0.0f, vtxB.g = 255.0f, vtxB.b = 0.0f, vtxB.a = 128.0f;
vtxC.r = 0.0f, vtxC.g = 0.0f, vtxC.b = 255.0f, vtxC.a = 128.0f;
vtxD.r = 0.0f, vtxD.g = 0.0f, vtxD.b = 0.0f, vtxD.a = 0.0f;
grConstantColorValue(0xFF0000FFUL);
grTexSource(GR_TMU0,
grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
grDrawTriangle(&vtxA, &vtxD, &vtxC);
grDrawTriangle(&vtxA, &vtxB, &vtxD);
tlConRender();
tlConClear();
grBufferSwap(1);
grFinish();
/* grab the frame buffer */
if (scrgrab) {
char fname[256], tmp[32];
FxU16 cnt;
cnt = strcspn(filename, ".");
strncpy(fname, filename, cnt);
fname[cnt] = 0;
sprintf(tmp,"_%d\0", subframe);
strcat(fname, tmp);
strcat(fname, filename+cnt);
if (!tlScreenDump(fname, (FxU16)scrWidth, (FxU16)scrHeight))
printf("Cannot open %s\n", filename);
/* cycle through all mode */
textureMode++;
if (textureMode > SPECALPHA) textureMode = DECAL;
subframe++;
}
while(tlKbHit()) {
const char curKey = tlGetCH();
switch(curKey) {
case 'e':
case 'E':
useCCExt = (!useCCExt);
if (!glideext.combineext)
useCCExt = 0;
break;
case 'm':
case 'M':
textureMode++;
if (textureMode > SPECALPHA) textureMode = DECAL;
break;
case 'b':
case 'B':
/* Cycle through some texture sizes */
if (glideext.canDo2kTexture) {
needToLoadNewTexture = FXTRUE;
bigTex = (bigTex + 1) % (TEX_MAX + 1); /* [0,...,TEX_MAX] */
printf ("%s", texWidthString[bigTex]);
}
break;
case 'u':
case 'U':
if (glideext.umaExt) {
/* Toggle UMA on/off */
if (umaIsEnabled) {
grDisable(GR_TEXTURE_UMA_EXT);
printf ("UMA extension is disabled.\n");
umaIsEnabled = FXFALSE;
} else {
grEnable(GR_TEXTURE_UMA_EXT);
printf ("UMA extension is enabled.\n");
umaIsEnabled = FXTRUE;
}
}
break;
default:
frames = 0;
break;
}
}
}
__errExit:
grGlideShutdown();
}
