Texture Class Reference

#include <TAPsOpenGLTexture.hpp>

List of all members.

Public Member Functions
void	BindTexture (unsigned short idx=0)
void	ChangeTexture (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum pixelFormat, GLenum dataType, GLvoid *texels=NULL, unsigned short numOfTextures=1)
void	ChangeTexture (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum pixelFormat, GLenum dataType, GLvoid *texels=NULL, unsigned short numOfTextures=1)
void	ChangeTexture (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum pixelFormat, GLenum dataType, GLvoid *texels=NULL, unsigned short numOfTextures=1)
void	CreateTexture (GLvoid const *texels)
void	DeleteTexture ()
void	DisableTextureTarget ()
void	EnableTextureTarget ()
GLint	GetBorder () const
GLenum	GetDataType () const
GLsizei	GetDepth () const
GLsizei	GetHeight () const
GLint	GetInternalFormat () const
unsigned char	GetInternalFormatNumberOfComponents () const
GLint	GetLevel () const
short	GetMaxCoordR () const
short	GetMaxCoordS () const
short	GetMaxCoordT () const
short	GetMinCoordR () const
short	GetMinCoordS () const
short	GetMinCoordT () const
unsigned short	GetNumberOfTextures () const
GLenum	GetPixelFormat () const
unsigned char	GetPixelFormatNumberOfComponents () const
GLenum	GetTarget () const
GLuint	GetTexture (unsigned short idx=0) const
GLsizei	GetWidth () const
void	NextOfCircularBuffer ()
void	PrintTextureData (unsigned short texNum=0)
void	SetBorder (GLint border)
void	SetDataType (GLenum dataType)
void	SetDepth (GLsizei depth)
void	SetHeight (GLsizei height)
void	SetInternalFormat (GLint inFormat)
void	SetLevel (GLint level)
void	SetMaxCoordR (short maxCoordR)
void	SetMaxCoordS (short maxCoordS)
void	SetMaxCoordT (short maxCoordT)
void	SetMinCoordR (short minCoordR)
void	SetMinCoordS (short minCoordS)
void	SetMinCoordT (short minCoordT)
void	SetNumberOfTextures (unsigned short numOfTextures)
void	SetParameterMagFilter (GLint param)
void	SetParameterMinFilter (GLint param)
void	SetParameterWrapR (GLint param)
void	SetParameterWrapS (GLint param)
void	SetParameterWrapT (GLint param)
void	SetPixelFormat (GLenum pixFormat)
void	SetTarget (GLenum target)
void	SetWidth (GLsizei width)
	Texture (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum pixelFormat, GLenum dataType, GLvoid *texels=NULL, unsigned short numOfTextures=1, GLint magFilter=GL_NEAREST, GLint minFilter=GL_NEAREST, GLint wrapS=GL_CLAMP, GLint wrapT=GL_CLAMP, GLint wrapR=GL_CLAMP)
	Texture (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum pixelFormat, GLenum dataType, GLvoid *texels=NULL, unsigned short numOfTextures=1, GLint magFilter=GL_NEAREST, GLint minFilter=GL_NEAREST, GLint wrapS=GL_CLAMP, GLint wrapT=GL_CLAMP, GLint wrapR=GL_CLAMP)
	Texture (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum pixelFormat, GLenum dataType, GLvoid *texels=NULL, unsigned short numOfTextures=1, GLint magFilter=GL_NEAREST, GLint minFilter=GL_NEAREST, GLint wrapS=GL_CLAMP, GLint wrapT=GL_CLAMP, GLint wrapR=GL_CLAMP)
	Texture ()
void	UnbindTexture ()
void	UseParameters ()
	~Texture ()
