windows-xp/Source/XPSP1/NT/multimedia/opengl/toolkits/libmtk/texture.cxx

/******************************Module*Header*******************************\
* Module Name: texture.c
*
* Texture handling functions
*
* Copyright (c) 1994 Microsoft Corporation
*
\**************************************************************************/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <sys/types.h>
#include <time.h>
#include <windows.h>
#include <scrnsave.h>
#include <commdlg.h>

#include "mtk.h"
#include "texture.hxx"
#include "glutil.hxx"

//static int VerifyTextureFile( TEXFILE *pTexFile );
static int GetTexFileType( TEXFILE *pTexFile );

static PFNGLCOLORTABLEEXTPROC pfnColorTableEXT;
static PFNGLCOLORSUBTABLEEXTPROC pfnColorSubTableEXT;

/******************************Public*Routine******************************\
*
* TEXTURE
*
* Create a texture from a BMP or RGB file
*
\**************************************************************************/

TEXTURE::TEXTURE( TEXFILE *pTexFile )
{
    TK_RGBImageRec *image = (TK_RGBImageRec *) NULL;
    LPTSTR pszBmpfile = pTexFile->szPathName;
    int type;

    Init();

    // Verify file / set type
    
    if( !(type = mtk_VerifyTextureFileData( pTexFile )) )
        return;

    // While we're still calling into the tk routines, disable popups
    // Eventually should pull tk code in here - all that's required is the
    // file parsing code.

    tkErrorPopups( FALSE );

//mf: I guess can't have TEX_A8 type file ?

    if( type == TEX_BMP ) {

#ifdef UNICODE
        image = tkDIBImageLoadAW( (char *) pszBmpfile, TRUE );
#else
        image = tkDIBImageLoadAW( (char *) pszBmpfile, FALSE );
#endif
    } else {
#ifdef UNICODE
        image = tkRGBImageLoadAW( (char *) pszBmpfile, TRUE );
#else
        image = tkRGBImageLoadAW( (char *) pszBmpfile, FALSE );
#endif
    }

    if( !image )  {
        return;
    }
    ProcessTkTexture( image );
}

TEXTURE::TEXTURE( LPTSTR pszBmpFile )
{
    TK_RGBImageRec *image = (TK_RGBImageRec *) NULL;
    int type;
    TEXFILE texFile; // path name, plus offset to file name

    Init();

//mf: this VerifyFile stuff needs some work

    // Look for file, and set nOffset if found
    lstrcpy( texFile.szPathName, pszBmpFile );
    if( ! mtk_VerifyTextureFilePath( &texFile ) )
        return;

    // Now determine the file type (this also aborts if size is too big)
    if( !(type = mtk_VerifyTextureFileData( &texFile )) )
        return;

    // Now the bmp file should point to the full path for tk
    pszBmpFile = texFile.szPathName;

//mf: I guess can't have TEX_A8 type file ?
    if( type == TEX_BMP ) {

#ifdef UNICODE
        image = tkDIBImageLoadAW( (char *) pszBmpFile, TRUE );
#else
        image = tkDIBImageLoadAW( (char *) pszBmpFile, FALSE );
#endif
    } else {
#ifdef UNICODE
        image = tkRGBImageLoadAW( (char *) pszBmpFile, TRUE );
#else
        image = tkRGBImageLoadAW( (char *) pszBmpFile, FALSE );
#endif
    }

    if( !image )  {
        return;
    }
    ProcessTkTexture( image );
}

/******************************Public*Routine******************************\
*
* TEXTURE
*
* Create a texture from a BMP or other resource (RGB , A8, etc. )
*
\**************************************************************************/


TEXTURE::TEXTURE( TEX_RES *pTexRes, HINSTANCE hInst )
{
    HMODULE hModule;

    Init();

    if( hInst )
        hModule = hInst;
    else
        hModule = GetModuleHandle(NULL);

    if( pTexRes->type == TEX_BMP )
        LoadBitmapResource( MAKEINTRESOURCE( pTexRes->name ), hModule );
    else
        LoadOtherResource( pTexRes, hModule );
}

/******************************Public*Routine******************************\
*
* TEXTURE
*
* Create a texture from an HBITMAP
*
\**************************************************************************/

