/*
** _3dfx_DownloadAndUseTexture
*/
void _3dfx_DownloadAndUseTexture( unsigned long index )
{
_3dfx_DownloadTexture( index );
if ( _3dfx_texture_info[index].handle != GR_NULL_MIPMAP_HANDLE )
grTexSource( _3dfx_texture_info[index].handle );
}
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];
int ftsize = 0;
TlTexture baseTexture;
unsigned long baseTextureAddr;
GrVertex vtxA, vtxB, vtxC, vtxD;
FxBool texchroma = FXFALSE;
char *extstr;
GrProc grTexChromaModeExt = NULL;
GrProc grTexChromaRangeExt = NULL;
GrColor_t min = 0x00, max = 0x007f7f7f;
FxU8 mincolor = 0x00;
FxU8 maxcolor = 0x7f;
FxFloat red = 1.7f, green = 1.7f, blue = 1.7f;
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "nrd", &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 = 1;
strcpy(filename, 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() );
grSstSelect( 0 );
assert( grSstWinOpen( 0,
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1 ) );
tlConSet( 0.0f, 0.0f, 1.0f, 1.0f,
60, 30, 0xffffff );
grVertexLayout(GR_PARAM_XY, GR_VERTEX_X_OFFSET << 2, 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 );
{
/*
** texChroma extension
*/
extension = grGetString(GR_EXTENSION);
extstr = strstr(extension, "CHROMARANGE");
if (!strncmp(extstr, "CHROMARANGE", 11)) {
grTexChromaModeExt = grGetProcAddress("grTexChromaModeExt");
grTexChromaRangeExt = grGetProcAddress("grTexChromaRangeExt");
}
grTexChromaModeExt(GR_TMU0, GR_TEXCHROMA_DISABLE_EXT);
grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
}
assert( tlLoadTexture( "miro.3df",
&baseTexture.info,
&baseTexture.tableType,
&baseTexture.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 );
}
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 );
grTexClampMode( GR_TMU0, GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP);
{
vtxA.x = tlScaleX( 0.2f );
vtxA.y = tlScaleY( 0.2f );
vtxA.oow = 1.0f;
vtxB.x = tlScaleX( 0.8f );
vtxB.y = tlScaleY( 0.2f );
vtxB.oow = 1.0f;
vtxC.x = tlScaleX( 0.2f );
vtxC.y = tlScaleY( 0.8f );
vtxC.oow = 1.0f;
vtxD.x = tlScaleX( 0.8f );
vtxD.y = tlScaleY( 0.8f );
vtxD.oow = 1.0f;
vtxA.tmuvtx[0].sow = 0.f;
vtxA.tmuvtx[0].tow = 0.f;
vtxB.tmuvtx[0].sow = 255.f;
vtxB.tmuvtx[0].tow = 0.f;
vtxC.tmuvtx[0].sow = 0.f;
vtxC.tmuvtx[0].tow = 255.f;
vtxD.tmuvtx[0].sow = 255.f;
vtxD.tmuvtx[0].tow = 255.f;
}
tlConOutput( "Press a key to quit\n" );
tlConOutput( "Press c to turn on/off texture chroma\n" );
tlConOutput( "Press {/} to change max color range\n" );
tlConOutput( "Press [/] to change min color range\n" );
while( frames-- && tlOkToRender()) {
char string[256], tmpstr[64];
if (texchroma)
strcpy(string, "");
else
strcpy(string, "");
sprintf(tmpstr, " (%x,%x,%x) (%x,%x,%x) (%f %f %f) \r", mincolor, mincolor, mincolor, maxcolor, maxcolor, maxcolor,red,green,blue);
strcat(string, tmpstr);
tlConOutput( string );
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear( 0x3f3f3f, 0, 0 );
grDrawTriangle( &vtxA, &vtxB, &vtxD );
grDrawTriangle( &vtxA, &vtxD, &vtxC );
tlConRender();
grBufferSwap( 1 );
/* grab the frame buffer */
if (scrgrab) {
if (!tlScreenDump(filename, (FxU16)scrWidth, (FxU16)scrHeight))
printf( "Cannot open %s\n", filename);
scrgrab = FXFALSE;
}
while( tlKbHit() ) {
switch( tlGetCH() ) {
case 'r':
red -= 0.1f;
guGammaCorrectionRGB(red, green, blue);
break;
case 'R':
red += 0.1f;
guGammaCorrectionRGB(red, green, blue);
break;
case 'g':
green -= 0.1f;
guGammaCorrectionRGB(red, green, blue);
break;
case 'G':
green += 0.1f;
guGammaCorrectionRGB(red, green, blue);
break;
case 'b':
blue -= 0.1f;
guGammaCorrectionRGB(red, green, blue);
break;
case 'B':
blue += 0.1f;
guGammaCorrectionRGB(red, green, blue);
break;
case 'c':
case 'C':
texchroma = !texchroma;
if (texchroma)
grTexChromaModeExt(GR_TMU0, GR_TEXCHROMA_ENABLE_EXT);
else
grTexChromaModeExt(GR_TMU0, GR_TEXCHROMA_DISABLE_EXT);
break;
case '{':
if ((maxcolor > 0x00) && (maxcolor > mincolor))
maxcolor--;
max = (maxcolor << 16) | (maxcolor << 8) | maxcolor;
grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
break;
case '}':
if (maxcolor < 0xff)
maxcolor++;
max = (maxcolor << 16) | (maxcolor << 8) | maxcolor;
grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
break;
case '[':
if (mincolor > 0x00)
mincolor--;
min = (mincolor << 16) | (mincolor << 8) | mincolor;
grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
break;
case ']':
if ((mincolor < 0xff) && (mincolor < maxcolor))
mincolor++;
min = (mincolor << 16) | (mincolor << 8) | mincolor;
grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
break;
default:
frames = 0;
break;
}
}
}
grGlideShutdown();
return;
}
int
main(int argc, char **argv)
{
char match;
char **remArgs;
int rv = -1;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
FxBool scrgrab = FXFALSE;
char filename[256];
FxU32 wrange[2];
FxU32
multiBaseMode = 0,
minTexSize = 1,
maxTexSize = 256;
const TlVertex3D
srcVerts[4] =
{
{ -0.5f, 0.0f, 0.5f, 1.0f, 0.0f, 0.0f },
{ 0.5f, 0.0f, 0.5f, 1.0f, 1.0f, 0.0f },
{ -0.5f, 0.0f, -0.5f, 1.0f, 0.0f, 1.0f },
{ 0.5f, 0.0f, -0.5f, 1.0f, 1.0f, 1.0f }
};
/* Initialize Glide */
grGlideInit();
if ((hwconfig = tlVoodooType()) == 0) {
printf("Error getting 3Dfx hw type.\n");
exit(-1);
}
/* Process Command Line Arguments */
while(rv = tlGetOpt(argc, argv, "dmnrx", &match, &remArgs)) {
if (rv == -1) {
printf("Unrecognized command line argument\n");
printf("%s %s\n", name, usage);
printf("Available resolutions:\n%s\n",
tlGetResolutionList());
exit(-1);
}
switch(match) {
case 'd':
scrgrab = FXTRUE;
if (scrgrab) {
frames = 1;
strcpy(filename, remArgs[0]);
}
break;
case 'm':
/* Do we want to test larger sizes if the hw supports it? */
if (!grGet(GR_MAX_TEXTURE_SIZE, sizeof(maxTexSize), (FxI32 *)&maxTexSize)) {
printf("grGet(GR_MAX_TEXTURE_SIZE) failed.\n");
exit(-1);
}
break;
case 'n':
if (remArgs[0] != NULL) frames = atoi(remArgs[0]);
break;
case 'r':
if (remArgs[0] != NULL) 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);
if (grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1) == 0) {
printf("grSstWinOpen failed.\n");
goto __errExit;
}
tlConSet(0.0f, 0.0f, 1.0f, 1.0f,
60, 30, 0xffffff);
/* Set up Render State */
grGet(GR_WDEPTH_MIN_MAX, 8, (FxI32 *)wrange);
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_CONSTANT,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
grTexCombine(GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
FXFALSE, FXFALSE);
/* Generate texture */
{
GrLOD_t
largeLod,
smallLod;
FxU16*
texData = NULL;
FxU32
totalMapSize,
curMapSize;
/* There's some closed form of this series thing, but I forget
* what it is and am way to lazy to actually go look it up. This
* is only a glide test after all.
*/
totalMapSize = 0;
curMapSize = maxTexSize;
while(curMapSize > 0) {
totalMapSize += (curMapSize * curMapSize) * sizeof(FxU16);
curMapSize >>= 1;
}
texData = (FxU16*)malloc(totalMapSize * sizeof(*texData));
if (texData == NULL) {
printf("Unable to allocate texture data.\n");
exit(-1);
}
/* Figure out the supported log2(lod size) */
largeLod = GR_LOD_LOG2_1;
while((0x01UL << largeLod) != maxTexSize) largeLod++;
smallLod = GR_LOD_LOG2_1;
while((0x01UL << smallLod) != minTexSize) smallLod++;
/* Build simple texture w/ a different color for each map to help
* distinguish the different maps when mipmapping. Additionally,
* add a 'border' so that we can see if the start of the texture
* gets mucked up due to an incorrect start address.
*/
{
FxU16
colorVal = 0xF800,
*curTexPtr = texData;
FxU32
i, j,
colorShift = (16 / largeLod);
curMapSize = maxTexSize;
while(curMapSize > 0) {
for(j = 0; j < curMapSize; j++) *curTexPtr++ = 0xFFFF;
for(i = 1; i < curMapSize - 1; i++) {
*curTexPtr++ = 0xFFFF;
for(j = 1; j < curMapSize - 1; j++) {
*curTexPtr++ = colorVal;
}
*curTexPtr++ = 0xFFFF;
}
for(j = 0; j < curMapSize; j++) *curTexPtr++ = 0xFFFF;
curMapSize >>= 1;
colorVal >>= colorShift;
}
}
{
GrTexInfo texInfo = {
GR_LOD_LOG2_1,
0,
GR_ASPECT_LOG2_1x1,
GR_TEXFMT_RGB_565,
0
};
FxU32
curTexAddr = 0x00UL,
texMultiBaseOffset;
texInfo.largeLodLog2 = largeLod;
texInfo.data = texData;
/* Determine the hw texture alignment and generate some random
* offset for the texture base addressing.
*/
{
FxU32
texAlign,
maxTexMem = grTexMaxAddress(GR_TMU0),
maxTexSize = grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
if (!grGet(GR_TEXTURE_ALIGN, sizeof(texAlign), (FxI32 *)&texAlign)) {
printf("grGet(GR_TEXTURE_ALIGN): Failed!\n");
exit(-1);
}
texAlign <<= 3UL;
/* Get some offset that has to be smaller than the amount of
* texxture space we have left divided by the # of times
* that we're going to add it in.
*/
do {
texMultiBaseOffset = rand();
} while ((texMultiBaseOffset < 0x1000UL) ||
(texMultiBaseOffset > ((maxTexMem - maxTexSize) / 4)));
texMultiBaseOffset = (texMultiBaseOffset + texAlign) & ~(texAlign - 1UL);
}
/* Download the texture to the multibase address specified by
* the current mode. We play a few games w/ offsetting the
* texture start address by texMultiBaseOffset to try to make
* sure that multi-base actually works inside of glide.
*/
/* Mmmm... multibase */
grTexMultibase(GR_TMU0, FXTRUE);
/* Download and set the base addresses in descending map size
* order offsetting by some dorky amount as we go.
*/
texInfo.smallLodLog2 = GR_LOD_LOG2_256;
texInfo.largeLodLog2 = largeLod;
grTexDownloadMipMap(GR_TMU0,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
grTexMultibaseAddress(GR_TMU0,
GR_TEXBASE_256,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
curTexAddr += (texMultiBaseOffset +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.data = (void*)((FxU8*)texInfo.data +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.smallLodLog2 = GR_LOD_LOG2_128;
texInfo.largeLodLog2 = GR_LOD_LOG2_128;
grTexDownloadMipMap(GR_TMU0,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
grTexMultibaseAddress(GR_TMU0,
GR_TEXBASE_128,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
curTexAddr += (texMultiBaseOffset +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.data = (void*)((FxU8*)texInfo.data +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.smallLodLog2 = GR_LOD_LOG2_64;
texInfo.largeLodLog2 = GR_LOD_LOG2_64;
grTexDownloadMipMap(GR_TMU0,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
grTexMultibaseAddress(GR_TMU0,
GR_TEXBASE_64,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
curTexAddr += (texMultiBaseOffset +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.data = (void*)((FxU8*)texInfo.data +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.smallLodLog2 = GR_LOD_LOG2_1;
texInfo.largeLodLog2 = GR_LOD_LOG2_32;
grTexDownloadMipMap(GR_TMU0,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
grTexMultibaseAddress(GR_TMU0,
GR_TEXBASE_32_TO_1,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
/* Source the whole texture. The large map start will reset
* baseAddr0, but that should be fine since we did not adjust
* its address because it came first.
*/
texInfo.smallLodLog2 = GR_LOD_LOG2_1;
texInfo.largeLodLog2 = largeLod;
grTexSource(GR_TMU0,
0x00UL,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
}
free((void*)texData);
}
grTexMipMapMode(GR_TMU0,
GR_MIPMAP_NEAREST,
FXFALSE);
tlConOutput("Press a key to quit\n");
while(frames-- && tlOkToRender()) {
static float
curOOW = 1.0f;
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight);
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear(0x808080, 0xFF, wrange[1]);
{
static float
distance = 1.0f,
dDelta = 0.1f;
TlVertex3D
xfVerts[4],
prjVerts[4];
GrVertex
vtxA,
vtxB,
vtxC,
vtxD;
/*----
A-B
|\|
C-D
-----*/
vtxA.oow = 1.0f;
vtxB = vtxC = vtxD = vtxA;
#define MAX_DIST 30.5f
#define MIN_DIST 1.0f
distance += dDelta;
if (distance > MAX_DIST ||
distance < MIN_DIST) {
dDelta *= -1.0f;
distance += dDelta;
}
tlSetMatrix(tlIdentity());
tlMultMatrix(tlXRotation(-20.0f));
tlMultMatrix(tlTranslation(0.0f, -0.3f, 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;
vtxA.tmuvtx[0].sow = prjVerts[0].s * 255.0f * vtxA.oow;
vtxA.tmuvtx[0].tow = prjVerts[0].t * 255.0f * vtxA.oow;
vtxB.x = tlScaleX(prjVerts[1].x);
vtxB.y = tlScaleY(prjVerts[1].y);
vtxB.oow = 1.0f / prjVerts[1].w;
vtxB.tmuvtx[0].sow = prjVerts[1].s * 255.0f * vtxB.oow;
vtxB.tmuvtx[0].tow = prjVerts[1].t * 255.0f * vtxB.oow;
vtxC.x = tlScaleX(prjVerts[2].x);
vtxC.y = tlScaleY(prjVerts[2].y);
vtxC.oow = 1.0f / prjVerts[2].w;
vtxC.tmuvtx[0].sow = prjVerts[2].s * 255.0f * vtxC.oow;
vtxC.tmuvtx[0].tow = prjVerts[2].t * 255.0f * vtxC.oow;
vtxD.x = tlScaleX(prjVerts[3].x);
vtxD.y = tlScaleY(prjVerts[3].y);
vtxD.oow = 1.0f / prjVerts[3].w;
vtxD.tmuvtx[0].sow = prjVerts[3].s * 255.0f * vtxD.oow;
vtxD.tmuvtx[0].tow = prjVerts[3].t * 255.0f * vtxD.oow;
grDrawTriangle(&vtxA, &vtxB, &vtxD);
grDrawTriangle(&vtxA, &vtxD, &vtxC);
}
tlConRender();
grBufferSwap(1);
/* grab the frame buffer */
if (scrgrab) {
if (!tlScreenDump(filename, (FxU16)scrWidth, (FxU16)scrHeight))
printf("Cannot open %s\n", filename);
scrgrab = FXFALSE;
}
if (tlKbHit()) {
char curKey = tlGetCH();
switch(curKey) {
default:
frames = 0;
break;
}
}
}
rv = 0;
__errExit:
grGlideShutdown();
return rv;
}
void main( int argc, char *argv[] ) {
/*------------------------------------------------------------------
Data
------------------------------------------------------------------*/
char texFile[256];
char texFile_2[256];
FxU32 startAddress,nextAddress;
FxU32 startAddress_2, nextAddress_2;
GrTexInfo texInfo, texInfo_2;
Gu3dfInfo info, info_2;
GuNccTable nccTable, nccTable_2;
GuTexPalette pal, pal_2;
FxBool hasTable = FXFALSE,
hasTable_2 = FXFALSE;
FxBool hasPalette = FXFALSE,
hasPalette_2 = FXFALSE;
FxU32 numTmus = 1;
FxU32 automate;
FxU32 numFrames = -1;
/*------------------------------------------------------------------
Glide State Initialization
------------------------------------------------------------------*/
grGlideInit();
grSstQueryHardware( &hwConfig );
grSstSelect( 0 );
grSstOpen( screenRes,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_LOWER_LEFT,
GR_SMOOTHING_ENABLE,
2 );
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
grAlphaCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
grTexCombine( GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
FXFALSE,
FXFALSE );
if ( hwConfig.SSTs[0].sstBoard.VoodooConfig.nTexelfx == 2 ) {
printf( "Detected 2 TMUs\n" );
grTexCombine( GR_TMU1,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
FXFALSE,
FXFALSE );
numTmus = 2;
}
/*------------------------------------------------------------------
Deal With Arguments
------------------------------------------------------------------*/
if ( numTmus == 1 ) {
if ( argc < 2 ) {
puts( usage_1tmu );
grGlideShutdown();
return;
}
else
{
if(strstr(argv[1], "-n"))
{
automate = 1;
numFrames = atoi(argv[2]);
if(argc >= 4)
strcpy( texFile, argv[3] );
else
{
puts( usage_1tmu );
grGlideShutdown();
return;
}
}
else
{
strcpy( texFile, argv[1] );
if(argc > 3)
if(strstr(argv[2], "-n"))
{
automate = 1;
numFrames = atoi(argv[3]);
}
else
{
puts( usage_1tmu );
grGlideShutdown();
return;
}
}
}
}
else
{
if(argc >= 3)
{
if(strstr(argv[1], "-n"))
{
automate = 1;
if(argc >= 5)
{
strcpy( texFile, argv[3] );
strcpy( texFile_2, argv[4] );
}
else
{
puts( usage_2tmu );
grGlideShutdown();
return;
}
}
else
{
strcpy( texFile, argv[1] );
strcpy( texFile_2, argv[2] );
if(argc >= 4)
if(strstr(argv[3], "-n"))
automate = 1;
else
{
puts( usage_2tmu );
grGlideShutdown();
return;
}
}
}
else
{
puts( usage_2tmu );
grGlideShutdown();
return;
}
}
grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_ZERO,
GR_BLEND_ONE, GR_BLEND_ZERO );
grDepthBufferMode( GR_DEPTHBUFFER_DISABLE );
grDepthBufferFunction( GR_CMP_LEQUAL );
grDepthMask( FXFALSE );
grCullMode( GR_CULL_DISABLE );
grBufferClear( 0x0, 0x0, 0x0 );
/*------------------------------------------------------------------
Load Texture(s)
------------------------------------------------------------------*/
if ( !gu3dfGetInfo( texFile, &info ) ) {
printf( "Couldn't load %s.\n", texFile );
return;
}
info.data = calloc( info.mem_required, 1 );
gu3dfLoad( texFile, &info );
texInfo.smallLod = info.header.small_lod;
texInfo.largeLod = info.header.large_lod;
texInfo.aspectRatio = info.header.aspect_ratio;
texInfo.format = info.header.format;
texInfo.data = info.data;
if ( texInfo.format == GR_TEXFMT_YIQ_422 ||
texInfo.format == GR_TEXFMT_AYIQ_8422 ) {
puts( "*******************YIQ TEXTURE(TMU0)***************" );
nccTable = info.table.nccTable;
hasTable = FXTRUE;
}
if ( texInfo.format == GR_TEXFMT_P_8 ||
texInfo.format == GR_TEXFMT_AP_88 ) {
puts( "*******************PAL TEXTURE(TMU0)***************" );
pal = info.table.palette;
hasPalette = FXTRUE;
}
if ( numTmus == 2 ) {
if ( !gu3dfGetInfo( texFile_2, &info_2 ) ) {
printf( "Couldn't load %s.\n", texFile_2 );
return;
}
info_2.data = calloc( info_2.mem_required, 1 );
gu3dfLoad( texFile_2, &info_2 );
texInfo_2.smallLod = info_2.header.small_lod;
texInfo_2.largeLod = info_2.header.large_lod;
texInfo_2.aspectRatio = info_2.header.aspect_ratio;
texInfo_2.format = info_2.header.format;
texInfo_2.data = info_2.data;
if ( texInfo_2.format == GR_TEXFMT_YIQ_422 ||
texInfo_2.format == GR_TEXFMT_AYIQ_8422 ) {
puts( "*******************YIQ TEXTURE(TMU1)***************" );
nccTable_2 = info_2.table.nccTable;
hasTable_2 = FXTRUE;
}
if ( texInfo_2.format == GR_TEXFMT_P_8 ||
texInfo_2.format == GR_TEXFMT_AP_88 ) {
puts( "*******************PAL TEXTURE(TMU1)***************" );
pal_2 = info_2.table.palette;
hasPalette_2 = FXTRUE;
}
}
/*------------------------------------------------------------------
Allocate Texture RAM
------------------------------------------------------------------*/
startAddress = nextAddress = grTexMinAddress( GR_TMU0 );
nextAddress = startAddress + grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH,
&texInfo );
printf( "tex0: startAddress: %d nextAddress %d\n", startAddress, nextAddress );
if ( nextAddress > grTexMaxAddress( GR_TMU0 ) ) {
printf( "Texture memory exhausted.\n" );
return;
}
if ( numTmus == 2 ) {
startAddress_2 = nextAddress_2 = grTexMinAddress( GR_TMU1 );
nextAddress_2 = startAddress_2 +
grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH,
&texInfo_2 );
printf( "tex1: startAddress: %d nextAddress %d\n", startAddress_2, nextAddress_2 );
}
/*------------------------------------------------------------------
Download Texture(s)
------------------------------------------------------------------*/
grTexDownloadMipMap( GR_TMU0,
startAddress,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo );
if ( hasTable ) {
grTexNCCTable( GR_TMU0, GR_NCCTABLE_NCC1 );
grTexDownloadTable( GR_TMU0,
GR_TEXTABLE_NCC1,
&nccTable );
}
if ( hasPalette ) {
grTexDownloadTable( GR_TMU0,
GR_TEXTABLE_PALETTE,
&pal );
}
if ( numTmus == 2 ) {
grTexDownloadMipMap( GR_TMU1,
startAddress_2,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo_2 );
if ( hasTable_2 ) {
grTexNCCTable( GR_TMU1, GR_NCCTABLE_NCC0 );
grTexDownloadTable( GR_TMU1,
GR_TEXTABLE_NCC0,
&nccTable_2 );
}
if ( hasPalette_2 ) {
grTexDownloadTable( GR_TMU1,
GR_TEXTABLE_PALETTE,
&pal_2 );
}
}
/*------------------------------------------------------------------
Set up Texture Params and Set Texture As Current
------------------------------------------------------------------*/
grTexFilterMode( GR_TMU0,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR );
grTexClampMode( GR_TMU0,
GR_TEXTURECLAMP_WRAP,
GR_TEXTURECLAMP_WRAP );
grTexMipMapMode( GR_TMU0,
GR_MIPMAP_NEAREST,
FXFALSE );
grTexSource( GR_TMU0,
startAddress,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo );
if ( numTmus == 2 ) {
grTexFilterMode( GR_TMU1,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR );
grTexClampMode( GR_TMU1,
GR_TEXTURECLAMP_WRAP,
GR_TEXTURECLAMP_WRAP );
grTexMipMapMode( GR_TMU1,
GR_MIPMAP_NEAREST,
FXFALSE );
grTexSource( GR_TMU1,
startAddress_2,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo_2 );
}
/*------------------------------------------------------------------
Render Triangles
------------------------------------------------------------------*/
puts("TEST39:\n");
puts("Tests the grTex routines\n");
if(!automate)
{
puts("Press any key to continue\n");
getch();
}
while(numFrames)
{
square( 0.0f, 0.0f, 256.0f, 256.0f );
square( 255.0f, 0.0f, 128.0f, 128.0f );
square( 382.0f, 0.0f, 64.0f, 64.0f );
square( 445.0f, 0.0f, 32.0f, 32.0f );
square( 476.0f, 0.0f, 16.0f, 16.0f );
square( 491.0f, 0.0f, 8.0f, 8.0f );
square( 498.0f, 0.0f, 4.0f, 4.0f );
square( 501.0f, 0.0f, 2.0f, 2.0f );
square( 502.0f, 0.0f, 1.0f, 1.0f );
if ( numTmus == 2 ) {
grTexCombine( GR_TMU0,
GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
FXFALSE,
FXFALSE );
grTexCombine( GR_TMU1,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
FXFALSE,
FXFALSE );
square( 0.0f, 300.0f, 256.0f, 256.0f );
square( 255.0f, 300.0f, 128.0f, 128.0f );
square( 382.0f, 300.0f, 64.0f, 64.0f );
square( 445.0f, 300.0f, 32.0f, 32.0f );
square( 476.0f, 300.0f, 16.0f, 16.0f );
square( 491.0f, 300.0f, 8.0f, 8.0f );
square( 498.0f, 300.0f, 4.0f, 4.0f );
square( 501.0f, 300.0f, 2.0f, 2.0f );
square( 502.0f, 300.0f, 1.0f, 1.0f );
}
grBufferSwap( 1 );
if(numFrames > 0)
numFrames--;
if(kbhit()) {
getch();
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;
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 */
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();
}
grSstSelect( 0 );
assert( grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
origin,
2, 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, wrange);
grGet(GR_GLIDE_STATE_SIZE, 4, &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;
grTexDownloadMipMap( GR_TMU0, startAddress, GR_MIPMAPLEVELMASK_BOTH, &bgDecal);
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 );
bgDecalAddress = startAddress;
startAddress += grTexCalcMemRequired ( bgDecal.smallLodLog2, bgDecal.largeLodLog2,
bgDecal.aspectRatioLog2, bgDecal.format );
free( bgInfo.data );
} 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;
grTexDownloadMipMap( GR_TMU0, startAddress, 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 );
triDecalAddress = startAddress;
free( triInfo.data );
} else {
fprintf( stderr, "could not get info on %s\n", triFileName );
grGlideShutdown();
exit( -1 );
}
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 );
while ( 1 ) {
Matrix rotm;
GrVertex xformedVerts[VERT_COUNT];
int i;
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;
SNAP_COORD( xformedVerts[i].x );
SNAP_COORD( xformedVerts[i].y );
}
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, &pStats.pixelsIn);
grGet(GR_STATS_PIXELS_CHROMA_FAIL, 4, &pStats.chromaFail);
grGet(GR_STATS_PIXELS_DEPTHFUNC_FAIL, 4, &pStats.zFuncFail);
grGet(GR_STATS_PIXELS_AFUNC_FAIL, 4, &pStats.aFuncFail);
grGet(GR_STATS_PIXELS_OUT, 4, &pStats.pixelsOut);
grGet(GR_STATS_TRIANGLES_IN, 4, &trisProcessed);
grGet(GR_STATS_TRIANGLES_OUT, 4, &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, 0.f, scrWidth / 5.f, scrHeight / 5.f, frameNum);
if (backbuffer) {
tlConRender();
grBufferSwap( swapDelay );
}
}
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':
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
square( float minx, float miny, float width, float height, float theta) {
GrVertex a, b, c, d;
float scale = (float) sin(theta);
static int calls;
int i, j;
#define NRECTS 10
for (i = 0; i < NRECTS; i++) {
for (j = 0; j < NRECTS; j++) {
float
startX, startY,
rectHeight, rectWidth;
/*
A - B
| \ |
C - D
*/
rectWidth = width / NRECTS;
rectHeight = height / NRECTS;
startX = rectWidth * i;
startY = rectHeight * j;
a.x = startX;
a.y = startY + rectHeight;
a.oow = 1.0f;
a.tmuvtx[0].oow = 1.0f;
a.tmuvtx[0].sow = 0.0f;
a.tmuvtx[0].tow = 0.0f;
a.tmuvtx[1].oow = 1.f / (31.f - (30.f * scale));
a.tmuvtx[1].sow = (20.f * scale) * a.tmuvtx[1].oow;
a.tmuvtx[1].tow = (20.f * scale) * a.tmuvtx[1].oow;
b.x = startX + rectWidth;
b.y = startY + rectHeight;
b.oow = 1.0f;
b.tmuvtx[0].oow = 1.0f;
b.tmuvtx[0].sow = 255.0f;
b.tmuvtx[0].tow = 0.0f;
b.tmuvtx[1].oow = 1.f / (31.f - (30.f * scale));
b.tmuvtx[1].sow = (255.0f - (20.f * scale)) * b.tmuvtx[1].oow;
b.tmuvtx[1].tow = (20.f * scale) * b.tmuvtx[1].oow;
c.x = startX;
c.y = startY;
c.oow = 1.0f;
c.tmuvtx[0].oow = 1.0f;
c.tmuvtx[0].sow = 0.0f;
c.tmuvtx[0].tow = 255.0f;
c.tmuvtx[1].oow = 1.f / (31.f - (30.f * scale));
c.tmuvtx[1].sow = (20.f * scale) * c.tmuvtx[1].oow;
c.tmuvtx[1].tow = (255.0f - (20.f * scale)) * c.tmuvtx[1].oow;
d.x = startX + rectWidth;
d.y = startY;
d.oow = 1.0f;
d.tmuvtx[0].oow = 1.0f;
d.tmuvtx[0].sow = 255.0f;
d.tmuvtx[0].tow = 255.0f;
d.tmuvtx[1].oow = 1.f / (31.f - (30.f * scale));
d.tmuvtx[1].sow = (255.f - (20.f * scale)) * d.tmuvtx[1].oow;
d.tmuvtx[1].tow = (255.f - (20.f * scale)) * d.tmuvtx[1].oow;
if ((i + j) & 1) {
if ( hasTable1 ) {
grTexNCCTable( GR_TMU0, GR_NCCTABLE_NCC1 );
grTexDownloadTable( GR_TMU0,
GR_TEXTABLE_NCC1,
&nccTable1 );
}
if ( hasPalette1 ) {
grTexDownloadTable( GR_TMU0,
GR_TEXTABLE_PALETTE,
&pal1 );
}
grTexSource( GR_TMU0,
tmu0Tex1Address,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo1 );
} else {
if ( hasTable ) {
grTexNCCTable( GR_TMU0, GR_NCCTABLE_NCC1 );
grTexDownloadTable( GR_TMU0,
GR_TEXTABLE_NCC1,
&nccTable );
}
if ( hasPalette ) {
grTexDownloadTable( GR_TMU0,
GR_TEXTABLE_PALETTE,
&pal0 );
}
grTexSource( GR_TMU0,
tmu0Tex0Address,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo );
}
grTexSource( GR_TMU1,
startAddress2,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo2 );
grDrawTriangle( &a, &b, &d );
grDrawTriangle( &a, &d, &c );
}
}
} /* square */
void main( int argc, char *argv[] ) {
char
texFile[256],
texFile1[256],
texFile2[256];
float
theta;
FxU32
numTmus = 1;
FxBool
paused = FXFALSE;
Gu3dfInfo
info, info2;
FxU32
numFrames = 0xffffffff;
puts("TEST44: Tests complex, multi-tmu textures\n");
puts("Press a key to continue...\n");
getch();
puts("Press q to quit\n");
/* Glide State Initialization */
grGlideInit();
grSstQueryHardware( &hwConfig );
grSstSelect( 0 );
grSstOpen( screenRes,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_LOWER_LEFT,
GR_SMOOTHING_ENABLE,
2 );
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
grAlphaCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
grTexCombine( GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
FXFALSE,
FXFALSE );
if ( hwConfig.SSTs[0].sstBoard.VoodooConfig.nTexelfx == 2 ) {
printf( "Detected 2 TMUs\n" );
grTexCombine( GR_TMU1,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
FXFALSE,
FXFALSE );
numTmus = 2;
}
/*------------------------------------------------------------------
Deal With Arguments
------------------------------------------------------------------*/
if ( numTmus == 1 ) {
if ( argc < 2 ) {
printf( "%s ", argv[0] );
puts( usage_1tmu );
grGlideShutdown();
return;
}
argc--;argv++;
while(argc) {
if(strcmp(argv[0], "-n") == 0) {
argc--;argv++;
if(argc)
numFrames = atoi(argv[0]);
else {
puts( usage_1tmu );
return;
}
}
strcpy( texFile, argv[0] );
strcpy( texFile1, argv[1] );
argc--;argv++;
argc--;argv++;
}
} else {
if ( argc < 4 ) {
printf( "%s ", argv[0] );
puts( usage2tmu );
grGlideShutdown();
return;
}
argc--;argv++;
while(argc) {
if(strcmp(argv[0], "-n") == 0) {
argc--;argv++;
if(argc)
numFrames = atoi(argv[0]);
else {
puts( usage_1tmu );
return;
}
}
strcpy( texFile, argv[0] );
strcpy( texFile1, argv[1]);
strcpy( texFile2, argv[2] );
argc -= 3;
argv += 3;
}
}
grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_ZERO,
GR_BLEND_ONE, GR_BLEND_ZERO );
grDepthBufferMode( GR_DEPTHBUFFER_DISABLE );
grDepthBufferFunction( GR_CMP_LEQUAL );
grDepthMask( FXFALSE );
grCullMode( GR_CULL_DISABLE );
grBufferClear( 0x0, 0x0, 0x0 );
/*------------------------------------------------------------------
Load Texture(s)
------------------------------------------------------------------*/
if ( !gu3dfGetInfo( texFile, &info ) ) {
printf( "Couldn't load %s.\n", texFile );
return;
}
info.data = calloc( info.mem_required, 1 );
gu3dfLoad( texFile, &info );
texInfo.smallLod = info.header.small_lod;
texInfo.largeLod = info.header.large_lod;
texInfo.aspectRatio = info.header.aspect_ratio;
texInfo.format = info.header.format;
texInfo.data = info.data;
if ( texInfo.format == GR_TEXFMT_YIQ_422 ||
texInfo.format == GR_TEXFMT_AYIQ_8422 ) {
puts( "*******************YIQ TEXTURE(TMU0)***************" );
nccTable = info.table.nccTable;
hasTable = FXTRUE;
}
if ( texInfo.format == GR_TEXFMT_P_8 ||
texInfo.format == GR_TEXFMT_AP_88 ) {
puts( "*******************PAL TEXTURE(TMU0)***************" );
pal0 = info.table.palette;
hasPalette = FXTRUE;
}
/* ++++ */
if ( !gu3dfGetInfo( texFile1, &info ) ) {
printf( "Couldn't load %s.\n", texFile1 );
return;
}
info.data = calloc( info.mem_required, 1 );
gu3dfLoad( texFile1, &info );
texInfo1.smallLod = info.header.small_lod;
texInfo1.largeLod = info.header.large_lod;
texInfo1.aspectRatio = info.header.aspect_ratio;
texInfo1.format = info.header.format;
texInfo1.data = info.data;
if ( texInfo1.format == GR_TEXFMT_YIQ_422 ||
texInfo1.format == GR_TEXFMT_AYIQ_8422 ) {
puts( "*******************YIQ TEXTURE(TMU0)***************" );
nccTable = info.table.nccTable;
hasTable = FXTRUE;
}
if ( texInfo1.format == GR_TEXFMT_P_8 ||
texInfo1.format == GR_TEXFMT_AP_88 ) {
puts( "*******************PAL TEXTURE(TMU0)***************" );
pal0 = info.table.palette;
hasPalette1 = FXTRUE;
}
/* ++++ */
if ( numTmus == 2 ) {
if ( !gu3dfGetInfo( texFile2, &info2 ) ) {
printf( "Couldn't load %s.\n", texFile2 );
return;
}
info2.data = calloc( info2.mem_required, 1 );
gu3dfLoad( texFile2, &info2 );
texInfo2.smallLod = info2.header.small_lod;
texInfo2.largeLod = info2.header.large_lod;
texInfo2.aspectRatio = info2.header.aspect_ratio;
texInfo2.format = info2.header.format;
texInfo2.data = info2.data;
if ( texInfo2.format == GR_TEXFMT_YIQ_422 ||
texInfo2.format == GR_TEXFMT_AYIQ_8422 ) {
puts( "*******************YIQ TEXTURE(TMU1)***************" );
nccTable2 = info2.table.nccTable;
hasTable2 = FXTRUE;
}
if ( texInfo2.format == GR_TEXFMT_P_8 ||
texInfo2.format == GR_TEXFMT_AP_88 ) {
puts( "*******************PAL TEXTURE(TMU1)***************" );
pal2 = info2.table.palette;
hasPalette2 = FXTRUE;
}
}
grHints(GR_HINT_STWHINT, GR_STWHINT_W_DIFF_TMU0 |
GR_STWHINT_ST_DIFF_TMU0 | GR_STWHINT_W_DIFF_TMU1 |
GR_STWHINT_ST_DIFF_TMU1);
/*------------------------------------------------------------------
Allocate Texture RAM
------------------------------------------------------------------*/
tmu0Tex0Address = startAddress =
nextAddress = grTexMinAddress( GR_TMU0 );
tmu0Tex1Address = nextAddress = startAddress +
grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH, &texInfo );
printf( "tex0: tmu0Tex0Address: %d tmu0Tex1Address %d\n",
tmu0Tex0Address, tmu0Tex1Address);
if ( nextAddress > grTexMaxAddress( GR_TMU0 ) ) {
printf( "Texture memory exhausted.\n" );
return;
}
if ( numTmus == 2 ) {
startAddress2 = nextAddress2 = grTexMinAddress( GR_TMU1 );
nextAddress2 = startAddress2 +
grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH,
&texInfo2 );
printf( "tex1: startAddress: %d nextAddress %d\n", startAddress2, nextAddress2 );
}
/*------------------------------------------------------------------
Download Texture(s)
------------------------------------------------------------------*/
grTexDownloadMipMap( GR_TMU0,
tmu0Tex0Address,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo );
/* ---- */
grTexDownloadMipMap( GR_TMU0,
tmu0Tex1Address,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo1 );
/* ---- */
if ( numTmus == 2 ) {
grTexDownloadMipMap( GR_TMU1,
startAddress2,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo2 );
if ( hasTable2 ) {
grTexNCCTable( GR_TMU1, GR_NCCTABLE_NCC0 );
grTexDownloadTable( GR_TMU1,
GR_TEXTABLE_NCC0,
&nccTable2 );
}
if ( hasPalette2 ) {
grTexDownloadTable( GR_TMU1,
GR_TEXTABLE_PALETTE,
&pal2 );
}
}
/*------------------------------------------------------------------
Set up Texture Params and Set Texture As Current
------------------------------------------------------------------*/
grTexFilterMode( GR_TMU0,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR );
grTexClampMode( GR_TMU0,
GR_TEXTURECLAMP_WRAP,
GR_TEXTURECLAMP_WRAP );
grTexMipMapMode( GR_TMU0,
GR_MIPMAP_NEAREST,
FXFALSE );
grTexSource( GR_TMU0,
startAddress,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo );
if ( numTmus == 2 ) {
grTexFilterMode( GR_TMU1,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR );
grTexClampMode( GR_TMU1,
GR_TEXTURECLAMP_WRAP,
GR_TEXTURECLAMP_WRAP );
grTexMipMapMode( GR_TMU1,
GR_MIPMAP_NEAREST,
FXFALSE );
grTexSource( GR_TMU1,
startAddress2,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo2 );
}
if ( numTmus == 2 ) {
grTexCombine( GR_TMU1,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
FXFALSE,
FXFALSE );
grTexCombine( GR_TMU0,
GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL,
GR_COMBINE_FACTOR_ONE,
FXFALSE,
FXFALSE );
}
#define INC 0.5f
theta = 0.f;
while (1 && numFrames) {
if (paused == FXFALSE) {
theta += INC;
if (theta > 180.f)
theta -= 180.f;
}
square(0.f, 0.f, 640.3f, 480.f, DEG2RAD(theta));
grBufferSwap( 1 );
if (kbhit()) {
char c;
c = getch();
switch (c) {
case '-':
theta -= INC;
break;
case '+':
theta += INC;
break;
case 'd':
case 'D':
printf("theta = %3.1f\n", theta);
break;
case 'P':
case 'p':
if (paused == FXFALSE)
paused = FXTRUE;
else
paused = FXFALSE;
break;
case 'q':
case 'Q':
case 27:
grGlideShutdown();
exit(0);
break;
}
} /* input switch */
if(numFrames != -1)
numFrames--;
} /* render loop */
}/* main */
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];
FxU32 wrange[2];
GrLOD_t largeLod = GR_LOD_LOG2_256;
GrLOD_t smallLod = GR_LOD_LOG2_1;
GrTexTable_t curPalType = GR_TEXTABLE_PALETTE;
FxU32 compBits = 0x08UL;
FxBool singleTexP = FXFALSE;
FxBool extMirrorP = FXFALSE;
FxBool extPalP = FXFALSE;
float minTexCoor = 0.0f;
float maxTexCoor = 256.0f;
/* Initialize Glide */
grGlideInit();
assert(hwconfig = tlVoodooType());
/* Process Command Line Arguments */
while(rv = tlGetOpt(argc, argv, "dlmnprs", &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 'd':
scrgrab = FXTRUE;
frames = 1;
strcpy(filename, remArgs[0]);
break;
case 'l':
if (sscanf(remArgs[0], "%d,%d", &smallLod, &largeLod) != 2) {
largeLod = GR_LOD_LOG2_256;
smallLod = GR_LOD_LOG2_1;
} else {
GrLOD_t
maxLod,
lodShift;
if (grGet(GR_MAX_TEXTURE_SIZE, sizeof(maxLod), &maxLod) == 0) {
largeLod = GR_LOD_LOG2_256;
smallLod = GR_LOD_LOG2_1;
} else {
lodShift = 0;
while((0x01 << lodShift) != maxLod) lodShift++;
if (largeLod > lodShift) largeLod = lodShift;
}
}
break;
case 'm':
extMirrorP = FXTRUE;
break;
case 'n':
frames = atoi(remArgs[0]);
break;
case 'p':
extPalP = FXTRUE;
break;
case 'r':
resolution = tlGetResolutionConstant(remArgs[0],
&scrWidth,
&scrHeight);
break;
case 's':
singleTexP = FXTRUE;
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, 1.0f,
60, 30, 0xffffff);
/* Set up Render State */
grGet(GR_WDEPTH_MIN_MAX, 8, wrange);
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_CONSTANT,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
grTexCombine(GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
FXFALSE, FXFALSE);
/* Load texture data into system ram */
if (!singleTexP) {
FxI32 numTmu = 0;
if (grGet(GR_NUM_TMU, sizeof(numTmu), &numTmu) && (numTmu > 1)) {
TlTexture texture;
assert(tlLoadTexture("decal1.3df",
&texture.info,
&texture.tableType,
&texture.tableData));
/* Download texture data to TMU */
grTexDownloadMipMap(GR_TMU1,
grTexMinAddress(GR_TMU1),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
if (texture.tableType != NO_TABLE) {
grTexDownloadTable(texture.tableType,
&texture.tableData);
}
grTexSource(GR_TMU1,
grTexMinAddress(GR_TMU1),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
grVertexLayout(GR_PARAM_ST1, GR_VERTEX_SOW_TMU1_OFFSET << 2, GR_PARAM_ENABLE);
grTexCombine(GR_TMU1,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
FXFALSE, FXFALSE);
grTexCombine(GR_TMU0,
GR_COMBINE_FUNCTION_BLEND_OTHER, GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_FUNCTION_BLEND_OTHER, GR_COMBINE_FACTOR_LOCAL,
FXFALSE, FXFALSE);
}
}
if (extMirrorP || extPalP) {
const char* extString = grGetString(GR_EXTENSION);
const char* tempStr = extString;
while(tempStr != NULL) {
const char* keyList[] = {
"TEXMIRROR",
"PALETTE6666"
};
if (extMirrorP &&
!singleTexP &&
(strncmp(tempStr, keyList[0], strlen(keyList[0])) == 0)) {
grTexClampMode(GR_TMU0,
GR_TEXTURECLAMP_MIRROR_EXT,
GR_TEXTURECLAMP_MIRROR_EXT);
minTexCoor = -256.0f;
maxTexCoor = 512.0f;
}
if (extPalP &&
(strncmp(tempStr, keyList[1], strlen(keyList[1])) == 0)) {
curPalType = GR_TEXTABLE_PALETTE_6666_EXT;
compBits = 0x06UL;
}
tempStr = strchr(tempStr, ' ');
if (tempStr != NULL) tempStr++;
}
}
{
GuTexPalette texPal;
GrTexInfo texInfo;
unsigned char* texData = NULL, *tmp;
int i, j, k;
i = 0;
while(i < 256) {
const FxU32 compVal = (FxU32)(i * (0x01UL << compBits) / 256.0f);
texPal.data[i] = ((compVal << (compBits * 2)) |
(compVal << (compBits * 1)) |
(compVal << (compBits * 0)));
i++;
}
/* Download this in a sequential way to test the palette download */
i = 0;
while(i < 256) {
const int max = i + (rand() % 10);
const int end = MIN(max, 255);
grTexDownloadTablePartial(curPalType, &texPal, i, end);
i = end + 1;
}
i = 0;
for(k = largeLod; k >= smallLod; k--) {
i += ((0x01 << k) * (0x01 << k));
}
texData = (unsigned char*)malloc(i * 2);
if (texData == NULL) {
printf("Unable to allocate texture data.\n");
goto __errExit;
}
/* Download dumb palettized texture */
texInfo.smallLodLog2 = smallLod;
texInfo.largeLodLog2 = largeLod;
texInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
texInfo.format = GR_TEXFMT_P_8;
texInfo.data = (void*)texData;
for(k = texInfo.largeLodLog2; k >= texInfo.smallLodLog2; k--) {
const int texDim = (0x01 << k);
const float levelStep = (256.0f / texDim);
tmp=texData;
for(i = 0; i < texDim; i++) {
for(j = 0; j < texDim; j++) {
*tmp++ = (FxU8)(levelStep * i);
}
}
}
grTexDownloadMipMap(GR_TMU0, 0, GR_MIPMAPLEVELMASK_BOTH, &texInfo);
grTexSource(GR_TMU0, 0, GR_MIPMAPLEVELMASK_BOTH, &texInfo);
free((void*)texData);
}
tlConOutput("Press a key to quit\n");
while(frames-- && tlOkToRender()) {
GrVertex vtxA, vtxB, vtxC;
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight);
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear(0xFF00FF00, 0xFF, wrange[1]);
/* Triangle w/ texture ramp going across and down. */
vtxA.oow =
vtxB.oow =
vtxC.oow = 1.0f;
{
vtxA.x = tlScaleX(0.2f), vtxA.y = tlScaleY(0.2f);
vtxA.tmuvtx[0].sow = minTexCoor;
vtxA.tmuvtx[0].tow = minTexCoor;
vtxA.tmuvtx[1].sow = 0.0f;
vtxA.tmuvtx[1].tow = 0.0f;
vtxB.x = tlScaleX(0.8f), vtxB.y = tlScaleY(0.2f);
vtxB.tmuvtx[0].sow = maxTexCoor;
vtxB.tmuvtx[0].tow = minTexCoor;
vtxB.tmuvtx[1].sow = 255.0f;
vtxB.tmuvtx[1].tow = 0.0f;
vtxC.x = tlScaleX(0.8f), vtxC.y = tlScaleY(0.8f);
vtxC.tmuvtx[0].sow = maxTexCoor;
vtxC.tmuvtx[0].tow = maxTexCoor;
vtxC.tmuvtx[1].sow = 255.0f;
vtxC.tmuvtx[1].tow = 255.0f;
grDrawTriangle(&vtxA, &vtxB, &vtxC);
}
{
vtxA.x = tlScaleX(0.2f), vtxA.y = tlScaleY(0.2f);
vtxA.tmuvtx[0].sow = minTexCoor;
vtxA.tmuvtx[0].tow = minTexCoor;
vtxA.tmuvtx[1].sow = 0.0f;
vtxA.tmuvtx[1].tow = 0.0f;
vtxB.x = tlScaleX(0.8f), vtxB.y = tlScaleY(0.8f);
vtxB.tmuvtx[0].sow = maxTexCoor;
vtxB.tmuvtx[0].tow = maxTexCoor;
vtxB.tmuvtx[1].sow = 255.0f;
vtxB.tmuvtx[1].tow = 255.0f;
vtxC.x = tlScaleX(0.2f), vtxC.y = tlScaleY(0.8f);
vtxC.tmuvtx[0].sow = minTexCoor;
vtxC.tmuvtx[0].tow = maxTexCoor;
vtxC.tmuvtx[1].sow = 0.0f;
vtxC.tmuvtx[1].tow = 255.0f;
grDrawTriangle(&vtxA, &vtxB, &vtxC);
}
tlConRender();
grBufferSwap(1);
/* grab the frame buffer */
if (scrgrab) {
if (!tlScreenDump(filename, (FxU16)scrWidth, (FxU16)scrHeight))
printf("Cannot open %s\n", filename);
scrgrab = FXFALSE;
}
if (tlKbHit()) frames = 0;
}
__errExit:
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;
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();
}