TAPsOpenGLTexture.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLTexture.cpp

OpenGL Material Properties

SUKITTI PUNAK   (05/12/2007)
MAJOR UPDATE    (08/14/2009)
******************************************************************************/
#include "TAPsOpenGLTexture.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
//-----------------------------------------------------------------------------
// Default Constructor
Texture::Texture () : m_TextureNames( NULL )
{
    m_ParamTex_Wrap_S = GL_CLAMP;
    m_ParamTex_Wrap_T = GL_CLAMP;
    m_ParamTex_Wrap_R = GL_CLAMP;
    m_ParamTex_MagFilter = GL_NEAREST;
    m_ParamTex_MinFilter = GL_NEAREST;
    //
    ChangeTexture( 
        GL_TEXTURE_2D, 0, GL_RGBA, 
        1, 1, 1, 
        0, GL_RGBA, GL_UNSIGNED_BYTE, 
        NULL, 
        1
    );
}
//-----------------------------------------------------------------------------
// Constructor for 1D Texture
Texture::Texture (
        GLenum  target,
        GLint   level,
        GLint   internalFormat,
        GLsizei width,
        GLint   border,
        GLenum  pixelFormat,
        GLenum  dataType,
        //-----------------------------
        GLvoid *    texels,             // texel data
        //-----------------------------
        unsigned short  numOfTextures,  // number of 2D textures
        //-----------------------------
        GLint magFilter,
        GLint minFilter,
        GLint wrapS,
        GLint wrapT,
        GLint wrapR
        //-----------------------------
) : m_TextureNames( NULL )
{
    std::cout << "START new Texture()" << std::endl;

    m_ParamTex_Wrap_S = wrapS;
    m_ParamTex_Wrap_T = wrapT;
    m_ParamTex_Wrap_R = wrapR;
    m_ParamTex_MagFilter = magFilter;
    m_ParamTex_MinFilter = minFilter;
    //
    ChangeTexture( 
        target, level, internalFormat, 
        width, 1, 1, 
        border, pixelFormat, dataType, 
        texels, 
        numOfTextures
    );
}
//-----------------------------------------------------------------------------
// Constructor for 2D Texture
Texture::Texture (
        GLenum  target,
        GLint   level,
        GLint   internalFormat,
        GLsizei width,
        GLsizei height,
        GLint   border,
        GLenum  pixelFormat,
        GLenum  dataType,
        //-----------------------------
        GLvoid *    texels,             // texel data
        //-----------------------------
        unsigned short  numOfTextures,  // number of 2D textures
        //-----------------------------
        GLint magFilter,
        GLint minFilter,
        GLint wrapS,
        GLint wrapT,
        GLint wrapR
        //-----------------------------
) : m_TextureNames( NULL )
{
    m_ParamTex_Wrap_S = wrapS;
    m_ParamTex_Wrap_T = wrapT;
    m_ParamTex_Wrap_R = wrapR;
    m_ParamTex_MagFilter = magFilter;
    m_ParamTex_MinFilter = minFilter;
    //
    ChangeTexture( 
        target, level, internalFormat, 
        width, height, 1, 
        border, pixelFormat, dataType, 
        texels, 
        numOfTextures
    );
}
//-----------------------------------------------------------------------------
// Constructor for 3D Texture
Texture::Texture (
        GLenum  target,
        GLint   level,
        GLint   internalFormat,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        GLint   border,
        GLenum  pixelFormat,
        GLenum  dataType,
        //-----------------------------
        GLvoid *    texels,             // texel data
        //-----------------------------
        unsigned short  numOfTextures,  // number of 2D textures
        //-----------------------------
        GLint magFilter,
        GLint minFilter,
        GLint wrapS,
        GLint wrapT,
        GLint wrapR
        //-----------------------------
) : m_TextureNames( NULL )
{
    m_ParamTex_MagFilter = magFilter;
    m_ParamTex_MinFilter = minFilter;
    m_ParamTex_Wrap_S = wrapS;
    m_ParamTex_Wrap_T = wrapT;
    m_ParamTex_Wrap_R = wrapR;
    //
    ChangeTexture( 
        target, level, internalFormat, 
        width, height, depth, 
        border, pixelFormat, dataType, 
        texels, 
        numOfTextures
    );
}
//-----------------------------------------------------------------------------
// Destructor
Texture::~Texture ()
{
    DeleteTexture();
}
//-----------------------------------------------------------------------------
// Delete
void Texture::DeleteTexture ()
{
    if ( m_TextureNames ) {
        glDeleteTextures( m_NumOfTextures, m_TextureNames );
        delete [] m_TextureNames;
        m_TextureNames = NULL;
    }
}
//-----------------------------------------------------------------------------
// Change (1D) Texture -- Delete and Recrete with the input data
void Texture::ChangeTexture ( 
        GLenum  target,
        GLint   level,
        GLint   internalFormat,
        GLsizei width,
        GLint   border,
        GLenum  pixelFormat,
        GLenum  dataType,
        //-----------------------------
        GLvoid *    texels,     // texel data
        //-----------------------------
        unsigned short  numOfTextures   // number of 2D textures
        //-----------------------------
)
{
    //-----------------------------------------------------
    m_Target    =   target;
    m_Level     =   level;
    m_InternalFormat    =   internalFormat;
    m_Width     =   width;
    m_Height    =   1;
    m_Depth     =   1;
    m_Border    =   border;
    m_PixelFormat       =   pixelFormat;
    m_DataType  =   dataType;
    //-----------------------
    m_NumOfTextures = numOfTextures;
    //-----------------------------------------------------
    CreateTexture( texels );
}
//-----------------------------------------------------------------------------
// Change (2D) Texture -- Delete and Recrete with the input data
void Texture::ChangeTexture ( 
        GLenum  target,
        GLint   level,
        GLint   internalFormat,
        GLsizei width,
        GLsizei height,
        GLint   border,
        GLenum  pixelFormat,
        GLenum  dataType,
        //-----------------------------
        GLvoid *    texels,     // texel data
        //-----------------------------
        unsigned short  numOfTextures   // number of 2D textures
        //-----------------------------
)
{
    //-----------------------------------------------------
    m_Target    =   target;
    m_Level     =   level;
    m_InternalFormat    =   internalFormat;
    m_Width     =   width;
    m_Height    =   height;
    m_Depth     =   1;
    m_Border    =   border;
    m_PixelFormat       =   pixelFormat;
    m_DataType  =   dataType;
    //-----------------------
    m_NumOfTextures = numOfTextures;
    //-----------------------------------------------------
    CreateTexture( texels );
}
//-----------------------------------------------------------------------------
// Change (3D) Texture -- Delete and Recreate with the input data
void Texture::ChangeTexture ( 
        GLenum  target,
        GLint   level,
        GLint   internalFormat,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        GLint   border,
        GLenum  pixelFormat,
        GLenum  dataType,
        //-----------------------------
        GLvoid *    texels,     // texel data
        //-----------------------------
        unsigned short  numOfTextures   // number of 2D textures
        //-----------------------------
)
{
    //-----------------------------------------------------
    m_Target    =   target;
    m_Level     =   level;
    m_InternalFormat    =   internalFormat;
    m_Width     =   width;
    m_Height    =   height;
    m_Depth     =   depth;
    m_Border    =   border;
    m_PixelFormat       =   pixelFormat;
    m_DataType  =   dataType;
    //-----------------------
    m_NumOfTextures = numOfTextures;
    //-----------------------------------------------------
    CreateTexture( texels );
}
//-----------------------------------------------------------------------------
// Change Texture -- Delete and Recrete with the input data
void Texture::CreateTexture ( GLvoid const * texels )
{
    DeleteTexture ();
    //-----------------------------------------------------
    // Set Number of Components for Internal Format 
    //-----------------------------------------------------
    // FOUR COMPONENTS
    if      ( m_InternalFormat == 4 
           || m_InternalFormat == GL_COMPRESSED_RGBA 
           || m_InternalFormat == GL_RGBA 
           || m_InternalFormat == GL_RGBA2 
           || m_InternalFormat == GL_RGBA4 
           || m_InternalFormat == GL_RGB5_A1 
           || m_InternalFormat == GL_RGBA8 
           || m_InternalFormat == GL_RGB10_A2 
           || m_InternalFormat == GL_RGBA12 
           || m_InternalFormat == GL_RGBA16 
           || m_InternalFormat == GL_RGBA16F_ARB
           || m_InternalFormat == GL_RGBA32F_ARB
    ) {
        m_InternalFormatNumOfComponents = 4;
    }
    // THREE COMPONENTS
    else if ( m_InternalFormat == 3 
           || m_InternalFormat == GL_COMPRESSED_RGB 
           || m_InternalFormat == GL_RGB 
           || m_InternalFormat == GL_R3_G3_B2 
           || m_InternalFormat == GL_RGB4 
           || m_InternalFormat == GL_RGB5 
           || m_InternalFormat == GL_RGB8 
           || m_InternalFormat == GL_RGB10 
           || m_InternalFormat == GL_RGB12 
           || m_InternalFormat == GL_RGB16 
           || m_InternalFormat == GL_RGB16F_ARB
           || m_InternalFormat == GL_RGB32F_ARB
    ) {
        m_InternalFormatNumOfComponents = 3;
    }
    // ONE COMPONENT
    else if ( m_InternalFormat == 1 
           || m_InternalFormat == GL_COMPRESSED_ALPHA 
           || m_InternalFormat == GL_ALPHA 
           || m_InternalFormat == GL_ALPHA4 
           || m_InternalFormat == GL_ALPHA8 
           || m_InternalFormat == GL_ALPHA12 
           || m_InternalFormat == GL_ALPHA16 
           || m_InternalFormat == GL_ALPHA16F_ARB 
           || m_InternalFormat == GL_ALPHA32F_ARB 
           || m_InternalFormat == GL_COMPRESSED_LUMINANCE 
           || m_InternalFormat == GL_LUMINANCE 
           || m_InternalFormat == GL_LUMINANCE4 
           || m_InternalFormat == GL_LUMINANCE8 
           || m_InternalFormat == GL_LUMINANCE12 
           || m_InternalFormat == GL_LUMINANCE16 
           || m_InternalFormat == GL_LUMINANCE16F_ARB
           || m_InternalFormat == GL_LUMINANCE32F_ARB
           || m_InternalFormat == GL_COMPRESSED_INTENSITY 
           || m_InternalFormat == GL_INTENSITY 
           || m_InternalFormat == GL_INTENSITY4 
           || m_InternalFormat == GL_INTENSITY8 
           || m_InternalFormat == GL_INTENSITY12 
           || m_InternalFormat == GL_INTENSITY16 
           || m_InternalFormat == GL_INTENSITY16F_ARB 
           || m_InternalFormat == GL_INTENSITY32F_ARB 
           || m_InternalFormat == GL_DEPTH_COMPONENT 
           || m_InternalFormat == GL_DEPTH_COMPONENT16 
           || m_InternalFormat == GL_DEPTH_COMPONENT24 
           || m_InternalFormat == GL_DEPTH_COMPONENT32 
    ) {
        m_InternalFormatNumOfComponents = 1;
    }
    // TWO COMPONENTS
    else if ( m_InternalFormat == 2 
           || m_InternalFormat == GL_COMPRESSED_LUMINANCE_ALPHA 
           || m_InternalFormat == GL_LUMINANCE_ALPHA 
           || m_InternalFormat == GL_LUMINANCE4_ALPHA4 
           || m_InternalFormat == GL_LUMINANCE6_ALPHA2 
           || m_InternalFormat == GL_LUMINANCE8_ALPHA8 
           || m_InternalFormat == GL_LUMINANCE12_ALPHA4 
           || m_InternalFormat == GL_LUMINANCE12_ALPHA12 
           || m_InternalFormat == GL_LUMINANCE16_ALPHA16 
           || m_InternalFormat == GL_LUMINANCE_ALPHA16F_ARB 
           || m_InternalFormat == GL_LUMINANCE_ALPHA32F_ARB 
    ) {
        m_InternalFormatNumOfComponents = 2;
    }
    else {
        std::cerr << "Internal Format is unsupported!" << std::endl;
        assert( false );
    }
    //-----------------------------------------------------
    //-----------------------------------------------------
    // Set Number of Components for Pixel Format 
    //-----------------------------------------------------
    // FOUR COMPONENTS
    if      ( m_PixelFormat == GL_RGBA 
           || m_PixelFormat == GL_BGRA 
    ) {
        m_PixelFormatNumOfComponents = 4;
    }
    // THREE COMPONENTS
    else if ( m_PixelFormat == GL_RGB 
           || m_PixelFormat == GL_BGR 
    ) {
        m_PixelFormatNumOfComponents = 3;
    }
    // ONE COMPONENT
    else if ( m_PixelFormat == GL_COLOR_INDEX   // a single color index
           || m_PixelFormat == GL_RED 
           || m_PixelFormat == GL_GREEN 
           || m_PixelFormat == GL_BLUE
           || m_PixelFormat == GL_ALPHA 
           || m_PixelFormat == GL_LUMINANCE 
           || m_PixelFormat == GL_DEPTH_COMPONENT 
    ) {
        m_PixelFormatNumOfComponents = 1;
    }
    // TWO COMPONENTS
    else if ( m_PixelFormat == GL_LUMINANCE_ALPHA 
    ) {
        m_PixelFormatNumOfComponents = 2;
    }
    else {
        std::cerr << "Pixel Format is unsupported!" << std::endl;
        assert( false );
    }
    //-----------------------------------------------------
    // Set Max & Min Texture Coordinates
    if ( m_Target == GL_TEXTURE_RECTANGLE_ARB ) {
        m_MaxCoordS = m_Width;
        m_MaxCoordT = m_Height;
        m_MaxCoordR = m_Depth;
    }
    else {
        m_MaxCoordS = 1;
        m_MaxCoordT = 1;
        m_MaxCoordR = 1;
    }
    m_MinCoordS = 0;
    m_MinCoordT = 0;
    m_MinCoordR = 0;
    //-----------------------------------------------------
    assert( m_NumOfTextures > 0 );
    m_TextureNames = new GLuint[ m_NumOfTextures ];
    glGenTextures( m_NumOfTextures, m_TextureNames );
    if ( m_Target == GL_TEXTURE_2D || m_Target == GL_TEXTURE_RECTANGLE_ARB ) {
        for ( int i = 0; i < m_NumOfTextures; ++i ) {
            glBindTexture( m_Target, m_TextureNames[i] );
            glTexParameterf( m_Target, GL_TEXTURE_MAG_FILTER, m_ParamTex_MagFilter );
            glTexParameterf( m_Target, GL_TEXTURE_MIN_FILTER, m_ParamTex_MinFilter );
            glTexParameterf( m_Target, GL_TEXTURE_WRAP_S, m_ParamTex_Wrap_S );
            glTexParameterf( m_Target, GL_TEXTURE_WRAP_T, m_ParamTex_Wrap_T );
        }
    }
    else if ( m_Target == GL_TEXTURE_3D ) {
        for ( int i = 0; i < m_NumOfTextures; ++i ) {
            glBindTexture( m_Target, m_TextureNames[i] );
            glTexParameterf( m_Target, GL_TEXTURE_MAG_FILTER, m_ParamTex_MagFilter );
            glTexParameterf( m_Target, GL_TEXTURE_MIN_FILTER, m_ParamTex_MinFilter );
            glTexParameterf( m_Target, GL_TEXTURE_WRAP_S, m_ParamTex_Wrap_S );
            glTexParameterf( m_Target, GL_TEXTURE_WRAP_T, m_ParamTex_Wrap_T );
            glTexParameterf( m_Target, GL_TEXTURE_WRAP_R, m_ParamTex_Wrap_R );
        }
    }
    else if ( m_Target == GL_TEXTURE_1D ) {
        for ( int i = 0; i < m_NumOfTextures; ++i ) {
            glBindTexture( m_Target, m_TextureNames[i] );
            glTexParameterf( m_Target, GL_TEXTURE_MAG_FILTER, m_ParamTex_MagFilter );
            glTexParameterf( m_Target, GL_TEXTURE_MIN_FILTER, m_ParamTex_MinFilter );
            glTexParameterf( m_Target, GL_TEXTURE_WRAP_S, m_ParamTex_Wrap_S );
        }
    }
    else {
        std::cerr << "Texture target is unsupported!" << std::endl;
        assert( false );
    }



    // DEBUG
    //std::cout << "m_NumOfTextures: " << m_NumOfTextures << std::endl;
    //for ( int i = 0; i < m_NumOfTextures; ++i ) {
    //  std::cout << "m_TextureNames[" << i << "] is " << m_TextureNames[i] << std::endl;
    //}

    //-----------------------------------------------------
    // Determine Data Type
    //-----------------------------------------------------
    GLubyte *   texelsUByte     = NULL;
    GLushort *  texelsUShort    = NULL;
    GLuint *    texelsUInt      = NULL;
    //
    GLfloat *   texelsFloat     = NULL;
    GLdouble *  texelsDouble    = NULL;
    //
    GLbyte *    texelsByte      = NULL;
    GLshort *   texelsShort     = NULL;
    GLint *     texelsInt       = NULL;
    //-----------------------------------------------------
    // GLubyte *
    if      ( m_DataType == GL_UNSIGNED_BYTE 
           //|| m_DataType == GL_BITMAP     // single bits in unsigned 8-bit integers
                                            //   using the same format is glBitmap()
           || m_DataType == GL_UNSIGNED_BYTE_3_3_2 
           || m_DataType == GL_UNSIGNED_BYTE_2_3_3_REV 
    ) {
        CreateTexImageFrom( (GLubyte *) texels );
    }
    // GLushort *
    else if ( m_DataType == GL_UNSIGNED_SHORT 
           || m_DataType == GL_UNSIGNED_SHORT_5_6_5 
           || m_DataType == GL_UNSIGNED_SHORT_5_6_5_REV 
           || m_DataType == GL_UNSIGNED_SHORT_4_4_4_4 
           || m_DataType == GL_UNSIGNED_SHORT_4_4_4_4_REV 
           || m_DataType == GL_UNSIGNED_SHORT_5_5_5_1 
           || m_DataType == GL_UNSIGNED_SHORT_1_5_5_5_REV 
    ) {
        CreateTexImageFrom( (GLushort *) texels );
    }
    // GLuint *
    else if ( m_DataType == GL_UNSIGNED_INT 
           || m_DataType == GL_UNSIGNED_INT_8_8_8_8 
           || m_DataType == GL_UNSIGNED_INT_8_8_8_8_REV 
           || m_DataType == GL_UNSIGNED_INT_10_10_10_2 
           || m_DataType == GL_UNSIGNED_INT_2_10_10_10_REV 
    ) {
        CreateTexImageFrom( (GLuint *) texels );
    }
    // GLfloat *
    else if ( m_DataType == GL_FLOAT 
    ) {
        CreateTexImageFrom( (GLfloat *) texels );
    }
    // GLdouble *
    else if ( m_DataType == GL_DOUBLE 
    ) {
        CreateTexImageFrom( (GLdouble *) texels );
    }
    // GLbyte *
    else if ( m_DataType == GL_BYTE 
    ) {
        CreateTexImageFrom( (GLbyte *) texels );
    }
    // GLshort *
    else if ( m_DataType == GL_SHORT 
    ) {
        CreateTexImageFrom( (GLshort *) texels );
    }
    // GLint *
    else if ( m_DataType == GL_INT 
    ) {
        CreateTexImageFrom( (GLint *) texels );
    }
    else {
        std::cerr << "DataType is unsupported!" << std::endl;
    }
    //-----------------------------------------------------
}
//-----------------------------------------------------------------------------
template <typename T>
void Texture::CreateTexImageFrom ( T const * texels )
{
    //*
    if ( m_Target == GL_TEXTURE_2D || m_Target == GL_TEXTURE_RECTANGLE_ARB ) {
        if ( texels ) {
            int idx = 0;
            int offset = m_Width * m_Height * m_PixelFormatNumOfComponents;
            for ( int i = 0; i < m_NumOfTextures; ++i ) {
                glBindTexture( m_Target, m_TextureNames[i] );
                UseParameters();
                glTexImage2D( m_Target, m_Level, m_InternalFormat, 
                    m_Width, m_Height, m_Border, 
                    m_PixelFormat, m_DataType, 
                    &texels[ idx ] 
                );
                idx += offset;
            }
        }
        else {
            for ( int i = 0; i < m_NumOfTextures; ++i ) {
                glBindTexture( m_Target, m_TextureNames[i] );
                UseParameters();
                glTexImage2D( m_Target, m_Level, m_InternalFormat, 
                    m_Width, m_Height, m_Border, 
                    m_PixelFormat, m_DataType, 
                    NULL 
                );
            }
        }
    }
#ifdef  TAPs_USE_GLSL
    else if ( m_Target == GL_TEXTURE_3D ) {
        if ( texels ) {
            int idx = 0;
            int offset = m_Width * m_Height * m_Depth * m_PixelFormatNumOfComponents;
            for ( int i = 0; i < m_NumOfTextures; ++i ) {
                glBindTexture( m_Target, m_TextureNames[i] );
                UseParameters();
                glTexImage3D( m_Target, m_Level, m_InternalFormat, 
                    m_Width, m_Height, m_Depth, m_Border, 
                    m_PixelFormat, m_DataType, 
                    &texels[ idx ] 
                );
                idx += offset;
            }
        }
        else {
            for ( int i = 0; i < m_NumOfTextures; ++i ) {
                glBindTexture( m_Target, m_TextureNames[i] );
                UseParameters();
                glTexImage3D( m_Target, m_Level, m_InternalFormat, 
                    m_Width, m_Height, m_Depth, m_Border, 
                    m_PixelFormat, m_DataType, 
                    NULL 
                );
            }
        }
    }
#endif//TAPs_USE_GLSL
    else if ( m_Target == GL_TEXTURE_1D ) {
        if ( texels ) {
            int idx = 0;
            int offset = m_Width * m_PixelFormatNumOfComponents;
            for ( int i = 0; i < m_NumOfTextures; ++i ) {
                glBindTexture( m_Target, m_TextureNames[i] );
                UseParameters();
                glTexImage1D( m_Target, m_Level, m_InternalFormat, 
                    m_Width, m_Border, 
                    m_PixelFormat, m_DataType, 
                    &texels[ idx ] 
                );
                idx += offset;
            }
        }
        else {
            for ( int i = 0; i < m_NumOfTextures; ++i ) {
                glBindTexture( m_Target, m_TextureNames[i] );
                UseParameters();
                glTexImage1D( m_Target, m_Level, m_InternalFormat, 
                    m_Width, m_Border, 
                    m_PixelFormat, m_DataType, 
                    NULL 
                );
            }
        }
    }
    else {
        std::cerr << "Texture Type is unsupported!" << std::endl;
        assert( false );
    }
    //*/
}
//-----------------------------------------------------------------------------
void Texture::PrintTextureData ( unsigned short texNum )
{
    assert( texNum < m_NumOfTextures );
    //-----------------------------------------------------
    // Determine Data Type
    //-----------------------------------------------------
    unsigned int size = m_Width * m_Height * m_Depth * 
                        m_InternalFormatNumOfComponents;
    //-----------------------------------------------------
    // GLubyte *
    if      ( m_DataType == GL_UNSIGNED_BYTE 
           //|| m_DataType == GL_BITMAP     // single bits in unsigned 8-bit integers
                                            //   using the same format is glBitmap()
           || m_DataType == GL_UNSIGNED_BYTE_3_3_2 
           || m_DataType == GL_UNSIGNED_BYTE_2_3_3_REV 
    ) {
        GLubyte * dataType = new GLubyte[ size ];
        PrintTextureData( texNum, dataType, size );
    }
    // GLushort *
    else if ( m_DataType == GL_UNSIGNED_SHORT 
           || m_DataType == GL_UNSIGNED_SHORT_5_6_5 
           || m_DataType == GL_UNSIGNED_SHORT_5_6_5_REV 
           || m_DataType == GL_UNSIGNED_SHORT_4_4_4_4 
           || m_DataType == GL_UNSIGNED_SHORT_4_4_4_4_REV 
           || m_DataType == GL_UNSIGNED_SHORT_5_5_5_1 
           || m_DataType == GL_UNSIGNED_SHORT_1_5_5_5_REV 
    ) {
        GLushort * dataType = new GLushort[ size ];
        PrintTextureData( texNum, dataType, size );
    }
    // GLuint *
    else if ( m_DataType == GL_UNSIGNED_INT 
           || m_DataType == GL_UNSIGNED_INT_8_8_8_8 
           || m_DataType == GL_UNSIGNED_INT_8_8_8_8_REV 
           || m_DataType == GL_UNSIGNED_INT_10_10_10_2 
           || m_DataType == GL_UNSIGNED_INT_2_10_10_10_REV 
    ) {
        GLuint * dataType = new GLuint[ size ];
        PrintTextureData( texNum, dataType, size );
    }
    // GLfloat *
    else if ( m_DataType == GL_FLOAT 
    ) {
        GLfloat * dataType= new GLfloat[ size ];
        PrintTextureData( texNum, dataType, size );
    }
    // GLdouble *
    else if ( m_DataType == GL_DOUBLE 
    ) {
        GLdouble * dataType = new GLdouble[ size ];
        PrintTextureData( texNum, dataType, size );
    }
    // GLbyte *
    else if ( m_DataType == GL_BYTE 
    ) {
        GLbyte * dataType = new GLbyte[ size ];
        PrintTextureData( texNum, dataType, size );
    }
    // GLshort *
    else if ( m_DataType == GL_SHORT 
    ) {
        GLshort * dataType = new GLshort[ size ];
        PrintTextureData( texNum, dataType, size );
    }
    // GLint *
    else if ( m_DataType == GL_INT 
    ) {
        GLint * dataType = new GLint[ size ];
        PrintTextureData( texNum, dataType, size );
    }
    else {
        std::cerr << "DataType is unsupported!" << std::endl;
    }
    //-----------------------------------------------------
}
//-----------------------------------------------------------------------------
template <typename T>
void Texture::PrintTextureData ( unsigned short texNum, T * outData, unsigned int size )
{
    //---------------------------------------------------------------
    if ( m_Target == GL_TEXTURE_2D || m_Target == GL_TEXTURE_RECTANGLE_ARB ) {
        //std::cout << "PrintTextureData for GL_TEXTURE_2D and GL_TEXTURE_RECTANGLE_ARB is NOT Implemented Yet!" << std::endl;
        glBindTexture( m_Target, m_TextureNames[texNum] );
        //-----------------------------
        std::cout << "2D (or RECTANGLE) TEXTURE TOTAL SIZE: " << size << std::endl;
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        //-----------------------------
        int count   = 0;
        int line    = 0;
        int sizeWH  = m_Width * m_Height * m_InternalFormatNumOfComponents;
        int lineWidth   = m_Width * m_InternalFormatNumOfComponents;
        int index   = 0;
        {
            std::cout << "2D Texture:\n";
            std::cout << "SIZE: " << sizeWH << "\n";
            for ( int i = 0; i < sizeWH; ++i ) {
                if ( line == 0 ) {
                    std::cout << "(";
                }
                std::cout << outData[index++];
                if ( ++line == lineWidth ) {
                    std::cout << ")\n";
                    line = 0;
                    count = 0;
                    continue;
                }
                if ( ++count % m_InternalFormatNumOfComponents != 0 )
                    std::cout << ", ";
                else
                    std::cout << ")\t(";
            }
        }
        glBindTexture( m_Target, 0 );
    }
    //---------------------------------------------------------------
    else if ( m_Target == GL_TEXTURE_3D ) {
        glBindTexture( m_Target, m_TextureNames[texNum] );
        //-----------------------------
        std::cout << "3D TEXTURE TOTAL SIZE: " << size << std::endl;
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        //-----------------------------
        int count   = 0;
        int line    = 0;
        int sizeWH  = m_Width * m_Height * m_InternalFormatNumOfComponents;
        int lineWidth   = m_Width * m_InternalFormatNumOfComponents;
        int index   = 0;
        for ( int d = 0; d < m_Depth; ++d ) {
            std::cout << "3D Texture Slice #" << d << ":\n";
            std::cout << "SIZE: " << sizeWH << "\n";
            for ( int i = 0; i < sizeWH; ++i ) {
                if ( line == 0 ) {
                    std::cout << "(";
                }
                std::cout << outData[index++];
                if ( ++line == lineWidth ) {
                    std::cout << ")\n";
                    line = 0;
                    count = 0;
                    continue;
                }
                if ( ++count % m_InternalFormatNumOfComponents != 0 )
                    std::cout << ", ";
                else
                    std::cout << ")\t(";
            }
        }
        glBindTexture( m_Target, 0 );
    }
    //---------------------------------------------------------------
    else if ( m_Target == GL_TEXTURE_1D ) {
        //std::cout << "PrintTextureData for GL_TEXTURE_1D is NOT Implemented Yet!" << std::endl;
        glBindTexture( m_Target, m_TextureNames[texNum] );
        //-----------------------------
        std::cout << "1D TEXTURE TOTAL SIZE: " << size << std::endl;
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        //-----------------------------
        int count   = 0;
        int line    = 0;
        int texelNum = 0;
        int sizeWH  = m_Width * m_InternalFormatNumOfComponents;
        int lineWidth   = m_InternalFormatNumOfComponents;
        int index   = 0;
        {
            std::cout << "1D Texture:\n";
            std::cout << "SIZE: " << sizeWH << "\n";
            for ( int i = 0; i < sizeWH; ++i, ++texelNum ) {
                if ( line == 0 ) {
                    std::cout << "#" << texelNum << "\t(";
                }
                std::cout << outData[index++];
                if ( ++line == lineWidth ) {
                    std::cout << ")\n";
                    line = 0;
                    count = 0;
                    continue;
                }
                if ( ++count % m_InternalFormatNumOfComponents != 0 )
                    std::cout << ", ";
                else
                    std::cout << ")\t(";
            }
        }
        glBindTexture( m_Target, 0 );
    }
    //---------------------------------------------------------------
    delete [] outData;
}
//-----------------------------------------------------------------------------
/*
template <typename T>
T* Texture::GetTextureData () const
{
    //-----------------------------------------------------
    // Determine Data Type
    //-----------------------------------------------------
    unsigned int size = m_Width * m_Height * m_Depth * 
                        m_InternalFormatNumOfComponents;
    //-----------------------------------------------------
    // GLubyte *
    if      ( m_DataType == GL_UNSIGNED_BYTE 
           //|| m_DataType == GL_BITMAP     // single bits in unsigned 8-bit integers
                                            //   using the same format is glBitmap()
           || m_DataType == GL_UNSIGNED_BYTE_3_3_2 
           || m_DataType == GL_UNSIGNED_BYTE_2_3_3_REV 
    ) {
        GLubyte * outData = new GLubyte[ size ];
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        return outData;
    }
    // GLushort *
    else if ( m_DataType == GL_UNSIGNED_SHORT 
           || m_DataType == GL_UNSIGNED_SHORT_5_6_5 
           || m_DataType == GL_UNSIGNED_SHORT_5_6_5_REV 
           || m_DataType == GL_UNSIGNED_SHORT_4_4_4_4 
           || m_DataType == GL_UNSIGNED_SHORT_4_4_4_4_REV 
           || m_DataType == GL_UNSIGNED_SHORT_5_5_5_1 
           || m_DataType == GL_UNSIGNED_SHORT_1_5_5_5_REV 
    ) {
        GLushort * outData = new GLushort[ size ];
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        return outData;
    }
    // GLuint *
    else if ( m_DataType == GL_UNSIGNED_INT 
           || m_DataType == GL_UNSIGNED_INT_8_8_8_8 
           || m_DataType == GL_UNSIGNED_INT_8_8_8_8_REV 
           || m_DataType == GL_UNSIGNED_INT_10_10_10_2 
           || m_DataType == GL_UNSIGNED_INT_2_10_10_10_REV 
    ) {
        GLuint * outData = new GLuint[ size ];
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        return outData;
    }
    // GLfloat *
    else if ( m_DataType == GL_FLOAT 
    ) {
        GLfloat * outData= new GLfloat[ size ];
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        return outData;
    }
    // GLdouble *
    else if ( m_DataType == GL_DOUBLE 
    ) {
        GLdouble * outData = new GLdouble[ size ];
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        return outData;
    }
    // GLbyte *
    else if ( m_DataType == GL_BYTE 
    ) {
        GLbyte * outData = new GLbyte[ size ];
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        return outData;
    }
    // GLshort *
    else if ( m_DataType == GL_SHORT 
    ) {
        GLshort * outData = new GLshort[ size ];
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        return outData;
    }
    // GLint *
    else if ( m_DataType == GL_INT 
    ) {
        GLint * outData = new GLint[ size ];
        glGetTexImage( m_Target, m_Level, m_PixelFormat, m_DataType, outData );
        return outData;
    }
    else {
        std::cerr << "DataType is unsupported!" << std::endl;
        return NULL;
    }
    //-----------------------------------------------------
}
//*/
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----