Protected Member Functions
template<typename T>
void	CreateTexImageFrom (T const *texels)
template<typename T>
void	PrintTextureData (unsigned short texNum, T *outData, unsigned int size)
Protected Attributes
GLint	m_Border
GLenum	m_DataType
GLsizei	m_Depth
GLsizei	m_Height
GLint	m_InternalFormat
unsigned char	m_InternalFormatNumOfComponents
GLint	m_Level
short	m_MaxCoordR
short	m_MaxCoordS
short	m_MaxCoordT
short	m_MinCoordR
short	m_MinCoordS
short	m_MinCoordT
unsigned short	m_NumOfTextures
GLint	m_ParamTex_MagFilter
GLint	m_ParamTex_MinFilter
GLint	m_ParamTex_Wrap_R
GLint	m_ParamTex_Wrap_S
GLint	m_ParamTex_Wrap_T
GLenum	m_PixelFormat
unsigned char	m_PixelFormatNumOfComponents
GLenum	m_Target
GLuint *	m_TextureNames
GLsizei	m_Width
Friends
std::ostream &	operator<< (std::ostream &output, Texture const &o)

---

Detailed Description

TAPs::OpenGL::Texture A simple class for storing parameters of a (1D-3D) texture with some static functions to help initializing and using the texture

Definition at line 26 of file TAPsOpenGLTexture.hpp.

---

Constructor & Destructor Documentation

BEGIN_NAMESPACE_TAPs__OpenGL Texture::Texture

(

)

Default Constructor

Definition at line 17 of file TAPsOpenGLTexture.cpp.

                  : 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
    );
}

Texture::Texture	(	GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLsizei	width,
		GLint	border,
		GLenum	pixelFormat,
		GLenum	dataType,
		GLvoid *	texels = NULL,
		unsigned short	numOfTextures = 1,
		GLint	magFilter = GL_NEAREST,
		GLint	minFilter = GL_NEAREST,
		GLint	wrapS = GL_CLAMP,
		GLint	wrapT = GL_CLAMP,
		GLint	wrapR = GL_CLAMP
	)

Constructor for 1D Texture

Definition at line 35 of file TAPsOpenGLTexture.cpp.

  : 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
    );
}

Texture::Texture	(	GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLint	border,
		GLenum	pixelFormat,
		GLenum	dataType,
		GLvoid *	texels = NULL,
		unsigned short	numOfTextures = 1,
		GLint	magFilter = GL_NEAREST,
		GLint	minFilter = GL_NEAREST,
		GLint	wrapS = GL_CLAMP,
		GLint	wrapT = GL_CLAMP,
		GLint	wrapR = GL_CLAMP
	)

Constructor for 2D Texture

Definition at line 74 of file TAPsOpenGLTexture.cpp.

  : 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
    );
}

Texture::Texture	(	GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLsizei	depth,
		GLint	border,
		GLenum	pixelFormat,
		GLenum	dataType,
		GLvoid *	texels = NULL,
		unsigned short	numOfTextures = 1,
		GLint	magFilter = GL_NEAREST,
		GLint	minFilter = GL_NEAREST,
		GLint	wrapS = GL_CLAMP,
		GLint	wrapT = GL_CLAMP,
		GLint	wrapR = GL_CLAMP
	)

Constructor for 3D Texture

Definition at line 112 of file TAPsOpenGLTexture.cpp.

  : 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
    );
}

Texture::~Texture

(

)

Destructor

Definition at line 151 of file TAPsOpenGLTexture.cpp.

{
    DeleteTexture();
}

---

Member Function Documentation

void Texture::BindTexture

(

unsigned short

idx = 0

)

[inline]

Definition at line 279 of file TAPsOpenGLTexture.hpp.

                                               {
        assert( 0 <= idx && idx < m_NumOfTextures );
        glBindTexture( m_Target, m_TextureNames[ idx ] );
    }

void Texture::ChangeTexture	(	GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLsizei	depth,
		GLint	border,
		GLenum	pixelFormat,
		GLenum	dataType,
		GLvoid *	texels = NULL,
		unsigned short	numOfTextures = 1
	)

Definition at line 232 of file TAPsOpenGLTexture.cpp.

{
    //-----------------------------------------------------
    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 );
}

void Texture::ChangeTexture	(	GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLint	border,
		GLenum	pixelFormat,
		GLenum	dataType,
		GLvoid *	texels = NULL,
		unsigned short	numOfTextures = 1
	)

