コード例 #1
0
ファイル: test35.c プロジェクト: grakidov/Render3D
void main( int argc, char **argv) {
    char match; 
    char **remArgs;
    int  rv;

    GrScreenResolution_t resolution = GR_RESOLUTION_640x480;
    float                scrWidth   = 640.0f;
    float                scrHeight  = 480.0f;
    int frames                      = -1;
    FxBool               scrgrab = FXFALSE;
    char                 filename[256];
    int                  ftsize = 0;

    TlTexture  baseTexture;
    unsigned long baseTextureAddr;
    GrVertex vtxA, vtxB, vtxC, vtxD;
    FxBool texchroma = FXFALSE;
    char *extstr;

    GrProc grTexChromaModeExt = NULL;
    GrProc grTexChromaRangeExt = NULL;
    GrColor_t min = 0x00, max = 0x007f7f7f;
    FxU8 mincolor = 0x00;
    FxU8 maxcolor = 0x7f;
    FxFloat red = 1.7f, green = 1.7f, blue = 1.7f;

    /* Process Command Line Arguments */
    while( rv = tlGetOpt( argc, argv, "nrd", &match, &remArgs ) ) {
        if ( rv == -1 ) {
            printf( "Unrecognized command line argument\n" );
            printf( "%s %s\n", name, usage );
            printf( "Available resolutions:\n%s\n",
                    tlGetResolutionList() );
            return;
        }
        switch( match ) {
        case 'n':
            frames = atoi( remArgs[0] );
            break;
        case 'r':
            resolution = tlGetResolutionConstant( remArgs[0], 
                                                  &scrWidth, 
                                                  &scrHeight );
            break;
        case 'd':
            scrgrab = FXTRUE;
            frames = 1;
            strcpy(filename, remArgs[0]);
            break;
        }
    }

    tlSetScreen( scrWidth, scrHeight );

    version = grGetString( GR_VERSION );

    printf( "%s:\n%s\n", name, purpose );
    printf( "%s\n", version );
    printf( "Resolution: %s\n", tlGetResolutionString( resolution ) );
    if ( frames == -1 ) {
        printf( "Press A Key To Begin Test.\n" );
        tlGetCH();
    }
    
    /* Initialize Glide */
    grGlideInit();
    assert( hwconfig = tlVoodooType() );

    grSstSelect( 0 );
    assert( grSstWinOpen( 0,
                      resolution,
                      GR_REFRESH_60Hz,
                      GR_COLORFORMAT_ABGR,
                      GR_ORIGIN_UPPER_LEFT,
                      2, 1 ) );
    
    tlConSet( 0.0f, 0.0f, 1.0f, 1.0f, 
              60, 30, 0xffffff );

    grVertexLayout(GR_PARAM_XY,  GR_VERTEX_X_OFFSET << 2, GR_PARAM_ENABLE);
    grVertexLayout(GR_PARAM_Q,   GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
    grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);

    grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
                    GR_COMBINE_FACTOR_ONE,
                    GR_COMBINE_LOCAL_NONE,
                    GR_COMBINE_OTHER_TEXTURE,
                    FXFALSE );
    grTexMipMapMode( GR_TMU0,
                     GR_MIPMAP_NEAREST,
                     FXFALSE );
    grTexFilterMode( GR_TMU0,
                     GR_TEXTUREFILTER_BILINEAR,
                     GR_TEXTUREFILTER_BILINEAR );

    {
      /*
      ** texChroma extension
      */
      extension = grGetString(GR_EXTENSION);

      extstr = strstr(extension, "CHROMARANGE");
      if (!strncmp(extstr, "CHROMARANGE", 11)) {
        grTexChromaModeExt = grGetProcAddress("grTexChromaModeExt");
        grTexChromaRangeExt = grGetProcAddress("grTexChromaRangeExt");
      }
      grTexChromaModeExt(GR_TMU0, GR_TEXCHROMA_DISABLE_EXT);
      grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
    }

    assert( tlLoadTexture( "miro.3df", 
                           &baseTexture.info, 
                           &baseTexture.tableType, 
                           &baseTexture.tableData ) );
    /* Download texture data to TMU */
    baseTextureAddr = grTexMinAddress( GR_TMU0 );
    grTexDownloadMipMap( GR_TMU0,
                         baseTextureAddr,
                         GR_MIPMAPLEVELMASK_BOTH,
                         &baseTexture.info );
    if ( baseTexture.tableType != NO_TABLE ) {
        grTexDownloadTable( baseTexture.tableType,
                            &baseTexture.tableData );
    }
    grTexCombine( GR_TMU0,
                  GR_COMBINE_FUNCTION_LOCAL,
                  GR_COMBINE_FACTOR_NONE,
                  GR_COMBINE_FUNCTION_LOCAL,
                  GR_COMBINE_FACTOR_NONE,
                  FXFALSE,
                  FXFALSE );
    grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_ZERO,
                          GR_BLEND_ONE, GR_BLEND_ZERO );
    grTexSource( GR_TMU0,
                 baseTextureAddr,
                 GR_MIPMAPLEVELMASK_BOTH,
                 &baseTexture.info );
    grTexClampMode( GR_TMU0, GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP);

    {
      vtxA.x = tlScaleX( 0.2f );
      vtxA.y = tlScaleY( 0.2f );
      vtxA.oow = 1.0f;
      
      vtxB.x = tlScaleX( 0.8f );
      vtxB.y = tlScaleY( 0.2f ); 
      vtxB.oow = 1.0f;
      
      vtxC.x = tlScaleX( 0.2f );
      vtxC.y = tlScaleY( 0.8f );
      vtxC.oow = 1.0f;
      
      vtxD.x = tlScaleX( 0.8f ); 
      vtxD.y = tlScaleY( 0.8f );
      vtxD.oow = 1.0f;
      
      vtxA.tmuvtx[0].sow = 0.f;
      vtxA.tmuvtx[0].tow = 0.f;
      
      vtxB.tmuvtx[0].sow = 255.f;
      vtxB.tmuvtx[0].tow = 0.f;
      
      vtxC.tmuvtx[0].sow = 0.f;
      vtxC.tmuvtx[0].tow = 255.f;
      
      vtxD.tmuvtx[0].sow = 255.f;
      vtxD.tmuvtx[0].tow = 255.f;
    }
    
    tlConOutput( "Press a key to quit\n" );
    tlConOutput( "Press c to turn on/off texture chroma\n" );
    tlConOutput( "Press {/} to change max color range\n" );
    tlConOutput( "Press [/] to change min color range\n" );
    while( frames-- && tlOkToRender()) {
      char string[256], tmpstr[64];

      if (texchroma)
        strcpy(string, "");
      else
        strcpy(string, "");
      sprintf(tmpstr, " (%x,%x,%x) (%x,%x,%x) (%f %f %f)   \r", mincolor, mincolor, mincolor, maxcolor, maxcolor, maxcolor,red,green,blue);
      strcat(string, tmpstr);

      tlConOutput( string );

      if (hwconfig == TL_VOODOORUSH) {
        tlGetDimsByConst(resolution,
                         &scrWidth, 
                         &scrHeight );
        
        grClipWindow(0, 0, (FxU32) scrWidth, (FxU32) scrHeight);
      }

      grBufferClear( 0x3f3f3f, 0, 0 );
      
      grDrawTriangle( &vtxA, &vtxB, &vtxD );
      grDrawTriangle( &vtxA, &vtxD, &vtxC );
      
      tlConRender();
      grBufferSwap( 1 );
      
      /* grab the frame buffer */
      if (scrgrab) {
        if (!tlScreenDump(filename, (FxU16)scrWidth, (FxU16)scrHeight))
          printf( "Cannot open %s\n", filename);
        scrgrab = FXFALSE;
      }
      
      while( tlKbHit() ) {
        switch( tlGetCH() ) {
        case 'r':
          red -= 0.1f;
          guGammaCorrectionRGB(red, green, blue);
          break;
        case 'R':
          red += 0.1f;
          guGammaCorrectionRGB(red, green, blue);
          break;
        case 'g':
          green -= 0.1f;
          guGammaCorrectionRGB(red, green, blue);
          break;
        case 'G':
          green += 0.1f;
          guGammaCorrectionRGB(red, green, blue);
          break;
        case 'b':
          blue -= 0.1f;
          guGammaCorrectionRGB(red, green, blue);
          break;
        case 'B':
          blue += 0.1f;
          guGammaCorrectionRGB(red, green, blue);
          break;
        case 'c':
        case 'C':
          texchroma = !texchroma;
          if (texchroma)
            grTexChromaModeExt(GR_TMU0, GR_TEXCHROMA_ENABLE_EXT);
          else
            grTexChromaModeExt(GR_TMU0, GR_TEXCHROMA_DISABLE_EXT);
          break;
        case '{':
          if ((maxcolor > 0x00) && (maxcolor > mincolor))
            maxcolor--;
          max = (maxcolor << 16) | (maxcolor << 8) | maxcolor;
          grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
          break;
        case '}':
          if (maxcolor < 0xff)
            maxcolor++;
          max = (maxcolor << 16) | (maxcolor << 8) | maxcolor;
          grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
          break;
        case '[':
          if (mincolor > 0x00)
            mincolor--;
          min = (mincolor << 16) | (mincolor << 8) | mincolor;
          grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
          break;
        case ']':
          if ((mincolor < 0xff) && (mincolor < maxcolor))
            mincolor++;
          min = (mincolor << 16) | (mincolor << 8) | mincolor;
          grTexChromaRangeExt(0, min, max, GR_TEXCHROMARANGE_RGB_ALL_EXT);
          break;
        default:
          frames = 0;
          break;
        }
      }
    }
    
    grGlideShutdown();
    return;
}
コード例 #2
0
ファイル: glide.cpp プロジェクト: alesegdia/snes-sdk
static void S9xGlideInitTextures ()
{
    grColorCombine (GR_COMBINE_FUNCTION_SCALE_OTHER,
		    GR_COMBINE_FACTOR_ONE,
		    GR_COMBINE_LOCAL_NONE,
		    GR_COMBINE_OTHER_TEXTURE,
		    FXFALSE);

    grTexCombine (GR_TMU0,
		  GR_COMBINE_FUNCTION_LOCAL,
		  GR_COMBINE_FACTOR_NONE,
		  GR_COMBINE_FUNCTION_NONE,
		  GR_COMBINE_FACTOR_NONE,
		  FXFALSE, 
		  FXFALSE);

    grTexMipMapMode (GR_TMU0,
		     GR_MIPMAP_DISABLE,
		     FXFALSE);

    grTexClampMode (GR_TMU0,
		    GR_TEXTURECLAMP_CLAMP,
		    GR_TEXTURECLAMP_CLAMP);

    grTexFilterMode (GR_TMU0, 
		     GR_TEXTUREFILTER_BILINEAR,
		     GR_TEXTUREFILTER_BILINEAR);

    /* XXX: trilinear */
    grTexCombine (GR_TMU0,
                  GR_COMBINE_FUNCTION_BLEND_LOCAL,
                  GR_COMBINE_FACTOR_LOD_FRACTION,
                  GR_COMBINE_FUNCTION_BLEND_LOCAL,
                  GR_COMBINE_FACTOR_LOD_FRACTION,
                  FXFALSE,
                  FXFALSE);

    texture_info.smallLod = GR_LOD_256;
    texture_info.largeLod = GR_LOD_256;
    texture_info.aspectRatio = GR_ASPECT_1x1;
    texture_info.format = GR_TEXFMT_RGB_565;

    Glide.texture.smallLod = GR_LOD_8;
    Glide.texture.largeLod = GR_LOD_8;
    Glide.texture.aspectRatio = GR_ASPECT_1x1;
    Glide.texture.format = GR_TEXFMT_RGB_565;
    Glide.texture_mem_size = grTexTextureMemRequired (GR_MIPMAPLEVELMASK_BOTH,
						      &Glide.texture);
    Glide.texture_mem_start = grTexMinAddress (GR_TMU0);

    int texture_mem_size = grTexTextureMemRequired (GR_MIPMAPLEVELMASK_BOTH,
						    &texture_info);
    int address = grTexMinAddress (GR_TMU0);

    // At maximum SNES resolution (512x478) four seperate Voodoo textures will
    // be needed since the maximum texture size on Voodoo cards is 256x256.
    
    for (int t = 0; t < 4; t++)
    {
	texture_mem_start [t] = address;
	address += texture_mem_size;
    }
    
    texture_download_buffer = (uint16 *) malloc (texture_mem_size);

    for (int i = 0; i < 4; i++)
    {
	Glide.sq [i].oow = 1.0;
	Glide.sq [i].ooz = 65535.0;
	Glide.sq [i].tmuvtx [0].oow = 1.0;
    }

    Glide.x_offset = 0.0;
    Glide.y_offset = 0.0;
    // XXX: Do this when the SNES screen resolution is known.
    Glide.x_scale = Glide.voodoo_width * 8.0 / 256;
    Glide.y_scale = Glide.voodoo_height * 8.0 / 224;
}
コード例 #3
0
ファイル: test22.c プロジェクト: grakidov/Render3D
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;
}
コード例 #4
0
ファイル: TEST39.C プロジェクト: grakidov/Render3D
void main( int argc, char *argv[] ) {
    
    /*------------------------------------------------------------------
      Data
      ------------------------------------------------------------------*/
    char texFile[256];
    char texFile_2[256];

    FxU32        startAddress,nextAddress;
    FxU32        startAddress_2, nextAddress_2;
    GrTexInfo    texInfo, texInfo_2;
    Gu3dfInfo    info, info_2;
    GuNccTable   nccTable, nccTable_2;
    GuTexPalette pal, pal_2;
    FxBool       hasTable   = FXFALSE,
                 hasTable_2 = FXFALSE;
    FxBool       hasPalette = FXFALSE,
                 hasPalette_2 = FXFALSE;
    FxU32        numTmus = 1;
    FxU32        automate;
    FxU32        numFrames = -1;
    /*------------------------------------------------------------------
      Glide State Initialization 
      ------------------------------------------------------------------*/
    grGlideInit();
    grSstQueryHardware( &hwConfig );
    grSstSelect( 0 );
    grSstOpen( screenRes,
               GR_REFRESH_60Hz,
               GR_COLORFORMAT_ABGR,
               GR_ORIGIN_LOWER_LEFT,
               GR_SMOOTHING_ENABLE,
               2 );
    grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
                    GR_COMBINE_FACTOR_ONE,
                    GR_COMBINE_LOCAL_NONE,
                    GR_COMBINE_OTHER_TEXTURE,
                    FXFALSE );
    grAlphaCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
                    GR_COMBINE_FACTOR_ONE,
                    GR_COMBINE_LOCAL_NONE,
                    GR_COMBINE_OTHER_TEXTURE,
                    FXFALSE );
    grTexCombine( GR_TMU0,
                  GR_COMBINE_FUNCTION_LOCAL,
                  GR_COMBINE_FACTOR_ZERO,
                  GR_COMBINE_FUNCTION_LOCAL,
                  GR_COMBINE_FACTOR_ZERO,
                  FXFALSE,
                  FXFALSE );

    if ( hwConfig.SSTs[0].sstBoard.VoodooConfig.nTexelfx == 2 ) {
        printf( "Detected 2 TMUs\n" );
        grTexCombine( GR_TMU1,
                      GR_COMBINE_FUNCTION_LOCAL,
                      GR_COMBINE_FACTOR_ZERO,
                      GR_COMBINE_FUNCTION_LOCAL,
                      GR_COMBINE_FACTOR_ZERO,
                      FXFALSE,
                      FXFALSE );
         numTmus = 2;
    }

    /*------------------------------------------------------------------
      Deal With Arguments
      ------------------------------------------------------------------*/
    if ( numTmus == 1 ) {
        if ( argc < 2 ) {
            puts( usage_1tmu );
            grGlideShutdown();
            return;        
        }
        else
        {
          if(strstr(argv[1], "-n"))
          {
            automate = 1;
	    numFrames = atoi(argv[2]);
            if(argc >= 4)  
              strcpy( texFile, argv[3] );    
            else
            {
              puts( usage_1tmu );
              grGlideShutdown();
              return;        
            }
          }
          else
          {
            strcpy( texFile, argv[1] );    
            if(argc > 3)
              if(strstr(argv[2], "-n"))
	      {
                automate = 1;
		numFrames = atoi(argv[3]);
	      }
              else 
              {
                puts( usage_1tmu );
                grGlideShutdown();
                return;    
              }    
          }
        } 
    }
    else
    {
      if(argc >= 3)
      {
	if(strstr(argv[1], "-n"))
	{
	  automate = 1;
	  if(argc >= 5)  
	  {
	    strcpy( texFile, argv[3] );    
	    strcpy( texFile_2, argv[4] );    
	  }
	  else
	  {
	    puts( usage_2tmu );
	    grGlideShutdown();
	    return;        
	  }
	}
	else
	{
	  strcpy( texFile, argv[1] );    
	  strcpy( texFile_2, argv[2] );    
	  if(argc >= 4)
	    if(strstr(argv[3], "-n"))
	      automate = 1;
	    else 
	    {
	      puts( usage_2tmu );
	      grGlideShutdown();
	      return;    
	    }    
	}
      }
      else
      {
	puts( usage_2tmu );
	grGlideShutdown();
	return;    
      }    
    }
    
    grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_ZERO,
                          GR_BLEND_ONE, GR_BLEND_ZERO );

    grDepthBufferMode( GR_DEPTHBUFFER_DISABLE );
    grDepthBufferFunction( GR_CMP_LEQUAL );
    grDepthMask( FXFALSE );

    grCullMode( GR_CULL_DISABLE );

    grBufferClear( 0x0, 0x0, 0x0 );

    /*------------------------------------------------------------------
      Load Texture(s)
      ------------------------------------------------------------------*/
    if ( !gu3dfGetInfo( texFile, &info ) ) {
        printf( "Couldn't load %s.\n", texFile );
        return;
    }
    info.data = calloc( info.mem_required, 1 );
    gu3dfLoad( texFile, &info );

    texInfo.smallLod    = info.header.small_lod;
    texInfo.largeLod    = info.header.large_lod;
    texInfo.aspectRatio = info.header.aspect_ratio;
    texInfo.format      = info.header.format;
    texInfo.data        = info.data;

    if ( texInfo.format == GR_TEXFMT_YIQ_422 ||
         texInfo.format == GR_TEXFMT_AYIQ_8422 ) {
        puts( "*******************YIQ TEXTURE(TMU0)***************" );
        nccTable = info.table.nccTable;
        hasTable = FXTRUE;
    }

    if ( texInfo.format == GR_TEXFMT_P_8 ||
         texInfo.format == GR_TEXFMT_AP_88 ) {
        puts( "*******************PAL TEXTURE(TMU0)***************" );
        pal = info.table.palette;
        hasPalette = FXTRUE;
    }

    if ( numTmus == 2 ) {
        if ( !gu3dfGetInfo( texFile_2, &info_2 ) ) {
            printf( "Couldn't load %s.\n", texFile_2 );
            return;
        }
        info_2.data = calloc( info_2.mem_required, 1 );
        gu3dfLoad( texFile_2, &info_2 );
    
        texInfo_2.smallLod    = info_2.header.small_lod;
        texInfo_2.largeLod    = info_2.header.large_lod;
        texInfo_2.aspectRatio = info_2.header.aspect_ratio;
        texInfo_2.format      = info_2.header.format;
        texInfo_2.data        = info_2.data;
    
        if ( texInfo_2.format == GR_TEXFMT_YIQ_422 ||
             texInfo_2.format == GR_TEXFMT_AYIQ_8422 ) {
            puts( "*******************YIQ TEXTURE(TMU1)***************" );
            nccTable_2 = info_2.table.nccTable;
            hasTable_2 = FXTRUE;
        }
        if ( texInfo_2.format == GR_TEXFMT_P_8 ||
             texInfo_2.format == GR_TEXFMT_AP_88 ) {
            puts( "*******************PAL TEXTURE(TMU1)***************" );
            pal_2 = info_2.table.palette;
            hasPalette_2 = FXTRUE;
        }
    }


    /*------------------------------------------------------------------
      Allocate Texture RAM
      ------------------------------------------------------------------*/
    startAddress =  nextAddress = grTexMinAddress( GR_TMU0 );
    nextAddress  = startAddress + grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH,
                                                           &texInfo );

    printf( "tex0: startAddress: %d nextAddress %d\n", startAddress, nextAddress );

    if ( nextAddress > grTexMaxAddress( GR_TMU0 ) ) {
        printf( "Texture memory exhausted.\n" );
        return;
    }

    if ( numTmus == 2 ) {
        startAddress_2 =  nextAddress_2 = grTexMinAddress( GR_TMU1 );
        nextAddress_2  = startAddress_2 + 
                         grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH,
                                                  &texInfo_2 );
        printf( "tex1: startAddress: %d nextAddress %d\n", startAddress_2, nextAddress_2 );
    }

    /*------------------------------------------------------------------
      Download Texture(s)
      ------------------------------------------------------------------*/
    grTexDownloadMipMap( GR_TMU0,
                         startAddress,
                         GR_MIPMAPLEVELMASK_BOTH,
                         &texInfo );
    if ( hasTable ) {
        grTexNCCTable( GR_TMU0, GR_NCCTABLE_NCC1 );
        grTexDownloadTable( GR_TMU0,
                            GR_TEXTABLE_NCC1,
                            &nccTable );
    }
    if ( hasPalette ) {
        grTexDownloadTable( GR_TMU0,
                            GR_TEXTABLE_PALETTE,
                            &pal );
    }

    if ( numTmus == 2 ) {
        grTexDownloadMipMap( GR_TMU1,
                             startAddress_2,
                             GR_MIPMAPLEVELMASK_BOTH,
                             &texInfo_2 );
        if ( hasTable_2 ) {
            grTexNCCTable( GR_TMU1, GR_NCCTABLE_NCC0 );
            grTexDownloadTable( GR_TMU1,
                                GR_TEXTABLE_NCC0,
                                &nccTable_2 );
        }

        if ( hasPalette_2 ) {
            grTexDownloadTable( GR_TMU1,
                                GR_TEXTABLE_PALETTE,
                                &pal_2 );
        }
    }

    /*------------------------------------------------------------------
      Set up Texture Params and Set Texture As Current
      ------------------------------------------------------------------*/
    grTexFilterMode( GR_TMU0,
                     GR_TEXTUREFILTER_BILINEAR, 
                     GR_TEXTUREFILTER_BILINEAR );
    grTexClampMode( GR_TMU0,
                    GR_TEXTURECLAMP_WRAP,
                    GR_TEXTURECLAMP_WRAP );
    grTexMipMapMode( GR_TMU0,
                     GR_MIPMAP_NEAREST,
                     FXFALSE );
    grTexSource( GR_TMU0,
                 startAddress,
                 GR_MIPMAPLEVELMASK_BOTH,
                 &texInfo );

    if ( numTmus == 2 ) {
        grTexFilterMode( GR_TMU1,
                         GR_TEXTUREFILTER_BILINEAR, 
                         GR_TEXTUREFILTER_BILINEAR );
        grTexClampMode( GR_TMU1,
                        GR_TEXTURECLAMP_WRAP,
                        GR_TEXTURECLAMP_WRAP );
        grTexMipMapMode( GR_TMU1,
                         GR_MIPMAP_NEAREST,
                         FXFALSE );
        grTexSource( GR_TMU1,
                     startAddress_2,
                     GR_MIPMAPLEVELMASK_BOTH, 
                     &texInfo_2 );
    }


    /*------------------------------------------------------------------
      Render Triangles
      ------------------------------------------------------------------*/

    puts("TEST39:\n");
    puts("Tests the grTex routines\n");
    if(!automate)
    {
      puts("Press any key to continue\n");
      getch();
    }
    while(numFrames)
    {
      square(    0.0f,   0.0f, 256.0f, 256.0f );
      square(  255.0f,   0.0f, 128.0f, 128.0f );
      square(  382.0f,   0.0f,  64.0f,  64.0f );
      square(  445.0f,   0.0f,  32.0f,  32.0f );
      square(  476.0f,   0.0f,  16.0f,  16.0f );
      square(  491.0f,   0.0f,   8.0f,   8.0f );
      square(  498.0f,   0.0f,   4.0f,   4.0f );
      square(  501.0f,   0.0f,   2.0f,   2.0f );
      square(  502.0f,   0.0f,   1.0f,   1.0f );


      if ( numTmus == 2 ) {
        grTexCombine( GR_TMU0,
                      GR_COMBINE_FUNCTION_SCALE_OTHER,
                      GR_COMBINE_FACTOR_ONE,
                      GR_COMBINE_FUNCTION_SCALE_OTHER,
                      GR_COMBINE_FACTOR_ONE,
                      FXFALSE,
                      FXFALSE );
	
        grTexCombine( GR_TMU1,
                      GR_COMBINE_FUNCTION_LOCAL,
                      GR_COMBINE_FACTOR_ZERO,
                      GR_COMBINE_FUNCTION_LOCAL,
                      GR_COMBINE_FACTOR_ZERO,
                      FXFALSE,
                      FXFALSE );
	
        square(    0.0f,  300.0f, 256.0f, 256.0f );
        square(  255.0f,  300.0f, 128.0f, 128.0f );
        square(  382.0f,  300.0f,  64.0f,  64.0f );
        square(  445.0f,  300.0f,  32.0f,  32.0f );
        square(  476.0f,  300.0f,  16.0f,  16.0f );
        square(  491.0f,  300.0f,   8.0f,   8.0f );
        square(  498.0f,  300.0f,   4.0f,   4.0f );
        square(  501.0f,  300.0f,   2.0f,   2.0f );
        square(  502.0f,  300.0f,   1.0f,   1.0f );
      }


      grBufferSwap( 1 );    

      if(numFrames > 0)
	numFrames--;

      if(kbhit()) {
	getch();
	break;
      }
    } 
    grGlideShutdown();

    return;
}
コード例 #5
0
ファイル: TEST44.C プロジェクト: grakidov/Render3D
void main( int argc, char *argv[] ) {
  char
    texFile[256],
    texFile1[256],
    texFile2[256];
  float
    theta;
  
  FxU32
    numTmus = 1;
  
  FxBool
    paused = FXFALSE;

  Gu3dfInfo
    info, info2;
  FxU32
    numFrames = 0xffffffff;
 
  puts("TEST44: Tests complex, multi-tmu textures\n");
  puts("Press a key to continue...\n");
  getch();
  puts("Press q to quit\n");

  /* Glide State Initialization */
  grGlideInit();
  grSstQueryHardware( &hwConfig );
  grSstSelect( 0 );
  grSstOpen( screenRes,
            GR_REFRESH_60Hz,
            GR_COLORFORMAT_ABGR,
            GR_ORIGIN_LOWER_LEFT,
            GR_SMOOTHING_ENABLE,
            2 );
  grColorCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
                 GR_COMBINE_FACTOR_ONE,
                 GR_COMBINE_LOCAL_NONE,
                 GR_COMBINE_OTHER_TEXTURE,
                 FXFALSE );
  grAlphaCombine( GR_COMBINE_FUNCTION_SCALE_OTHER,
                 GR_COMBINE_FACTOR_ONE,
                 GR_COMBINE_LOCAL_NONE,
                 GR_COMBINE_OTHER_TEXTURE,
                 FXFALSE );
  grTexCombine( GR_TMU0,
               GR_COMBINE_FUNCTION_LOCAL,
               GR_COMBINE_FACTOR_ZERO,
               GR_COMBINE_FUNCTION_LOCAL,
               GR_COMBINE_FACTOR_ZERO,
               FXFALSE,
               FXFALSE );
  
  if ( hwConfig.SSTs[0].sstBoard.VoodooConfig.nTexelfx == 2 ) {
    printf( "Detected 2 TMUs\n" );
    grTexCombine( GR_TMU1,
                 GR_COMBINE_FUNCTION_LOCAL,
                 GR_COMBINE_FACTOR_ZERO,
                 GR_COMBINE_FUNCTION_LOCAL,
                 GR_COMBINE_FACTOR_ZERO,
                 FXFALSE,
                 FXFALSE );
    numTmus = 2;
  }
  
  /*------------------------------------------------------------------
    Deal With Arguments
    ------------------------------------------------------------------*/
  if ( numTmus == 1 ) {
    if ( argc < 2 ) {
      printf( "%s ", argv[0] );
      puts( usage_1tmu );
      grGlideShutdown();
      return;
    }
    argc--;argv++;
    while(argc) {
      if(strcmp(argv[0], "-n") == 0)  {
        argc--;argv++;
        if(argc)
          numFrames = atoi(argv[0]);
        else {
          puts( usage_1tmu );
          return;
        }
      }
      strcpy( texFile, argv[0] );
      strcpy( texFile1, argv[1] );
      argc--;argv++;
      argc--;argv++;
    }
  } else {
    if ( argc < 4 ) {
      printf( "%s ", argv[0] );
      puts( usage2tmu );
      grGlideShutdown();
      return;
    }
    argc--;argv++;
    while(argc) {
      if(strcmp(argv[0], "-n") == 0) {
        argc--;argv++;
        if(argc)
          numFrames = atoi(argv[0]);
        else {
          puts( usage_1tmu );
          return;
        }
      }
      strcpy( texFile, argv[0] );    
      strcpy( texFile1, argv[1]);
      strcpy( texFile2, argv[2] );
      argc -= 3;
      argv += 3;
    }
  }
  
  grAlphaBlendFunction( GR_BLEND_ONE, GR_BLEND_ZERO,
                       GR_BLEND_ONE, GR_BLEND_ZERO );
  
  grDepthBufferMode( GR_DEPTHBUFFER_DISABLE );
  grDepthBufferFunction( GR_CMP_LEQUAL );
  grDepthMask( FXFALSE );
  
  grCullMode( GR_CULL_DISABLE );
  
  grBufferClear( 0x0, 0x0, 0x0 );
  
  /*------------------------------------------------------------------
    Load Texture(s)
    ------------------------------------------------------------------*/
  if ( !gu3dfGetInfo( texFile, &info ) ) {
    printf( "Couldn't load %s.\n", texFile );
    return;
  }
  info.data = calloc( info.mem_required, 1 );
  gu3dfLoad( texFile, &info );
  
  texInfo.smallLod    = info.header.small_lod;
  texInfo.largeLod    = info.header.large_lod;
  texInfo.aspectRatio = info.header.aspect_ratio;
  texInfo.format      = info.header.format;
  texInfo.data        = info.data;
  
  if ( texInfo.format == GR_TEXFMT_YIQ_422 ||
      texInfo.format == GR_TEXFMT_AYIQ_8422 ) {
    puts( "*******************YIQ TEXTURE(TMU0)***************" );
    nccTable = info.table.nccTable;
    hasTable = FXTRUE;
  }
  
  if ( texInfo.format == GR_TEXFMT_P_8 ||
      texInfo.format == GR_TEXFMT_AP_88 ) {
    puts( "*******************PAL TEXTURE(TMU0)***************" );
    pal0 = info.table.palette;
   hasPalette = FXTRUE;
  }

  /* ++++ */
  if ( !gu3dfGetInfo( texFile1, &info ) ) {
    printf( "Couldn't load %s.\n", texFile1 );
    return;
  }
  info.data = calloc( info.mem_required, 1 );
  gu3dfLoad( texFile1, &info );
  
  texInfo1.smallLod    = info.header.small_lod;
  texInfo1.largeLod    = info.header.large_lod;
  texInfo1.aspectRatio = info.header.aspect_ratio;
  texInfo1.format      = info.header.format;
  texInfo1.data        = info.data;
  
  if ( texInfo1.format == GR_TEXFMT_YIQ_422 ||
      texInfo1.format == GR_TEXFMT_AYIQ_8422 ) {
    puts( "*******************YIQ TEXTURE(TMU0)***************" );
    nccTable = info.table.nccTable;
    hasTable = FXTRUE;
  }
  
  if ( texInfo1.format == GR_TEXFMT_P_8 ||
      texInfo1.format == GR_TEXFMT_AP_88 ) {
    puts( "*******************PAL TEXTURE(TMU0)***************" );
    pal0 = info.table.palette;
    hasPalette1 = FXTRUE;
  }


  /* ++++ */

  if ( numTmus == 2 ) {
    if ( !gu3dfGetInfo( texFile2, &info2 ) ) {
      printf( "Couldn't load %s.\n", texFile2 );
      return;
    }
    info2.data = calloc( info2.mem_required, 1 );
    gu3dfLoad( texFile2, &info2 );
    
    texInfo2.smallLod    = info2.header.small_lod;
    texInfo2.largeLod    = info2.header.large_lod;
    texInfo2.aspectRatio = info2.header.aspect_ratio;
    texInfo2.format      = info2.header.format;
    texInfo2.data        = info2.data;
    
    if ( texInfo2.format == GR_TEXFMT_YIQ_422 ||
        texInfo2.format == GR_TEXFMT_AYIQ_8422 ) {
      puts( "*******************YIQ TEXTURE(TMU1)***************" );
      nccTable2 = info2.table.nccTable;
      hasTable2 = FXTRUE;
    }
    if ( texInfo2.format == GR_TEXFMT_P_8 ||
        texInfo2.format == GR_TEXFMT_AP_88 ) {
      puts( "*******************PAL TEXTURE(TMU1)***************" );
      pal2 = info2.table.palette;
      hasPalette2 = FXTRUE;
    }
  }
  
  grHints(GR_HINT_STWHINT, GR_STWHINT_W_DIFF_TMU0 |
          GR_STWHINT_ST_DIFF_TMU0 | GR_STWHINT_W_DIFF_TMU1 |
          GR_STWHINT_ST_DIFF_TMU1);
  
  
  /*------------------------------------------------------------------
    Allocate Texture RAM
    ------------------------------------------------------------------*/
  tmu0Tex0Address = startAddress =
    nextAddress = grTexMinAddress( GR_TMU0 );
  tmu0Tex1Address = nextAddress  = startAddress +
    grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH, &texInfo );
  
  
  printf( "tex0: tmu0Tex0Address: %d tmu0Tex1Address %d\n",
         tmu0Tex0Address, tmu0Tex1Address);
  
  if ( nextAddress > grTexMaxAddress( GR_TMU0 ) ) {
    printf( "Texture memory exhausted.\n" );
    return;
  }
  
  if ( numTmus == 2 ) {
    startAddress2 =  nextAddress2 = grTexMinAddress( GR_TMU1 );
    nextAddress2  = startAddress2 + 
      grTexTextureMemRequired( GR_MIPMAPLEVELMASK_BOTH,
                              &texInfo2 );
    printf( "tex1: startAddress: %d nextAddress %d\n", startAddress2, nextAddress2 );
  }
  
  /*------------------------------------------------------------------
    Download Texture(s)
    ------------------------------------------------------------------*/
  grTexDownloadMipMap( GR_TMU0,
                      tmu0Tex0Address,
                      GR_MIPMAPLEVELMASK_BOTH,
                      &texInfo );
  /* ---- */
  grTexDownloadMipMap( GR_TMU0,
                      tmu0Tex1Address,
                      GR_MIPMAPLEVELMASK_BOTH,
                      &texInfo1 );


  /* ---- */

  if ( numTmus == 2 ) {
    grTexDownloadMipMap( GR_TMU1,
                        startAddress2,
                        GR_MIPMAPLEVELMASK_BOTH,
                        &texInfo2 );
    if ( hasTable2 ) {
      grTexNCCTable( GR_TMU1, GR_NCCTABLE_NCC0 );
      grTexDownloadTable( GR_TMU1,
                         GR_TEXTABLE_NCC0,
                         &nccTable2 );
    }

    if ( hasPalette2 ) {
      grTexDownloadTable( GR_TMU1,
                         GR_TEXTABLE_PALETTE,
                         &pal2 );
    }
  }
  
  /*------------------------------------------------------------------
    Set up Texture Params and Set Texture As Current
    ------------------------------------------------------------------*/
  grTexFilterMode( GR_TMU0,
                  GR_TEXTUREFILTER_BILINEAR, 
                  GR_TEXTUREFILTER_BILINEAR );
  grTexClampMode( GR_TMU0,
                 GR_TEXTURECLAMP_WRAP,
                 GR_TEXTURECLAMP_WRAP );
  grTexMipMapMode( GR_TMU0,
                  GR_MIPMAP_NEAREST,
                  FXFALSE );
  grTexSource( GR_TMU0,
              startAddress,
              GR_MIPMAPLEVELMASK_BOTH,
              &texInfo );
  


  if ( numTmus == 2 ) {
    grTexFilterMode( GR_TMU1,
                    GR_TEXTUREFILTER_BILINEAR, 
                    GR_TEXTUREFILTER_BILINEAR );
    grTexClampMode( GR_TMU1,
                   GR_TEXTURECLAMP_WRAP,
                   GR_TEXTURECLAMP_WRAP );
    grTexMipMapMode( GR_TMU1,
                    GR_MIPMAP_NEAREST,
                    FXFALSE );
    grTexSource( GR_TMU1,
                startAddress2,
                GR_MIPMAPLEVELMASK_BOTH, 
                &texInfo2 );
  }
  
  if ( numTmus == 2 ) {
    grTexCombine( GR_TMU1,
                  GR_COMBINE_FUNCTION_LOCAL,
                  GR_COMBINE_FACTOR_NONE,
                  GR_COMBINE_FUNCTION_LOCAL,
                  GR_COMBINE_FACTOR_NONE,
                  FXFALSE,
                  FXFALSE );

    grTexCombine( GR_TMU0,
                  GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL,
                  GR_COMBINE_FACTOR_ONE, 
                  GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL,
                  GR_COMBINE_FACTOR_ONE,
                  FXFALSE,
                  FXFALSE ); 
  }
  
#define INC 0.5f
  
  theta = 0.f;
  while (1 && numFrames) {
    if (paused == FXFALSE) {
      theta += INC;
      if (theta > 180.f)
        theta -= 180.f;
    }

    square(0.f, 0.f, 640.3f, 480.f, DEG2RAD(theta));

    grBufferSwap( 1 );

    if (kbhit()) {
      char c;
      c = getch();

      switch (c) {
      case '-':
        theta -= INC;
        break;

      case '+':
        theta += INC;
        break;

      case 'd':
      case 'D':
        printf("theta = %3.1f\n", theta);
        break;

      case 'P':
      case 'p':
        if (paused == FXFALSE)
          paused = FXTRUE;
        else
          paused = FXFALSE;
        break;

      case 'q':
      case 'Q':
      case 27:
        grGlideShutdown();
        exit(0);
        break;
      }
    } /* input switch */
    if(numFrames != -1)
      numFrames--;
  } /* render loop */
}/* main */
コード例 #6
0
ファイル: test29.c プロジェクト: basecq/q2dos
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();
}
コード例 #7
0
ファイル: test42.c プロジェクト: basecq/q2dos
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();
}