gfx_opengl_texture2.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2007 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 ******************************************************************************/

#ifndef GFX_TEXTURE2_OPENGL_HH
#define GFX_TEXTURE2_OPENGL_HH 1

#include "gfx_targa.hh"

namespace gfx {

#if DEBUG
#define CHECK_TEXTURE() ASSERT(mBits.mValid), CHECK_TYPESIG(this,TYPESIG_TEXTURE)
#else
#define CHECK_TEXTURE()
#endif

class Texture : public TextureBase
{

public:
    // Force giving an Alpha channel to the internal texture
    // despite the external texture lacking Alpha.
    enum eForceAlpha { eForceAlpha_FALSE, eForceAlpha_TRUE };

public:
    Texture( void );  // create texture with empty texture data
    Texture( const uint width, const uint height,
             const eTexelType externalTexelType,
             const eTexelType internalTexelType );
    Texture( const Targa& targa,
             const eMipmap mipmap = eMipmap_OFF,
             const eForceAlpha forceAlpha = eForceAlpha_FALSE );
    ~Texture();

public:
    void
    Bind( void ) const
    {
    CHECK_TEXTURE();
    ASSERT( glIsEnabled( GL_TEXTURE_2D ) );  // user required to enable texturing
    ASSERT( IfValid() );  // checks if texture image was loaded (mId)

        // Switch/bind to this texture.
        glBindTexture( GL_TEXTURE_2D, mId );

        // Unlike glTexParameter(), the effect of glTexEnv() doesn't stick to a texture object.
        glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mTexFunc );
    }

    CLASS_METHOD void
    Map( const TexCoord2& tc )
    {
        glTexCoord2f( tc.x, tc.y );
    }

    CLASS_METHOD void
    Map( fp tx, fp ty )
    {
        glTexCoord2f( tx, ty );
    }

public:
    bool
    IfValid( void ) const
    {
        return mBits.mValid && (mId != TEXTURE_ID_INVALID);
    }

    uint
    GetWidth( void ) const
    {
    CHECK_TEXTURE();
        return mBits.mWidth;
    }

    uint
    GetHeight( void ) const
    {
    CHECK_TEXTURE();
        return mBits.mWidth;  // w=h
    }

    uint
    DimCnt( void ) const
    {
    CHECK_TEXTURE();
        return 2;  // 2D
    }

    uint GetTexelCnt( void ) const;  // no data member for this
    uint GetExternalByteCnt( void ) const;  // texel cnt same but byte cnt may differ

    #if STATS
    // Track texture memory usage.
    CLASS_METHOD uint
    GetTotalMemoryUsed( void )
    {
        return msTotalMemoryUsed;
    }
    #endif

public:
    void    SetTextureImage( const Array<Texel32>& texels, const eMipmap mipmap = eMipmap_OFF );
    void    SetTextureImage( const Texel32* texels, const uint texelCnt, const eMipmap mipmap = eMipmap_OFF );
    void    SetTextureImage( const uint8* texels, const uint externalByteCnt, const eMipmap mipmap = eMipmap_OFF );  // raw byte array

public:
    void    SetMinFilter( eMinFilter filter );
    void    SetMagFilter( eMagFilter filter );
    void    SetFastestFilters( void );
    void    SetWrap( eWrap wrap, uint dim );
    void    SetWrap( eWrap wrap );
    void    SetFunc( eFunc func );

private:
    friend bool
    operator<( Texture& a, Texture& b )
    {
    CHECK_TYPESIG(&a,TYPESIG_TEXTURE);
    CHECK_TYPESIG(&b,TYPESIG_TEXTURE);
        return a.mId < b.mId;
    }

private:
    void    Init( const uint width, const uint height,
                  const eTexelType externalTexelType,
                  const eTexelType internalTexelType );
    uint    TexelCntToExternalByteCnt( const uint texelCnt ) const;
    uint    TexelCntToInternalByteCnt( const uint texelCnt ) const;
    uint    GetInternalTexelCnt( void ) const;
    uint    GetInternalByteCnt( void ) const;
    uint    GetByteCnt_( const bool hasAlpha ) const;  // subroutine
    uint    GetTexelCnt_( const bool hasAlpha ) const;  // subroutine
    uint    TexelCntToByteCnt_( const uint texelCnt, const uint texelLen ) const;  // subroutine
    #if STATS
    uint    EstimateInternalByteCnt( const eMipmap mipmap ) const;
    #endif
    
public:
    enum    { MAX_TEXTURE_WIDTH_BITS = 12 };
    enum    { MAX_TEXTURE_WIDTH = 1 << (MAX_TEXTURE_WIDTH_BITS-1) };
    enum    { MAX_TEXTURE_BYTES = MAX_TEXTURE_WIDTH * MAX_TEXTURE_WIDTH * 4 };  // limit texture memory consumption

private:
    // The parameters of glTexParameter() sticks to bound texture object.
    // But glTexEnv() don't, so need to store them in class members.
    // mTexFunc is passed to glTexEnv() every time this texture is active.

    struct Bits
    {
        uint    mValid              : 1;
        uint    mWidth              : 16;   
        uint    mExternalTexelLen   : 3;    
        uint    mInternalTexelLen   : 3;    
        uint    mLoaded             : 1;    
        uint    mMipmap             : 1;    
    };
    Bits            mBits;
    eTexelType      mExternalTexelType; 
    eTexelType      mInternalTexelType; 
    GLuint          mId;                
    eFunc           mTexFunc;           

private:
    #if STATS
    CLASS_VAR int   msTotalMemoryUsed;  
    #endif

public:
    
};

} // namespace gfx

#endif // GFX_TEXTURE2_OPENGL_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:11 2007