VNGError Vngo3Dfx::init()
{
grGlideInit();
if (!grSstQueryHardware (&hwconfig))
{
term();
return (VNGO_MISSING_HARDWARE);
}
type_info = SCREENTYPE_3DFX;
grSstSelect(0);
return (VNGO_NO_ERROR);
}
int main(void)
{
GrHwConfiguration hwconfig;
grGlideInit();
if (grSstQueryHardware(&hwconfig))
{
grSstSelect(0);
grSstWinOpen(0, GR_RESOLUTION_640x480, GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR, GR_ORIGIN_LOWER_LEFT,
2, 1);
grSstControl(GR_CONTROL_DEACTIVATE);
grGlideShutdown();
}
return 0;
}
//==================================================================================
// GMain_GetBoardInfo
// Glide is assumed to be initialized before this function is called...
//==================================================================================
geBoolean GMain_GetBoardInfo(GMain_BoardInfo *Info)
{
GrHwConfiguration GlideHwConfig;
// detect the Voodoo Graphics hardware in the host system
if (!grSstQueryHardware(&GlideHwConfig))
{
SetLastDrvError(DRV_ERROR_GENERIC, "GMain_GetBoardInfo: grSstQueryHardware failed.");
return GE_FALSE;
}
memset(Info, 0, sizeof(*Info));
switch (GlideHwConfig.SSTs[0].type)
{
case GR_SSTTYPE_VOODOO:
Info->MainRam = GlideHwConfig.SSTs[0].sstBoard.VoodooConfig.fbRam;
Info->NumTMU = GlideHwConfig.SSTs[0].sstBoard.VoodooConfig.nTexelfx;
break;
case GR_SSTTYPE_SST96:
Info->MainRam = GlideHwConfig.SSTs[0].sstBoard.SST96Config.fbRam;
Info->NumTMU = GlideHwConfig.SSTs[0].sstBoard.SST96Config.nTexelfx;
break;
case GR_SSTTYPE_AT3D:
SetLastDrvError(DRV_ERROR_GENERIC, "GMain_GetBoardInfo: GR_SSTTYPE_AT3D not supported.");
return GE_FALSE;
case GR_SSTTYPE_Voodoo2:
Info->MainRam = GlideHwConfig.SSTs[0].sstBoard.Voodoo2Config.fbRam;
Info->NumTMU = GlideHwConfig.SSTs[0].sstBoard.Voodoo2Config.nTexelfx;
break;
}
#if 0
Info->NumTMU = 1;
#endif
return GE_TRUE;
}
/* convinient initialization function */
void initGlide(int argc, char** argv)
{
GrScreenResolution_t
screenRes;
int
i;
wWidth = 640.f;
wHeight = 480.f;
screenRes = GR_RESOLUTION_640x480;
/* Let the user specify a resolution on the command line
and save the resolution in wWidth and wHeight */
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: test33 {320x200|320x240|400x256|512x384|640x480|800x600|640x200|640x350|640x400|960x720} {-n numFrames}");
exit(-1);
}
} else {
fprintf(stderr, "Usage: test33 {320x200|320x240|400x256|512x384|640x480|800x600|640x200|640x350|640x400|960x720} {-n numFrames}");
exit(-1);
}
}
}
/* Describe the program */
puts( "\nTEST35: (expanding cliping window)" );
puts( "Clipping test" );
if(numFrames == -1)
{
puts( "press a key to begin" );
getch();
}
/* Startup glide */
grGlideInit();
/* Get the hardware configuration */
if ( !grSstQueryHardware( &hwconfig ) )
{
fprintf( stderr, "grQuery failed!" );
exit( -1 );
}
/* Select the correct sst */
grSstSelect( 0 );
/* Open the device */
if ( !grSstOpen( screenRes,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_LOWER_LEFT,
GR_SMOOTHING_ENABLE,
2 ) )
{
fprintf( stderr, "grOpen failed!" );
grGlideShutdown();
exit( -1 );
}
/* Setup for iterrated color */
grColorCombine(GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED, GR_COMBINE_OTHER_NONE,
FXFALSE);
}
int _3dfx_Init( void )
{
int i;
mprintf( ( 0, "Initializing 3Dfx Interactive Voodoo Graphics hardware\n" ) );
grGlideInit();
grErrorSetCallback( MyErrorHandler );
if ( !grSstQueryHardware( &hwconfig ) )
{
mprintf( ( 0, "3Dfx Interactive Voodoo Graphics not found!" ) );
return 0;
}
grSstSelect( 0 );
if ( !grSstOpen( GR_RESOLUTION_640x480,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ARGB,
GR_ORIGIN_UPPER_LEFT,
GR_SMOOTHING_ENABLE,
2 ) )
{
mprintf( ( 0, "3Dfx Interactive Voodoo Graphics not opened!" ) );
return 0;
}
if ( getenv( "GLIDE_OFF" ) != 0 )
{
mprintf( ( 0, "3Dfx Interactive Voodoo Graphics disabled!" ) );
return 0;
}
grDepthBufferMode( GR_DEPTHBUFFER_DISABLE );
grBufferClear( 0x00000000, 0, 0 );
grCullMode( GR_CULL_DISABLE );
/*
** configure environment variable controlled options
*/
if ( getenv( "GLIDE_NO_BILINEAR" ) )
_3dfx_no_bilinear = 1;
if ( getenv( "GLIDE_NO_DDRAW" ) )
_3dfx_skip_ddraw = 1;
if ( getenv( "GLIDE_NO_TEXTURE" ) )
_3dfx_no_texture = 1;
if ( getenv( "GLIDE_NO_TRANSPARENCY" ) )
_3dfx_allow_transparency = 0;
else
_3dfx_allow_transparency = 1;
if ( getenv( "GLIDE_NO_SYNC" ) )
_3dfx_should_sync = 0;
else
_3dfx_should_sync = 1;
/*
** allocate texture memory
*/
for ( i = 0; i < MAX_BITMAP_FILES; i++ )
{
_3dfx_texture_info[i].handle = GR_NULL_MIPMAP_HANDLE;
}
_3dfx_current_handle = 0;
for ( i = 0; i < _3DFX_MAX_HANDLES; i++ )
{
GrMipMapId_t id;
id = grTexAllocateMemory( GR_TMU0,
GR_MIPMAPLEVELMASK_BOTH,
64, 64,
GR_TEXFMT_ARGB_1555,
GR_MIPMAP_NEAREST,
GR_LOD_1, GR_LOD_64,
GR_ASPECT_1x1,
GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP,
GR_TEXTUREFILTER_BILINEAR, _3dfx_no_bilinear ? GR_TEXTUREFILTER_POINT_SAMPLED : GR_TEXTUREFILTER_BILINEAR,
1.0F,
FXFALSE );
if ( id == GR_NULL_MIPMAP_HANDLE )
{
mprintf( ( 0, " - unexpected null mmid returned\n" ) );
exit( 1 );
}
}
return 1;
}
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) {
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;
GrFog_t fogtable[GR_FOG_TABLE_SIZE];
TlVertex3D srcVerts[4];
float distance, dDelta;
/* 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 );
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_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 */
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( GR_TMU0,
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( GR_TMU0,
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.SSTs[0].type == GR_SSTTYPE_SST96) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear( 0x00404040, 0, GR_ZDEPTHVALUE_FARTHEST );
/* 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 );
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 );
grDrawTriangle( &vtxA, &vtxB, &vtxD );
grDrawTriangle( &vtxA, &vtxD, &vtxC );
tlConRender();
grBufferSwap( 1 );
grSstIdle();
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;
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[] ) {
/*------------------------------------------------------------------
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
texFile[256],
texFile1[256],
texFile2[256];
float
theta;
FxU32
numTmus = 1;
FxBool
paused = FXFALSE;
Gu3dfInfo
info, info2;
FxU32
numFrames = 0xffffffff;
puts("TEST44: Tests complex, multi-tmu textures\n");
puts("Press a key to continue...\n");
getch();
puts("Press q to quit\n");
/* Glide State Initialization */
grGlideInit();
grSstQueryHardware( &hwConfig );
grSstSelect( 0 );
grSstOpen( screenRes,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_LOWER_LEFT,
GR_SMOOTHING_ENABLE,
2 );
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
grAlphaCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
grTexCombine( GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
FXFALSE,
FXFALSE );
if ( hwConfig.SSTs[0].sstBoard.VoodooConfig.nTexelfx == 2 ) {
printf( "Detected 2 TMUs\n" );
grTexCombine( GR_TMU1,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_ZERO,
FXFALSE,
FXFALSE );
numTmus = 2;
}
/*------------------------------------------------------------------
Deal With Arguments
------------------------------------------------------------------*/
if ( numTmus == 1 ) {
if ( argc < 2 ) {
printf( "%s ", argv[0] );
puts( usage_1tmu );
grGlideShutdown();
return;
}
argc--;argv++;
while(argc) {
if(strcmp(argv[0], "-n") == 0) {
argc--;argv++;
if(argc)
numFrames = atoi(argv[0]);
else {
puts( usage_1tmu );
return;
}
}
strcpy( texFile, argv[0] );
strcpy( texFile1, argv[1] );
argc--;argv++;
argc--;argv++;
}
} else {
if ( argc < 4 ) {
printf( "%s ", argv[0] );
puts( usage2tmu );
grGlideShutdown();
return;
}
argc--;argv++;
while(argc) {
if(strcmp(argv[0], "-n") == 0) {
argc--;argv++;
if(argc)
numFrames = atoi(argv[0]);
else {
puts( usage_1tmu );
return;
}
}
strcpy( texFile, argv[0] );
strcpy( texFile1, argv[1]);
strcpy( texFile2, argv[2] );
argc -= 3;
argv += 3;
}
}
grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_ZERO,
GR_BLEND_ONE, GR_BLEND_ZERO );
grDepthBufferMode( GR_DEPTHBUFFER_DISABLE );
grDepthBufferFunction( GR_CMP_LEQUAL );
grDepthMask( FXFALSE );
grCullMode( GR_CULL_DISABLE );
grBufferClear( 0x0, 0x0, 0x0 );
/*------------------------------------------------------------------
Load Texture(s)
------------------------------------------------------------------*/
if ( !gu3dfGetInfo( texFile, &info ) ) {
printf( "Couldn't load %s.\n", texFile );
return;
}
info.data = calloc( info.mem_required, 1 );
gu3dfLoad( texFile, &info );
texInfo.smallLod = info.header.small_lod;
texInfo.largeLod = info.header.large_lod;
texInfo.aspectRatio = info.header.aspect_ratio;
texInfo.format = info.header.format;
texInfo.data = info.data;
if ( texInfo.format == GR_TEXFMT_YIQ_422 ||
texInfo.format == GR_TEXFMT_AYIQ_8422 ) {
puts( "*******************YIQ TEXTURE(TMU0)***************" );
nccTable = info.table.nccTable;
hasTable = FXTRUE;
}
if ( texInfo.format == GR_TEXFMT_P_8 ||
texInfo.format == GR_TEXFMT_AP_88 ) {
puts( "*******************PAL TEXTURE(TMU0)***************" );
pal0 = info.table.palette;
hasPalette = FXTRUE;
}
/* ++++ */
if ( !gu3dfGetInfo( texFile1, &info ) ) {
printf( "Couldn't load %s.\n", texFile1 );
return;
}
info.data = calloc( info.mem_required, 1 );
gu3dfLoad( texFile1, &info );
texInfo1.smallLod = info.header.small_lod;
texInfo1.largeLod = info.header.large_lod;
texInfo1.aspectRatio = info.header.aspect_ratio;
texInfo1.format = info.header.format;
texInfo1.data = info.data;
if ( texInfo1.format == GR_TEXFMT_YIQ_422 ||
texInfo1.format == GR_TEXFMT_AYIQ_8422 ) {
puts( "*******************YIQ TEXTURE(TMU0)***************" );
nccTable = info.table.nccTable;
hasTable = FXTRUE;
}
if ( texInfo1.format == GR_TEXFMT_P_8 ||
texInfo1.format == GR_TEXFMT_AP_88 ) {
puts( "*******************PAL TEXTURE(TMU0)***************" );
pal0 = info.table.palette;
hasPalette1 = FXTRUE;
}
/* ++++ */
if ( numTmus == 2 ) {
if ( !gu3dfGetInfo( texFile2, &info2 ) ) {
printf( "Couldn't load %s.\n", texFile2 );
return;
}
info2.data = calloc( info2.mem_required, 1 );
gu3dfLoad( texFile2, &info2 );
texInfo2.smallLod = info2.header.small_lod;
texInfo2.largeLod = info2.header.large_lod;
texInfo2.aspectRatio = info2.header.aspect_ratio;
texInfo2.format = info2.header.format;
texInfo2.data = info2.data;
if ( texInfo2.format == GR_TEXFMT_YIQ_422 ||
texInfo2.format == GR_TEXFMT_AYIQ_8422 ) {
puts( "*******************YIQ TEXTURE(TMU1)***************" );
nccTable2 = info2.table.nccTable;
hasTable2 = FXTRUE;
}
if ( texInfo2.format == GR_TEXFMT_P_8 ||
texInfo2.format == GR_TEXFMT_AP_88 ) {
puts( "*******************PAL TEXTURE(TMU1)***************" );
pal2 = info2.table.palette;
hasPalette2 = FXTRUE;
}
}
grHints(GR_HINT_STWHINT, GR_STWHINT_W_DIFF_TMU0 |
GR_STWHINT_ST_DIFF_TMU0 | GR_STWHINT_W_DIFF_TMU1 |
GR_STWHINT_ST_DIFF_TMU1);
/*------------------------------------------------------------------
Allocate Texture RAM
------------------------------------------------------------------*/
tmu0Tex0Address = startAddress =
nextAddress = grTexMinAddress( GR_TMU0 );
tmu0Tex1Address = nextAddress = startAddress +
grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH, &texInfo );
printf( "tex0: tmu0Tex0Address: %d tmu0Tex1Address %d\n",
tmu0Tex0Address, tmu0Tex1Address);
if ( nextAddress > grTexMaxAddress( GR_TMU0 ) ) {
printf( "Texture memory exhausted.\n" );
return;
}
if ( numTmus == 2 ) {
startAddress2 = nextAddress2 = grTexMinAddress( GR_TMU1 );
nextAddress2 = startAddress2 +
grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH,
&texInfo2 );
printf( "tex1: startAddress: %d nextAddress %d\n", startAddress2, nextAddress2 );
}
/*------------------------------------------------------------------
Download Texture(s)
------------------------------------------------------------------*/
grTexDownloadMipMap( GR_TMU0,
tmu0Tex0Address,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo );
/* ---- */
grTexDownloadMipMap( GR_TMU0,
tmu0Tex1Address,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo1 );
/* ---- */
if ( numTmus == 2 ) {
grTexDownloadMipMap( GR_TMU1,
startAddress2,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo2 );
if ( hasTable2 ) {
grTexNCCTable( GR_TMU1, GR_NCCTABLE_NCC0 );
grTexDownloadTable( GR_TMU1,
GR_TEXTABLE_NCC0,
&nccTable2 );
}
if ( hasPalette2 ) {
grTexDownloadTable( GR_TMU1,
GR_TEXTABLE_PALETTE,
&pal2 );
}
}
/*------------------------------------------------------------------
Set up Texture Params and Set Texture As Current
------------------------------------------------------------------*/
grTexFilterMode( GR_TMU0,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR );
grTexClampMode( GR_TMU0,
GR_TEXTURECLAMP_WRAP,
GR_TEXTURECLAMP_WRAP );
grTexMipMapMode( GR_TMU0,
GR_MIPMAP_NEAREST,
FXFALSE );
grTexSource( GR_TMU0,
startAddress,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo );
if ( numTmus == 2 ) {
grTexFilterMode( GR_TMU1,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR );
grTexClampMode( GR_TMU1,
GR_TEXTURECLAMP_WRAP,
GR_TEXTURECLAMP_WRAP );
grTexMipMapMode( GR_TMU1,
GR_MIPMAP_NEAREST,
FXFALSE );
grTexSource( GR_TMU1,
startAddress2,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo2 );
}
if ( numTmus == 2 ) {
grTexCombine( GR_TMU1,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
FXFALSE,
FXFALSE );
grTexCombine( GR_TMU0,
GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL,
GR_COMBINE_FACTOR_ONE,
FXFALSE,
FXFALSE );
}
#define INC 0.5f
theta = 0.f;
while (1 && numFrames) {
if (paused == FXFALSE) {
theta += INC;
if (theta > 180.f)
theta -= 180.f;
}
square(0.f, 0.f, 640.3f, 480.f, DEG2RAD(theta));
grBufferSwap( 1 );
if (kbhit()) {
char c;
c = getch();
switch (c) {
case '-':
theta -= INC;
break;
case '+':
theta += INC;
break;
case 'd':
case 'D':
printf("theta = %3.1f\n", theta);
break;
case 'P':
case 'p':
if (paused == FXFALSE)
paused = FXTRUE;
else
paused = FXFALSE;
break;
case 'q':
case 'Q':
case 27:
grGlideShutdown();
exit(0);
break;
}
} /* input switch */
if(numFrames != -1)
numFrames--;
} /* render loop */
}/* main */
void main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
#define NVERT 5
GrVertex vtx[NVERT];
int index[NVERT];
int frames = -1;
int i, idx;
#define NHUE 360
RGB hues[NHUE];
/* 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 );
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, 1.0f,
60, 30, 0xffffff );
/* Set up Render State - gouraud shading */
grColorCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_NONE,
FXFALSE );
// grRenderBuffer(GR_BUFFER_FRONTBUFFER); /* debug only */
tlConOutput( "Press a key to quit\n" );
/* init a table of hues */
for (i=0; i<NHUE; i++) {
const float theta = i * 360.0f / NHUE;
hlsToRGB( theta, 0.4f, 0.5f, &hues[i]);
}
/* assign hues to vertices */
for (i=0; i<NVERT; i++) {
vtx[i].r = hues[PHASE(0, i*(NHUE / NVERT), NHUE)].r;
vtx[i].g = hues[PHASE(0, i*(NHUE / NVERT), NHUE)].g;
vtx[i].b = hues[PHASE(0, i*(NHUE / NVERT), NHUE)].b;
}
#if 1
/*
* Force polygon RGB values to be planar... note overflow!
* this is deliberate as a sanity check
*/
vtx[3].r = 235.519f; vtx[3].g = 51.001f; vtx[3].b = 115.721f;
vtx[4].r = 298.559f; vtx[4].g = -12.039f; vtx[4].b = 91.0f;
#endif
while( frames-- && tlOkToRender()) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
grBufferClear( 0x00, 0, GR_WDEPTHVALUE_FARTHEST );
/* generate a equilateral polygon */
for (i=0; i<NVERT; i++) {
double theta = 2.0 * PI * i / (double) NVERT;
vtx[i].x = tlScaleX((float)((cos(theta) / 4.0) + 0.5));
vtx[i].y = tlScaleY((float)((sin(theta) / 4.0) + 0.5));
index[i] = i;
}
idx = 30 /* (-frames) % NHUE */;
#if 1
/* cyclical permutation: turn off to see just one set of triangles */
for (i=0; i<NVERT; i++) {
index[i] = (index[i] + 1) % NVERT;
}
#endif
grDrawPlanarPolygon(NVERT, index, vtx);
tlConRender();
grBufferSwap( 1 );
if ( tlKbHit() ) frames = 0;
}
grGlideShutdown();
return;
}
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();
}
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();
}
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
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();
}
static int OpenDisplay( vout_thread_t *p_vout )
{
static char version[80];
GrHwConfiguration hwconfig;
GrScreenResolution_t resolution = GR_RESOLUTION_800x600;
GrLfbInfo_t p_front_buffer_info; /* front buffer info */
grGlideGetVersion( version );
grGlideInit();
if( !grSstQueryHardware(&hwconfig) )
{
msg_Err( p_vout, "cannot get 3dfx hardware config" );
return( 1 );
}
grSstSelect( 0 );
if( !grSstWinOpen( 0, resolution, GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR, GR_ORIGIN_UPPER_LEFT, 2, 1 ) )
{
msg_Err( p_vout, "cannot open 3dfx screen" );
return( 1 );
}
/* disable dithering */
/*grDitherMode( GR_DITHER_DISABLE );*/
/* clear both buffers */
grRenderBuffer( GR_BUFFER_BACKBUFFER );
grBufferClear( 0, 0, 0 );
grRenderBuffer( GR_BUFFER_FRONTBUFFER );
grBufferClear( 0, 0, 0 );
grRenderBuffer( GR_BUFFER_BACKBUFFER );
p_vout->p_sys->p_buffer_info.size = sizeof( GrLfbInfo_t );
p_front_buffer_info.size = sizeof( GrLfbInfo_t );
/* lock the buffers to find their adresses */
if ( grLfbLock(GR_LFB_WRITE_ONLY, GR_BUFFER_FRONTBUFFER,
GR_LFBWRITEMODE_565, GR_ORIGIN_UPPER_LEFT, FXFALSE,
&p_front_buffer_info) == FXFALSE )
{
msg_Err( p_vout, "cannot take 3dfx front buffer lock" );
grGlideShutdown();
return( 1 );
}
grLfbUnlock( GR_LFB_WRITE_ONLY, GR_BUFFER_FRONTBUFFER );
if ( grLfbLock(GR_LFB_WRITE_ONLY, GR_BUFFER_BACKBUFFER,
GR_LFBWRITEMODE_565, GR_ORIGIN_UPPER_LEFT, FXFALSE,
&p_vout->p_sys->p_buffer_info) == FXFALSE )
{
msg_Err( p_vout, "cannot take 3dfx back buffer lock" );
grGlideShutdown();
return( 1 );
}
grLfbUnlock( GR_LFB_WRITE_ONLY, GR_BUFFER_BACKBUFFER );
grBufferClear( 0, 0, 0 );
p_vout->p_sys->pp_buffer[0] = p_vout->p_sys->p_buffer_info.lfbPtr;
p_vout->p_sys->pp_buffer[1] = p_front_buffer_info.lfbPtr;
p_vout->p_sys->i_index = 0;
return( 0 );
}