TEXTURE::TEXTURE( HBITMAP hBitmap )
{
    if (hBitmap == NULL)
    {
        SS_ERROR( "TEXTURE::TEXTURE : hBitmap is NULL\n" );
        return;
    }

    Init();
    LoadFromBitmap( hBitmap );
}

/******************************Public*Routine******************************\
*
* Load a bitmap texture resource, creating the HBITMAP from the resource
* identifier
*
\**************************************************************************/

BOOL
TEXTURE::LoadBitmapResource( LPTSTR pRes, HINSTANCE hInst )
{
    HBITMAP hBitmap = LoadBitmap( hInst, pRes );
    if( hBitmap == NULL ) {
        SS_ERROR( "TEXTURE::LoadBitmapResource : LoadBitmap failure\n" );
        return FALSE;
    }
    LoadFromBitmap( hBitmap );
    DeleteObject( hBitmap );
    return TRUE;
}

/******************************Public*Routine******************************\
*
* Load a non-bmp texture resource
*
\**************************************************************************/

BOOL
TEXTURE::LoadOtherResource( TEX_RES *pTexRes, HINSTANCE hInst )
{
    HRSRC hr;
    HGLOBAL hg;
    LPVOID pv;
    LPCTSTR lpType;
    BOOL fLoaded = FALSE;

    switch(pTexRes->type)
    {
        case TEX_RGB:
            lpType = MAKEINTRESOURCE(RT_RGB);
            break;
        case TEX_A8:
            lpType = MAKEINTRESOURCE(RT_A8);
            break;
        default :
            return FALSE;
    }

    hr = FindResource(hInst, MAKEINTRESOURCE(pTexRes->name), lpType);
    if (hr == NULL)
    {
        SS_ERROR( "TEXTURE::LoadOtherResource() : Can't find texture resource\n" );
        goto EH_NotFound;
    }
    hg = LoadResource(hInst, hr);
    if (hg == NULL)
    {
        SS_ERROR( "TEXTURE::LoadOtherResource() : Error loading texture resource\n" );
        goto EH_FreeResource;
    }
    pv = (PSZ)LockResource(hg);
    if (pv == NULL)
    {
        SS_ERROR( "TEXTURE::LoadOtherResource() : Error locking texture resource\n" );
        goto EH_FreeResource;
    }

    switch(pTexRes->type)
    {
    case TEX_RGB:
        fLoaded = RGBImageLoad( pv );
        break;
    case TEX_A8:
        fLoaded = A8ImageLoad( pv );
        break;
    }

 EH_FreeResource:
    FreeResource(hr);
 EH_NotFound:
    
    if( !fLoaded )  {
        SS_ERROR( "TEXTURE::LoadOtherResource() : Texture resource did not load\n" );
        return FALSE;
    }

    Process();
    return TRUE;
}

/******************************Public*Routine******************************\
*
* Load a bitmap texture resource from an HBITMAP
*
\**************************************************************************/


BOOL
TEXTURE::LoadFromBitmap( HBITMAP hBitmap )
{
    BOOL fLoaded = DIBImageLoad( hBitmap );

    if( !fLoaded )  {
        SS_ERROR( "TEXTURE::LoadFromBitmap : bitmap texture did not load\n" );
        return FALSE;
    }
    Process();
    return TRUE;
}

/******************************Public*Routine******************************\
*
* Init
*
* Common constructor intialization
*
\**************************************************************************/

void
TEXTURE::Init()
{
    width   = 0;
    height  = 0;
    data    = NULL;
    pal_size = 0;
    pal     = NULL;
    texObj  = 0;
    iPalRot = 0;
    bMipmap = FALSE;
}

/******************************Public*Routine******************************\
*
* ValidateTextureSize
* 
* - Scales the texture to powers of 2
*
\**************************************************************************/

