void _3dfx_BlitScale( grs_bitmap *source_bmp, grs_bitmap *dest_bmp,
int x0, int y0, int x1, int y1,
fix u0, fix v0, fix u1, fix v1, int orient )
{
if ( _3dfx_available )
{
if ( source_bmp->bm_flags & BM_FLAG_RLE )
{
fix u, v, du, dv;
int x, y;
ubyte * sbits;
unsigned long * dbits;
unsigned long * fb;
du = (u1-u0) / (x1-x0);
dv = (v1-v0) / (y1-y0);
v = v0;
grLfbBegin();
grLfbBypassMode( GR_LFBBYPASS_ENABLE );
fb = ( unsigned long * ) grLfbGetWritePtr( GR_BUFFER_BACKBUFFER );
grLfbWriteMode( GR_LFBWRITEMODE_8888 );
guColorCombineFunction( GR_COLORCOMBINE_DECAL_TEXTURE );
for ( y = y0; y <= y1; y++, v += dv )
{
extern ubyte scale_rle_data[];
decode_row( source_bmp, f2i( v ) );
sbits = scale_rle_data + f2i( u0 );
dbits = fb + _3DFX_FB_WIDTH * y + x0;
u = u0;
for ( x = x0; x <= x1; x++ )
{
int pindex = sbits[ u >> 16 ];
if ( pindex != 255 )
*dbits = _3dfx_PaletteToARGB( pindex );
dbits++;
u += du;
}
}
grLfbBypassMode( GR_LFBBYPASS_DISABLE );
grLfbEnd();
}
else
{
void _3dfx_DrawFlatShadedPoly( g3ds_tmap *Tmap1, unsigned long argb )
{
GrVertex a, b, c;
int i;
float lowest_y = 10000, highest_y = 0;
float lowest_x = 10000, highest_x = 0;
for ( i = 0; i < Tmap1->nv; i++ )
{
float x = SNAP( Tmap1->verts[i].x2d ) * fix_to_float;
float y = SNAP( Tmap1->verts[i].y2d ) * fix_to_float;
if ( x < lowest_x ) lowest_x = x;
if ( x > highest_x ) highest_x = x;
if ( y < lowest_y ) lowest_y = y;
if ( y > highest_y ) highest_y = y;
}
if ( highest_x < 0 || highest_y < 0 || lowest_x > 639 || lowest_y > 479 )
{
mprintf( ( 0, "3dfx - rejecting fspoly way off screen\n" ) );
return;
}
guColorCombineFunction( GR_COLORCOMBINE_CCRGB );
grConstantColorValue( argb );
a.x = SNAP( Tmap1->verts[0].x2d ) * fix_to_float;
a.y = SNAP( Tmap1->verts[0].y2d ) * fix_to_float;
for ( i = 1; i < Tmap1->nv - 1; i++ )
{
b.x = SNAP( Tmap1->verts[i].x2d ) * fix_to_float;
b.y = SNAP( Tmap1->verts[i].y2d ) * fix_to_float;
c.x = SNAP( Tmap1->verts[i+1].x2d ) * fix_to_float;
c.y = SNAP( Tmap1->verts[i+1].y2d ) * fix_to_float;
grDrawTriangle( &a, &b, &c );
}
}
void main( int argc, char **argv )
{
GrMipMapId_t decal0;
Gu3dfInfo info;
float
wWidth, wHeight;
int automate = 0;
int i;
char *fileName;
GrScreenResolution_t
screenRes = GR_RESOLUTION_800x600;
GrVertex vtx1, vtx2, vtx3, vtx4;
float near_z = 2.0F;
float far_z = 16.0F;
if (argc < 2 || strstr(argv[1], "-n")) {
fprintf(stderr, "usage: test20 filename.3df [-n]\n");
exit(-1);
}
fileName = argv[1];
if(argc > 2)
if(strstr(argv[2], "-n"))
automate = 1;
else
{
fprintf(stderr, "usage: test20 filename.3df [-n]\n");
exit(-1);
}
wWidth = 800.f;
wHeight = 600.f;
puts( "TEST20: " );
puts( "tests loading of 3df files");
if(!automate)
{
puts("Press a key to continue");
getch();
}
/*
** set up Glide and the hardware
*/
grGlideInit();
if ( !grSstQueryHardware( &hwconfig ) )
{
fprintf( stderr, "main: grSstQueryHardware failed!\n" );
grGlideShutdown();
exit( -1 );
}
grSstSelect( 0 );
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 );
}
/*
** load up texture maps
*/
if ( !gu3dfGetInfo( fileName, &info ) )
{
fprintf(stderr, "ERROR: could not load %s\n", fileName);
grGlideShutdown();
exit( -1 );
}
else
{
info.data = malloc( info.mem_required );
if ( info.data == 0 ) {
fprintf( stderr, "out of memory for texture\n" );
grGlideShutdown();
exit( -1 );
}
if ( !gu3dfLoad( fileName, &info ) ) {
fprintf( stderr, "could not load texture file\n" );
grGlideShutdown();
exit( -1 );
}
decal0 = guTexAllocateMemory( 0, GR_MIPMAPLEVELMASK_BOTH,
info.header.width, info.header.height,
info.header.format,
GR_MIPMAP_NEAREST,
info.header.small_lod, info.header.large_lod,
info.header.aspect_ratio,
GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP,
GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR,
0.0F,
FXFALSE );
if ( decal0 == GR_NULL_MIPMAP_HANDLE ) {
fprintf( stderr, "could not allocate memory for lava.3df\n" );
grGlideShutdown();
exit( -1 );
}
guTexDownloadMipMap( decal0, info.data, &info.table.nccTable );
free( info.data );
}
grBufferClear( 0xFFFF0000, 0, GR_WDEPTHVALUE_FARTHEST );
guColorCombineFunction(GR_COLORCOMBINE_DECAL_TEXTURE);
guTexSource( decal0 );
grTexCombineFunction(GR_TMU0, GR_TEXTURECOMBINE_DECAL);
vtx1.x = 160.f;
vtx1.y = 20.f;
vtx1.r = 255.f;
vtx1.g = 0.f;
vtx1.b = 0.f;
vtx1.a = 255.f;
vtx1.oow = 1.f / near_z;
vtx1.tmuvtx[0].sow = 0.f / near_z;
vtx1.tmuvtx[0].tow = 255.f / near_z;
vtx2.x = 480.f;
vtx2.y = 20.f;
vtx2.r = 0.f;
vtx2.g = 255.f;
vtx2.b = 0.f;
vtx2.a = 255.f;
vtx2.oow = 1.f / near_z;
vtx2.tmuvtx[0].sow = 255.f / near_z;
vtx2.tmuvtx[0].tow = 255.f / near_z;
vtx3.x = 300.f;
vtx3.y = 460.f;
vtx3.r = 0.f;
vtx3.g = 0.f;
vtx3.b = 255.f;
vtx3.a = 255.f;
vtx3.oow = 1.f/ far_z;
vtx3.tmuvtx[0].sow = 0.f/ far_z;
vtx3.tmuvtx[0].tow = 0.f / far_z;
vtx4.x = 340.f;
vtx4.y = 460.f;
vtx4.r = 0.f;
vtx4.g = 0.f;
vtx4.b = 255.f;
vtx4.a = 255.f;
vtx4.oow = 1.f / far_z;
vtx4.tmuvtx[0].sow = 255.f / far_z;
vtx4.tmuvtx[0].tow = 0.f / far_z;
vtx1.x = WINSCALEX(vtx1.x);
vtx1.y = WINSCALEX(vtx1.y);
vtx2.x = WINSCALEX(vtx2.x);
vtx2.y = WINSCALEX(vtx2.y);
vtx3.x = WINSCALEX(vtx3.x);
vtx3.y = WINSCALEX(vtx3.y);
vtx4.x = WINSCALEX(vtx4.x);
vtx4.y = WINSCALEX(vtx4.y);
grDrawTriangle( &vtx1, &vtx2, &vtx3 );
grDrawTriangle( &vtx3, &vtx4, &vtx2 );
grBufferSwap( 1 );
if(!automate)
{
printf("Press a key to end...\n");
getch();
}
else
for(i = 0; i < 700000000; i++);
grGlideShutdown();
}
//==================================================================================
// GMain_InitGlideRegisters
//==================================================================================
geBoolean GMain_InitGlideRegisters(void)
{
//
// Setup card register states
//
// fix up the z-buffer
grDepthBufferMode( GR_DEPTHBUFFER_ZBUFFER );
grDepthBufferFunction( GR_CMP_GEQUAL );
grDepthMask( FXTRUE );
// Fixup the transparent color
grChromakeyMode(GR_CHROMAKEY_DISABLE); // Off by default, on for decals though...
grChromakeyValue(1);
// Fixup the Mipmapping
// TMU
// Bias -32...+31
// Detail scale 0...7
// Detail Max 0...1.0
grTexDetailControl(TMU[0], 0, 1, 1.0f);
// -8... 7.75
grTexLodBiasValue(TMU[0], -1.0f);
//grTexLodBiasValue(TMU[0], 7.0f);
// Tell it how we like it...
guColorCombineFunction( GR_COLORCOMBINE_DECAL_TEXTURE );
guTexCombineFunction( TMU[0], GR_TEXTURECOMBINE_DECAL );
//rTexMipMapMode( TMU[0], GR_MIPMAP_NEAREST, FXFALSE);
//grTexMipMapMode( TMU[0], GR_MIPMAP_DISABLE, FXFALSE );
//grTexFilterMode( TMU[0], GR_TEXTUREFILTER_POINT_SAMPLED,GR_TEXTUREFILTER_BILINEAR);
//grTexFilterMode( TMU[0], GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_POINT_SAMPLED);
grTexFilterMode( TMU[0], GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR);
grTexClampMode( TMU[0], GR_TEXTURECLAMP_WRAP,GR_TEXTURECLAMP_WRAP);
grTexCombine( TMU[0],
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
FXFALSE, FXFALSE );
// turn on gouraud shading
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
grAlphaCombine( GR_COMBINE_FUNCTION_BLEND_OTHER,
GR_COMBINE_FACTOR_LOCAL_ALPHA,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
/*
grAlphaCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
*/
//grAlphaControlsITRGBLighting(FXTRUE);
//grGlideShamelessPlug(FXTRUE);
if (g_BoardInfo.NumTMU >= 2)
{
grTexDetailControl(TMU[1], 0, 1, 0.3f);
grTexLodBiasValue(TMU[1], 0.3f);
guTexCombineFunction( TMU[1], GR_TEXTURECOMBINE_DECAL );
grTexFilterMode( TMU[1], GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR);
grTexClampMode( TMU[1], GR_TEXTURECLAMP_CLAMP,GR_TEXTURECLAMP_CLAMP);
grTexCombine( TMU[1],
GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL,
FXFALSE, FXFALSE );
// Always texture clamp on second TMU (it only uses lightmaps for now)
grTexClampMode(TMU[1], GR_TEXTURECLAMP_CLAMP,GR_TEXTURECLAMP_CLAMP);
grHints(GR_HINT_STWHINT, GR_STWHINT_ST_DIFF_TMU0 | GR_STWHINT_ST_DIFF_TMU1);
}
//GMain_SetFogEnable(GE_TRUE, 0.0f, 255.0f, 0.0f, 500.0f, 1500.0f);
GMain_SetFogEnable(GE_FALSE, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
return GE_TRUE;
}
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 color = 255.f;
int
i, j, num_sst, jj,
numFrames = -1,
frameCount = 0;
char
*texFileNames[2];
float
wWidth, wHeight;
GrMipMapId_t
mipmaps[2];
GrScreenResolution_t
screenRes;
GrVertex
vtx1, vtx2, vtx3;
texFileNames[0] = "bfly.3df";
texFileNames[1] = "lava.3df";
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: test42 {320x200|320x240|400x256|512x384|640x480|800x600|640x200|640x350|640x400|960x720} {-n numFrames}");
exit(-1);
}
} else {
fprintf(stderr, "Usage: test42 {320x200|320x240|400x256|512x384|640x480|800x600|640x200|640x350|640x400|960x720} {-n numFrames}\n");
exit(-1);
}
}
}
puts( "\nTEST42:" );
puts( "renders a Gouraud-modulated, textured triangle on each screen" );
if(numFrames == -1) {
puts( "press a key to continue" );
getch();
}
grGlideInit();
if ( !grSstQueryHardware( &hwconfig ) ) {
fprintf( stderr, "main: grSstQueryHardware failed!\n" );
grGlideShutdown();
exit( -1 );
}
for (i = 0; i < hwconfig.num_sst; i++) {
if (hwconfig.SSTs[i].type != GR_SSTTYPE_VOODOO) {
fprintf(stderr, "Somebody needs to update this program!\n");
grGlideShutdown();
exit( -1 );
} else
printf("SST %d: 3Dfx Voodoo Graphics:\n", 1);
printf(" Pixelfx Revision %d, %d MB Frame Buffer RAM\n",
hwconfig.SSTs[i].sstBoard.VoodooConfig.fbiRev,
hwconfig.SSTs[i].sstBoard.VoodooConfig.fbRam);
for (j = 0; j < hwconfig.SSTs[i].sstBoard.VoodooConfig.nTexelfx; j++) {
printf(" Texelfx %d: Revision %d, %d MB Texture RAM\n",
j,
hwconfig.SSTs[i].sstBoard.VoodooConfig.tmuConfig[j].tmuRev,
hwconfig.SSTs[i].sstBoard.VoodooConfig.tmuConfig[j].tmuRam);
}
}
num_sst = hwconfig.num_sst;
for(jj=0; jj<num_sst; jj++) {
/*
** Select SST
*/
grSstSelect( jj );
/*
** 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 for SST#%d!\n", jj );
grGlideShutdown();
exit( -1 );
}
guColorCombineFunction( GR_COLORCOMBINE_TEXTURE_TIMES_ITRGB );
grTexCombineFunction(GR_TMU0, GR_TEXTURECOMBINE_DECAL);
}
for (jj = 0; jj < num_sst; jj++) {
Gu3dfInfo
info;
grSstSelect(jj);
if ( gu3dfGetInfo(texFileNames[jj], &info)) {
if ((info.data = malloc(info.mem_required)) == NULL) {
fprintf(stderr, "couldn't allocate host memory for %s\n",
texFileNames[jj]) ;
grGlideShutdown();
exit(-1);
}
if (!gu3dfLoad(texFileNames[jj], &info)) {
fprintf(stderr, "Couldn't load %s\n", texFileNames[jj]);
grGlideShutdown();
exit(-1);
}
mipmaps[jj] = guTexAllocateMemory(0, 0x3,
info.header.width,
info.header.height,
info.header.format,
GR_MIPMAP_NEAREST_DITHER,
info.header.small_lod,
info.header.large_lod,
info.header.aspect_ratio,
GR_TEXTURECLAMP_CLAMP,
GR_TEXTURECLAMP_CLAMP,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR,
0.f,
FXFALSE);
if (mipmaps[jj] == GR_NULL_MIPMAP_HANDLE) {
fprintf(stderr, "could not allocate memory for %s\n",
texFileNames[jj]);
grGlideShutdown();
exit(-1);
}
guTexDownloadMipMap( mipmaps[jj], info.data, &info.table.nccTable );
} else {
fprintf(stderr, "couldn't get info on %s\n", texFileNames[jj]);
grGlideShutdown();
exit(-1);
}
guTexSource(mipmaps[jj]);
}
vtx1.x = 160.0F;
vtx1.y = 120.0F;
vtx1.r = (float) 0xff;
vtx1.g = 0.0F;
vtx1.b = 0.0F;
vtx1.a = 25.0F;
vtx1.oow = 1.0F;
vtx1.tmuvtx[0].sow = 0.0F;
vtx1.tmuvtx[0].tow = 0.0F;
vtx2.x = 480.0F;
vtx2.y = 120.0F;
vtx2.r = 0.0F;
vtx2.g = (float) 0xff;
vtx2.b = 0.0F;
vtx2.a = 25.0F;
vtx2.oow = 1.0F;
vtx2.tmuvtx[0].sow = 255.0F;
vtx2.tmuvtx[0].tow = 0.0F;
vtx3.x = 320.0F;
vtx3.y = 360.0F;
vtx3.r = 0.0F;
vtx3.g = 0.0F;
vtx3.b = (float) 0xff;
vtx3.a = 255.0F;
vtx3.oow = 1.0F;
vtx3.tmuvtx[0].sow = 128.0F;
vtx3.tmuvtx[0].tow = 255.0F;
while ( 1 ) {
for(jj=0; jj<num_sst; jj++) {
grSstSelect( jj );
switch(jj & 0x3) {
case 0:
grBufferClear( 0xff0000, 0, GR_WDEPTHVALUE_FARTHEST );
break;
case 1:
grBufferClear( 0xff, 0, GR_WDEPTHVALUE_FARTHEST );
break;
case 2:
grBufferClear( 0xff00, 0, GR_WDEPTHVALUE_FARTHEST );
break;
default:
grBufferClear( 0xff00ff, 0, GR_WDEPTHVALUE_FARTHEST );
break;
}
grDrawTriangle( &vtx1, &vtx2, &vtx3 );
grBufferSwap( 1 );
}
if (kbhit()) {
getch();
break;
}
frameCount++;
if(frameCount < 0)
frameCount = 0;
if(frameCount == numFrames)
break;
}
for(jj=0; jj<num_sst; jj++) {
grSstSelect( jj );
grGlideShutdown();
}
}
void
main( int argc, char **argv )
{
float color = 255.f;
float
wWidth, wHeight;
GrScreenResolution_t
screenRes;
GrVertex
vtx1, vtx2, vtx3;
int
frameCount = 0,
numFrames = -1,
i;
wWidth = 640.f;
wHeight = 480.f;
screenRes = GR_RESOLUTION_640x480;
if (argc > 1) {
for(i = 1; i < argc; i++) {
if (strstr(argv[1], "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: test29 {320x200|320x240|400x256|512x384|640x480|800x600|640x200|640x350|640x400|960x720} {-n numFrames}\n");
exit(-1);
}
} else {
fprintf(stderr, "Usage: test29 {320x200|320x240|400x256|512x384|640x480|800x600|640x200|640x350|640x400|960x720} {-n numFrames}\n");
exit(-1);
}
}
}
puts( "\nTEST29:" );
puts( "renders a Gouraud shaded triangle bigger than the screen with clipping" );
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 );
}
guColorCombineFunction( GR_COLORCOMBINE_ITRGB );
vtx1.x = -2000.f;
vtx1.y = 2000.f;
vtx1.r = color;
vtx1.g = 0.f;
vtx1.b = 0.f;
vtx2.x = 2000.f;
vtx2.y = 2000.f;
vtx2.r = 0.f;
vtx2.g = color;
vtx2.b = 0.f;
vtx3.x = 320.f;
vtx3.y = -2000.f;
vtx3.r = 0.f;
vtx3.g = 0.f;
vtx3.b = color;
vtx1.x = WINSCALEX(vtx1.x);
vtx1.y = WINSCALEY(vtx1.y);
vtx2.x = WINSCALEX(vtx2.x);
vtx2.y = WINSCALEY(vtx2.y);
vtx3.x = WINSCALEX(vtx3.x);
vtx3.y = WINSCALEY(vtx3.y);
while ( 1 ) {
grBufferClear( 0, 0, GR_WDEPTHVALUE_FARTHEST );
guDrawTriangleWithClip( &vtx1, &vtx2, &vtx3 );
grBufferSwap( 1 );
if (kbhit()) {
getch();
break;
}
frameCount++;
if(frameCount < 0)
frameCount = 0;
if(frameCount == numFrames)
break;
}
grGlideShutdown();
}
void
main( int argc, char **argv ) {
int
i,
wWidth = 640, wHeight = 480; /* Screen width & height */
GrMipMapId_t
mmids[NUM_MIPMAPS]; /* The mipmaps with which we're testing. */
GrHwConfiguration
hwconfig;
GrScreenResolution_t
screenRes = GR_RESOLUTION_800x600;
GrVertex
vtx1, vtx2, vtx3, vtx4;
int
numFrames = -1,
frameCount = 0;
if(argc > 2)
if( strstr(argv[1], "-n"))
numFrames = atoi(argv[2]);
else
{
fprintf(stderr, "usage: test26 {-n numFrames}\n");
exit(-1);
}
else if(argc > 1)
if(strstr(argv[1], "-n"))
{
fprintf(stderr, "usage: test26 {-n numFrames}\n");
exit(-1);
}
puts("TEST26:");
puts("Tests texture mapping");
if(numFrames == -1)
{
puts("Press a key to continue");
getch();
}
grGlideInit(); /* Initialize glide library */
if ( !grSstQueryHardware( &hwconfig ) ) {
fprintf( stderr, "main: grSstQueryHardware failed!\n" );
grGlideShutdown();
exit( -1 );
}
grSstSelect( 0 );
if ( !grSstOpen( screenRes,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
GR_SMOOTHING_ENABLE,
2 ) )
{
fprintf( stderr, "main: grSstOpen failed!\n" );
grGlideShutdown();
exit( -1 );
}
/*
** load up texture maps
*/
for (i = 0; i < NUM_MIPMAPS; i++)
mmids[i] = doTexture("ramp.3df");
guColorCombineFunction(GR_COLORCOMBINE_DECAL_TEXTURE);
grTexCombineFunction(GR_TMU0, GR_TEXTURECOMBINE_DECAL);
grBufferClear( 0xFFFF0000, 0, GR_WDEPTHVALUE_FARTHEST );
while (1) {
grBufferClear( 0xFFFF0000, 0, GR_WDEPTHVALUE_FARTHEST );
for (i = 0; i < NUM_MIPMAPS; i++) {
/* upper-left-hand corner */
vtx1.x = 0.f + (i * 0.1f);
vtx1.y = 0.f + (i * 0.1f);
vtx1.oow = 1.0f;
vtx1.tmuvtx[0].sow = 0.f;
vtx1.tmuvtx[0].tow = 0.f;
/* upper-right-hand corner */
vtx2.x = 0.5f + (i * 0.1f);
vtx2.y = 0.f + (i * 0.1f);
vtx2.oow = 1.0f;
vtx2.tmuvtx[0].sow = 255.0f;
vtx2.tmuvtx[0].tow = 0.f;
/* lower-left-hand corner */
vtx3.x = 0.f + (i * 0.1f);
vtx3.y = 0.5f + (i * 0.1f);;
vtx3.oow = 1.f;
vtx3.tmuvtx[0].sow = 0.f;
vtx3.tmuvtx[0].tow = 255.f;
/* lower-right-hand corner */
vtx4.x = 0.5f + (i * 0.1f); ;
vtx4.y = 0.5f + (i * 0.1f);;
vtx4.oow = 1.f;
vtx4.tmuvtx[0].sow = 255.f;
vtx4.tmuvtx[0].tow = 255.f;
vtx1.x = WINSCALEX(vtx1.x);
vtx1.y = WINSCALEY(vtx1.y);
vtx2.x = WINSCALEX(vtx2.x);
vtx2.y = WINSCALEY(vtx2.y);
vtx3.x = WINSCALEX(vtx3.x);
vtx3.y = WINSCALEY(vtx3.y);
vtx4.x = WINSCALEX(vtx4.x);
vtx4.y = WINSCALEY(vtx4.y);
guTexSource(mmids[i]);
grDrawTriangle( &vtx1, &vtx2, &vtx3 );
grDrawTriangle( &vtx3, &vtx4, &vtx2 );
} /* for (i ...) */
while (grBufferNumPending() > 2);
grBufferSwap( 1 );
if (kbhit()) {
getch();
break;
}
frameCount++;
if(frameCount < 0)
frameCount = 0;
if(frameCount == numFrames)
break;
} /* while (1) */
grGlideShutdown();
} /* main */
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: test13 {320x200|320x240|400x256|512x384|640x480|800x600|640x200|640x350|640x400|960x720} {-n numFrames}\n");
exit(-1);
}
} else {
fprintf(stderr, "Usage: test13 {320x200|320x240|400x256|512x384|640x480|800x600} {-n numFrames}\n");
exit(-1);
}
}
}
puts( "\nTEST13:" );
puts( "backface culling test. Green triangle should be backface" );
puts( "culled, thus only a red triangle should be visible." );
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 );
}
/*
** Configure Glide to test backface culling
*/
guColorCombineFunction( GR_COLORCOMBINE_CCRGB );
grCullMode( GR_CULL_NEGATIVE );
/*
** Render a green triangle on a red triangle. The green triangle
** is clockwise and thus should not be rendered. The red triangle
** is counterclockwise and should be rendered.
*/
while ( 1 )
{
int i;
GrVertex vtxlist[3];
grBufferClear( 0, 0, 0 );
vtxlist[0].x = 160.f;
vtxlist[0].y = 100.f;
vtxlist[1].x = 320.f;
vtxlist[1].y = 380.f;
vtxlist[2].x = 480.f;
vtxlist[2].y = 100.f;
for (i = 0; i < 3; i++) {
vtxlist[i].x = WINSCALEX(vtxlist[i].x);
vtxlist[i].y = WINSCALEY(vtxlist[i].y);
}
/*
** Red triangle (counterclockwise, should be visible)
*/
grConstantColorValue( 0x000000FF );
grDrawTriangle( &vtxlist[0], &vtxlist[2], &vtxlist[1] );
/*
** Green triangle (clockwise, should be rejected)
*/
grConstantColorValue( 0x0000FF00 );
grDrawTriangle( &vtxlist[0], &vtxlist[1], &vtxlist[2] );
grBufferSwap( 1 );
if (kbhit())
{
getch();
break;
}
frameCount++;
if(frameCount < 0)
frameCount = 0;
if(frameCount == numFrames)
break;
}
grGlideShutdown();
}
