/**
* Query hardware.
*
* \param pname parameter
*
* \return value, or -1 if error
*/
static FxI32
getInteger (FxU32 pname)
{
FxI32 result;
if (grGet(pname, 4, &result)) {
return result;
}
return -1;
}
/**
* Query screen width and height.
*
* \param[out] w width
* \param[out] h height
*
* \return 0 if success, -1 if error
*/
static FxI32
getGeometry (int *w, int *h)
{
FxI32 result[4];
if (grGet(GR_VIEWPORT, 16, result)) {
*w = result[2];
*h = result[3];
return 0;
}
return -1;
}
void
TestGet(char * getvalstr, int getval, int memcount , long * memval, int * failures)
{
int ret;
int i;
int correct;
correct = FXTRUE; /*Set to TRUE to start with*/
for(i=0;i<4;i++) /*Clear Memory to some unique Pattern*/
memval[i] =0xdeadbeef;
ret = grGet(getval, memcount*sizeof(long), memval ); /*Do the Get*/
for(i=0;i<memcount;i++)
/*if pattern still exists, then we have a problem*/
if(memval[i]==0xdeadbeef)
correct=FXFALSE;
/* if Number of bytes returned is wrong, then we have a problem*/
if(ret!=(int)(memcount*sizeof(long)))
correct=FXFALSE;
if(correct) /*print the results*/
printf("Success(%d) - ",ret);
else {
printf("Failed (%d) - ", ret);
failures[0]++;
}
switch(memcount) {
case 4:
printf("%s Result = %d, %d, %d, %d\n",getvalstr, memval[0],memval[1],memval[2],memval[3]);
break;
case 2:
printf("%s Result = %d, %d\n",getvalstr, memval[0],memval[1]);
break;
case 1:
default:
printf("%s Result = %d\n",getvalstr, memval[0]);
break;
}
} /* TestGet */
static int
get_unwind_table (unw_dyn_info_t *di, unw_addr_space_t as,
struct load_module *lm)
{
ADDR table_addr, table_size, text_addr = 0, text_size = 0, gp;
Elf64_Phdr *ph, *pdyn = NULL, *punw = NULL;
ADDR dyn_addr, tag, addr, *p, min_text_addr, max_text_addr;
extern DWORD *pmemLookup_p (ADDR);
char *mem;
for (ph = lm->phdr; ph < lm->phdr + lm->phnum; ++ph) {
switch (ph->p_type) {
case PT_IA_64_UNWIND: punw = ph; break;
case PT_DYNAMIC: pdyn = ph; break;
default: break;
}
}
if (!punw)
return -1;
table_addr = lm->load_base + punw->p_vaddr;
table_size = punw->p_memsz;
for (ph = lm->phdr; ph < lm->phdr + lm->phnum; ++ph) {
if (ph->p_type == PT_LOAD) {
text_addr = ph->p_vaddr + lm->load_base;
text_size = ph->p_memsz;
if (table_addr >= text_addr && table_addr < text_addr + text_size)
break;
}
}
/*
* The Linux kernel's unwind table covers multiple text segments:
* the one for the main kernel and the one for the init text
* section.
*/
min_text_addr = ~(ADDR) 0;
max_text_addr = 0;
for (ph = lm->phdr; ph < lm->phdr + lm->phnum; ++ph) {
if (ph->p_type == PT_LOAD && (ph->p_flags & PF_X)) {
if (ph->p_vaddr + lm->load_base < min_text_addr)
min_text_addr = ph->p_vaddr + lm->load_base;
if (ph->p_vaddr + ph->p_memsz + lm->load_base > max_text_addr)
max_text_addr = ph->p_vaddr + ph->p_memsz + lm->load_base;
}
}
if (pdyn) {
dyn_addr = pdyn->p_vaddr + lm->load_base;
for (;
memMRd(dyn_addr, 8, &tag), tag != DT_NULL;
dyn_addr += 8)
if (tag == DT_PLTGOT) {
/* On IA-64, _DYNAMIC is writable and GLIBC has
relocate it. */
memMRd(dyn_addr + 8, 8, &gp);
break;
}
} else
/* there is a single global pointer for the entire program */
gp = grGet(0, GP_ID);
di->start_ip = min_text_addr;
di->end_ip = max_text_addr;
di->gp = gp;
di->format = UNW_INFO_FORMAT_TABLE;
di->u.ti.name_ptr = 0;
di->u.ti.segbase = text_addr;
di->u.ti.table_len = punw->p_memsz / sizeof (unw_word_t);
table_addr = punw->p_vaddr + lm->load_base;
mem = malloc(punw->p_memsz + sizeof (unw_word_t));
if (!mem)
return -UNW_ENOMEM;
mem += sizeof(unw_word_t) - 1;
mem = (char *) ((uintptr_t) mem & -sizeof (unw_word_t));
addr = punw->p_vaddr + lm->load_base;
#ifdef UNWIND_DEBUG
fprintf(stderr, "\tget_unwind_table: copying %llu bytes from %llx to %p\n",
punw->p_memsz, addr, mem);
#endif
for (p = (ADDR *) mem; (char *) p < mem + punw->p_memsz; ++p) {
memMRd(addr, 8, p);
addr += 8;
}
di->u.ti.table_data = (unw_word_t *) mem;
return 0;
}
void
main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
FxBool scrgrab = FXFALSE;
char filename[256];
FxU32 wrange[2];
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "nrd", &match, &remArgs ) ) {
if ( rv == -1 ) {
printf( "Unrecognized command line argument\n" );
printf( "%s %s\n", name, usage );
printf( "Available resolutions:\n%s\n",
tlGetResolutionList() );
return;
}
switch( match ) {
case 'n':
frames = atoi( remArgs[0] );
break;
case 'r':
resolution = tlGetResolutionConstant( remArgs[0],
&scrWidth,
&scrHeight );
break;
case 'd':
scrgrab = FXTRUE;
frames = 1;
strcpy(filename, remArgs[0]);
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
grSstSelect( 0 );
assert( grSstWinOpen( 0,
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1 ) );
grGet(GR_WDEPTH_MIN_MAX, 8, wrange);
grVertexLayout(GR_PARAM_XY, 0, GR_PARAM_ENABLE);
tlConSet( 0.0f, 0.0f, 1.0f, 1.0f,
60, 30, 0xffffff );
/* Set up Render State - flat shading */
grColorCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_NONE,
FXFALSE );
grConstantColorValue( 0xFFFFFF );
tlConOutput( "Press a key to quit\n" );
while( frames-- && tlOkToRender()) {
int i;
GrVertex vtx;
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear(0x00000000, 0, wrange[1]);
for( i = 0; i < 100; i++ ) {
float pos = ((float)i)/100.0f;
vtx.x = tlScaleX( pos ), vtx.y = tlScaleY( pos );
grDrawPoint( &vtx );
}
tlConRender();
grBufferSwap( 1 );
/* grab the frame buffer */
if (scrgrab) {
if (!tlScreenDump(filename, (FxU16)scrWidth, (FxU16)scrHeight))
printf( "Cannot open %s\n", filename);
scrgrab = FXFALSE;
}
if ( tlKbHit() ) frames = 0;
}
grGlideShutdown();
return;
}
void main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
int doNothing = 0;
int cycles;
FxU32 wrange[2];
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "Nnr", &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 'N':
doNothing = 1;
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
grSstSelect( 0 );
cycles = 0;
while( frames-- && tlOkToRender()) {
GrVertex a, b, c;
GrContext_t context;
char inchar;
context = grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1 );
assert(context);
/*
* Don't like gotos? In the immortal words of Schwarzenegger
* (Total Recall): "...so sue me d**khead"
*/
if (doNothing) goto doNothing;
grVertexLayout(GR_PARAM_XY, 0, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_RGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
grGet(GR_WDEPTH_MIN_MAX, 8, wrange);
grColorCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_NONE,
FXFALSE );
tlConSet( 0.0f, 0.0f, 1.0f, 1.0f,
60, 30, 0xffffff );
/* deal with dynamic resizing */
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution, &scrWidth, &scrHeight);
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
tlConOutput( "Press <space> to cycle hardware\n" );
tlConOutput( "Any other key to quit\n" );
grBufferClear( 0x000000, 0, wrange[1] );
a.r = a.g = a.b = 0.0f;
b = c = a;
a.x = tlScaleX(((float)rRandom( 0, 100 ))/100.0f);
a.y = tlScaleY(((float)rRandom( 0, 100 ))/100.0f);
a.r = 255.0f;
b.x = tlScaleX(((float)rRandom( 0, 100 ))/100.0f);
b.y = tlScaleY(((float)rRandom( 0, 100 ))/100.0f);
b.g = 255.0f;
c.x = tlScaleX(((float)rRandom( 0, 100 ))/100.0f);
c.y = tlScaleY(((float)rRandom( 0, 100 ))/100.0f);
c.b = 255.0f;
grDrawTriangle( &a, &b, &c );
tlConOutput( "Cycle: %d\r", cycles );
tlConRender();
grBufferSwap( 1 );
doNothing:
inchar = tlGetCH();
if ( inchar != ' ' ) frames = 0;
grSstWinClose(context);
cycles++;
}
grGlideShutdown();
return;
}
int
main(int argc, char **argv)
{
char match;
char **remArgs;
int rv = -1;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
FxBool scrgrab = FXFALSE;
char filename[256];
FxU32 wrange[2];
FxU32
multiBaseMode = 0,
minTexSize = 1,
maxTexSize = 256;
const TlVertex3D
srcVerts[4] =
{
{ -0.5f, 0.0f, 0.5f, 1.0f, 0.0f, 0.0f },
{ 0.5f, 0.0f, 0.5f, 1.0f, 1.0f, 0.0f },
{ -0.5f, 0.0f, -0.5f, 1.0f, 0.0f, 1.0f },
{ 0.5f, 0.0f, -0.5f, 1.0f, 1.0f, 1.0f }
};
/* Initialize Glide */
grGlideInit();
if ((hwconfig = tlVoodooType()) == 0) {
printf("Error getting 3Dfx hw type.\n");
exit(-1);
}
/* Process Command Line Arguments */
while(rv = tlGetOpt(argc, argv, "dmnrx", &match, &remArgs)) {
if (rv == -1) {
printf("Unrecognized command line argument\n");
printf("%s %s\n", name, usage);
printf("Available resolutions:\n%s\n",
tlGetResolutionList());
exit(-1);
}
switch(match) {
case 'd':
scrgrab = FXTRUE;
if (scrgrab) {
frames = 1;
strcpy(filename, remArgs[0]);
}
break;
case 'm':
/* Do we want to test larger sizes if the hw supports it? */
if (!grGet(GR_MAX_TEXTURE_SIZE, sizeof(maxTexSize), (FxI32 *)&maxTexSize)) {
printf("grGet(GR_MAX_TEXTURE_SIZE) failed.\n");
exit(-1);
}
break;
case 'n':
if (remArgs[0] != NULL) frames = atoi(remArgs[0]);
break;
case 'r':
if (remArgs[0] != NULL) resolution = tlGetResolutionConstant(remArgs[0],
&scrWidth,
&scrHeight);
break;
}
}
tlSetScreen(scrWidth, scrHeight);
version = grGetString(GR_VERSION);
printf("%s:\n%s\n", name, purpose);
printf("%s\n", version);
printf("Resolution: %s\n", tlGetResolutionString(resolution));
if (frames == -1) {
printf("Press A Key To Begin Test.\n");
tlGetCH();
}
grSstSelect(0);
if (grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1) == 0) {
printf("grSstWinOpen failed.\n");
goto __errExit;
}
tlConSet(0.0f, 0.0f, 1.0f, 1.0f,
60, 30, 0xffffff);
/* Set up Render State */
grGet(GR_WDEPTH_MIN_MAX, 8, (FxI32 *)wrange);
grVertexLayout(GR_PARAM_XY, 0, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
grTexCombine(GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
FXFALSE, FXFALSE);
/* Generate texture */
{
GrLOD_t
largeLod,
smallLod;
FxU16*
texData = NULL;
FxU32
totalMapSize,
curMapSize;
/* There's some closed form of this series thing, but I forget
* what it is and am way to lazy to actually go look it up. This
* is only a glide test after all.
*/
totalMapSize = 0;
curMapSize = maxTexSize;
while(curMapSize > 0) {
totalMapSize += (curMapSize * curMapSize) * sizeof(FxU16);
curMapSize >>= 1;
}
texData = (FxU16*)malloc(totalMapSize * sizeof(*texData));
if (texData == NULL) {
printf("Unable to allocate texture data.\n");
exit(-1);
}
/* Figure out the supported log2(lod size) */
largeLod = GR_LOD_LOG2_1;
while((0x01UL << largeLod) != maxTexSize) largeLod++;
smallLod = GR_LOD_LOG2_1;
while((0x01UL << smallLod) != minTexSize) smallLod++;
/* Build simple texture w/ a different color for each map to help
* distinguish the different maps when mipmapping. Additionally,
* add a 'border' so that we can see if the start of the texture
* gets mucked up due to an incorrect start address.
*/
{
FxU16
colorVal = 0xF800,
*curTexPtr = texData;
FxU32
i, j,
colorShift = (16 / largeLod);
curMapSize = maxTexSize;
while(curMapSize > 0) {
for(j = 0; j < curMapSize; j++) *curTexPtr++ = 0xFFFF;
for(i = 1; i < curMapSize - 1; i++) {
*curTexPtr++ = 0xFFFF;
for(j = 1; j < curMapSize - 1; j++) {
*curTexPtr++ = colorVal;
}
*curTexPtr++ = 0xFFFF;
}
for(j = 0; j < curMapSize; j++) *curTexPtr++ = 0xFFFF;
curMapSize >>= 1;
colorVal >>= colorShift;
}
}
{
GrTexInfo texInfo = {
GR_LOD_LOG2_1,
0,
GR_ASPECT_LOG2_1x1,
GR_TEXFMT_RGB_565,
0
};
FxU32
curTexAddr = 0x00UL,
texMultiBaseOffset;
texInfo.largeLodLog2 = largeLod;
texInfo.data = texData;
/* Determine the hw texture alignment and generate some random
* offset for the texture base addressing.
*/
{
FxU32
texAlign,
maxTexMem = grTexMaxAddress(GR_TMU0),
maxTexSize = grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
if (!grGet(GR_TEXTURE_ALIGN, sizeof(texAlign), (FxI32 *)&texAlign)) {
printf("grGet(GR_TEXTURE_ALIGN): Failed!\n");
exit(-1);
}
texAlign <<= 3UL;
/* Get some offset that has to be smaller than the amount of
* texxture space we have left divided by the # of times
* that we're going to add it in.
*/
do {
texMultiBaseOffset = rand();
} while ((texMultiBaseOffset < 0x1000UL) ||
(texMultiBaseOffset > ((maxTexMem - maxTexSize) / 4)));
texMultiBaseOffset = (texMultiBaseOffset + texAlign) & ~(texAlign - 1UL);
}
/* Download the texture to the multibase address specified by
* the current mode. We play a few games w/ offsetting the
* texture start address by texMultiBaseOffset to try to make
* sure that multi-base actually works inside of glide.
*/
/* Mmmm... multibase */
grTexMultibase(GR_TMU0, FXTRUE);
/* Download and set the base addresses in descending map size
* order offsetting by some dorky amount as we go.
*/
texInfo.smallLodLog2 = GR_LOD_LOG2_256;
texInfo.largeLodLog2 = largeLod;
grTexDownloadMipMap(GR_TMU0,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
grTexMultibaseAddress(GR_TMU0,
GR_TEXBASE_256,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
curTexAddr += (texMultiBaseOffset +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.data = (void*)((FxU8*)texInfo.data +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.smallLodLog2 = GR_LOD_LOG2_128;
texInfo.largeLodLog2 = GR_LOD_LOG2_128;
grTexDownloadMipMap(GR_TMU0,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
grTexMultibaseAddress(GR_TMU0,
GR_TEXBASE_128,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
curTexAddr += (texMultiBaseOffset +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.data = (void*)((FxU8*)texInfo.data +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.smallLodLog2 = GR_LOD_LOG2_64;
texInfo.largeLodLog2 = GR_LOD_LOG2_64;
grTexDownloadMipMap(GR_TMU0,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
grTexMultibaseAddress(GR_TMU0,
GR_TEXBASE_64,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
curTexAddr += (texMultiBaseOffset +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.data = (void*)((FxU8*)texInfo.data +
grTexTextureMemRequired(GR_MIPMAPLEVELMASK_BOTH,
&texInfo));
texInfo.smallLodLog2 = GR_LOD_LOG2_1;
texInfo.largeLodLog2 = GR_LOD_LOG2_32;
grTexDownloadMipMap(GR_TMU0,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
grTexMultibaseAddress(GR_TMU0,
GR_TEXBASE_32_TO_1,
curTexAddr,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
/* Source the whole texture. The large map start will reset
* baseAddr0, but that should be fine since we did not adjust
* its address because it came first.
*/
texInfo.smallLodLog2 = GR_LOD_LOG2_1;
texInfo.largeLodLog2 = largeLod;
grTexSource(GR_TMU0,
0x00UL,
GR_MIPMAPLEVELMASK_BOTH,
&texInfo);
}
free((void*)texData);
}
grTexMipMapMode(GR_TMU0,
GR_MIPMAP_NEAREST,
FXFALSE);
tlConOutput("Press a key to quit\n");
while(frames-- && tlOkToRender()) {
static float
curOOW = 1.0f;
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight);
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear(0x808080, 0xFF, wrange[1]);
{
static float
distance = 1.0f,
dDelta = 0.1f;
TlVertex3D
xfVerts[4],
prjVerts[4];
GrVertex
vtxA,
vtxB,
vtxC,
vtxD;
/*----
A-B
|\|
C-D
-----*/
vtxA.oow = 1.0f;
vtxB = vtxC = vtxD = vtxA;
#define MAX_DIST 30.5f
#define MIN_DIST 1.0f
distance += dDelta;
if (distance > MAX_DIST ||
distance < MIN_DIST) {
dDelta *= -1.0f;
distance += dDelta;
}
tlSetMatrix(tlIdentity());
tlMultMatrix(tlXRotation(-20.0f));
tlMultMatrix(tlTranslation(0.0f, -0.3f, distance));
tlTransformVertices(xfVerts, srcVerts, 4);
tlProjectVertices(prjVerts, xfVerts, 4);
vtxA.x = tlScaleX(prjVerts[0].x);
vtxA.y = tlScaleY(prjVerts[0].y);
vtxA.oow = 1.0f / prjVerts[0].w;
vtxA.tmuvtx[0].sow = prjVerts[0].s * 255.0f * vtxA.oow;
vtxA.tmuvtx[0].tow = prjVerts[0].t * 255.0f * vtxA.oow;
vtxB.x = tlScaleX(prjVerts[1].x);
vtxB.y = tlScaleY(prjVerts[1].y);
vtxB.oow = 1.0f / prjVerts[1].w;
vtxB.tmuvtx[0].sow = prjVerts[1].s * 255.0f * vtxB.oow;
vtxB.tmuvtx[0].tow = prjVerts[1].t * 255.0f * vtxB.oow;
vtxC.x = tlScaleX(prjVerts[2].x);
vtxC.y = tlScaleY(prjVerts[2].y);
vtxC.oow = 1.0f / prjVerts[2].w;
vtxC.tmuvtx[0].sow = prjVerts[2].s * 255.0f * vtxC.oow;
vtxC.tmuvtx[0].tow = prjVerts[2].t * 255.0f * vtxC.oow;
vtxD.x = tlScaleX(prjVerts[3].x);
vtxD.y = tlScaleY(prjVerts[3].y);
vtxD.oow = 1.0f / prjVerts[3].w;
vtxD.tmuvtx[0].sow = prjVerts[3].s * 255.0f * vtxD.oow;
vtxD.tmuvtx[0].tow = prjVerts[3].t * 255.0f * vtxD.oow;
grDrawTriangle(&vtxA, &vtxB, &vtxD);
grDrawTriangle(&vtxA, &vtxD, &vtxC);
}
tlConRender();
grBufferSwap(1);
/* grab the frame buffer */
if (scrgrab) {
if (!tlScreenDump(filename, (FxU16)scrWidth, (FxU16)scrHeight))
printf("Cannot open %s\n", filename);
scrgrab = FXFALSE;
}
if (tlKbHit()) {
char curKey = tlGetCH();
switch(curKey) {
default:
frames = 0;
break;
}
}
}
rv = 0;
__errExit:
grGlideShutdown();
return rv;
}
void main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
TlTexture baseTexture;
unsigned long baseTextureAddr;
TlTexture lightTexture;
unsigned long lightTextureAddr;
int ftsize = 0;
GrFog_t *fogtable = NULL;
TlVertex3D srcVerts[4];
float distance, dDelta;
FxU32 zrange[2];
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "nr", &match, &remArgs ) ) {
if ( rv == -1 ) {
printf( "Unrecognized command line argument\n" );
printf( "%s %s\n", name, usage );
printf( "Available resolutions:\n%s\n",
tlGetResolutionList() );
return;
}
switch( match ) {
case 'n':
frames = atoi( remArgs[0] );
break;
case 'r':
resolution = tlGetResolutionConstant( remArgs[0],
&scrWidth,
&scrHeight );
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
grSstSelect( 0 );
assert( grSstWinOpen( 0,
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_LOWER_LEFT,
2, 1 ) );
tlConSet( 0.0f, 0.0f, 1.0f, 0.5f,
60, 15, 0xffffff );
/* Set up Render State - decal - bilinear - nearest mipmapping - fogging */
grGet(GR_ZDEPTH_MIN_MAX, 8, zrange);
grGet(GR_FOG_TABLE_ENTRIES, 4, &ftsize);
fogtable = malloc(sizeof(GrFog_t)*ftsize);
assert(fogtable);
grVertexLayout(GR_PARAM_XY, 0, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE );
grTexMipMapMode( GR_TMU0,
GR_MIPMAP_NEAREST,
FXFALSE );
grTexFilterMode( GR_TMU0,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR );
grFogColorValue( 0x404040 );
guFogGenerateExp( fogtable, .2f );
grFogTable( fogtable );
/* Load texture data into system ram */
assert( tlLoadTexture( "decal1.3df",
&baseTexture.info,
&baseTexture.tableType,
&baseTexture.tableData ) );
assert( tlLoadTexture( "light.3df",
&lightTexture.info,
&lightTexture.tableType,
&lightTexture.tableData ) );
/* Download texture data to TMU */
baseTextureAddr = grTexMinAddress( GR_TMU0 );
grTexDownloadMipMap( GR_TMU0,
baseTextureAddr,
GR_MIPMAPLEVELMASK_BOTH,
&baseTexture.info );
if ( baseTexture.tableType != NO_TABLE ) {
grTexDownloadTable( baseTexture.tableType,
&baseTexture.tableData );
}
lightTextureAddr =
baseTextureAddr +
grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH,
&baseTexture.info );
grTexDownloadMipMap( GR_TMU0,
lightTextureAddr,
GR_MIPMAPLEVELMASK_BOTH,
&lightTexture.info );
if ( lightTexture.tableType != NO_TABLE ) {
grTexDownloadTable( lightTexture.tableType,
&lightTexture.tableData );
}
/* Initialize Source 3D data - Rectangle on X/Z Plane
Centered about Y Axis
0--1 Z+
| | |
2--3 - X+
*/
srcVerts[0].x = -0.5f, srcVerts[0].y = 0.0f, srcVerts[0].z = 0.5f, srcVerts[0].w = 1.0f;
srcVerts[1].x = 0.5f, srcVerts[1].y = 0.0f, srcVerts[1].z = 0.5f, srcVerts[1].w = 1.0f;
srcVerts[2].x = -0.5f, srcVerts[2].y = 0.0f, srcVerts[2].z = -0.5f, srcVerts[2].w = 1.0f;
srcVerts[3].x = 0.5f, srcVerts[3].y = 0.0f, srcVerts[3].z = -0.5f, srcVerts[3].w = 1.0f;
srcVerts[0].s = 0.0f, srcVerts[0].t = 0.0f;
srcVerts[1].s = 1.0f, srcVerts[1].t = 0.0f;
srcVerts[2].s = 0.0f, srcVerts[2].t = 1.0f;
srcVerts[3].s = 1.0f, srcVerts[3].t = 1.0f;
#define RED 0x000000ff
#define BLUE 0x00ff0000
#define MAX_DIST 10.0f
#define MIN_DIST 1.0f
distance = 1.0f;
dDelta = 0.05f;
tlConOutput( "Press any key to quit\n\n" );
while( frames-- && tlOkToRender()) {
GrVertex vtxA, vtxB, vtxC, vtxD;
TlVertex3D xfVerts[4];
TlVertex3D prjVerts[4];
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear( 0x00404040, 0, zrange[1] );
/* 3D Transformations */
/*----
A-B
|\|
C-D
-----*/
vtxA.oow = 1.0f;
vtxB = vtxC = vtxD = vtxA;
distance += dDelta;
if ( distance > MAX_DIST ||
distance < MIN_DIST ) {
dDelta *= -1.0f;
distance += dDelta;
}
tlSetMatrix( tlIdentity() );
tlMultMatrix( tlXRotation( -90.0f ) );
tlMultMatrix( tlTranslation( 0.0f, 0.0f, distance ) );
tlTransformVertices( xfVerts, srcVerts, 4 );
tlProjectVertices( prjVerts, xfVerts, 4 );
vtxA.x = tlScaleX( prjVerts[0].x );
vtxA.y = tlScaleY( prjVerts[0].y );
vtxA.oow = 1.0f / prjVerts[0].w;
vtxB.x = tlScaleX( prjVerts[1].x );
vtxB.y = tlScaleY( prjVerts[1].y );
vtxB.oow = 1.0f / prjVerts[1].w;
vtxC.x = tlScaleX( prjVerts[2].x );
vtxC.y = tlScaleY( prjVerts[2].y );
vtxC.oow = 1.0f / prjVerts[2].w;
vtxD.x = tlScaleX( prjVerts[3].x );
vtxD.y = tlScaleY( prjVerts[3].y );
vtxD.oow = 1.0f / prjVerts[3].w;
vtxA.tmuvtx[0].sow = prjVerts[0].s * 255.0f * vtxA.oow;
vtxA.tmuvtx[0].tow = prjVerts[0].t * 255.0f * vtxA.oow;
vtxB.tmuvtx[0].sow = prjVerts[1].s * 255.0f * vtxB.oow;
vtxB.tmuvtx[0].tow = prjVerts[1].t * 255.0f * vtxB.oow;
vtxC.tmuvtx[0].sow = prjVerts[2].s * 255.0f * vtxC.oow;
vtxC.tmuvtx[0].tow = prjVerts[2].t * 255.0f * vtxC.oow;
vtxD.tmuvtx[0].sow = prjVerts[3].s * 255.0f * vtxD.oow;
vtxD.tmuvtx[0].tow = prjVerts[3].t * 255.0f * vtxD.oow;
/* Render First Pass */
grTexCombine( GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
FXFALSE,
FXFALSE );
grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_ZERO,
GR_BLEND_ONE, GR_BLEND_ZERO );
grTexSource( GR_TMU0,
baseTextureAddr,
GR_MIPMAPLEVELMASK_BOTH,
&baseTexture.info );
grFogMode( GR_FOG_ADD2 | GR_FOG_WITH_TABLE_ON_W );
grDrawTriangle( &vtxA, &vtxB, &vtxD );
grDrawTriangle( &vtxA, &vtxD, &vtxC );
/* Render Second Pass */
grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_PREFOG_COLOR,
GR_BLEND_ZERO, GR_BLEND_ZERO );
grTexSource( GR_TMU0,
lightTextureAddr,
GR_MIPMAPLEVELMASK_BOTH,
&lightTexture.info );
grFogMode( GR_FOG_MULT2 | GR_FOG_WITH_TABLE_ON_W );
grDrawTriangle( &vtxA, &vtxB, &vtxD );
grDrawTriangle( &vtxA, &vtxD, &vtxC );
tlConRender();
grBufferSwap( 1 );
grFinish();
while( tlKbHit() ) {
switch( tlGetCH() ) {
default:
frames = 0;
break;
}
}
}
grGlideShutdown();
free(fogtable);
return;
}
void
main( int argc, char **argv)
{
char
match,
**remArgs,
*args = "nrd",
filename[256];
int
frames = -1,
rv;
float
scrWidth = 640.f,
scrHeight = 480.f;
FxBool
scrgrab = FXFALSE;
GrScreenResolution_t
resolution = GR_RESOLUTION_640x480;
FxI32 listType = -1;
FxBool aaenable = FXFALSE;
FxBool packedrgb = FXFALSE;
FxBool varraycont = FXFALSE;
GrVertex vtxList[4];
void *vtxListArray[6];
GrVertex vtxListCont[6];
FxU32 wrange[2];
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, args, &match, &remArgs ) ) {
if ( rv == -1 ) {
printf( "Unrecognized command line argument\n" );
printf( "%s %s\n", name, usage );
printf( "Available resolutions:\n%s\n",
tlGetResolutionList() );
return;
}
switch( match ) {
case 'n':
frames = atoi( remArgs[0] );
break;
case 'r':
resolution = tlGetResolutionConstant( remArgs[0],
&scrWidth,
&scrHeight );
break;
case 'd':
scrgrab = FXTRUE;
frames = 1;
strcpy(filename, remArgs[0]);
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
grSstSelect( 0 );
assert( grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1 ) );
tlConSet( 0.f, 0.f, 1.f, 1.f,
60, 30, 0xffffff );
/* Set up Render State - gouraud shading */
grVertexLayout(GR_PARAM_XY, GR_VERTEX_X_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_RGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
grGet(GR_WDEPTH_MIN_MAX, 8, wrange);
grColorCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_NONE,
FXFALSE );
grCullMode(GR_CULL_DISABLE);
if(frames == -1) {
doHelp();
}
/*
** data
*/
{
vtxList[0].x = tlScaleX( 0.3f ), vtxList[0].y = tlScaleY( 0.3f );
vtxList[0].r = 255.f, vtxList[0].g = 0.f, vtxList[0].b = 0.f, vtxList[0].a = 255.f;
vtxList[1].x = tlScaleX( 0.8f ), vtxList[1].y = tlScaleY( 0.4f );
vtxList[1].r = 0.f, vtxList[1].g = 255.f, vtxList[1].b = 0.f, vtxList[1].a = 255.f;
vtxList[2].x = tlScaleX( 0.5f ), vtxList[2].y = tlScaleY( 0.8f );
vtxList[2].r = 0.f, vtxList[2].g = 0.f, vtxList[2].b = 255.f, vtxList[2].a = 255.f;
vtxList[3].x = tlScaleX( 0.9f ), vtxList[3].y = tlScaleY( 0.8f );
vtxList[3].r = 0.f, vtxList[3].g = 0.f, vtxList[3].b = 255.f, vtxList[3].a = 255.f;
vtxListCont[0] = vtxList[0];
vtxListCont[1] = vtxList[1];
vtxListCont[2] = vtxList[2];
vtxListCont[3] = vtxList[3];
}
while( frames-- && tlOkToRender()) {
tlConClear();
tlConOutput( "Press a key to quit\n" );
if (aaenable)
tlConOutput("Antialiasing ON\n");
else
tlConOutput("Antialiasing OFF\n");
if (packedrgb)
tlConOutput("Packed Color ON\n");
else
tlConOutput("Packed Color OFF\n");
if (listType >= 0) {
if (varraycont)
tlConOutput("grDrawVertexArrayContiguous\n");
else
tlConOutput("grDrawVertexArray\n");
switch (listType) {
case GR_POINTS:
tlConOutput("POINTS\n");
break;
case GR_LINE_STRIP:
tlConOutput("LINE STRIP\n");
break;
case GR_LINES:
tlConOutput("LINES\n");
break;
case GR_POLYGON:
tlConOutput("POLYGON\n");
break;
case GR_TRIANGLE_STRIP:
tlConOutput("TRIANGLE STRIP\n");
break;
case GR_TRIANGLE_FAN:
tlConOutput("TRIANGLE FAN\n");
break;
case GR_TRIANGLES:
tlConOutput("TRIANGLES\n");
break;
}
}
else
tlConOutput("grDrawTriangle\n");
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grRenderBuffer( GR_BUFFER_BACKBUFFER );
grBufferClear( 0x00, 0, wrange[1] );
switch (listType) {
case GR_POINTS:
case GR_LINE_STRIP:
case GR_LINES:
case GR_POLYGON:
case GR_TRIANGLE_STRIP:
case GR_TRIANGLE_FAN:
if (varraycont)
grDrawVertexArrayContiguous(listType, 4, vtxListCont, sizeof(GrVertex));
else
grDrawVertexArray(listType, 4, vtxListArray);
break;
case GR_TRIANGLES:
if (varraycont)
grDrawVertexArrayContiguous(listType, 6, vtxListCont, sizeof(GrVertex));
else
grDrawVertexArray(listType, 6, vtxListArray);
break;
default:
if (aaenable)
grAADrawTriangle(vtxList, vtxList+1, vtxList+2, FXTRUE, FXTRUE, FXTRUE);
else
grDrawTriangle(vtxList, vtxList+1, vtxList+2);
}
tlConRender();
grBufferSwap( 1 );
/* grab the frame buffer */
if (scrgrab) {
if (!tlScreenDump(filename, (FxU16)scrWidth, (FxU16)scrHeight))
printf( "Cannot open %s\n", filename);
scrgrab = FXFALSE;
}
while( tlKbHit() ) {
FxU32 key;
switch( key = tlGetCH() ) {
case 'c':
case 'C':
varraycont = !varraycont;
break;
case 't':
case 'T':
listType = -1;
break;
case 'a':
case 'A':
aaenable = !aaenable;
if (aaenable) {
grAlphaCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_NONE,
FXFALSE );
grAlphaBlendFunction( GR_BLEND_SRC_ALPHA, GR_BLEND_ONE_MINUS_SRC_ALPHA,
GR_BLEND_ZERO, GR_BLEND_ZERO );
grEnable(GR_AA_ORDERED);
if (!packedrgb)
grVertexLayout(GR_PARAM_A,
GR_VERTEX_A_OFFSET << 2,
GR_PARAM_ENABLE);
}
else {
grAlphaCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_CONSTANT,
FXFALSE);
grAlphaBlendFunction(GR_BLEND_ONE , GR_BLEND_ZERO,
GR_BLEND_ONE, GR_BLEND_ZERO);
grDisable(GR_AA_ORDERED);
if (!packedrgb)
grVertexLayout(GR_PARAM_A,
GR_VERTEX_A_OFFSET << 2,
GR_PARAM_DISABLE);
}
break;
case 'p':
case 'P':
packedrgb = !packedrgb;
if (packedrgb) {
grVertexLayout(GR_PARAM_PARGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
*(FxU32*)&vtxList[0].r = 0xff0000ff;
*(FxU32*)&vtxList[1].r = 0xff00ff00;
*(FxU32*)&vtxList[2].r = 0xffff0000;
*(FxU32*)&vtxList[3].r = 0xffff0000;
*(FxU32*)&vtxList[4].r = 0xff00ff00;
*(FxU32*)&vtxList[5].r = 0xff0000ff;
}
else {
grVertexLayout(GR_PARAM_RGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
if (aaenable)
grVertexLayout(GR_PARAM_A, GR_VERTEX_A_OFFSET << 2, GR_PARAM_ENABLE);
vtxList[0].r = 255.f, vtxList[0].g = 0.f, vtxList[0].b = 0.f, vtxList[0].a = 255.f;
vtxList[1].r = 0.f, vtxList[1].g = 255.f, vtxList[1].b = 0.f, vtxList[1].a = 255.f;
vtxList[2].r = 0.f, vtxList[2].g = 0.f, vtxList[2].b = 255.f, vtxList[2].a = 255.f;
vtxList[3].r = 0.f, vtxList[3].g = 0.f, vtxList[3].b = 255.f, vtxList[3].a = 255.f;
vtxList[4].r = 0.f, vtxList[4].g = 255.f, vtxList[4].b = 0.f, vtxList[4].a = 255.f;
vtxList[5].r = 0.f, vtxList[5].g = 0.f, vtxList[5].b = 255.f, vtxList[5].a = 255.f;
}
switch (listType) {
case 0:
case 1:
case 2:
case 4:
vtxListCont[0] = vtxList[0]; vtxListCont[1] = vtxList[1];
vtxListCont[2] = vtxList[2]; vtxListCont[3] = vtxList[3];
break;
case 3:
case 5:
vtxListCont[0] = vtxList[1]; vtxListCont[1] = vtxList[0];
vtxListCont[2] = vtxList[2]; vtxListCont[3] = vtxList[3];
break;
case 6:
vtxListCont[0] = vtxList[1]; vtxListCont[1] = vtxList[0]; vtxListCont[2] = vtxList[2];
vtxListCont[3] = vtxList[1]; vtxListCont[4] = vtxList[2]; vtxListCont[5] = vtxList[3];
break;
}
break;
case '0':
case '1':
case '2':
case '4':
listType = key - '0';
vtxListArray[0] = (void *)&vtxList[0]; vtxListArray[1] = (void *)&vtxList[1];
vtxListArray[2] = (void *)&vtxList[2]; vtxListArray[3] = (void *)&vtxList[3];
vtxListCont[0] = vtxList[0]; vtxListCont[1] = vtxList[1];
vtxListCont[2] = vtxList[2]; vtxListCont[3] = vtxList[3];
break;
case '3':
case '5':
listType = key - '0';
vtxListArray[0] = (void *)&vtxList[1]; vtxListArray[1] = (void *)&vtxList[0];
vtxListArray[2] = (void *)&vtxList[2]; vtxListArray[3] = (void *)&vtxList[3];
vtxListCont[0] = vtxList[1]; vtxListCont[1] = vtxList[0];
vtxListCont[2] = vtxList[2]; vtxListCont[3] = vtxList[3];
break;
case '6':
listType = key - '0';
vtxListArray[0] = (void *)&vtxList[1]; vtxListArray[1] = (void *)&vtxList[0];
vtxListArray[2] = (void *)&vtxList[2];
vtxListArray[3] = (void *)&vtxList[1]; vtxListArray[4] = (void *)&vtxList[2];
vtxListArray[5] = (void *)&vtxList[3];
vtxListCont[0] = vtxList[1]; vtxListCont[1] = vtxList[0]; vtxListCont[2] = vtxList[2];
vtxListCont[3] = vtxList[1]; vtxListCont[4] = vtxList[2]; vtxListCont[5] = vtxList[3];
break;
default:
frames = 0;
break;
}
}
}
grGlideShutdown();
return;
} /* main */
void main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
#define NVERT 5
GrVertex vtx[NVERT];
int index[NVERT];
int frames = -1;
int i, idx;
#define NHUE 360
RGB hues[NHUE];
FxU32 wrange[2];
GrContext_t gc = 0;
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "nr", &match, &remArgs ) ) {
if ( rv == -1 ) {
printf( "Unrecognized command line argument\n" );
printf( "%s %s\n", name, usage );
printf( "Available resolutions:\n%s\n",
tlGetResolutionList() );
return;
}
switch( match ) {
case 'n':
frames = atoi( remArgs[0] );
break;
case 'r':
resolution = tlGetResolutionConstant( remArgs[0],
&scrWidth,
&scrHeight );
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
grSstSelect( 0 );
gc = grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1 );
if (!gc) {
printf("Could not allocate glide fullscreen context.\n");
goto __errExit;
}
tlConSet( 0.0f, 0.0f, 1.0f, 1.0f,
60, 30, 0xffffff );
/* Set up Render State - gouraud shading */
grGet(GR_WDEPTH_MIN_MAX, 8, (FxI32 *)wrange);
grVertexLayout(GR_PARAM_XY, 0, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_RGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
grColorCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_NONE,
FXFALSE );
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, wrange[1] );
/* 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
grDrawVertexArrayContiguous(GR_POLYGON, NVERT, vtx, sizeof(GrVertex));
tlConRender();
grBufferSwap( 1 );
if ( tlKbHit() ) frames = 0;
}
__errExit:
grGlideShutdown();
return;
}
void main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
float clipX, clipY, clipSize, clipSizeDelta, clipPosDelta;
FxU32 zrange[2];
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "nr", &match, &remArgs ) ) {
if ( rv == -1 ) {
printf( "Unrecognized command line argument\n" );
printf( "%s %s\n", name, usage );
printf( "Available resolutions:\n%s\n",
tlGetResolutionList() );
return;
}
switch( match ) {
case 'n':
frames = atoi( remArgs[0] );
break;
case 'r':
resolution = tlGetResolutionConstant( remArgs[0],
&scrWidth,
&scrHeight );
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
grSstSelect( 0 );
assert( grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1 ) );
tlConSet( 0.0f, 0.0f, 1.0f, 0.5f,
60, 15, 0xffffff );
/* Set up Render State - iterated alpha + z buffering */
grGet(GR_ZDEPTH_MIN_MAX, 8, zrange);
grVertexLayout(GR_PARAM_XY, 0, GR_PARAM_ENABLE);
grColorCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_NONE,
FXFALSE );
clipX = 0.2f;
clipY = 0.5f;
clipSize = 0.3f;
clipSizeDelta = 0.005f;
clipPosDelta = 0.01f;
#define CLIPSIZE_MIN 0.05f
#define CLIPSIZE_MAX 0.6f
#define GRAY 0x00808080
#define BLACK 0x00000000
tlConOutput( "+/- - grow/shrink clip rectangle\n" );
tlConOutput( "a/d - clip window left/right \n" );
tlConOutput( "w/s - clip window up/down \n" );
tlConOutput( "Press any other key to quit\n" );
while( frames-- && tlOkToRender()) {
int x, y;
GrVertex vtxA, vtxB, vtxC;
int minx, miny, maxx, maxy;
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight );
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grClipWindow( (int)tlScaleX(0.0f),(int)tlScaleY(0.0f),
(int)tlScaleX(1.0f),(int)tlScaleY(1.0f) );
grBufferClear( BLACK, 0, zrange[1] );
/* Set Clipping Rectangle */
minx = (int)tlScaleX(clipX);
miny = (int)tlScaleY(clipY);
if ( (clipX+clipSize)>1.0f )
maxx = (int)tlScaleX( 1.0f );
else
maxx = (int)tlScaleX( clipX + clipSize );
if ( (clipY+clipSize)>1.0f )
maxy = (int)tlScaleY( 1.0f );
else
maxy = (int)tlScaleY( clipY + clipSize );
grClipWindow( minx, miny, maxx, maxy );
/* Draw 10x10 grid of triangles */
for( y = 0; y < 10; y++ ) {
for( x = 0; x < 10; x++ ) {
/*
A
|\
B-C
*/
vtxA.x = vtxB.x = tlScaleX( ((float)x)/10.0f );
vtxA.y = tlScaleY( ((float)y)/10.0f );
vtxB.y = vtxC.y = tlScaleY( (((float)y)/10.0f) + 0.1f );
vtxC.x = tlScaleX( (((float)x)/10.0f) + 0.1f );
grConstantColorValue( GRAY );
grDrawTriangle( &vtxA, &vtxB, &vtxC );
}
}
tlConRender();
grBufferSwap( 1 );
grFinish();
while( tlKbHit() ) {
switch( tlGetCH() ) {
case '+':
if ( clipSize < CLIPSIZE_MAX )
clipSize += clipSizeDelta;
break;
case '-':
if ( clipSize > CLIPSIZE_MIN )
clipSize -= clipSizeDelta;
break;
case 'a':
case 'A':
if ( clipX > 0.0f )
clipX -= clipPosDelta;
if ( clipX < 0.0f ) clipX = 0.0f;
break;
case 'd':
case 'D':
if ( clipX < 1.0f )
clipX += clipPosDelta;
break;
case 'w':
case 'W':
if ( clipY > 0.0f )
clipY -= clipPosDelta;
if ( clipY < 0.0f ) clipY = 0.0f;
break;
case 's':
case 'S':
if ( clipY < 1.0f )
clipY += clipPosDelta;
break;
default:
frames = 0;
break;
}
}
}
grGlideShutdown();
return;
}
void main( int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
float
minColor = 10.f, /* Vertex min color */
maxColor = 245.f; /* Vertex max color */
GrVertex
localVerts[VERT_COUNT], /* Vertices in world coordinates */
texVerts[4]; /* Texture vertices for background */
float
alpha = 192.0f, /* Alpha for blending tringle over background */
y_angle = 0.0f; /* rotation amount */
int
firstTime; /* Used for performance calculations */
FxBool
plugging = FXFALSE, /* Show shameless plug */
printPerf = FXFALSE, /* Print performance numbers */
lines = FXFALSE, /* Draw lines instead of triangles */
blend = FXFALSE, /* Blend the triangle over the background */
texturing = FXFALSE, /* Texture the tiangle */
antialias = FXTRUE, /* Antialias the triangle? */
bilinear = FXTRUE, /* Perform bilinear filtering on the texture? */
render = FXTRUE, /* Draw? */
backbuffer = FXTRUE, /* Draw to backbuffer? */
background = FXTRUE; /* Draw background? */
GrOriginLocation_t
origin = GR_ORIGIN_LOWER_LEFT; /* Origin */
FxU32
swapDelay = 1, /* Arg to grBufferSwap */
trisDrawn, /* # triangles drawn */
trisProcessed, /* # triangles through pipeline */
lastFrame, /* Number of last frame we did perf stats */
frameNum = 0L; /* id of each frame drawn */
GrCullMode_t
cullMode = GR_CULL_DISABLE; /* backface culling */
FxU32 startAddress = 0, bgDecalAddress = 0, triDecalAddress = 0;
GrTexInfo
triDecal, /* Triangle decal texture */
bgDecal; /* Background decal texture */
Gu3dfInfo
bgInfo, /* Info on background texture */
triInfo; /* Info on triangle texture */
GrColorCombineFnc_t
ccFnc = GR_COLORCOMBINE_ITRGB; /* Start of w/ Gouraud shading */
char
*bgFileName = NULL, /* Name of background texture file */
*triFileName = NULL; /* Name of triangle texture file */
int
frameCount = 0;
FxU32 wrange[2];
FxI32 state_size;
void *oldState;
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
/* Process Command Line Arguments */
while( rv = tlGetOpt( argc, argv, "nrbtea", &match, &remArgs ) ) {
if ( rv == -1 ) {
printf( "Unrecognized command line argument\n" );
printf( "%s %s\n", name, usage );
printf( "Available resolutions:\n%s\n",
tlGetResolutionList() );
return;
}
switch( match ) {
case 'n':
frames = atoi( remArgs[0] );
break;
case 'r':
resolution = tlGetResolutionConstant( remArgs[0],
&scrWidth,
&scrHeight );
break;
case 'b':
bgFileName = strdup( remArgs[0] );
break;
case 't':
triFileName = strdup( remArgs[0] );
break;
case 'a':
alpha = (float)atof( remArgs[0] );
break;
}
}
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf( "%s:\n%s\n", name, purpose );
printf( "%s\n", version );
printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
if ( frames == -1 ) {
printf( "Press A Key To Begin Test.\n" );
tlGetCH();
}
grSstSelect( 0 );
assert( grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
origin,
2, 1 ) );
grVertexLayout(GR_PARAM_XY, GR_VERTEX_X_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_RGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_A, GR_VERTEX_A_OFFSET << 2, GR_PARAM_ENABLE);
grGet(GR_WDEPTH_MIN_MAX, 8, wrange);
grGet(GR_GLIDE_STATE_SIZE, 4, &state_size);
oldState = malloc(state_size);
tlConSet( 0.0f, 0.0f, 1.0f, 1.0f,
80, 40, 0xffffff );
if(frames == -1) {
doHelp();
}
localVerts[0].x = 0.f;
localVerts[0].y = 0.75f;
localVerts[0].z = 0.0f;
localVerts[0].tmuvtx[0].sow = 255.f;
localVerts[0].tmuvtx[0].tow = 255.f;
localVerts[0].oow = 1.f;
localVerts[0].r = maxColor;
localVerts[0].g = minColor;
localVerts[0].b = minColor;
localVerts[0].a = 255.f;
localVerts[1].x = -0.75f;
localVerts[1].y = -0.75f;
localVerts[1].z = 0.0f;
localVerts[1].tmuvtx[0].sow = 0.f;
localVerts[1].tmuvtx[0].tow = 255.f;
localVerts[1].oow = 1.f;
localVerts[1].r = minColor;
localVerts[1].g = maxColor;
localVerts[1].b = minColor;
localVerts[1].a = 255.f;
localVerts[2].x = 0.75f;
localVerts[2].y = -0.75f;
localVerts[2].z = 0.0f;
localVerts[2].tmuvtx[0].sow = 255.f;
localVerts[2].tmuvtx[0].tow = 0.f;
localVerts[2].oow = 1.f;
localVerts[2].r = minColor;
localVerts[2].g = minColor;
localVerts[2].b = maxColor;
localVerts[2].a = 255.f;
texVerts[0].x = 0.f;
texVerts[0].y = 0.f;
texVerts[0].a = 255.f;
texVerts[0].oow = 1.f;
texVerts[0].tmuvtx[0].sow = 0.f * texVerts[0].oow;
texVerts[0].tmuvtx[0].tow = 255.f * texVerts[0].oow;
texVerts[1].x = scrWidth;
texVerts[1].y = 0.f;
texVerts[1].a = 255.f;
texVerts[1].oow = 1.f;
texVerts[1].tmuvtx[0].sow = 255.f * texVerts[1].oow;
texVerts[1].tmuvtx[0].tow = 255.f * texVerts[1].oow;
texVerts[2].x = scrWidth;
texVerts[2].y = scrHeight;
texVerts[2].a = 255.f;
texVerts[2].oow = 1.f;
texVerts[2].tmuvtx[0].sow = 255.f * texVerts[2].oow;
texVerts[2].tmuvtx[0].tow = 0.f * texVerts[2].oow;
texVerts[3].x = 0.f;
texVerts[3].y = scrHeight;
texVerts[3].a = 255.f;
texVerts[3].oow = 1.f;
texVerts[3].tmuvtx[0].sow = 0.f * texVerts[3].oow;
texVerts[3].tmuvtx[0].tow = 0.f * texVerts[3].oow;
if (bgFileName == NULL)
bgFileName = "miro.3df";
if (triFileName == NULL)
triFileName = "matt1.3df";
/* Read in background texture file */
if ( gu3dfGetInfo( bgFileName, &bgInfo ) ) {
bgInfo.data = malloc( bgInfo.mem_required );
if ( bgInfo.data == 0 ) {
fprintf( stderr, "out of memory for texture file %s\n", bgFileName );
grGlideShutdown();
exit( -1 );
}
if ( !gu3dfLoad( bgFileName, &bgInfo ) ) {
fprintf( stderr, "could not load texture file %s\n", bgFileName );
grGlideShutdown();
exit( -1 );
}
bgDecal.smallLodLog2 = bgInfo.header.small_lod;
bgDecal.largeLodLog2 = bgInfo.header.large_lod;
bgDecal.aspectRatioLog2 = bgInfo.header.aspect_ratio;
bgDecal.data = bgInfo.data;
bgDecal.format = bgInfo.header.format;
grTexDownloadMipMap( GR_TMU0, startAddress, GR_MIPMAPLEVELMASK_BOTH, &bgDecal);
grTexMipMapMode(GR_TMU0, GR_MIPMAP_NEAREST, FXTRUE);
grTexClampMode( GR_TMU0, GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP);
grTexFilterMode( GR_TMU0, GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR );
bgDecalAddress = startAddress;
startAddress += grTexCalcMemRequired ( bgDecal.smallLodLog2, bgDecal.largeLodLog2,
bgDecal.aspectRatioLog2, bgDecal.format );
free( bgInfo.data );
} else {
fprintf( stderr, "could not get info on %s\n", bgFileName );
grGlideShutdown();
exit( -1 );
}
if ( gu3dfGetInfo( triFileName, &triInfo ) ) {
triInfo.data = malloc( triInfo.mem_required );
if ( triInfo.data == 0 ) {
fprintf( stderr, "out of memory for texture file %s\n", triFileName );
grGlideShutdown();
exit( -1 );
}
if ( !gu3dfLoad( triFileName, &triInfo ) ) {
fprintf( stderr, "could not load texture file %s\n", triFileName );
grGlideShutdown();
exit( -1 );
}
triDecal.smallLodLog2 = triInfo.header.small_lod;
triDecal.largeLodLog2 = triInfo.header.large_lod;
triDecal.aspectRatioLog2 = triInfo.header.aspect_ratio;
triDecal.data = triInfo.data;
triDecal.format = triInfo.header.format;
grTexDownloadMipMap( GR_TMU0, startAddress, GR_MIPMAPLEVELMASK_BOTH, &triDecal);
grTexMipMapMode(GR_TMU0, GR_MIPMAP_NEAREST, FXTRUE);
grTexClampMode( GR_TMU0, GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP);
grTexFilterMode( GR_TMU0, GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR );
triDecalAddress = startAddress;
free( triInfo.data );
} else {
fprintf( stderr, "could not get info on %s\n", triFileName );
grGlideShutdown();
exit( -1 );
}
grTexCombine( GR_TMU0, GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_NONE, FXFALSE, FXFALSE );
grRenderBuffer(backbuffer == FXTRUE ? GR_BUFFER_BACKBUFFER : GR_BUFFER_FRONTBUFFER);
/* Set up alpha blending for AA and compositing... */
grAlphaCombine( GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_NONE,
FXFALSE );
grAlphaBlendFunction( GR_BLEND_SRC_ALPHA,
GR_BLEND_ONE_MINUS_SRC_ALPHA, GR_BLEND_ONE,
GR_BLEND_ZERO );
grAlphaTestFunction( GR_CMP_ALWAYS );
while ( 1 ) {
Matrix rotm;
GrVertex xformedVerts[VERT_COUNT];
int i;
MatMakeYRot( rotm, DEG2RAD( y_angle ) );
if (resolution == GR_RESOLUTION_NONE)
tlGetResolutionConstant("0",
&scrWidth,
&scrHeight );
for( i = 0; i < VERT_COUNT; i++ ) {
PointMatMult( &xformedVerts[i], &localVerts[i], rotm );
xformedVerts[i].x = xformedVerts[i].x / ( xformedVerts[i].z + 2.0f );
xformedVerts[i].y = xformedVerts[i].y / ( xformedVerts[i].z + 2.0f );
xformedVerts[i].x *= scrWidth / 2.0f;
xformedVerts[i].y *= scrHeight / 2.0f;
xformedVerts[i].x += scrWidth / 2.0f;
xformedVerts[i].y += scrHeight / 2.0f;
xformedVerts[i].oow = 1.f / ((xformedVerts[i].z + 2) * scrHeight);
xformedVerts[i].tmuvtx[0].sow *= xformedVerts[i].oow;
xformedVerts[i].tmuvtx[0].tow *= xformedVerts[i].oow;
SNAP_COORD( xformedVerts[i].x );
SNAP_COORD( xformedVerts[i].y );
}
switch ( ccFnc )
{
case GR_COLORCOMBINE_ITRGB:
grColorCombine( GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_NONE, GR_COMBINE_LOCAL_ITERATED, GR_COMBINE_OTHER_NONE, FXFALSE );
break;
case GR_COLORCOMBINE_DECAL_TEXTURE:
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER, GR_COMBINE_FACTOR_ONE, GR_COMBINE_LOCAL_NONE, GR_COMBINE_OTHER_TEXTURE, FXFALSE );
break;
case GR_COLORCOMBINE_TEXTURE_TIMES_ITRGB:
grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER, GR_COMBINE_FACTOR_LOCAL, GR_COMBINE_LOCAL_ITERATED, GR_COMBINE_OTHER_TEXTURE, FXFALSE );
break;
}
/* grLfbBypassMode(GR_LFBBYPASS_ENABLE); */
if (render == FXTRUE) {
++frameNum;
if ((frameNum % NFRAMES) == 0) {
if (printPerf) {
if (!firstTime) {
GrSstPerfStats_t
pStats;
FxU32
lfbWritePixels,
nFrames = frameNum - lastFrame,
fillPixels = nFrames * screenFulls[resolution],
totFail;
lastFrame = frameNum;
grGet(GR_STATS_PIXELS_IN, 4, &pStats.pixelsIn);
grGet(GR_STATS_PIXELS_CHROMA_FAIL, 4, &pStats.chromaFail);
grGet(GR_STATS_PIXELS_DEPTHFUNC_FAIL, 4, &pStats.zFuncFail);
grGet(GR_STATS_PIXELS_AFUNC_FAIL, 4, &pStats.aFuncFail);
grGet(GR_STATS_PIXELS_OUT, 4, &pStats.pixelsOut);
grGet(GR_STATS_TRIANGLES_IN, 4, &trisProcessed);
grGet(GR_STATS_TRIANGLES_OUT, 4, &trisDrawn);
totFail = pStats.chromaFail + pStats.zFuncFail +
pStats.aFuncFail;
lfbWritePixels = pStats.pixelsOut - pStats.pixelsIn - fillPixels;
tlConOutput("In the last %d frames:\n", nFrames);
tlConOutput(" Pixels Processed: %d\n",
pStats.pixelsIn);
tlConOutput(" Chroma Failures: %d\n",
pStats.chromaFail);
tlConOutput(" Z Compare Failures: %d\n",
pStats.zFuncFail);
tlConOutput(" Alpha Compare Failures: %d\n",
pStats.aFuncFail);
tlConOutput(" Fast Fill Pixels: %d\n",
fillPixels);
tlConOutput(" LFB Write Pixels: %d\n",
lfbWritePixels);
tlConOutput(" Total Pixels Drawn: %d\n",
pStats.pixelsOut);
tlConOutput(" Triangles Processed %d\n",
trisProcessed);
tlConOutput(" Triangles Drawn %d\n",
trisDrawn);
if (
(pStats.pixelsOut - lfbWritePixels - fillPixels - pStats.pixelsIn) != totFail)
tlConOutput("Error: %d != %d\n",
pStats.pixelsOut - lfbWritePixels - fillPixels,
totFail);
grReset(GR_STATS_PIXELS);
} else {
lastFrame = frameNum;
grReset(GR_STATS_PIXELS);
firstTime = 0;
}
}
}
grBufferClear( 0xffffffff, 0, (FxU16)wrange[1] );
if (background == FXTRUE) {
texVerts[0].x = 0.f;
texVerts[0].y = 0.f;
texVerts[1].x = scrWidth;
texVerts[1].y = 0.f;
texVerts[1].x = scrWidth;
texVerts[1].y = 0.f;
texVerts[2].x = scrWidth;
texVerts[2].y = scrHeight;
texVerts[3].x = 0.f;
texVerts[3].y = scrHeight;
grGlideGetState(oldState);
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
grAlphaBlendFunction(
GR_BLEND_ONE, GR_BLEND_ZERO,
GR_BLEND_ONE, GR_BLEND_ZERO);
grColorCombine(
GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE, FXFALSE
);
grTexSource( GR_TMU0, bgDecalAddress, GR_MIPMAPLEVELMASK_BOTH, &bgDecal );
for (i = 0; i < NTRIS; i++) {
grDrawTriangle(&texVerts[0], &texVerts[1], &texVerts[2]);
grDrawTriangle(&texVerts[2], &texVerts[3], &texVerts[0]);
}
grGlideSetState(oldState);
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
if (texturing == FXTRUE)
grTexSource( GR_TMU0, bgDecalAddress, GR_MIPMAPLEVELMASK_BOTH, &bgDecal );
if (texturing)
grTexSource( GR_TMU0, triDecalAddress, GR_MIPMAPLEVELMASK_BOTH, &triDecal );
if (antialias == FXTRUE) {
grEnable(GR_AA_ORDERED);
if (lines == FXTRUE) {
grDrawLine(&xformedVerts[0], &xformedVerts[1]);
grDrawLine(&xformedVerts[1], &xformedVerts[2]);
grDrawLine(&xformedVerts[2], &xformedVerts[0]);
} else {
grAADrawTriangle(
&xformedVerts[0], &xformedVerts[1],
&xformedVerts[2], FXTRUE, FXTRUE, FXTRUE
);
}
} else {
grDisable(GR_AA_ORDERED);
if (lines == FXTRUE) {
grDrawLine(&xformedVerts[0], &xformedVerts[1]);
grDrawLine(&xformedVerts[1], &xformedVerts[2]);
grDrawLine(&xformedVerts[2], &xformedVerts[0]);
} else {
grDrawTriangle(
&xformedVerts[0], &xformedVerts[1],
&xformedVerts[2]
);
}
}
if (plugging)
grSplash(0.f, 0.f, scrWidth / 5.f, scrHeight / 5.f, frameNum);
if (backbuffer) {
tlConRender();
grBufferSwap( swapDelay );
}
}
if (tlKbHit()) {
char c = (char) tlGetCH();
switch (c) {
case 'a':
case 'A':
if (antialias == FXFALSE) {
tlConOutput("Turning ON Antialiasing\n");
antialias = FXTRUE;
} else {
tlConOutput("Turning OFF Antialiasing\n");
antialias = FXFALSE;
}
break;
case 'B':
case 'b':
if (bilinear == FXFALSE) {
bilinear = FXTRUE;
tlConOutput("Turning ON BiLinear blending\n");
grTexFilterMode ( GR_TMU0, GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR );
} else {
bilinear = FXFALSE;
tlConOutput("Turning OFF BiLinear blending\n");
grTexFilterMode ( GR_TMU0, GR_TEXTUREFILTER_POINT_SAMPLED,
GR_TEXTUREFILTER_POINT_SAMPLED );
}
break;
case 'c':
case 'C':
if (blend == FXTRUE) {
int i;
blend = FXFALSE;
for(i=0;i<VERT_COUNT;i++) localVerts[i].a = 255.0f;
} else {
int i;
blend = FXTRUE;
for(i=0;i<VERT_COUNT;i++) localVerts[i].a = alpha;
}
break;
case 'd':
case 'D':
tlConOutput("vtxa = (%.2f, %.2f), vtxb = (%.2f, %.2f), vtxc = (%.2f, %.2f)\n",
xformedVerts[0].x, xformedVerts[0].y,
xformedVerts[1].x, xformedVerts[1].y,
xformedVerts[2].x, xformedVerts[2].y
);
break;
case 'f':
case 'F':
if (backbuffer == FXTRUE) {
backbuffer = FXFALSE;
grRenderBuffer(GR_BUFFER_FRONTBUFFER);
} else {
backbuffer = FXTRUE;
grRenderBuffer(GR_BUFFER_BACKBUFFER);
}
break;
case 'g':
case 'G':
#if 0
grLfbBegin();
grLfbWriteMode(GR_LFBWRITEMODE_565);
grLfbOrigin(GR_ORIGIN_UPPER_LEFT);
grLfbGetReadPtr(GR_BUFFER_FRONTBUFFER);
tlConOutput("Press a key to get front buffer\n");
while (!tlKbHit());
c = (char) tlGetCH();
guFbReadRegion(0,0,(int)wWidth,(int)scrHeight,scrnImage,(int)wWidth * sizeof(FxU16));
tlConOutput("Press a key to put image in back buffer and swap\n");
while (!tlKbHit());
tlGetCH();
grLfbGetWritePtr(GR_BUFFER_BACKBUFFER);
guFbWriteRegion(0,0,(int)wWidth,(int)scrHeight,scrnImage,(int)wWidth * sizeof(FxU16));
grBufferSwap(swapDelay);
tlConOutput("Press a key to continue...\n");
while (!tlKbHit());
tlGetCH();
grLfbEnd();
#endif
break;
case 'h':
case 'H':
case '?':
doHelp();
break;
case 'i':
case 'I':
if (background == FXTRUE) {
background = FXFALSE;
tlConOutput("Turning off background\n");
} else {
tlConOutput("Turning on background\n");
background = FXTRUE;
}
break;
case 'l':
case 'L':
if (lines == FXTRUE) {
lines = FXFALSE;
tlConOutput("Turning OFF lines\n");
} else {
lines = FXTRUE;
tlConOutput("Turning ON lines\n");
}
break;
case 'm':
case 'M':
ccFnc = GR_COLORCOMBINE_TEXTURE_TIMES_ITRGB;
break;
case 'n':
case 'N':
if (printPerf == FXFALSE) {
printPerf = FXTRUE;
firstTime = 1;
grReset(GR_STATS_PIXELS);
grReset(GR_STATS_TRIANGLES);
} else {
printPerf= FXFALSE;
}
break;
case 'o':
case 'O':
if (origin == GR_ORIGIN_LOWER_LEFT)
origin = GR_ORIGIN_UPPER_LEFT;
else
origin = GR_ORIGIN_LOWER_LEFT;
grSstOrigin(origin);
break;
case 'p':
case 'P':
if (render == FXTRUE)
render = FXFALSE;
else
render = FXTRUE;
break;
case 'q':
case 'Q':
case 27:
grGlideShutdown();
exit(0);
break;
case 'r':
case 'R':
tlConOutput("Screen Resolution is %s\n", tlGetResolutionString( resolution ) );
break;
case 'S':
case 's':
if (cullMode == GR_CULL_DISABLE) {
cullMode = GR_CULL_NEGATIVE;
tlConOutput("Turning ON backface culling (hidden Surface removal)\n");
} else {
cullMode = GR_CULL_DISABLE;
tlConOutput("Turning OFF backface culling (hidden Surface removal)\n");
}
grCullMode(cullMode);
break;
case 'T':
case 't':
if (texturing == FXFALSE) {
tlConOutput("Turning ON texturing\n");
ccFnc = GR_COLORCOMBINE_DECAL_TEXTURE;
texturing = FXTRUE;
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
} else {
tlConOutput("Turning OFF texturing\n");
ccFnc = GR_COLORCOMBINE_ITRGB;
texturing = FXFALSE;
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_DISABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_DISABLE);
}
break;
case 'u':
case 'U':
if (plugging == FXTRUE) {
plugging = FXFALSE;
grDisable(GR_SHAMELESS_PLUG);
}
else {
plugging = FXTRUE;
grEnable(GR_SHAMELESS_PLUG);
}
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '0':
{
char str[256];
swapDelay = (int) c - 0x30;
sprintf(str, "Swapdelay = %d\n", swapDelay);
tlConOutput(str);
}
break;
}
}
if (render) {
y_angle += 2.f;
if( y_angle > 360.0f )
y_angle -= 360.0f;
}
frameCount++;
if(frameCount < 0)
frameCount = 0;
if(frames == frameCount)
break;
}
grGlideShutdown();
}
void main(int argc, char **argv) {
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
FxBool scrgrab = FXFALSE;
char filename[256];
FxU32 wrange[2];
GrLOD_t largeLod = GR_LOD_LOG2_256;
GrLOD_t smallLod = GR_LOD_LOG2_1;
GrTexTable_t curPalType = GR_TEXTABLE_PALETTE;
FxU32 compBits = 0x08UL;
FxBool singleTexP = FXFALSE;
FxBool extMirrorP = FXFALSE;
FxBool extPalP = FXFALSE;
float minTexCoor = 0.0f;
float maxTexCoor = 256.0f;
/* Initialize Glide */
grGlideInit();
assert(hwconfig = tlVoodooType());
/* Process Command Line Arguments */
while(rv = tlGetOpt(argc, argv, "dlmnprs", &match, &remArgs)) {
if (rv == -1) {
printf("Unrecognized command line argument\n");
printf("%s %s\n", name, usage);
printf("Available resolutions:\n%s\n",
tlGetResolutionList());
return;
}
switch(match) {
case 'd':
scrgrab = FXTRUE;
frames = 1;
strcpy(filename, remArgs[0]);
break;
case 'l':
if (sscanf(remArgs[0], "%d,%d", &smallLod, &largeLod) != 2) {
largeLod = GR_LOD_LOG2_256;
smallLod = GR_LOD_LOG2_1;
} else {
GrLOD_t
maxLod,
lodShift;
if (grGet(GR_MAX_TEXTURE_SIZE, sizeof(maxLod), &maxLod) == 0) {
largeLod = GR_LOD_LOG2_256;
smallLod = GR_LOD_LOG2_1;
} else {
lodShift = 0;
while((0x01 << lodShift) != maxLod) lodShift++;
if (largeLod > lodShift) largeLod = lodShift;
}
}
break;
case 'm':
extMirrorP = FXTRUE;
break;
case 'n':
frames = atoi(remArgs[0]);
break;
case 'p':
extPalP = FXTRUE;
break;
case 'r':
resolution = tlGetResolutionConstant(remArgs[0],
&scrWidth,
&scrHeight);
break;
case 's':
singleTexP = FXTRUE;
break;
}
}
tlSetScreen(scrWidth, scrHeight);
version = grGetString(GR_VERSION);
printf("%s:\n%s\n", name, purpose);
printf("%s\n", version);
printf("Resolution: %s\n", tlGetResolutionString(resolution));
if (frames == -1) {
printf("Press A Key To Begin Test.\n");
tlGetCH();
}
grSstSelect(0);
assert(grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1));
tlConSet(0.0f, 0.0f, 1.0f, 1.0f,
60, 30, 0xffffff);
/* Set up Render State */
grGet(GR_WDEPTH_MIN_MAX, 8, wrange);
grVertexLayout(GR_PARAM_XY, 0, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
grTexCombine(GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
FXFALSE, FXFALSE);
/* Load texture data into system ram */
if (!singleTexP) {
FxI32 numTmu = 0;
if (grGet(GR_NUM_TMU, sizeof(numTmu), &numTmu) && (numTmu > 1)) {
TlTexture texture;
assert(tlLoadTexture("decal1.3df",
&texture.info,
&texture.tableType,
&texture.tableData));
/* Download texture data to TMU */
grTexDownloadMipMap(GR_TMU1,
grTexMinAddress(GR_TMU1),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
if (texture.tableType != NO_TABLE) {
grTexDownloadTable(texture.tableType,
&texture.tableData);
}
grTexSource(GR_TMU1,
grTexMinAddress(GR_TMU1),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
grVertexLayout(GR_PARAM_ST1, GR_VERTEX_SOW_TMU1_OFFSET << 2, GR_PARAM_ENABLE);
grTexCombine(GR_TMU1,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
GR_COMBINE_FUNCTION_LOCAL, GR_COMBINE_FACTOR_ONE,
FXFALSE, FXFALSE);
grTexCombine(GR_TMU0,
GR_COMBINE_FUNCTION_BLEND_OTHER, GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_FUNCTION_BLEND_OTHER, GR_COMBINE_FACTOR_LOCAL,
FXFALSE, FXFALSE);
}
}
if (extMirrorP || extPalP) {
const char* extString = grGetString(GR_EXTENSION);
const char* tempStr = extString;
while(tempStr != NULL) {
const char* keyList[] = {
"TEXMIRROR",
"PALETTE6666"
};
if (extMirrorP &&
!singleTexP &&
(strncmp(tempStr, keyList[0], strlen(keyList[0])) == 0)) {
grTexClampMode(GR_TMU0,
GR_TEXTURECLAMP_MIRROR_EXT,
GR_TEXTURECLAMP_MIRROR_EXT);
minTexCoor = -256.0f;
maxTexCoor = 512.0f;
}
if (extPalP &&
(strncmp(tempStr, keyList[1], strlen(keyList[1])) == 0)) {
curPalType = GR_TEXTABLE_PALETTE_6666_EXT;
compBits = 0x06UL;
}
tempStr = strchr(tempStr, ' ');
if (tempStr != NULL) tempStr++;
}
}
{
GuTexPalette texPal;
GrTexInfo texInfo;
unsigned char* texData = NULL, *tmp;
int i, j, k;
i = 0;
while(i < 256) {
const FxU32 compVal = (FxU32)(i * (0x01UL << compBits) / 256.0f);
texPal.data[i] = ((compVal << (compBits * 2)) |
(compVal << (compBits * 1)) |
(compVal << (compBits * 0)));
i++;
}
/* Download this in a sequential way to test the palette download */
i = 0;
while(i < 256) {
const int max = i + (rand() % 10);
const int end = MIN(max, 255);
grTexDownloadTablePartial(curPalType, &texPal, i, end);
i = end + 1;
}
i = 0;
for(k = largeLod; k >= smallLod; k--) {
i += ((0x01 << k) * (0x01 << k));
}
texData = (unsigned char*)malloc(i * 2);
if (texData == NULL) {
printf("Unable to allocate texture data.\n");
goto __errExit;
}
/* Download dumb palettized texture */
texInfo.smallLodLog2 = smallLod;
texInfo.largeLodLog2 = largeLod;
texInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
texInfo.format = GR_TEXFMT_P_8;
texInfo.data = (void*)texData;
for(k = texInfo.largeLodLog2; k >= texInfo.smallLodLog2; k--) {
const int texDim = (0x01 << k);
const float levelStep = (256.0f / texDim);
tmp=texData;
for(i = 0; i < texDim; i++) {
for(j = 0; j < texDim; j++) {
*tmp++ = (FxU8)(levelStep * i);
}
}
}
grTexDownloadMipMap(GR_TMU0, 0, GR_MIPMAPLEVELMASK_BOTH, &texInfo);
grTexSource(GR_TMU0, 0, GR_MIPMAPLEVELMASK_BOTH, &texInfo);
free((void*)texData);
}
tlConOutput("Press a key to quit\n");
while(frames-- && tlOkToRender()) {
GrVertex vtxA, vtxB, vtxC;
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight);
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear(0xFF00FF00, 0xFF, wrange[1]);
/* Triangle w/ texture ramp going across and down. */
vtxA.oow =
vtxB.oow =
vtxC.oow = 1.0f;
{
vtxA.x = tlScaleX(0.2f), vtxA.y = tlScaleY(0.2f);
vtxA.tmuvtx[0].sow = minTexCoor;
vtxA.tmuvtx[0].tow = minTexCoor;
vtxA.tmuvtx[1].sow = 0.0f;
vtxA.tmuvtx[1].tow = 0.0f;
vtxB.x = tlScaleX(0.8f), vtxB.y = tlScaleY(0.2f);
vtxB.tmuvtx[0].sow = maxTexCoor;
vtxB.tmuvtx[0].tow = minTexCoor;
vtxB.tmuvtx[1].sow = 255.0f;
vtxB.tmuvtx[1].tow = 0.0f;
vtxC.x = tlScaleX(0.8f), vtxC.y = tlScaleY(0.8f);
vtxC.tmuvtx[0].sow = maxTexCoor;
vtxC.tmuvtx[0].tow = maxTexCoor;
vtxC.tmuvtx[1].sow = 255.0f;
vtxC.tmuvtx[1].tow = 255.0f;
grDrawTriangle(&vtxA, &vtxB, &vtxC);
}
{
vtxA.x = tlScaleX(0.2f), vtxA.y = tlScaleY(0.2f);
vtxA.tmuvtx[0].sow = minTexCoor;
vtxA.tmuvtx[0].tow = minTexCoor;
vtxA.tmuvtx[1].sow = 0.0f;
vtxA.tmuvtx[1].tow = 0.0f;
vtxB.x = tlScaleX(0.8f), vtxB.y = tlScaleY(0.8f);
vtxB.tmuvtx[0].sow = maxTexCoor;
vtxB.tmuvtx[0].tow = maxTexCoor;
vtxB.tmuvtx[1].sow = 255.0f;
vtxB.tmuvtx[1].tow = 255.0f;
vtxC.x = tlScaleX(0.2f), vtxC.y = tlScaleY(0.8f);
vtxC.tmuvtx[0].sow = minTexCoor;
vtxC.tmuvtx[0].tow = maxTexCoor;
vtxC.tmuvtx[1].sow = 0.0f;
vtxC.tmuvtx[1].tow = 255.0f;
grDrawTriangle(&vtxA, &vtxB, &vtxC);
}
tlConRender();
grBufferSwap(1);
/* grab the frame buffer */
if (scrgrab) {
if (!tlScreenDump(filename, (FxU16)scrWidth, (FxU16)scrHeight))
printf("Cannot open %s\n", filename);
scrgrab = FXFALSE;
}
if (tlKbHit()) frames = 0;
}
__errExit:
grGlideShutdown();
}
/*
* Create a new FX/Mesa context and return a handle to it.
*/
fxMesaContext GLAPIENTRY
fxMesaCreateContext(GLuint win,
GrScreenResolution_t res,
GrScreenRefresh_t ref, const GLint attribList[])
{
fxMesaContext fxMesa = NULL;
GLcontext *ctx = NULL, *shareCtx = NULL;
struct dd_function_table functions;
int i;
const char *str;
int sliaa, numSLI, samplesPerChip;
struct SstCard_St *voodoo;
struct tdfx_glide *Glide;
GLboolean aux;
GLboolean doubleBuffer;
GLuint colDepth;
GLuint depthSize, alphaSize, stencilSize, accumSize;
GLuint redBits, greenBits, blueBits, alphaBits;
GrPixelFormat_t pixFmt;
if (TDFX_DEBUG & VERBOSE_DRIVER) {
fprintf(stderr, "fxMesaCreateContext(...)\n");
}
/* Okay, first process the user flags */
aux = GL_FALSE;
doubleBuffer = GL_FALSE;
colDepth = 16;
depthSize = alphaSize = stencilSize = accumSize = 0;
i = 0;
while (attribList[i] != FXMESA_NONE) {
switch (attribList[i]) {
case FXMESA_COLORDEPTH:
colDepth = attribList[++i];
break;
case FXMESA_DOUBLEBUFFER:
doubleBuffer = GL_TRUE;
break;
case FXMESA_ALPHA_SIZE:
if ((alphaSize = attribList[++i])) {
aux = GL_TRUE;
}
break;
case FXMESA_DEPTH_SIZE:
if ((depthSize = attribList[++i])) {
aux = GL_TRUE;
}
break;
case FXMESA_STENCIL_SIZE:
stencilSize = attribList[++i];
break;
case FXMESA_ACCUM_SIZE:
accumSize = attribList[++i];
break;
/* XXX ugly hack here for sharing display lists */
case FXMESA_SHARE_CONTEXT:
shareCtx = (GLcontext *)attribList[++i];
break;
default:
fprintf(stderr, "fxMesaCreateContext: ERROR: wrong parameter (%d) passed\n", attribList[i]);
return NULL;
}
i++;
}
if (!fxQueryHardware()) {
str = "no Voodoo hardware!";
goto errorhandler;
}
grSstSelect(glbCurrentBoard);
/*grEnable(GR_OPENGL_MODE_EXT);*/ /* [koolsmoky] */
voodoo = &glbHWConfig.SSTs[glbCurrentBoard];
fxMesa = (fxMesaContext)CALLOC_STRUCT(tfxMesaContext);
if (!fxMesa) {
str = "private context";
goto errorhandler;
}
if (getenv("MESA_FX_INFO")) {
fxMesa->verbose = GL_TRUE;
}
fxMesa->type = voodoo->type;
fxMesa->HavePalExt = voodoo->HavePalExt && !getenv("MESA_FX_IGNORE_PALEXT");
fxMesa->HavePixExt = voodoo->HavePixExt && !getenv("MESA_FX_IGNORE_PIXEXT");
fxMesa->HaveTexFmt = voodoo->HaveTexFmt && !getenv("MESA_FX_IGNORE_TEXFMT");
fxMesa->HaveCmbExt = voodoo->HaveCmbExt && !getenv("MESA_FX_IGNORE_CMBEXT");
fxMesa->HaveMirExt = voodoo->HaveMirExt && !getenv("MESA_FX_IGNORE_MIREXT");
fxMesa->HaveTexUma = voodoo->HaveTexUma && !getenv("MESA_FX_IGNORE_TEXUMA");
fxMesa->Glide = glbHWConfig.Glide;
Glide = &fxMesa->Glide;
fxMesa->HaveTexus2 = Glide->txImgQuantize &&
Glide->txMipQuantize &&
Glide->txPalToNcc && !getenv("MESA_FX_IGNORE_TEXUS2");
/* Determine if we need vertex swapping, RGB order and SLI/AA */
sliaa = 0;
switch (fxMesa->type) {
case GR_SSTTYPE_VOODOO:
case GR_SSTTYPE_SST96:
case GR_SSTTYPE_Banshee:
fxMesa->bgrOrder = GL_TRUE;
fxMesa->snapVertices = (getenv("MESA_FX_NOSNAP") == NULL);
break;
case GR_SSTTYPE_Voodoo2:
fxMesa->bgrOrder = GL_TRUE;
fxMesa->snapVertices = GL_FALSE;
break;
case GR_SSTTYPE_Voodoo4:
case GR_SSTTYPE_Voodoo5:
/* number of SLI units and AA Samples per chip */
if ((str = Glide->grGetRegistryOrEnvironmentStringExt("SSTH3_SLI_AA_CONFIGURATION")) != NULL) {
sliaa = atoi(str);
}
case GR_SSTTYPE_Voodoo3:
default:
fxMesa->bgrOrder = GL_FALSE;
fxMesa->snapVertices = GL_FALSE;
break;
}
/* XXX todo - Add the old SLI/AA settings for Napalm. */
switch(voodoo->numChips) {
case 4: /* 4 chips */
switch(sliaa) {
case 8: /* 8 Sample AA */
numSLI = 1;
samplesPerChip = 2;
break;
case 7: /* 4 Sample AA */
numSLI = 1;
samplesPerChip = 1;
break;
case 6: /* 2 Sample AA */
numSLI = 2;
samplesPerChip = 1;
break;
default:
numSLI = 4;
samplesPerChip = 1;
}
break;
case 2: /* 2 chips */
switch(sliaa) {
case 4: /* 4 Sample AA */
numSLI = 1;
samplesPerChip = 2;
break;
case 3: /* 2 Sample AA */
numSLI = 1;
samplesPerChip = 1;
break;
default:
numSLI = 2;
samplesPerChip = 1;
}
break;
default: /* 1 chip */
switch(sliaa) {
case 1: /* 2 Sample AA */
numSLI = 1;
samplesPerChip = 2;
break;
default:
numSLI = 1;
samplesPerChip = 1;
}
}
fxMesa->fsaa = samplesPerChip * voodoo->numChips / numSLI; /* 1:noFSAA, 2:2xFSAA, 4:4xFSAA, 8:8xFSAA */
switch (fxMesa->colDepth = colDepth) {
case 15:
redBits = 5;
greenBits = 5;
blueBits = 5;
alphaBits = depthSize ? 1 : 8;
switch(fxMesa->fsaa) {
case 8:
pixFmt = GR_PIXFMT_AA_8_ARGB_1555;
break;
case 4:
pixFmt = GR_PIXFMT_AA_4_ARGB_1555;
break;
case 2:
pixFmt = GR_PIXFMT_AA_2_ARGB_1555;
break;
default:
pixFmt = GR_PIXFMT_ARGB_1555;
}
break;
case 16:
redBits = 5;
greenBits = 6;
blueBits = 5;
alphaBits = depthSize ? 0 : 8;
switch(fxMesa->fsaa) {
case 8:
pixFmt = GR_PIXFMT_AA_8_RGB_565;
break;
case 4:
pixFmt = GR_PIXFMT_AA_4_RGB_565;
break;
case 2:
pixFmt = GR_PIXFMT_AA_2_RGB_565;
break;
default:
pixFmt = GR_PIXFMT_RGB_565;
}
break;
case 24:
fxMesa->colDepth = 32;
case 32:
redBits = 8;
greenBits = 8;
blueBits = 8;
alphaBits = 8;
switch(fxMesa->fsaa) {
case 8:
pixFmt = GR_PIXFMT_AA_8_ARGB_8888;
break;
case 4:
pixFmt = GR_PIXFMT_AA_4_ARGB_8888;
break;
case 2:
pixFmt = GR_PIXFMT_AA_2_ARGB_8888;
break;
default:
pixFmt = GR_PIXFMT_ARGB_8888;
}
break;
default:
str = "pixelFormat";
goto errorhandler;
}
/* Tips:
* 1. we don't bother setting/checking AUX for stencil, because we'll decide
* later whether we have HW stencil, based on depth buffer (thus AUX is
* properly set)
* 2. when both DEPTH and ALPHA are enabled, depth should win. However, it is
* not clear whether 15bpp and 32bpp require AUX alpha buffer. Furthermore,
* alpha buffering is required only if destination alpha is used in alpha
* blending; alpha blending modes that do not use destination alpha can be
* used w/o alpha buffer.
* 3. `alphaBits' is what we can provide
* `alphaSize' is what app requests
* if we cannot provide enough bits for alpha buffer, we should fallback to
* SW alpha. However, setting `alphaBits' to `alphaSize' might confuse some
* of the span functions...
*/
fxMesa->haveHwAlpha = GL_FALSE;
if (alphaSize && (alphaSize <= alphaBits)) {
alphaSize = alphaBits;
fxMesa->haveHwAlpha = GL_TRUE;
}
fxMesa->haveHwStencil = (fxMesa->HavePixExt && stencilSize && depthSize == 24);
fxMesa->haveZBuffer = depthSize > 0;
fxMesa->haveDoubleBuffer = doubleBuffer;
fxMesa->haveGlobalPaletteTexture = GL_FALSE;
fxMesa->board = glbCurrentBoard;
fxMesa->haveTwoTMUs = (voodoo->nTexelfx > 1);
if ((str = Glide->grGetRegistryOrEnvironmentStringExt("FX_GLIDE_NUM_TMU"))) {
if (atoi(str) <= 1) {
fxMesa->haveTwoTMUs = GL_FALSE;
}
}
if ((str = Glide->grGetRegistryOrEnvironmentStringExt("FX_GLIDE_SWAPPENDINGCOUNT"))) {
fxMesa->maxPendingSwapBuffers = atoi(str);
if (fxMesa->maxPendingSwapBuffers > 6) {
fxMesa->maxPendingSwapBuffers = 6;
} else if (fxMesa->maxPendingSwapBuffers < 0) {
fxMesa->maxPendingSwapBuffers = 0;
}
} else {
fxMesa->maxPendingSwapBuffers = 2;
}
if ((str = Glide->grGetRegistryOrEnvironmentStringExt("FX_GLIDE_SWAPINTERVAL"))) {
fxMesa->swapInterval = atoi(str);
} else {
fxMesa->swapInterval = 0;
}
BEGIN_BOARD_LOCK();
if (fxMesa->HavePixExt) {
fxMesa->glideContext = Glide->grSstWinOpenExt((FxU32)win, res, ref,
GR_COLORFORMAT_ABGR, GR_ORIGIN_LOWER_LEFT,
pixFmt,
2, aux);
} else if (pixFmt == GR_PIXFMT_RGB_565) {
fxMesa->glideContext = grSstWinOpen((FxU32)win, res, ref,
GR_COLORFORMAT_ABGR, GR_ORIGIN_LOWER_LEFT,
2, aux);
} else {
fxMesa->glideContext = 0;
}
END_BOARD_LOCK();
if (!fxMesa->glideContext) {
str = "grSstWinOpen";
goto errorhandler;
}
/* screen */
fxMesa->screen_width = FX_grSstScreenWidth();
fxMesa->screen_height = FX_grSstScreenHeight();
/* window inside screen */
fxMesa->width = fxMesa->screen_width;
fxMesa->height = fxMesa->screen_height;
/* scissor inside window */
fxMesa->clipMinX = 0;
fxMesa->clipMaxX = fxMesa->width;
fxMesa->clipMinY = 0;
fxMesa->clipMaxY = fxMesa->height;
if (fxMesa->verbose) {
FxI32 tmuRam, fbRam;
/* Not that it matters, but tmuRam and fbRam change after grSstWinOpen. */
tmuRam = voodoo->tmuConfig[GR_TMU0].tmuRam;
fbRam = voodoo->fbRam;
BEGIN_BOARD_LOCK();
grGet(GR_MEMORY_TMU, 4, &tmuRam);
grGet(GR_MEMORY_FB, 4, &fbRam);
END_BOARD_LOCK();
fprintf(stderr, "Voodoo Using Glide %s\n", grGetString(GR_VERSION));
fprintf(stderr, "Voodoo Board: %d/%d, %s, %d GPU\n",
fxMesa->board + 1,
glbHWConfig.num_sst,
grGetString(GR_HARDWARE),
voodoo->numChips);
fprintf(stderr, "Voodoo Memory: FB = %ld, TM = %d x %ld\n",
fbRam,
voodoo->nTexelfx,
tmuRam);
fprintf(stderr, "Voodoo Screen: %dx%d:%d %s, %svertex snapping\n",
fxMesa->screen_width,
fxMesa->screen_height,
colDepth,
fxMesa->bgrOrder ? "BGR" : "RGB",
fxMesa->snapVertices ? "" : "no ");
}
sprintf(fxMesa->rendererString, "Mesa %s v0.63 %s%s",
grGetString(GR_RENDERER),
grGetString(GR_HARDWARE),
((fxMesa->type < GR_SSTTYPE_Voodoo4) && (voodoo->numChips > 1)) ? " SLI" : "");
fxMesa->glVis = _mesa_create_visual(GL_TRUE, /* RGB mode */
doubleBuffer,
GL_FALSE, /* stereo */
redBits, /* RGBA.R bits */
greenBits, /* RGBA.G bits */
blueBits, /* RGBA.B bits */
alphaSize, /* RGBA.A bits */
0, /* index bits */
depthSize, /* depth_size */
stencilSize, /* stencil_size */
accumSize,
accumSize,
accumSize,
alphaSize ? accumSize : 0,
1);
if (!fxMesa->glVis) {
str = "_mesa_create_visual";
goto errorhandler;
}
_mesa_init_driver_functions(&functions);
ctx = fxMesa->glCtx = _mesa_create_context(fxMesa->glVis, shareCtx,
&functions, (void *) fxMesa);
if (!ctx) {
str = "_mesa_create_context";
goto errorhandler;
}
if (!fxDDInitFxMesaContext(fxMesa)) {
str = "fxDDInitFxMesaContext";
goto errorhandler;
}
fxMesa->glBuffer = _mesa_create_framebuffer(fxMesa->glVis);
#if 0
/* XXX this is a complete mess :(
* _mesa_add_soft_renderbuffers
* driNewRenderbuffer
*/
GL_FALSE, /* no software depth */
stencilSize && !fxMesa->haveHwStencil,
fxMesa->glVis->accumRedBits > 0,
alphaSize && !fxMesa->haveHwAlpha);
#endif
if (!fxMesa->glBuffer) {
str = "_mesa_create_framebuffer";
goto errorhandler;
}
glbTotNumCtx++;
/* install signal handlers */
#if defined(__linux__)
/* Only install if environment var. is not set. */
if (!getenv("MESA_FX_NO_SIGNALS")) {
signal(SIGINT, cleangraphics_handler);
signal(SIGHUP, cleangraphics_handler);
signal(SIGPIPE, cleangraphics_handler);
signal(SIGFPE, cleangraphics_handler);
signal(SIGBUS, cleangraphics_handler);
signal(SIGILL, cleangraphics_handler);
signal(SIGSEGV, cleangraphics_handler);
signal(SIGTERM, cleangraphics_handler);
}
#endif
return fxMesa;
errorhandler:
if (fxMesa) {
if (fxMesa->glideContext) {
grSstWinClose(fxMesa->glideContext);
fxMesa->glideContext = 0;
}
if (fxMesa->state) {
FREE(fxMesa->state);
}
if (fxMesa->fogTable) {
FREE(fxMesa->fogTable);
}
if (fxMesa->glBuffer) {
_mesa_unreference_framebuffer(&fxMesa->glBuffer);
}
if (fxMesa->glVis) {
_mesa_destroy_visual(fxMesa->glVis);
}
if (fxMesa->glCtx) {
_mesa_destroy_context(fxMesa->glCtx);
}
FREE(fxMesa);
}
fprintf(stderr, "fxMesaCreateContext: ERROR: %s\n", str);
return NULL;
}
void
main( int argc, char **argv)
{
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
long val4[4];
long * histbuffer;
long histsize;
const char * str;
int ret;
int i;
int failures = 0;
int warnings = 0;
GrProc func;
GrContext_t gc = 0;
/* Initialize Glide */
grGlideInit();
assert( hwconfig = tlVoodooType() );
/* Process Command Line Arguments */
tlSetScreen( scrWidth, scrHeight );
version = grGetString( GR_VERSION );
printf("Test 37 - grGet() Stress Test. All output goes to the Console.\n\n");
tlGetCH ();
/* Test the Num Boards Call before we do the win open*/
TestGet("GR_NUM_BOARDS", GR_NUM_BOARDS, 1 , &val4[0], &failures);
grSstSelect( 0 );
gc = grSstWinOpen( tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1 );
if (!gc) {
printf("Could not allocate glide fullscreen context.\n");
goto __errExit;
}
tlConSet( 0.0f, 0.0f, 1.0f, 1.0f,
60, 30, 0xffffff );
/*do the 4 byte grGet()'s*/
TestGet("GR_BITS_DEPTH", GR_BITS_DEPTH, 1 , &val4[0], &failures);
if(val4[0]!=CORRECT_GR_BITS_DEPTH) {
printf("WARNING : Value returned was not not equal to %d\n",CORRECT_GR_BITS_DEPTH);
warnings++;
}
TestGet("GR_BITS_GAMMA", GR_BITS_GAMMA, 1 , &val4[0], &failures);
if(val4[0]<CORRECT_GR_BITS_GAMMA) {
printf("WARNING : Value returned was less than expected\n");
warnings++;
}
TestGet("GR_FOG_TABLE_ENTRIES", GR_FOG_TABLE_ENTRIES, 1 , &val4[0], &failures);
if(val4[0]<CORRECT_GR_FOG_TABLE_ENTRIES) {
printf("WARNING : Value returned was less than expected\n");
warnings++;
}
TestGet("GR_GAMMA_TABLE_ENTRIES", GR_GAMMA_TABLE_ENTRIES, 1 , &val4[0], &failures);
if(val4[0]<CORRECT_GR_GAMMA_TABLE_ENTRIES) {
printf("WARNING : Value returned was less than expected\n");
warnings++;
}
TestGet("GR_IS_BUSY", GR_IS_BUSY, 1 , &val4[0], &failures);
if(val4[0]!=FXTRUE && val4[0]!=FXFALSE) {
printf("WARNING : Value returned was not FXTRUE or FXFALSE\n");
warnings++;
}
TestGet("GR_LFB_PIXEL_PIPE", GR_LFB_PIXEL_PIPE, 1 , &val4[0], &failures);
if(val4[0]!=FXTRUE && val4[0]!=FXFALSE) {
printf("WARNING : Value returned was not FXTRUE or FXFALSE\n");
warnings++;
}
TestGet("GR_MAX_TEXTURE_SIZE", GR_MAX_TEXTURE_SIZE, 1 , &val4[0], &failures);
if(val4[0]<CORRECT_GR_MAX_TEXTURE_SIZE) {
printf("WARNING : Value returned was less than expected\n");
warnings++;
}
TestGet("GR_MAX_TEXTURE_ASPECT_RATIO", GR_MAX_TEXTURE_ASPECT_RATIO, 1 , &val4[0], &failures);
if(val4[0]<CORRECT_GR_MAX_TEXTURE_ASPECT_RATIO) {
printf("WARNING : Value returned was less than expected\n");
warnings++;
}
TestGet("GR_NON_POWER_OF_TWO_TEXTURES", GR_NON_POWER_OF_TWO_TEXTURES, 1 , &val4[0], &failures);
if(val4[0]!=FXTRUE && val4[0]!=FXFALSE) {
printf("WARNING : Value returned was not FXTRUE or FXFALSE\n");
warnings++;
}
TestGet("GR_NUM_FB", GR_NUM_FB, 1 , &val4[0], &failures);
if(val4[0]>CORRECT_GR_NUM_FB) {
printf("WARNING : Value returned was greater than %d\n",CORRECT_GR_NUM_FB);
warnings++;
}
TestGet("GR_NUM_TMU", GR_NUM_TMU, 1 , &val4[0], &failures);
if(val4[0]<CORRECT_GR_NUM_TMU) {
printf("WARNING : Value returned was less than %d\n",CORRECT_GR_NUM_TMU);
warnings++;
}
TestGet("GR_SUPPORTS_PASSTHRU", GR_SUPPORTS_PASSTHRU, 1 , &val4[0], &failures);
if(val4[0]!=FXTRUE && val4[0]!=FXFALSE) {
printf("WARNING : Value returned was not FXTRUE or FXFALSE\n");
warnings++;
}
TestGet("GR_TEXTURE_ALIGN", GR_TEXTURE_ALIGN, 1 , &val4[0], &failures);
if(val4[0]<CORRECT_GR_TEXTURE_ALIGN) {
printf("WARNING : Value returned was less than expected\n");
warnings++;
}
/*Now do the ones we cant verify*/
TestGet("GR_GLIDE_STATE_SIZE", GR_GLIDE_STATE_SIZE, 1 , &val4[0], &failures);
TestGet("GR_GLIDE_VERTEXLAYOUT_SIZE", GR_GLIDE_VERTEXLAYOUT_SIZE, 1 , &val4[0], &failures);
TestGet("GR_MEMORY_FB", GR_MEMORY_FB, 1 , &val4[0], &failures);
TestGet("GR_MEMORY_TMU", GR_MEMORY_TMU, 1 , &val4[0], &failures);
TestGet("GR_MEMORY_UMA", GR_MEMORY_UMA, 1 , &val4[0], &failures);
TestGet("GR_NUM_SWAP_HISTORY_BUFFER", GR_NUM_SWAP_HISTORY_BUFFER, 1 , &val4[0], &failures);
TestGet("GR_PENDING_BUFFERSWAPS", GR_PENDING_BUFFERSWAPS, 1 , &val4[0], &failures);
TestGet("GR_REVISION_FB", GR_REVISION_FB, 1 , &val4[0], &failures);
TestGet("GR_REVISION_TMU", GR_REVISION_TMU, 1 , &val4[0], &failures);
TestGet("GR_STATS_LINES", GR_STATS_LINES, 1 , &val4[0], &failures);
TestGet("GR_STATS_PIXELS_AFUNC_FAIL", GR_STATS_PIXELS_AFUNC_FAIL, 1 , &val4[0], &failures);
TestGet("GR_STATS_PIXELS_CHROMA_FAIL", GR_STATS_PIXELS_CHROMA_FAIL, 1 , &val4[0], &failures);
TestGet("GR_STATS_PIXELS_DEPTHFUNC_FAIL", GR_STATS_PIXELS_DEPTHFUNC_FAIL, 1 , &val4[0], &failures);
TestGet("GR_STATS_PIXELS_IN", GR_STATS_PIXELS_IN, 1 , &val4[0], &failures);
TestGet("GR_STATS_PIXELS_OUT", GR_STATS_PIXELS_OUT, 1 , &val4[0], &failures);
TestGet("GR_STATS_POINTS", GR_STATS_POINTS, 1 , &val4[0], &failures);
TestGet("GR_STATS_TRIANGLES_IN", GR_STATS_TRIANGLES_IN, 1 , &val4[0], &failures);
TestGet("GR_STATS_TRIANGLES_OUT", GR_STATS_TRIANGLES_OUT, 1 , &val4[0], &failures);
/*Now do 8 byte grGet()'s*/
TestGet("GR_WDEPTH_MIN_MAX", GR_WDEPTH_MIN_MAX, 2 , &val4[0], &failures);
if(val4[0]>val4[1]) {
printf("WARNING : Value[0] returned was greater than Value[1]\n");
warnings++;
}
TestGet("GR_ZDEPTH_MIN_MAX", GR_ZDEPTH_MIN_MAX, 2 , &val4[0], &failures);
if(val4[0]<val4[1]) {
printf("WARNING : Value[0] returned was less than Value[1]\n");
warnings++;
}
/*Now do the ones we cant verify*/
TestGet("GR_FIFO_FULLNESS", GR_FIFO_FULLNESS, 2 , &val4[0], &failures);
TestGet("GR_VIDEO_POSITION", GR_VIDEO_POSITION, 2 , &val4[0], &failures);
/* Now do 16 byte grGet()*/
TestGet("GR_BITS_RGBA", GR_BITS_RGBA, 4 , &val4[0], &failures);
if((val4[0]!=CORRECT_GR_BITS_RGBA_R) | (val4[1]!=CORRECT_GR_BITS_RGBA_G) |
(val4[2]!=CORRECT_GR_BITS_RGBA_B) | (val4[3]!=CORRECT_GR_BITS_RGBA_A) ) {
printf("WARNING : Values returned were not in range expected\n");
warnings++;
}
TestGet("GR_VIEWPORT", GR_VIEWPORT, 4 , &val4[0], &failures);
if((val4[0]!=CORRECT_GR_VIEWPORT_X) | (val4[1]!=CORRECT_GR_VIEWPORT_Y) |
(val4[2]!=CORRECT_GR_VIEWPORT_WIDTH) |
(val4[3]!=CORRECT_GR_VIEWPORT_HEIGHT)){
printf("WARNING : Values returned were not in range expected\n");
warnings++;
}
/* Now do the Swap History Test*/
ret = grGet(GR_NUM_SWAP_HISTORY_BUFFER, sizeof(histsize), &histsize );
if(ret==sizeof(histsize)) {
histbuffer = malloc(histsize*sizeof(long));
ret = grGet(GR_SWAP_HISTORY, histsize*sizeof(long), histbuffer );
if(ret==(int)(histsize*sizeof(long)))
printf("Success(%d) - ",ret);
else {
printf("Failed (%d) - ", ret);
failures++;
}
printf("GR_SWAP_HISTORY Result = ");
for(i=0;i<histsize;i++) {
printf("%d ", histbuffer[i]);
}
printf("\n", histbuffer[i]);
free(histbuffer);
} else {
printf("GR_NUM_SWAP_HISTORY_BUFFER failed, so unable to call GR_SWAP_HISTORY\n");
}
/* Now Test The GetString Calls*/
TestGetString("GR_HARDWARE", GR_HARDWARE, &failures);
TestGetString("GR_RENDERER", GR_RENDERER, &failures);
TestGetString("GR_VENDOR", GR_VENDOR, &failures);
TestGetString("GR_VERSION", GR_VERSION, &failures);
TestGetString("GR_EXTENSION", GR_EXTENSION, &failures);
str = grGetString(GR_EXTENSION);
if(strstr(str,"CHROMARANGE")) {
/*try and do the getprocaddress calls for Chromarange*/
func = grGetProcAddress ( "grChromaRangeModeExt");
if(!func) {
printf("GetProcAddress for grChromaRangeModeExt Failed\n");
failures++;
}
func = grGetProcAddress ( "grChromaRangeExt");
if(!func) {
printf("GetProcAddress for grChromaRangeExt Failed\n");
failures++;
}
}
if(strstr(str,"TEXCHROMA")) {
/* try and do the getprocaddress calls for TexChroma*/
func = grGetProcAddress ( "grTexChromaModeExt");
if(!func) {
printf("GetProcAddress for grTexChromaModeExt Failed\n");
failures++;
}
func = grGetProcAddress ( "grTexChromaRangeExt");
if(!func) {
printf("GetProcAddress for grTexChromaRangeExt Failed\n");
failures++;
}
}
if(failures)
printf("\n%d failures encountered during this test\n",failures);
else
printf("\ntesting complete - no failures reported\n");
if(warnings)
printf("%d warnings encountered during this test\n",warnings);
else
printf("testing complete - no warnings reported\n");
__errExit:
grGlideShutdown();
return;
} /* main */
void
main(int argc, char **argv)
{
char match;
char **remArgs;
int rv;
GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
float scrWidth = 640.0f;
float scrHeight = 480.0f;
int frames = -1;
FxBool scrgrab = FXFALSE;
char filename[256];
FxU8 subframe = 0;
TlTexture texture;
FxU32 zrange[2];
GrContext_t gc = 0;
FxU32 pixelformat = 0x0003; /* 16 bit 565 */
static FxBool useCCExt = 1;
char textureFile[256];
int bigTex = 0;
FxBool needToLoadNewTexture = FXFALSE;
FxBool umaIsEnabled = FXFALSE;
float
xLeft,
xRight,
yTop,
yBottom;
/* Process Command Line Arguments */
while(rv = tlGetOpt(argc, argv, "nrdxp", &match, &remArgs)) {
if (rv == -1) {
printf("Unrecognized command line argument\n");
printf("%s %s\n", name, usage);
printf("Available resolutions:\n%s\n",
tlGetResolutionList());
return;
}
switch(match) {
case 'n':
frames = atoi(remArgs[0]);
break;
case 'r':
resolution = tlGetResolutionConstant(remArgs[0],
&scrWidth,
&scrHeight);
break;
case 'd':
scrgrab = FXTRUE;
frames = 5;
strcpy(filename, remArgs[0]);
break;
case 'p':
pixelformat = tlGetPixelFormat( remArgs[0] );
break;
}
}
tlSetScreen(scrWidth, scrHeight);
version = grGetString(GR_VERSION);
printf("%s:\n%s\n", name, purpose);
printf("%s\n", version);
printf("Resolution: %s\n", tlGetResolutionString(resolution));
if (frames == -1) {
printf("Press A Key To Begin Test.\n");
tlGetCH();
}
/* Initialize Glide */
grGlideInit();
assert(hwconfig = tlVoodooType());
grGet(GR_ZDEPTH_MIN_MAX, 8, (FxI32 *)zrange);
grSstSelect(0);
tlInitGlideExt(&glideext);
if (!glideext.combineext) {
printf("Could not use COMBINE extension.\n");
useCCExt = 0;
}
if (glideext.canDo32BitTexture) {
printf("Using TEXFMT 32-bit extension.\n");
strcpy(textureFile, "t256x32.3df"); /* 32 bits deep */
} else {
printf("Could not use TEXFMT 32-bit extension.\n");
strcpy(textureFile, "miro.3df"); /* 16 bits deep */
}
if (glideext.umaExt) {
printf("Using TEXUMA extension.\n");
grEnable(GR_TEXTURE_UMA_EXT);
umaIsEnabled = FXTRUE;
} else {
printf("Could not use TEXUMA extension.\n");
grDisable(GR_TEXTURE_UMA_EXT);
umaIsEnabled = FXFALSE;
}
if (glideext.grSstWinOpen) {
gc = glideext.grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
pixelformat,
2, 1);
} else {
gc = grSstWinOpen(tlGethWnd(),
resolution,
GR_REFRESH_60Hz,
GR_COLORFORMAT_ABGR,
GR_ORIGIN_UPPER_LEFT,
2, 1);
}
if (!gc) {
printf("Could not allocate glide fullscreen context.\n");
goto __errExit;
}
tlVertexLayout();
tlConSet(0.0f, 0.0f, 1.0f, 0.5f,
60, 15, 0xffffff);
/* Load texture data into system ram */
assert(tlLoadTexture(textureFile,
&texture.info,
&texture.tableType,
&texture.tableData));
/* Download texture data to TMU */
grTexDownloadMipMap(GR_TMU0,
grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
if (texture.tableType != NO_TABLE) {
grTexDownloadTable(texture.tableType,
&texture.tableData);
}
/* Select Texture As Source of all texturing operations */
grTexSource(GR_TMU0,
grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
/* Enable Bilinear Filtering + Mipmapping */
grTexFilterMode(GR_TMU0,
GR_TEXTUREFILTER_BILINEAR,
GR_TEXTUREFILTER_BILINEAR);
grTexMipMapMode(GR_TMU0,
GR_MIPMAP_NEAREST,
FXFALSE);
xLeft = tlScaleX( 0.2f );
xRight = tlScaleX( 0.8f );
yTop = tlScaleY( 0.2f );
yBottom = tlScaleY( 0.8f );
while(frames-- && tlOkToRender()) {
GrVertex vtxA, vtxB, vtxC, vtxD;
static TextureMode textureMode;
if (hwconfig == TL_VOODOORUSH) {
tlGetDimsByConst(resolution,
&scrWidth,
&scrHeight);
grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
}
grBufferClear(0x00, 0, zrange[1]);
tlConOutput( "m : change lighting mode\n");
tlConOutput( "e : toggle combine extension\n");
tlConOutput( "b : big textures (if TEXFMT extension is available)\n");
tlConOutput( "u : toggle UMA (if TEXUMA extension is available)\n");
tlConOutput("Press any other key to quit\n");
tlConOutput("Current Texture Mode: %s\n", textureModeNames[textureMode]);
tlConOutput("COMBINE extension %s\n", cmodeName[useCCExt]);
if (needToLoadNewTexture) {
/*
* This is only true if TEXFMT extension is available, which
* implies 2k texture capability. Also, this is only true if
* the user has just hit 'b' for big texture testing.
*/
assert(bigTex <= TEX_MAX);
strcpy(textureFile, texFileNames[bigTex]);
/* Redo all the texture loading stuff. */
/* Load texture data into system ram */
assert(tlLoadTexture(textureFile, &texture.info, &texture.tableType,
&texture.tableData));
/* Download texture data to TMU */
grTexDownloadMipMap(GR_TMU0, grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH, &texture.info);
if (texture.tableType != NO_TABLE) {
grTexDownloadTable(texture.tableType, &texture.tableData);
}
/* Select Texture As Source of all texturing operations */
grTexSource(GR_TMU0, grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH, &texture.info);
needToLoadNewTexture = FXFALSE;
}
if (useCCExt) {
#ifdef FX_GLIDE_NAPALM
glideext.grTexColorCombineExt(GR_TMU0,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_LOCAL_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ZERO, FXFALSE,
GR_CMBX_B, FXFALSE,
0, FXFALSE);
switch(textureMode) {
case DECAL:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_ZERO, FXTRUE,
GR_CMBX_ZERO, FXFALSE,
0, FXFALSE);
break;
case FLATLIT:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_CONSTANT_COLOR, FXFALSE,
GR_CMBX_ZERO, FXFALSE,
0, FXFALSE);
break;
case RGBLIT:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_ITRGB, FXFALSE,
GR_CMBX_ZERO, FXFALSE,
0, FXFALSE);
break;
case WHITELIT:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ITALPHA, GR_FUNC_MODE_ZERO,
GR_CMBX_B, FXFALSE,
GR_CMBX_ZERO, FXFALSE,
0, FXFALSE);
glideext.grAlphaCombineExt(GR_CMBX_ITALPHA, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_ZERO, FXTRUE,
GR_CMBX_ALOCAL, FXFALSE,
0, FXFALSE);
break;
case SPECALPHA:
glideext.grColorCombineExt(GR_CMBX_TEXTURE_RGB, GR_FUNC_MODE_X,
GR_CMBX_ITALPHA, GR_FUNC_MODE_ZERO,
GR_CMBX_ITRGB, FXFALSE,
GR_CMBX_B, FXFALSE,
0, FXFALSE);
glideext.grAlphaCombineExt(GR_CMBX_ITALPHA, GR_FUNC_MODE_X,
GR_CMBX_ZERO, GR_FUNC_MODE_X,
GR_CMBX_ZERO, FXTRUE,
GR_CMBX_ALOCAL, FXFALSE,
0, FXFALSE);
break;
}
#endif
}
else {
/* Set up Render State - Decal Texture - color combine set in render loop */
grTexCombine(GR_TMU0,
GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_FUNCTION_NONE,
GR_COMBINE_FACTOR_NONE,
FXFALSE, FXFALSE);
switch(textureMode) {
case DECAL:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
case FLATLIT:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
case RGBLIT:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
case WHITELIT:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL_ALPHA,
GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
grAlphaCombine(GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
case SPECALPHA:
grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL_ALPHA,
GR_COMBINE_FACTOR_LOCAL,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
grAlphaCombine(GR_COMBINE_FUNCTION_LOCAL,
GR_COMBINE_FACTOR_NONE,
GR_COMBINE_LOCAL_ITERATED,
GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
break;
}
}
/*----
A-B
|\|
C-D
-----*/
vtxA.oow = 1.0f;
vtxB = vtxC = vtxD = vtxA;
vtxA.x = vtxC.x = xLeft;
vtxB.x = vtxD.x = xRight;
vtxA.y = vtxB.y = yTop;
vtxC.y = vtxD.y = yBottom;
vtxA.tmuvtx[0].sow = vtxC.tmuvtx[0].sow = 0.0f;
vtxB.tmuvtx[0].sow = vtxD.tmuvtx[0].sow = 255.0f;
vtxA.tmuvtx[0].tow = vtxB.tmuvtx[0].tow = 0.0f;
vtxC.tmuvtx[0].tow = vtxD.tmuvtx[0].tow = 255.0f;
vtxA.r = 255.0f, vtxA.g = 0.0f, vtxA.b = 0.0f, vtxA.a = 255.0f;
vtxB.r = 0.0f, vtxB.g = 255.0f, vtxB.b = 0.0f, vtxB.a = 128.0f;
vtxC.r = 0.0f, vtxC.g = 0.0f, vtxC.b = 255.0f, vtxC.a = 128.0f;
vtxD.r = 0.0f, vtxD.g = 0.0f, vtxD.b = 0.0f, vtxD.a = 0.0f;
grConstantColorValue(0xFF0000FFUL);
grTexSource(GR_TMU0,
grTexMinAddress(GR_TMU0),
GR_MIPMAPLEVELMASK_BOTH,
&texture.info);
grDrawTriangle(&vtxA, &vtxD, &vtxC);
grDrawTriangle(&vtxA, &vtxB, &vtxD);
tlConRender();
tlConClear();
grBufferSwap(1);
grFinish();
/* grab the frame buffer */
if (scrgrab) {
char fname[256], tmp[32];
FxU16 cnt;
cnt = strcspn(filename, ".");
strncpy(fname, filename, cnt);
fname[cnt] = 0;
sprintf(tmp,"_%d\0", subframe);
strcat(fname, tmp);
strcat(fname, filename+cnt);
if (!tlScreenDump(fname, (FxU16)scrWidth, (FxU16)scrHeight))
printf("Cannot open %s\n", filename);
/* cycle through all mode */
textureMode++;
if (textureMode > SPECALPHA) textureMode = DECAL;
subframe++;
}
while(tlKbHit()) {
const char curKey = tlGetCH();
switch(curKey) {
case 'e':
case 'E':
useCCExt = (!useCCExt);
if (!glideext.combineext)
useCCExt = 0;
break;
case 'm':
case 'M':
textureMode++;
if (textureMode > SPECALPHA) textureMode = DECAL;
break;
case 'b':
case 'B':
/* Cycle through some texture sizes */
if (glideext.canDo2kTexture) {
needToLoadNewTexture = FXTRUE;
bigTex = (bigTex + 1) % (TEX_MAX + 1); /* [0,...,TEX_MAX] */
printf ("%s", texWidthString[bigTex]);
}
break;
case 'u':
case 'U':
if (glideext.umaExt) {
/* Toggle UMA on/off */
if (umaIsEnabled) {
grDisable(GR_TEXTURE_UMA_EXT);
printf ("UMA extension is disabled.\n");
umaIsEnabled = FXFALSE;
} else {
grEnable(GR_TEXTURE_UMA_EXT);
printf ("UMA extension is enabled.\n");
umaIsEnabled = FXTRUE;
}
}
break;
default:
frames = 0;
break;
}
}
}
__errExit:
grGlideShutdown();
}