BOOL
TEXTURE::ValidateSize()
{
    double xPow2, yPow2;
    int ixPow2, iyPow2;
    int xSize2, ySize2;
    float fxFact, fyFact;
    GLint glMaxTexDim;

    if( (width <= 0) || (height <= 0) ) {
        SS_WARNING( "ValidateTextureSize : invalid texture dimensions\n" );
        return FALSE;
    }

//    origAspectRatio = (float) height / (float) width;
//mf: changed this to standard x/y
    origAspectRatio = (float) width / (float) height;

    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &glMaxTexDim);
    if( glMaxTexDim <= 0 )
        return FALSE;

    if( format != GL_COLOR_INDEX ) {

        // We limit the max dimension here for performance reasons
        glMaxTexDim = min(256, glMaxTexDim);

        if (width <= glMaxTexDim)
            xPow2 = log((double)width) / log((double)2.0);
        else
            xPow2 = log((double)glMaxTexDim) / log((double)2.0);

        if (height <= glMaxTexDim)
            yPow2 = log((double)height) / log((double)2.0);
        else
            yPow2 = log((double)glMaxTexDim) / log((double)2.0);

        ixPow2 = (int)xPow2;
        iyPow2 = (int)yPow2;

        // Always scale to higher nearest power
        if (xPow2 != (double)ixPow2)
            ixPow2++;
        if (yPow2 != (double)iyPow2)
            iyPow2++;

        xSize2 = 1 << ixPow2;
        ySize2 = 1 << iyPow2;

        if (xSize2 != width ||
            ySize2 != height)
        {
            BYTE *pData;

            pData = (BYTE *) malloc(xSize2 * ySize2 * components * sizeof(BYTE));
            if (!pData) {
                SS_WARNING( "ValidateTextureSize : can't alloc pData\n" );
                return FALSE;
            }

            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

            if( gluScaleImage(format, width, height,
                      GL_UNSIGNED_BYTE, data,
                      xSize2, ySize2, GL_UNSIGNED_BYTE,
                      pData) )
            {
                // glu failure
                SS_WARNING( "ValidateTextureSize : gluScaleImage failure\n" );
                return FALSE;
            }
        
            // set the new width,height,data
            width = xSize2;
            height = ySize2;
            free(data);
            data = pData;
        }
    } else {  // paletted texture case
        //mf
        // paletted texture: must be power of 2 - but might need to enforce
        // here if not done in a8 load.  Also have to check against
        // GL_MAX_TEXTURE_SIZE.  Could then clip it to power of 2 size
    }
    return TRUE;
}

/******************************Public*Routine******************************\
*
* SetDefaultTextureParams
*
\**************************************************************************/

void
TEXTURE::SetDefaultParams()
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    if( bMipmap )
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
                        GL_LINEAR_MIPMAP_LINEAR);
    else
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}

/******************************Public*Routine******************************\
*
* ProcessTexture
*
* - Verifies texture size
* - Fills out TEXTURE structure with required data
* - Creates a texture object if extension exists
*
\**************************************************************************/

int 
TEXTURE::Process()
{
    // Enforce proper texture size (power of 2, etc.)

    if( !ValidateSize() )
        return 0;

    // if texturing objects available, init the object
    if( gGLCaps.bTextureObjects ) {
        glGenTextures( 1, &texObj );
        glBindTexture( GL_TEXTURE_2D, texObj );

//mf: mipmap stuff
        // Default attributes for texObj
        SetDefaultParams();

        if( bMipmap )
//mf: error return...
            gluBuild2DMipmaps( GL_TEXTURE_2D, components,
                      width, height, format,
                      GL_UNSIGNED_BYTE, data );
        else
            glTexImage2D( GL_TEXTURE_2D, 0, components,
                      width, height, 0, format,
                      GL_UNSIGNED_BYTE, data );
        
        if (gGLCaps.bPalettedTexture && pal != NULL)
        {
            pfnColorTableEXT(GL_TEXTURE_2D, GL_RGBA, pal_size,
                             GL_BGRA_EXT, GL_UNSIGNED_BYTE, pal);
        }
    } else
        texObj = 0;

    return 1;
}

/******************************Public*Routine******************************\
*
* ProcessTkTexture
*
* Simple wrapper for ProcessTexture which fills out a TEXTURE
* from a TK_RGBImageRec
*
* Frees the ImageRec if ProcessTexture succeeds
*
\**************************************************************************/