Definition at line 199 of file TAPsOpenGLTexture.cpp.

{
    //-----------------------------------------------------
    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 );
}

void Texture::ChangeTexture	(	GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLsizei	width,
		GLint	border,
		GLenum	pixelFormat,
		GLenum	dataType,
		GLvoid *	texels = NULL,
		unsigned short	numOfTextures = 1
	)

Definition at line 167 of file TAPsOpenGLTexture.cpp.

{
    //-----------------------------------------------------
    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 );
}

template<typename T>

void Texture::CreateTexImageFrom

(

T const *

texels

)

[inline, protected]

Definition at line 526 of file TAPsOpenGLTexture.cpp.

{
    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 
                );
            }
        }
    }
    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 
                );
            }
        }
    }
    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::CreateTexture

(

GLvoid const *

texels

)

Definition at line 266 of file TAPsOpenGLTexture.cpp.

{
    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;
    }
    //-----------------------------------------------------
}

void Texture::DeleteTexture

(

)

Definition at line 157 of file TAPsOpenGLTexture.cpp.

{
    if ( m_TextureNames ) {
        glDeleteTextures( m_NumOfTextures, m_TextureNames );
        delete [] m_TextureNames;
        m_TextureNames = NULL;
    }
}

void Texture::DisableTextureTarget

(

)

[inline]

Definition at line 276 of file TAPsOpenGLTexture.hpp.

                                 {
        glDisable( m_Target );
    }

void Texture::EnableTextureTarget

(

)

[inline]

Definition at line 273 of file TAPsOpenGLTexture.hpp.

                                {
        glEnable( m_Target );
    }

GLint Texture::GetBorder

(

)

const [inline]

Definition at line 223 of file TAPsOpenGLTexture.hpp.

{ return m_Border; }

GLenum Texture::GetDataType

(

)

const [inline]

Definition at line 225 of file TAPsOpenGLTexture.hpp.

{ return m_DataType; }

GLsizei Texture::GetDepth

(

)

const [inline]

Definition at line 222 of file TAPsOpenGLTexture.hpp.

{ return m_Depth; }

GLsizei Texture::GetHeight

(

)

const [inline]

Definition at line 221 of file TAPsOpenGLTexture.hpp.

{ return m_Height; }

GLint Texture::GetInternalFormat

(

)

const [inline]

Definition at line 219 of file TAPsOpenGLTexture.hpp.

{ return m_InternalFormat; }

unsigned char Texture::GetInternalFormatNumberOfComponents

(

)

const [inline]

Definition at line 227 of file TAPsOpenGLTexture.hpp.

        { return m_InternalFormatNumOfComponents; }

GLint Texture::GetLevel

(

)

const [inline]

Definition at line 218 of file TAPsOpenGLTexture.hpp.

{ return m_Level; }

short Texture::GetMaxCoordR

(

)

const [inline]

Definition at line 234 of file TAPsOpenGLTexture.hpp.

{ return m_MaxCoordR; }

short Texture::GetMaxCoordS

(

)

const [inline]

Definition at line 232 of file TAPsOpenGLTexture.hpp.

{ return m_MaxCoordS; }

short Texture::GetMaxCoordT

(

)

const [inline]

Definition at line 233 of file TAPsOpenGLTexture.hpp.

{ return m_MaxCoordT; }

short Texture::GetMinCoordR

(

)

const [inline]

Definition at line 237 of file TAPsOpenGLTexture.hpp.

{ return m_MinCoordR; }

short Texture::GetMinCoordS

(

)

const [inline]

Definition at line 235 of file TAPsOpenGLTexture.hpp.

{ return m_MinCoordS; }

short Texture::GetMinCoordT

(

)

const [inline]

Definition at line 236 of file TAPsOpenGLTexture.hpp.

{ return m_MinCoordT; }

unsigned short Texture::GetNumberOfTextures

(

)

const [inline]

Definition at line 239 of file TAPsOpenGLTexture.hpp.

{ return m_NumOfTextures; }

GLenum Texture::GetPixelFormat

(

)

const [inline]

