void
main( int argc, char **argv ) {
float
minColor = 55.f,
maxColor = 200.f;
GrVertex
localVerts[3],
texVerts[4];
float
alpha = 192.0f,
y_angle = 0.0f;
int
n,
nTris = 0;
FxBool
depthBias = FXTRUE,
blend = FXFALSE,
texturing = FXFALSE,
antialias = FXTRUE,
bilinear = FXTRUE,
render = FXTRUE,
backbuffer = FXTRUE,
background = FXTRUE;
GrState
nonBlendState, blendState;
float
wWidth, wHeight;
GrScreenResolution_t
screenRes;
GrMipMapId_t
triDecal,
bgDecal;
Gu3dfInfo
bgInfo, triInfo;
FxU16
*scrnImage;
GrColorCombineFnc_t
ccFnc = GR_COLORCOMBINE_ITRGB;
int
numFrames = -1,
frameCount = 0;
char
*bgFileName = NULL,
*triFileName = NULL;
wWidth = 640.0f;
wHeight = 480.0f;
screenRes = GR_RESOLUTION_640x480;
--argc; ++argv;
while (argc) {
if (strstr(*argv, "320x200")) {
wWidth = 320.0f; wHeight = 200.0f;
screenRes = GR_RESOLUTION_320x200;
--argc; ++argv;
} else if (strstr(*argv, "320x240")) {
wWidth = 320.0f; wHeight = 240.0f;
screenRes = GR_RESOLUTION_320x240;
--argc; ++argv;
} else if (strstr(*argv, "400x256")) {
wWidth = 400.0f; wHeight = 256.0f;
screenRes = GR_RESOLUTION_400x256;
--argc; ++argv;
} else if (strstr(*argv, "512x384")) {
wWidth = 512.0f; wHeight = 384.0f;
screenRes = GR_RESOLUTION_512x384;
--argc; ++argv;
} else if (strstr(*argv, "640x480")) {
wWidth = 640.0f; wHeight = 480.0f;
screenRes = GR_RESOLUTION_640x480;
--argc; ++argv;
} else if (strstr(*argv, "800x600")) {
wWidth = 800.0f; wHeight = 600.0f;
screenRes = GR_RESOLUTION_800x600;
--argc; ++argv;
} else if (strstr(*argv, "856x480")) {
wWidth = 856.0f; wHeight = 480.0f;
screenRes = GR_RESOLUTION_856x480;
--argc; ++argv;
} else if (strstr(*argv, "960x720")) {
wWidth = 960.0f; wHeight = 720.0f;
screenRes = GR_RESOLUTION_960x720;
--argc; ++argv;
} else if (strstr(*argv, "640x200")) {
wWidth = 640.f; wHeight = 200.f;
screenRes = GR_RESOLUTION_640x200;
--argc; ++argv;
} else if (strstr(*argv, "640x350")) {
wWidth = 640.f; wHeight = 350.f;
screenRes = GR_RESOLUTION_640x350;
--argc; ++argv;
} else if (strstr(*argv, "640x400")) {
wWidth = 640.f; wHeight = 400.f;
screenRes = GR_RESOLUTION_640x400;
--argc; ++argv;
} else if (strstr(*argv, "bgFile")) {
bgFileName = argv[1];
argc-= 2; argv += 2;
} else if (strstr(*argv, "triFile")) {
triFileName = argv[1];
argc-= 2; argv += 2;
} else if (strstr(*argv, "alpha")) {
alpha = (float)atof(argv[1]);
argc -= 2; argv += 2;
} else if (strstr(*argv, "-n")) {
numFrames = atoi(argv[1]);
argc -= 2; argv += 2;
} else {
fprintf(
stderr,
"Useage: test24 [-bgFile bgfile.3ds] [-triFile triFile.3ds] [ScreenRes (i.e. 640x480 .. 960x720] [-alpha alphavalue] [-n numFrames]\n");
exit(-1);
}
}
scrnImage = malloc((int)wWidth * (int)wHeight * sizeof(FxU16));
puts( "\ntest30:" );
puts( "Depth Bias Level Test\n" );
puts("press H for help\n");
if(numFrames == -1)
{
puts("Press a key to continue");
getch();
}
grGlideInit();
if ( !grSstQueryHardware( &hwconfig ) )
{
fprintf( stderr, "main: grSstQueryHardware failed!\n" );
grGlideShutdown();
exit( -1 );
}
/* Select SST 0 */
grSstSelect( 0 );
/* Open up the hardware */
if ( !grSstOpen( screenRes,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_LOWER_LEFT,
GR_SMOOTHING_ENABLE,
2 ) )
{
fprintf( stderr, "main: grSstOpen failed!\n" );
grGlideShutdown();
exit( -1 );
}
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 = wWidth;
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 = wWidth;
texVerts[2].y = wHeight;
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 = wHeight;
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";
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 = guTexAllocateMemory( 0, GR_MIPMAPLEVELMASK_BOTH,
bgInfo.header.width, bgInfo.header.height,
bgInfo.header.format,
GR_MIPMAP_NEAREST,
bgInfo.header.small_lod, bgInfo.header.large_lod,
bgInfo.header.aspect_ratio,
GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP,
GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR,
0.0F,
FXFALSE );
if ( bgDecal == GR_NULL_MIPMAP_HANDLE ) {
fprintf( stderr, "could not allocate memory for texture file %s\n", bgFileName );
grGlideShutdown();
exit( -1 );
}
guTexDownloadMipMap( bgDecal, bgInfo.data, &bgInfo.table.nccTable );
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 = guTexAllocateMemory( 0, GR_MIPMAPLEVELMASK_BOTH,
triInfo.header.width,
triInfo.header.height,
triInfo.header.format,
GR_MIPMAP_NEAREST,
triInfo.header.small_lod,
triInfo.header.large_lod,
triInfo.header.aspect_ratio,
GR_TEXTURECLAMP_WRAP,
GR_TEXTURECLAMP_WRAP,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR,
0.0F,
FXFALSE );
if ( triDecal == GR_NULL_MIPMAP_HANDLE ) {
fprintf( stderr, "could not allocate memory for %s\n", triFileName );
grGlideShutdown();
exit( -1 );
}
guTexDownloadMipMap( triDecal, triInfo.data, &triInfo.table.nccTable );
free( triInfo.data );
} else {
fprintf( stderr, "could not get info on %s\n", triFileName );
grGlideShutdown();
exit( -1 );
}
grTexCombineFunction(GR_TMU0, GR_TEXTURECOMBINE_DECAL);
grRenderBuffer(backbuffer == FXTRUE ? GR_BUFFER_BACKBUFFER : GR_BUFFER_FRONTBUFFER);
/* Set up alpha blend state for compositing and antialiasing */
guAlphaSource( GR_ALPHASOURCE_ITERATED_ALPHA );
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[4];
int i;
grSstIdle();
++nTris;
MatMakeYRot( rotm, DEG2RAD( y_angle ) );
for( i = 0; i < 4; 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 *= wHeight / 2.0f;
xformedVerts[i].y *= wHeight / 2.0f;
xformedVerts[i].x += wHeight / 2.0f;
xformedVerts[i].y += wHeight / 2.0f;
xformedVerts[i].oow = 1.f / ((xformedVerts[i].z + 2) * wHeight);
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 );
}
if (render == FXTRUE) {
grBufferClear( 0xffffffff, 0, GR_WDEPTHVALUE_FARTHEST );
if (background == FXTRUE) {
GrState
oldState;
grGlideGetState(&oldState);
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
);
guTexSource(bgDecal);
for (i = 0; i < NTRIS; i++) {
grDrawTriangle(&texVerts[0], &texVerts[1], &texVerts[2]);
grDrawTriangle(&texVerts[2], &texVerts[3], &texVerts[0]);
}
grGlideSetState(&oldState);
}
guTexSource(triDecal);
if (antialias == FXTRUE) {
if (depthBias)
grDepthBiasLevel((short)0x8000);
guColorCombineFunction(GR_COLORCOMBINE_DECAL_TEXTURE);
grAADrawTriangle(
&xformedVerts[0], &xformedVerts[1],
&xformedVerts[2], FXTRUE, FXTRUE, FXTRUE
);
#define SHIFT 20.f;
for (n = 0; n < 3; n++) {
xformedVerts[n].x += SHIFT;
xformedVerts[n].y -= SHIFT;
}
if (depthBias)
grDepthBiasLevel(0x7fff);
guColorCombineFunction(GR_COLORCOMBINE_ITRGB);
grAADrawTriangle(
&xformedVerts[0], &xformedVerts[1],
&xformedVerts[2], FXTRUE, FXTRUE, FXTRUE
);
} else {
if (depthBias)
grDepthBiasLevel((short)0x8000);
guColorCombineFunction(GR_COLORCOMBINE_DECAL_TEXTURE);
grDrawTriangle(
&xformedVerts[0], &xformedVerts[1],
&xformedVerts[2]
);
for (n = 0; n < 3; n++) {
xformedVerts[n].x += SHIFT;
xformedVerts[n].y -= SHIFT;
}
if (depthBias)
grDepthBiasLevel(0x7fff);
guColorCombineFunction(GR_COLORCOMBINE_ITRGB);
grDrawTriangle(
&xformedVerts[0], &xformedVerts[1],
&xformedVerts[2]
);
}
if (backbuffer) {
grBufferSwap( 1 );
}
}
if (kbhit()) {
char c = getch();
switch (c) {
case 'a':
case 'A':
if (antialias == FXFALSE) {
printf("Turning ON Antialiasing\n");
antialias = FXTRUE;
} else {
printf("Turning OFF Antialiasing\n");
antialias = FXFALSE;
}
break;
case 'B':
case 'b':
if (bilinear == FXFALSE) {
bilinear = FXTRUE;
printf("Turning ON BiLinear blending\n");
guTexChangeAttributes(
triDecal, bgInfo.header.width,
bgInfo.header.height,
bgInfo.header.format, GR_MIPMAP_NEAREST,
bgInfo.header.small_lod,
bgInfo.header.large_lod,
bgInfo.header.aspect_ratio,
GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR);
} else {
bilinear = FXFALSE;
printf("Turning OFF BiLinear blending\n");
guTexChangeAttributes(
triDecal, bgInfo.header.width,
bgInfo.header.height,
bgInfo.header.format, GR_MIPMAP_NEAREST,
bgInfo.header.small_lod,
bgInfo.header.large_lod,
bgInfo.header.aspect_ratio,
GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP,
GR_TEXTUREFILTER_POINT_SAMPLED,
GR_TEXTUREFILTER_POINT_SAMPLED);
}
break;
case 'c':
case 'C':
if (blend == FXTRUE) {
blend = FXFALSE;
localVerts[0].a = 255.0f;
localVerts[1].a = 255.0f;
localVerts[2].a = 255.0f;
localVerts[3].a = 255.0f;
} else {
blend = FXTRUE;
localVerts[0].a = alpha;
localVerts[1].a = alpha;
localVerts[2].a = alpha;
}
break;
case 'd':
case 'D':
if (depthBias == FXTRUE) {
printf("Turning OFF depth bias level\n");
depthBias = FXFALSE;
grDepthBiasLevel(0);
} else {
printf("Turning ON depth bias level\n");
depthBias = FXTRUE;
}
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':
grLfbBegin();
grLfbWriteMode(GR_LFBWRITEMODE_565);
grLfbOrigin(GR_ORIGIN_UPPER_LEFT);
grLfbGetReadPtr(GR_BUFFER_FRONTBUFFER);
printf("Press a key to get front buffer\n");
while (!kbhit());
c = getch();
guFbReadRegion(0,0,(int)wWidth,(int)wHeight,scrnImage,(int)wWidth * sizeof(FxU16));
printf("Press a key to put image in back buffer and swap\n");
while (!kbhit());
getch();
grLfbGetWritePtr(GR_BUFFER_BACKBUFFER);
guFbWriteRegion(0,0,(int)wWidth,(int)wHeight,scrnImage,(int)wWidth * sizeof(FxU16));
grBufferSwap(1);
printf("Press a key to continue...\n");
while (!kbhit());
getch();
grLfbEnd();
break;
case 'h':
case 'H':
case '?':
grSstPassthruMode(GR_PASSTHRU_SHOW_VGA);
printf("Keymap:\n");
printf(" A or a: toggle Antialiasing\n");
printf(" B or b: toggle Bilinear\n");
printf(" D or d: toggle Depth bias level\n");
printf(" F or f: toggle Front buffer \n");
printf(" H, h, or ?: Help\n");
printf(" I or i: toggle background Image\n");
printf(" P or p: Pause rendering\n");
printf(" Q or q: Quit\n");
printf("Press a key to continue...\n");
getch();
grSstPassthruMode(GR_PASSTHRU_SHOW_SST1);
break;
case 'i':
case 'I':
if (background == FXTRUE) {
background = FXFALSE;
printf("Turning off background\n");
} else {
printf("Turning on background\n");
background = FXTRUE;
}
break;
case 'p':
case 'P':
if (render == FXTRUE)
render = FXFALSE;
else
render = FXTRUE;
break;
case 'q':
case 'Q':
grGlideShutdown();
exit(0);
break;
case 'T':
case 't':
if (texturing == FXFALSE) {
printf("Turning ON texturing\n");
ccFnc = GR_COLORCOMBINE_DECAL_TEXTURE;
texturing = FXTRUE;
} else {
printf("Turning OFF texturing\n");
ccFnc = GR_COLORCOMBINE_ITRGB;
texturing = FXFALSE;
}
break;
}
}
if (render) {
y_angle += 2.f;
if( y_angle > 360.0f )
y_angle -= 360.0f;
}
frameCount++;
if(frameCount < 0)
frameCount = 0;
if(numFrames == frameCount)
break;
}
grGlideShutdown();
}
void
main(int argc, char **argv) {
float
wWidth, wHeight;
GrScreenResolution_t
screenRes;
int
numFrames = -1,
frameCount = 0;
int
i;
wWidth = 640.f;
wHeight = 480.f;
screenRes = GR_RESOLUTION_640x480;
if (argc > 1) {
for(i = 1; i < argc; i++) {
if (strstr(argv[i], "320x200")) {
wWidth = 320.f; wHeight = 200.f;
screenRes = GR_RESOLUTION_320x200;
} else if (strstr(argv[i], "320x240")) {
wWidth = 320.f; wHeight = 240.f;
screenRes = GR_RESOLUTION_320x240;
} else if (strstr(argv[i], "400x256")) {
wWidth = 400.f; wHeight = 256.f;
screenRes = GR_RESOLUTION_400x256;
} else if (strstr(argv[i], "512x384")) {
wWidth = 512.f; wHeight = 384.f;
screenRes = GR_RESOLUTION_512x384;
} else if (strstr(argv[i], "640x480")) {
wWidth = 640.f; wHeight = 480.f;
screenRes = GR_RESOLUTION_640x480;
} else if (strstr(argv[i], "800x600")) {
wWidth = 800.f; wHeight = 600.f;
screenRes = GR_RESOLUTION_800x600;
} else if (strstr(argv[i], "640x200")) {
wWidth = 640.f; wHeight = 200.f;
screenRes = GR_RESOLUTION_640x200;
} else if (strstr(argv[i], "640x350")) {
wWidth = 640.f; wHeight = 350.f;
screenRes = GR_RESOLUTION_640x350;
} else if (strstr(argv[i], "640x400")) {
wWidth = 640.f; wHeight = 400.f;
screenRes = GR_RESOLUTION_640x400;
} else if (strstr(argv[i], "960x720")) {
wWidth = 960.f; wHeight = 720.f;
screenRes = GR_RESOLUTION_960x720;
} else if (strstr(argv[i], "-n")) {
if(argc > i + 1) {
numFrames = atoi(argv[i + 1]);
i++;
} else {
fprintf(stderr, "Usage: test09 {320x200|320x240|400x256|512x384|640x480|800x600|640x200|640x350|640x400|960x720} {-n numFrames}\n");
exit(-1);
}
} else {
fprintf(stderr, "Usage: test09 {320x200|320x240|400x256|512x384|640x480|800x600|640x200|640x350|640x400|960x720} {-n numFrames}\n");
exit(-1);
}
}
}
puts( "\nTEST09:" );
puts( "tests alpha blending" );
if(numFrames == -1)
{
puts( "Press any key to continue" );
getch();
}
grGlideInit();
if ( !grSstQueryHardware( &hwconfig ) )
{
fprintf( stderr, "main: grSstQueryHardware failed!\n" );
grGlideShutdown();
exit( -1 );
}
/*
** Select SST 0
*/
grSstSelect( 0 );
/*
** Open up the hardware
*/
if ( !grSstOpen( screenRes,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_LOWER_LEFT,
GR_SMOOTHING_ENABLE,
2 ) )
{
fprintf( stderr, "main: grSstOpen failed!\n" );
grGlideShutdown();
exit( -1 );
}
/*
** Configure Glide to test alpha blending
*/
guAlphaSource( GR_ALPHASOURCE_CC_ALPHA );
grAlphaBlendFunction( GR_BLEND_SRC_ALPHA, GR_BLEND_ONE_MINUS_SRC_ALPHA, GR_BLEND_ONE, GR_BLEND_ZERO );
grColorCombine(
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_CONSTANT, GR_COMBINE_OTHER_NONE, FXFALSE);
while ( 1 )
{
static GrVertex vtxlist[3];
int i;
grBufferClear( 0, 0, 0 );
vtxlist[0].x = 160.f;
vtxlist[0].y = 100.f;
vtxlist[1].x = 480.f;
vtxlist[1].y = 100.f;
vtxlist[2].x = 320.f;
vtxlist[2].y = 380.f;
grConstantColorValue4(255.f, 0.f, 0.f, 255.f);
grConstantColorValue( 0xFF0000FF );
for (i = 0; i < 3; i++) {
vtxlist[i].x = WINSCALEX(vtxlist[i].x);
vtxlist[i].y = WINSCALEY(vtxlist[i].y);
}
grDrawTriangle( &vtxlist[0], &vtxlist[2], &vtxlist[1] );
vtxlist[0].x = 160.f;
vtxlist[0].y = 380.f;
vtxlist[1].x = 480.f;
vtxlist[1].y = 380.f;
vtxlist[2].x = 320.f;
vtxlist[2].y = 100.f;
grConstantColorValue4(128.f, 255.f, 0.f, 0.f);
grConstantColorValue( 0x80FF0000 );
for (i = 0; i < 3; i++) {
vtxlist[i].x = WINSCALEX(vtxlist[i].x);
vtxlist[i].y = WINSCALEY(vtxlist[i].y);
}
grDrawTriangle( &vtxlist[0], &vtxlist[1], &vtxlist[2] );
grBufferSwap( 0 );
if (kbhit()) {
getch();
break;
}
frameCount++;
if(frameCount < 0)
frameCount = 0;
if(frameCount == numFrames)
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;
FxBool scrgrab = FXFALSE;
char filename[256];
/* 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 );
/* Set up Render State - flat shading + alpha blend on constant alpha */
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 );
grAlphaCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_NONE,
FXFALSE );
grAlphaBlendFunction( GR_BLEND_SRC_ALPHA, GR_BLEND_ONE_MINUS_SRC_ALPHA,
GR_BLEND_ZERO, GR_BLEND_ZERO );
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( 0x00, 0, 0 );
vtxA.x = tlScaleX( 0.25f ), vtxA.y = tlScaleY( 0.21f );
vtxB.x = tlScaleX( 0.75f ), vtxB.y = tlScaleY( 0.21f );
vtxC.x = tlScaleX( 0.5f ), vtxC.y = tlScaleY( 0.79f );
grConstantColorValue( 0xFF0000FF );
grDrawTriangle( &vtxA, &vtxB, &vtxC );
vtxA.x = tlScaleX( 0.86f ), vtxA.y = tlScaleY( 0.21f );
vtxB.x = tlScaleX( 0.86f ), vtxB.y = tlScaleY( 0.79f );
vtxC.x = tlScaleX( 0.14f ), vtxC.y = tlScaleY( 0.5f );
grConstantColorValue( 0x80FF0000 );
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;
}
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];
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;
}
void
main( int argc, char **argv)
{
char
match,
**remArgs,
*args = "nrd",
filename[256];
int
frames = -1,
rv;
float
scrWidth = 640.f,
scrHeight = 480.f;
FxBool
scrgrab = FXFALSE;
GrScreenResolution_t
resolution = GR_RESOLUTION_640x480;
FxI32 listType = -1;
FxBool aaenable = FXFALSE;
FxBool packedrgb = FXFALSE;
FxBool varraycont = FXFALSE;
GrVertex vtxList[4];
void *vtxListArray[6];
GrVertex vtxListCont[6];
FxU32 wrange[2];
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, args, &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();
}
grSstSelect( 0 );
assert( grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1 ) );
tlConSet( 0.f, 0.f, 1.f, 1.f,
60, 30, 0xffffff );
/* Set up Render State - gouraud shading */
grVertexLayout(GR_PARAM_XY, GR_VERTEX_X_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_RGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
grGet(GR_WDEPTH_MIN_MAX, 8, wrange);
grColorCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_NONE,
FXFALSE );
grCullMode(GR_CULL_DISABLE);
if(frames == -1) {
doHelp();
}
/*
** data
*/
{
vtxList[0].x = tlScaleX( 0.3f ), vtxList[0].y = tlScaleY( 0.3f );
vtxList[0].r = 255.f, vtxList[0].g = 0.f, vtxList[0].b = 0.f, vtxList[0].a = 255.f;
vtxList[1].x = tlScaleX( 0.8f ), vtxList[1].y = tlScaleY( 0.4f );
vtxList[1].r = 0.f, vtxList[1].g = 255.f, vtxList[1].b = 0.f, vtxList[1].a = 255.f;
vtxList[2].x = tlScaleX( 0.5f ), vtxList[2].y = tlScaleY( 0.8f );
vtxList[2].r = 0.f, vtxList[2].g = 0.f, vtxList[2].b = 255.f, vtxList[2].a = 255.f;
vtxList[3].x = tlScaleX( 0.9f ), vtxList[3].y = tlScaleY( 0.8f );
vtxList[3].r = 0.f, vtxList[3].g = 0.f, vtxList[3].b = 255.f, vtxList[3].a = 255.f;
vtxListCont[0] = vtxList[0];
vtxListCont[1] = vtxList[1];
vtxListCont[2] = vtxList[2];
vtxListCont[3] = vtxList[3];
}
while( frames-- && tlOkToRender()) {
tlConClear();
tlConOutput( "Press a key to quit\n" );
if (aaenable)
tlConOutput("Antialiasing ON\n");
else
tlConOutput("Antialiasing OFF\n");
if (packedrgb)
tlConOutput("Packed Color ON\n");
else
tlConOutput("Packed Color OFF\n");
if (listType >= 0) {
if (varraycont)
tlConOutput("grDrawVertexArrayContiguous\n");
else
tlConOutput("grDrawVertexArray\n");
switch (listType) {
case GR_POINTS:
tlConOutput("POINTS\n");
break;
case GR_LINE_STRIP:
tlConOutput("LINE STRIP\n");
break;
case GR_LINES:
tlConOutput("LINES\n");
break;
case GR_POLYGON:
tlConOutput("POLYGON\n");
break;
case GR_TRIANGLE_STRIP:
tlConOutput("TRIANGLE STRIP\n");
break;
case GR_TRIANGLE_FAN:
tlConOutput("TRIANGLE FAN\n");
break;
case GR_TRIANGLES:
tlConOutput("TRIANGLES\n");
break;
}
}
else
tlConOutput("grDrawTriangle\n");
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grRenderBuffer( GR_BUFFER_BACKBUFFER );
grBufferClear( 0x00, 0, wrange[1] );
switch (listType) {
case GR_POINTS:
case GR_LINE_STRIP:
case GR_LINES:
case GR_POLYGON:
case GR_TRIANGLE_STRIP:
case GR_TRIANGLE_FAN:
if (varraycont)
grDrawVertexArrayContiguous(listType, 4, vtxListCont, sizeof(GrVertex));
else
grDrawVertexArray(listType, 4, vtxListArray);
break;
case GR_TRIANGLES:
if (varraycont)
grDrawVertexArrayContiguous(listType, 6, vtxListCont, sizeof(GrVertex));
else
grDrawVertexArray(listType, 6, vtxListArray);
break;
default:
if (aaenable)
grAADrawTriangle(vtxList, vtxList+1, vtxList+2, FXTRUE, FXTRUE, FXTRUE);
else
grDrawTriangle(vtxList, vtxList+1, vtxList+2);
}
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() ) {
FxU32 key;
switch( key = tlGetCH() ) {
case 'c':
case 'C':
varraycont = !varraycont;
break;
case 't':
case 'T':
listType = -1;
break;
case 'a':
case 'A':
aaenable = !aaenable;
if (aaenable) {
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_ZERO, GR_BLEND_ZERO );
grEnable(GR_AA_ORDERED);
if (!packedrgb)
grVertexLayout(GR_PARAM_A,
GR_VERTEX_A_OFFSET << 2,
GR_PARAM_ENABLE);
}
else {
grAlphaCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_CONSTANT,
FXFALSE);
grAlphaBlendFunction(GR_BLEND_ONE , GR_BLEND_ZERO,
GR_BLEND_ONE, GR_BLEND_ZERO);
grDisable(GR_AA_ORDERED);
if (!packedrgb)
grVertexLayout(GR_PARAM_A,
GR_VERTEX_A_OFFSET << 2,
GR_PARAM_DISABLE);
}
break;
case 'p':
case 'P':
packedrgb = !packedrgb;
if (packedrgb) {
grVertexLayout(GR_PARAM_PARGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
*(FxU32*)&vtxList[0].r = 0xff0000ff;
*(FxU32*)&vtxList[1].r = 0xff00ff00;
*(FxU32*)&vtxList[2].r = 0xffff0000;
*(FxU32*)&vtxList[3].r = 0xffff0000;
*(FxU32*)&vtxList[4].r = 0xff00ff00;
*(FxU32*)&vtxList[5].r = 0xff0000ff;
}
else {
grVertexLayout(GR_PARAM_RGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
if (aaenable)
grVertexLayout(GR_PARAM_A, GR_VERTEX_A_OFFSET << 2, GR_PARAM_ENABLE);
vtxList[0].r = 255.f, vtxList[0].g = 0.f, vtxList[0].b = 0.f, vtxList[0].a = 255.f;
vtxList[1].r = 0.f, vtxList[1].g = 255.f, vtxList[1].b = 0.f, vtxList[1].a = 255.f;
vtxList[2].r = 0.f, vtxList[2].g = 0.f, vtxList[2].b = 255.f, vtxList[2].a = 255.f;
vtxList[3].r = 0.f, vtxList[3].g = 0.f, vtxList[3].b = 255.f, vtxList[3].a = 255.f;
vtxList[4].r = 0.f, vtxList[4].g = 255.f, vtxList[4].b = 0.f, vtxList[4].a = 255.f;
vtxList[5].r = 0.f, vtxList[5].g = 0.f, vtxList[5].b = 255.f, vtxList[5].a = 255.f;
}
switch (listType) {
case 0:
case 1:
case 2:
case 4:
vtxListCont[0] = vtxList[0]; vtxListCont[1] = vtxList[1];
vtxListCont[2] = vtxList[2]; vtxListCont[3] = vtxList[3];
break;
case 3:
case 5:
vtxListCont[0] = vtxList[1]; vtxListCont[1] = vtxList[0];
vtxListCont[2] = vtxList[2]; vtxListCont[3] = vtxList[3];
break;
case 6:
vtxListCont[0] = vtxList[1]; vtxListCont[1] = vtxList[0]; vtxListCont[2] = vtxList[2];
vtxListCont[3] = vtxList[1]; vtxListCont[4] = vtxList[2]; vtxListCont[5] = vtxList[3];
break;
}
break;
case '0':
case '1':
case '2':
case '4':
listType = key - '0';
vtxListArray[0] = (void *)&vtxList[0]; vtxListArray[1] = (void *)&vtxList[1];
vtxListArray[2] = (void *)&vtxList[2]; vtxListArray[3] = (void *)&vtxList[3];
vtxListCont[0] = vtxList[0]; vtxListCont[1] = vtxList[1];
vtxListCont[2] = vtxList[2]; vtxListCont[3] = vtxList[3];
break;
case '3':
case '5':
listType = key - '0';
vtxListArray[0] = (void *)&vtxList[1]; vtxListArray[1] = (void *)&vtxList[0];
vtxListArray[2] = (void *)&vtxList[2]; vtxListArray[3] = (void *)&vtxList[3];
vtxListCont[0] = vtxList[1]; vtxListCont[1] = vtxList[0];
vtxListCont[2] = vtxList[2]; vtxListCont[3] = vtxList[3];
break;
case '6':
listType = key - '0';
vtxListArray[0] = (void *)&vtxList[1]; vtxListArray[1] = (void *)&vtxList[0];
vtxListArray[2] = (void *)&vtxList[2];
vtxListArray[3] = (void *)&vtxList[1]; vtxListArray[4] = (void *)&vtxList[2];
vtxListArray[5] = (void *)&vtxList[3];
vtxListCont[0] = vtxList[1]; vtxListCont[1] = vtxList[0]; vtxListCont[2] = vtxList[2];
vtxListCont[3] = vtxList[1]; vtxListCont[4] = vtxList[2]; vtxListCont[5] = vtxList[3];
break;
default:
frames = 0;
break;
}
}
}
grGlideShutdown();
return;
} /* 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;
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[] ) {
/*------------------------------------------------------------------
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;
FxBool scrgrab = FXFALSE;
char filename[256];
/* 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 );
grGlideGetVersion( 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( grSstQueryHardware( &hwconfig ) );
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, 0.5f,
60, 15, 0xffffff );
/* Set up Render State - iterated alpha + constant color */
grColorCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_NONE,
FXFALSE );
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_ZERO, GR_BLEND_ZERO );
#define RED 0x000000ff
#define BLUE 0x00ff0000
tlConOutput( "Press any key to quit\n" );
while( frames-- && tlOkToRender()) {
GrVertex vtxA, vtxB, vtxC;
if (hwconfig.SSTs[0].type == GR_SSTTYPE_SST96) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear( 0x00, 0, 0 );
vtxA.x = tlScaleX( 0.5f ), vtxA.y = tlScaleY( 0.1f );
vtxB.x = tlScaleX( 0.8f ), vtxB.y = tlScaleY( 0.9f );
vtxC.x = tlScaleX( 0.2f ), vtxC.y = tlScaleY( 0.9f );
vtxA.a = vtxB.a = vtxC.a = 255.0f;
grConstantColorValue( RED );
grDrawTriangle( &vtxA, &vtxB, &vtxC );
grSstOrigin( GR_ORIGIN_LOWER_LEFT );
vtxA.a = 0.0f;
grConstantColorValue( BLUE );
grDrawTriangle( &vtxA, &vtxB, &vtxC );
grSstOrigin( GR_ORIGIN_UPPER_LEFT );
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() ) {
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;
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 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 */
static int SetupFBtoScreenCombiner(uint32_t texture_size, uint32_t opaque)
{
int tmu, filter;
if (voodoo.tmem_ptr[GR_TMU0]+texture_size < voodoo.tex_max_addr)
{
tmu = GR_TMU0;
grTexCombine( GR_TMU1,
GR_COMBINE_FUNCTION_NONE,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_NONE,
GR_COMBINE_FACTOR_NONE,
FXFALSE,
FXFALSE );
grTexCombine( GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
FXFALSE,
FXFALSE );
}
else
{
if (voodoo.tmem_ptr[GR_TMU1]+texture_size >= voodoo.tex_max_addr)
ClearCache ();
tmu = GR_TMU1;
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,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
FXFALSE,
FXFALSE );
}
filter = (rdp.filter_mode != 2) ? GR_TEXTUREFILTER_POINT_SAMPLED : GR_TEXTUREFILTER_BILINEAR;
grTexFilterClampMode (tmu,
GR_TEXTURECLAMP_CLAMP,
GR_TEXTURECLAMP_CLAMP,
filter,
filter);
grColorCombine (GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
// GR_COMBINE_OTHER_CONSTANT,
FXFALSE);
grAlphaCombine (GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
if (opaque)
{
grAlphaTestFunction (GR_CMP_ALWAYS, 0x00, 0);
grAlphaBlendFunction( GR_BLEND_ONE,
GR_BLEND_ZERO,
GR_BLEND_ONE,
GR_BLEND_ZERO);
}
else
{
grAlphaBlendFunction( GR_BLEND_SRC_ALPHA,
GR_BLEND_ONE_MINUS_SRC_ALPHA,
GR_BLEND_ONE,
GR_BLEND_ZERO);
}
grDepthBufferFunction (GR_CMP_ALWAYS);
grCullMode(GR_CULL_DISABLE);
grDepthMask (FXFALSE);
rdp.update |= UPDATE_COMBINE | UPDATE_ZBUF_ENABLED | UPDATE_CULL_MODE;
return tmu;
}