int
TEXTURE::ProcessTkTexture( TK_RGBImageRec *image )
{
    width = image->sizeX;
    height = image->sizeY;
    format = GL_RGB;
    components = 3;
    data = image->data;
    pal_size = 0;
    pal = NULL;

    if( Process() )
    {
//mf: ?? don't understand this freeing stuff...
        free(image);
        return 1;
    }
    else
    {
        return 0;
    }
}
    
/******************************Public*Routine******************************\
*
* MakeCurrent
*
\**************************************************************************/

void
TEXTURE::MakeCurrent()
{
    if( texObj ) {
        glBindTexture( GL_TEXTURE_2D, texObj );
        return;
    }
    
    if( bMipmap )
        gluBuild2DMipmaps( GL_TEXTURE_2D, components,
                  width, height, format,
                  GL_UNSIGNED_BYTE, data );
    else
        glTexImage2D( GL_TEXTURE_2D, 0, components,
                  width, height, 0, format,
                  GL_UNSIGNED_BYTE, data );
        
//mf: ? no rotation if no tex objs ?
    if( pal )
    {
        pfnColorTableEXT(GL_TEXTURE_2D, GL_RGBA, pal_size,
                         GL_BGRA_EXT, GL_UNSIGNED_BYTE, pal);
    }
}

    
#if 0
/******************************Public*Routine******************************\
*
* ss_CopyTexture
*
* Make a copy of a texture.
*
\**************************************************************************/

BOOL
TEXTURE::ss_CopyTexture( TEXTURE *pTexDst, TEXTURE *pTexSrc )
{
    int size;

    if( (pTexDst == NULL) || (pTexSrc == NULL) )
        return FALSE;

    *pTexDst = *pTexSrc;

    if( gGLCaps.bTextureObjects && pTexSrc->texObj ) {
        glGenTextures( 1, &pTexDst->texObj );
    }
    
    // copy image data

    size = pTexSrc->width * pTexSrc->height;
    if( pTexSrc->components != GL_COLOR_INDEX8_EXT )
        size *= pTexSrc->components; // since data format always UNSIGNED_BYTE

    pTexDst->data = (unsigned char *) malloc( size );
    if( pTexDst->pal == NULL )
        return FALSE;
    memcpy( pTexDst->data, pTexSrc->data, size );

    // copy palette data

    if( gGLCaps.bPalettedTexture && pTexSrc->pal != NULL )
    {
        size = pTexSrc->pal_size*sizeof(RGBQUAD);
        pTexDst->pal = (RGBQUAD *) malloc(size);
        if( pTexDst->pal == NULL )
        {
            free(pTexDst->data);
            return FALSE;
        }
        memcpy( pTexDst->pal, pTexSrc->pal, size );
    }
    
    if( pTexDst->texObj ) {
        glBindTexture( GL_TEXTURE_2D, pTexDst->texObj );

        // Default attributes for texObj
        SetDefaultTextureParams( pTexDst );

        if( pTexDst->bMipmap )
            gluBuild2DMipmaps( GL_TEXTURE_2D, pTexDst->components,
                      pTexDst->width, pTexDst->height, pTexDst->format,
                      GL_UNSIGNED_BYTE, pTexDst->data );
        else
            glTexImage2D( GL_TEXTURE_2D, 0, pTexDst->components,
                      pTexDst->width, pTexDst->height, 0, pTexDst->format,
                      GL_UNSIGNED_BYTE, pTexDst->data );
        
        if( pTexDst->pal )
        {
            pfnColorTableEXT(GL_TEXTURE_2D, GL_RGBA, pTexDst->pal_size,
                             GL_BGRA_EXT, GL_UNSIGNED_BYTE, pTexDst->pal);
        }
    }
    return TRUE;
}
#endif

/******************************Public*Routine******************************\
*
* ss_SetTexturePalette
*
* Set a texture's palette according to the supplied index. This index
* indicates the start of the palette, which then wraps around if necessary.
* Of course this only works on paletted textures.
*
\**************************************************************************/

void
TEXTURE::SetPaletteRotation( int index )
{
    if( index == iPalRot )
        return;

    if( pal && pal_size ) {
        iPalRot = index & (pal_size - 1);
        MakeCurrent();
        SetPalette();
    }
}