Definition at line 224 of file TAPsOpenGLTexture.hpp.

{ return m_PixelFormat; }

unsigned char Texture::GetPixelFormatNumberOfComponents

(

)

const [inline]

Definition at line 229 of file TAPsOpenGLTexture.hpp.

        { return m_PixelFormatNumOfComponents; }

GLenum Texture::GetTarget

(

)

const [inline]

Definition at line 217 of file TAPsOpenGLTexture.hpp.

{ return m_Target; }

GLuint Texture::GetTexture

(

unsigned short

idx = 0

)

const [inline]

Definition at line 241 of file TAPsOpenGLTexture.hpp.

        { 
            assert( 0 <= idx && idx < m_NumOfTextures );
            return m_TextureNames[ idx ]; 
        }

GLsizei Texture::GetWidth

(

)

const [inline]

Definition at line 220 of file TAPsOpenGLTexture.hpp.

{ return m_Width; }

void Texture::NextOfCircularBuffer

(

)

[inline]

Care must be taken when using this function. Move (by exchanging of pointer) 0th texture to 1th texture, 1th texture to 2nd texture, ... and the (n-1)th (last) texture to 0th texture. Same as swap if there are only two textures in this texture object

Definition at line 257 of file TAPsOpenGLTexture.hpp.

                                 {
        unsigned short i = 0;
        GLuint tempTexName = m_TextureNames[i];
        while ( i < m_NumOfTextures-1 ) {
            m_TextureNames[i] = m_TextureNames[i+1];
            ++i;
        }
        m_TextureNames[i] = tempTexName;
    }

template<typename T>

void Texture::PrintTextureData	(	unsigned short	texNum,
		T *	outData,
		unsigned int	size
	)			[inline, protected]

Definition at line 693 of file TAPsOpenGLTexture.cpp.

{
    //---------------------------------------------------------------
    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;
}

void Texture::PrintTextureData

(

unsigned short

texNum = 0

)

Definition at line 615 of file TAPsOpenGLTexture.cpp.

{
    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;
    }
    //-----------------------------------------------------
}

void Texture::SetBorder

(

GLint

border

)

[inline]

Definition at line 197 of file TAPsOpenGLTexture.hpp.

{ m_Border = border; }

void Texture::SetDataType

(

GLenum

dataType

)

[inline]

Definition at line 199 of file TAPsOpenGLTexture.hpp.

{ m_DataType = dataType; }

void Texture::SetDepth

(

GLsizei

depth

)

[inline]

Definition at line 196 of file TAPsOpenGLTexture.hpp.

{ m_Depth = depth; }

void Texture::SetHeight

(

GLsizei

height

)

[inline]

Definition at line 195 of file TAPsOpenGLTexture.hpp.

{ m_Height = height; }

void Texture::SetInternalFormat

(

GLint

inFormat

)

[inline]

Definition at line 193 of file TAPsOpenGLTexture.hpp.

{ m_InternalFormat = inFormat; }

void Texture::SetLevel

(

GLint

level

)

[inline]

Definition at line 192 of file TAPsOpenGLTexture.hpp.

{ m_Level = level; }

void Texture::SetMaxCoordR

(

short

maxCoordR

)

[inline]

Definition at line 209 of file TAPsOpenGLTexture.hpp.

{ m_MaxCoordR = maxCoordR; }

void Texture::SetMaxCoordS

(

short

maxCoordS

)

[inline]

Drawing functions contained in this class will use min and max coordinates to define the texture region to be drawn -- e.g. can be used for zooming in/out.

Definition at line 207 of file TAPsOpenGLTexture.hpp.

{ m_MaxCoordS = maxCoordS; }

void Texture::SetMaxCoordT

(

short

maxCoordT

)

[inline]

Definition at line 208 of file TAPsOpenGLTexture.hpp.

{ m_MaxCoordT = maxCoordT; }

void Texture::SetMinCoordR

(

short

minCoordR

)

[inline]

Definition at line 212 of file TAPsOpenGLTexture.hpp.

{ m_MinCoordR = minCoordR; }

void Texture::SetMinCoordS