void
TEXTURE::IncrementPaletteRotation()
{
    if( pal && pal_size ) {
        iPalRot = ++iPalRot & (pal_size - 1);
        MakeCurrent();
        SetPalette();
    }
}

void
TEXTURE::SetPalette()
{
    int start, count;

    start = iPalRot & (pal_size - 1);
    count = pal_size - start;
    pfnColorSubTableEXT(GL_TEXTURE_2D, 0, count, GL_BGRA_EXT,
                        GL_UNSIGNED_BYTE, pal + start);
    if (start != 0)
    {
        pfnColorSubTableEXT(GL_TEXTURE_2D, count, start, GL_BGRA_EXT,
                            GL_UNSIGNED_BYTE, pal);
    }
}

/******************************Public*Routine******************************\
*
* SetTextureAlpha
*
* Set a constant alpha value for the texture
* Again, don't overwrite any existing 0 alpha values, as explained in
* ss_SetTextureTransparency
*
\**************************************************************************/

void
TEXTURE::SetAlpha( float fAlpha )
{
    int i;
    unsigned char *pData = data;
    RGBA8 *pColor = (RGBA8 *) data;
    BYTE bAlpha = (BYTE) (fAlpha * 255.0f);

    if( components != 4 )
        return;

    for( i = 0; i < width*height; i ++, pColor++ ) {
        if( pColor->a != 0 ) 
            pColor->a = bAlpha;
    }
}

/******************************Public*Routine******************************\
*
* ConvertToRGBA
*
* Convert RGB texture to RGBA
*
\**************************************************************************/

BOOL
TEXTURE::ConvertToRGBA( float fAlpha )
{
    unsigned char *pNewData;
    int count = width * height;
    unsigned char *src, *dst;
    BYTE bAlpha = (BYTE) (fAlpha * 255.0f);
    int i;

    if( components != 3 ) {
        SS_ERROR( "TEXTURE::ConvertToRGBA : Can't convert, components != 3\n" );
        return FALSE;
    }

    pNewData = (unsigned char *) LocalAlloc(LMEM_FIXED, count * sizeof(RGBA8));
    if( !pNewData ) {
        SS_ERROR( "TEXTURE::ConvertToRGBA : memory failure\n" );
        return FALSE;
    }

    src = data;
    dst = pNewData;

    if( format == GL_RGB ) {
        // R is lsb, A will be msb
        for( i = 0; i < count; i ++ ) {
            *((RGB8 *)dst) = *((RGB8 *)src);
            dst += sizeof(RGB8);
            src += sizeof(RGB8);
            *dst++ = bAlpha;
        }
        format = GL_RGBA;
    } else { // format == GL_BGR_EXT
        // R is msb, A will be msb
        for( i = 0; i < count; i ++ ) {
            *dst++ = bAlpha;
            *((RGB8 *)dst) = *((RGB8 *)src);
            dst += sizeof(RGB8);
            src += sizeof(RGB8);
        }
        format = GL_BGRA_EXT;
    }

    LocalFree( data );
    data = pNewData;
    components = 4;
    return TRUE;
}

/******************************Public*Routine******************************\
*
* ss_SetTextureTransparency
*
* Set transparency for a texture by adding or modifying the alpha data.  
* Transparency value must be between 0.0 (opaque) and 1.0 (fully transparent)
* If the texture data previously had no alpha, add it in.
* If bSet is TRUE, make this the current texture.
*
* Note: Currently fully transparent pixels (alpha=0) will not be altered, since
* it is assumed these should be permanently transparent (could make this an
* option? - bPreserveTransparentPixels )
*
\**************************************************************************/

BOOL
TEXTURE::SetTransparency( float fTransp, BOOL bSet )
{
    int i;
    float fAlpha;

    SS_CLAMP_TO_RANGE2( fTransp, 0.0f, 1.0f );
    fAlpha = 1 - fTransp;

    if( format == GL_COLOR_INDEX )
    {
        // just need to modify the palette
            RGBQUAD *pPal = pal;
            BYTE bAlpha = (BYTE) (fAlpha * 255.0f);

            if( !pPal )
                return FALSE;

            for( i = 0; i < pal_size; i ++, pPal++ ) {
                if( pPal->rgbReserved != 0 )
                    pPal->rgbReserved = bAlpha;
            }
        
            // need to send down the new palette for texture objects
            if( texObj && pal )
            {
                glBindTexture( GL_TEXTURE_2D, texObj );
                pfnColorTableEXT(GL_TEXTURE_2D, GL_RGBA, pal_size,
                                 GL_BGRA_EXT, GL_UNSIGNED_BYTE, pal);
            }
    }
    else {
        // Need to setup new texture data
        if( components != 4 ) {
            // Make room for alpha component
            //mf: ? change to byte Alpha ?
            if( !ConvertToRGBA( fAlpha ) )
                return FALSE;
        } else {
            // Set alpha component
            SetAlpha( fAlpha );
        }
        // Send down new data if texture objects
        if( texObj )
        {
            glBindTexture( GL_TEXTURE_2D, texObj );
            if( bMipmap )
//mf: inefficient !!!
                gluBuild2DMipmaps( GL_TEXTURE_2D, components,
                      width, height, format,
                      GL_UNSIGNED_BYTE, data );
            else
                glTexImage2D( GL_TEXTURE_2D, 0, components,
                          width, height, 0, format,
                          GL_UNSIGNED_BYTE, data );
        }
    }

    if( bSet )
        MakeCurrent();

    return TRUE;
}

/******************************Public*Routine******************************\
*
* ss_DeleteTexture
*
\**************************************************************************/

TEXTURE::~TEXTURE()
{
    if( texObj ) {
        glDeleteTextures( 1, &texObj );
    }
    if (pal != NULL)
    {
        free(pal);
    }
    if( data )
        free( data );
}



/******************************Public*Routine******************************\
*
* ss_TextureObjectsEnabled
*
* Returns BOOL set by ss_QueryGLVersion (Texture Objects only supported on
* GL v.1.1 or greater)
*
\**************************************************************************/

BOOL
mtk_TextureObjectsEnabled( void )
{
    return gGLCaps.bTextureObjects;
}

/******************************Public*Routine******************************\
*
* ss_PalettedTextureEnabled
*
* Returns result from ss_QueryPalettedTextureEXT
*
\**************************************************************************/

BOOL
mtk_PalettedTextureEnabled( void )
{
    return gGLCaps.bPalettedTexture;
}

/******************************Public*Routine******************************\
*
* ss_QueryPalettedTextureEXT
*
* Queries the OpenGL implementation to see if paletted texture is supported
* Typically called once at app startup.
*
\**************************************************************************/

BOOL
mtk_QueryPalettedTextureEXT( void )
{
    PFNGLGETCOLORTABLEPARAMETERIVEXTPROC pfnGetColorTableParameterivEXT;
    int size;

    pfnColorTableEXT = (PFNGLCOLORTABLEEXTPROC)
        wglGetProcAddress("glColorTableEXT");
    if (pfnColorTableEXT == NULL)
        return FALSE;
    pfnColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)
        wglGetProcAddress("glColorSubTableEXT");
    if (pfnColorSubTableEXT == NULL)
        return FALSE;
        
    // Check color table size
    pfnGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)
        wglGetProcAddress("glGetColorTableParameterivEXT");
    if (pfnGetColorTableParameterivEXT == NULL)
        return FALSE;
    // For now, the only paletted textures supported in this lib are TEX_A8,
    // with 256 color table entries.  Make sure the device supports this.
    pfnColorTableEXT(GL_PROXY_TEXTURE_2D, GL_RGBA, 256,
                     GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL );
    pfnGetColorTableParameterivEXT( GL_PROXY_TEXTURE_2D, 
                                    GL_COLOR_TABLE_WIDTH_EXT, &size );
    if( size != 256 )
        // The device does not support a color table size of 256, so we don't
        // enable paletted textures in general.
        return FALSE;

    return TRUE;
}


/******************************Public*Routine******************************\
*
* ss_VerifyTextureFile
*
* Validates texture bmp or rgb file, by checking for valid pathname and
* correct format.
*
* History
*  Apr. 28, 95 : [marcfo]
*    - Wrote it
*
*  Jul. 25, 95 : [marcfo]
*    - Suppress warning dialog box in child preview mode, as it will
*      be continuously brought up.
*
*  Dec. 12, 95 : [marcfo]
*     - Support .rgb files as well
*
*  Dec. 14, 95 : [marcfo]
*     - Change to have it only check the file path
*
\**************************************************************************/