(

short

minCoordS

)

[inline]

Definition at line 210 of file TAPsOpenGLTexture.hpp.

{ m_MinCoordS = minCoordS; }

void Texture::SetMinCoordT

(

short

minCoordT

)

[inline]

Definition at line 211 of file TAPsOpenGLTexture.hpp.

{ m_MinCoordT = minCoordT; }

void Texture::SetNumberOfTextures

(

unsigned short

numOfTextures

)

[inline]

Definition at line 200 of file TAPsOpenGLTexture.hpp.

        { m_NumOfTextures = numOfTextures; }

void Texture::SetParameterMagFilter

(

GLint

param

)

[inline]

Definition at line 267 of file TAPsOpenGLTexture.hpp.

{ m_ParamTex_MagFilter = param; }

void Texture::SetParameterMinFilter

(

GLint

param

)

[inline]

Definition at line 268 of file TAPsOpenGLTexture.hpp.

{ m_ParamTex_MinFilter = param; }

void Texture::SetParameterWrapR

(

GLint

param

)

[inline]

Definition at line 271 of file TAPsOpenGLTexture.hpp.

{ m_ParamTex_Wrap_R = param; }

void Texture::SetParameterWrapS

(

GLint

param

)

[inline]

Definition at line 269 of file TAPsOpenGLTexture.hpp.

{ m_ParamTex_Wrap_S = param; }

void Texture::SetParameterWrapT

(

GLint

param

)

[inline]

Definition at line 270 of file TAPsOpenGLTexture.hpp.

{ m_ParamTex_Wrap_T = param; }

void Texture::SetPixelFormat

(

GLenum

pixFormat

)

[inline]

Definition at line 198 of file TAPsOpenGLTexture.hpp.

{ m_PixelFormat = pixFormat; }

void Texture::SetTarget

(

GLenum

target

)

[inline]

Definition at line 191 of file TAPsOpenGLTexture.hpp.

{ m_Target = target; }

void Texture::SetWidth

(

GLsizei

width

)

[inline]

Definition at line 194 of file TAPsOpenGLTexture.hpp.

{ m_Width = width; }

void Texture::UnbindTexture

(

)

[inline]

Definition at line 290 of file TAPsOpenGLTexture.hpp.

                         {
        glBindTexture( m_Target, 0 );
    }

void Texture::UseParameters

(

)

[inline]

Definition at line 283 of file TAPsOpenGLTexture.hpp.

                          {
        glTexParameteri( m_Target, GL_TEXTURE_WRAP_S, m_ParamTex_Wrap_S );
        glTexParameteri( m_Target, GL_TEXTURE_WRAP_T, m_ParamTex_Wrap_T );
        glTexParameteri( m_Target, GL_TEXTURE_WRAP_R, m_ParamTex_Wrap_R );
        glTexParameteri( m_Target, GL_TEXTURE_MAG_FILTER, m_ParamTex_MagFilter );
        glTexParameteri( m_Target, GL_TEXTURE_MIN_FILTER, m_ParamTex_MinFilter );
    }

---

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	output,
		Texture const &	o
	)			[friend]

Definition at line 30 of file TAPsOpenGLTexture.hpp.

    {
        output  <<   "TAPs Texture:"
                    << "\n-------------"
                    << "\nTarget:   " << o.m_Target
                    << "\nLevel:    " << o.m_Level
                    << "\nInternalFormat: " << o.m_InternalFormat
                    << "\n#InternalFormatComponents: " << (int) o.m_InternalFormatNumOfComponents
                    << "\nWidth:    " << o.m_Width
                    << "\nHeight:   " << o.m_Height
                    << "\nDepth:    " << o.m_Depth
                    << "\nBorder:   " << o.m_Border
                    << "\nPixelFormat: " << o.m_PixelFormat
                    << "\n#PixelFormatComponents: " << (int) o.m_PixelFormatNumOfComponents
                    << "\nDataType: " << o.m_DataType
                    << "\n#Textures: " << o.m_NumOfTextures
                    << "\nMaxCoord: " << o.m_MaxCoordS << ", " << o.m_MaxCoordT << ", " << o.m_MaxCoordR
                    << "\nMinCoord: " << o.m_MinCoordS << ", " << o.m_MinCoordT << ", " << o.m_MinCoordR
                    << "\nWrapS: " << o.m_ParamTex_Wrap_S
                    << "\nWrapT: " << o.m_ParamTex_Wrap_T
                    << "\nWrapR: " << o.m_ParamTex_Wrap_R
                    << "\nMagFilter: " << o.m_ParamTex_MagFilter
                    << "\nMinFilter: " << o.m_ParamTex_MinFilter
                    << "\n-------------\n";
        return output;
    }