//mf: this can become a standard file function

BOOL
mtk_VerifyTextureFilePath( TEXFILE *ptf )
{
    // Make sure the selected texture file is OK.

    ISIZE size;
    TCHAR szFileName[MAX_PATH];
    PTSTR pszString;
    TCHAR szString[MAX_PATH];

    lstrcpy(szFileName, ptf->szPathName);

    if ( SearchPath(NULL, szFileName, NULL, MAX_PATH,
                     ptf->szPathName, &pszString)
       )
    {
        ptf->nOffset = pszString - ptf->szPathName;
        return TRUE;
    }
    else
    {
        lstrcpy(ptf->szPathName, szFileName);    // restore
        return FALSE;
    }
}


/******************************Public*Routine******************************\
*
* VerifyTextureFile
*
* Verify that a bitmap or rgb file is valid
*
* Returns:
*   File type (RGB or BMP) if valid file; otherwise, 0.
*
* History
*  Dec. 12, 95 : [marcfo]
*    - Creation
*
\**************************************************************************/

int
mtk_VerifyTextureFileData( TEXFILE *pTexFile )
{
    int type;
    ISIZE size;
    BOOL bValid;
    TCHAR szString[2 * MAX_PATH]; // May contain a pathname

    // check for 0 offset and null strings
    if( (pTexFile->nOffset == 0) || (*pTexFile->szPathName == 0) )
        return 0;

    type = GetTexFileType( pTexFile );

    switch( type ) {
        case TEX_BMP:
            bValid = bVerifyDIB( pTexFile->szPathName, &size );
            break;
        case TEX_RGB:
            bValid = bVerifyRGB( pTexFile->szPathName, &size );
            break;
        case TEX_UNKNOWN:
        default:
            bValid = FALSE;
    }

    if( !bValid ) {
        return 0;
    }

    // Check size ?

    if ( (size.width > TEX_WIDTH_MAX)     || 
         (size.height > TEX_HEIGHT_MAX) )
    {
        return 0;
    }

    return type;
}

/******************************Public*Routine******************************\
*
* ss_InitAutoTexture
*
* Generate texture coordinates automatically.
* If pTexRep is not NULL, use it to set the repetition of the generated
* texture.
*
\**************************************************************************/

void
mtk_InitAutoTexture( TEX_POINT2D *pTexRep )
{
    GLfloat sgenparams[] = {1.0f, 0.0f, 0.0f, 0.0f};
    GLfloat tgenparams[] = {0.0f, 1.0f, 0.0f, 0.0f};

    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
    if( pTexRep )
        sgenparams[0] = pTexRep->s;
    glTexGenfv(GL_S, GL_OBJECT_PLANE, sgenparams );

    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
    if( pTexRep )
        tgenparams[0] = pTexRep->t;
    glTexGenfv(GL_T, GL_OBJECT_PLANE, tgenparams );

    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);
    glEnable( GL_TEXTURE_2D );
}

/******************************Public*Routine******************************\
*
* GetTexFileType
*
* Determine if a texture file is rgb or bmp, based on extension.  This is
* good enough, as the open texture dialog only shows files with these
* extensions.
*
\**************************************************************************/

static int
GetTexFileType( TEXFILE *pTexFile )
{
    LPTSTR pszStr;

#ifdef UNICODE
    pszStr = wcsrchr( pTexFile->szPathName + pTexFile->nOffset, 
             (USHORT) L'.' );
#else
    pszStr = strrchr( pTexFile->szPathName + pTexFile->nOffset, 
             (USHORT) L'.' );
#endif
    if( !pszStr || (lstrlen(++pszStr) == 0) )
        return TEX_UNKNOWN;

    if( !lstrcmpi( pszStr, TEXT("bmp") ) )
        return TEX_BMP;
    else if( !lstrcmpi( pszStr, TEXT("rgb") ) )
        return TEX_RGB;
    else
        return TEX_UNKNOWN;
}