---

Member Data Documentation

GLint Texture::m_Border [protected]

Definition at line 314 of file TAPsOpenGLTexture.hpp.

GLenum Texture::m_DataType [protected]

Definition at line 316 of file TAPsOpenGLTexture.hpp.

GLsizei Texture::m_Depth [protected]

Definition at line 313 of file TAPsOpenGLTexture.hpp.

GLsizei Texture::m_Height [protected]

Definition at line 312 of file TAPsOpenGLTexture.hpp.

GLint Texture::m_InternalFormat [protected]

Definition at line 310 of file TAPsOpenGLTexture.hpp.

unsigned char Texture::m_InternalFormatNumOfComponents [protected]

Definition at line 318 of file TAPsOpenGLTexture.hpp.

GLint Texture::m_Level [protected]

Definition at line 309 of file TAPsOpenGLTexture.hpp.

short Texture::m_MaxCoordR [protected]

Definition at line 331 of file TAPsOpenGLTexture.hpp.

short Texture::m_MaxCoordS [protected]

If the target is GL_TEXTURE_3D or GL_TEXTURE_2D, then these max values will be automatically set to 1. If the target is GL_TEXTURE_RECTANGLE_ARB, then these max values must be automatically set to width and height of the texture. The min texture coordinates will be automatically set to 0.

Definition at line 329 of file TAPsOpenGLTexture.hpp.

short Texture::m_MaxCoordT [protected]

Definition at line 330 of file TAPsOpenGLTexture.hpp.

short Texture::m_MinCoordR [protected]

Definition at line 334 of file TAPsOpenGLTexture.hpp.

short Texture::m_MinCoordS [protected]

Definition at line 332 of file TAPsOpenGLTexture.hpp.

short Texture::m_MinCoordT [protected]

Definition at line 333 of file TAPsOpenGLTexture.hpp.

unsigned short Texture::m_NumOfTextures [protected]

Definition at line 336 of file TAPsOpenGLTexture.hpp.

GLint Texture::m_ParamTex_MagFilter [protected]

Definition at line 344 of file TAPsOpenGLTexture.hpp.

GLint Texture::m_ParamTex_MinFilter [protected]

Definition at line 345 of file TAPsOpenGLTexture.hpp.

GLint Texture::m_ParamTex_Wrap_R [protected]

Definition at line 343 of file TAPsOpenGLTexture.hpp.

GLint Texture::m_ParamTex_Wrap_S [protected]

Definition at line 341 of file TAPsOpenGLTexture.hpp.

GLint Texture::m_ParamTex_Wrap_T [protected]

Definition at line 342 of file TAPsOpenGLTexture.hpp.

GLenum Texture::m_PixelFormat [protected]

Definition at line 315 of file TAPsOpenGLTexture.hpp.

unsigned char Texture::m_PixelFormatNumOfComponents [protected]

Definition at line 319 of file TAPsOpenGLTexture.hpp.

GLenum Texture::m_Target [protected]

Definition at line 308 of file TAPsOpenGLTexture.hpp.

GLuint* Texture::m_TextureNames [protected]

Definition at line 338 of file TAPsOpenGLTexture.hpp.

GLsizei Texture::m_Width [protected]

Definition at line 311 of file TAPsOpenGLTexture.hpp.

---

The documentation for this class was generated from the following files:

• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGL/TAPsOpenGLTexture.hpp
• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGL/TAPsOpenGLTexture.cpp