D:/Programming/GUI Editor (Source)/OpenGLTexture.cpp

// OpenGLTexture.cpp: implementation of the COpenGLTexture class.
//
#include "StdAfx.h"
#include "OpenGLTexture.h"

// Construction/Destruction

COpenGLTexture::COpenGLTexture()
{
        SetEntityType(Entity_OpenGLTexture);
        m_uiGLTextureID = m_uiGLFormat = m_uiGLInternalFormat = m_uiPixelStride = 0;
        m_Mask = tRGBA(-1, -1, -1, -1);
}

COpenGLTexture::~COpenGLTexture()
{
        Release();
}

void COpenGLTexture::Release()
{
        if(glIsTexture(m_uiGLTextureID))
                glDeleteTextures(1, &m_uiGLTextureID);

        m_uiGLTextureID = 0;
}

void COpenGLTexture::Bind()
{
        if(m_uiGLTextureID == 0)
        {
                glDisable(GL_TEXTURE_2D);
                return;
        }
        else
        {
                if(glIsTexture(m_uiGLTextureID))
                {
                        glEnable(GL_TEXTURE_2D);
                        glBindTexture(GL_TEXTURE_2D, m_uiGLTextureID);
                }
                else
                        glDisable(GL_TEXTURE_2D);
        }
}

int COpenGLTexture::LoadXML(TiXmlNode *pDataNode, CString strFilename)
{
        TiXmlElement* pXMLElement = NULL;
        const char *pcValue = NULL;

        int iRetValue = CTexture::LoadXML(pDataNode, strFilename);      // LoadXML the data of derivative
        if(iRetValue !=1)
                return iRetValue;
        
        return Create();
}

int COpenGLTexture::SaveXML(TiXmlNode *pDataNode, CString strFilename)
{
        return CTexture::SaveXML(pDataNode, strFilename);
}

UINT COpenGLTexture::Create()
{
        UINT ImageWidth = 0, ImageHeight = 0, ImageDepth = 0;
        BYTE* ImageData = NULL;

        ImageWidth = FreeImage_GetWidth(m_pBitmap);// Get width
        ImageHeight = FreeImage_GetHeight(m_pBitmap);// Get height
        ImageDepth = FreeImage_GetBPP(m_pBitmap);       // get depth
        
        if(!IsMasked())
                FreeImage_ConvertTo24Bits(m_pBitmap);// Convert to 3 bytes
        else
                FreeImage_ConvertTo32Bits(m_pBitmap);// Convert to 4 bytes

        ImageData = FreeImage_GetBits(m_pBitmap);// Get image data

        // OpenGL Stuff:
        //glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glGenTextures(1, &m_uiGLTextureID);// Get next available texture handle
        glBindTexture(GL_TEXTURE_2D, m_uiGLTextureID);// Bind 2D texture to handle

        // If you want your own texture parameters, remove next two lines
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        BYTE *MaskedTexture = NULL;
        UINT uiIndex = 0;

        if(IsMasked())
        {
                MaskedTexture = new BYTE[ImageWidth * ImageHeight * 4];

                UINT uiIndex = 0;
                for (UINT i=0; i<ImageWidth * ImageHeight * (ImageDepth / 8); i+=(ImageDepth / 8))
                {
                        MaskedTexture[uiIndex] = ImageData[i];
                        MaskedTexture[uiIndex+1] = ImageData[i+1];
                        MaskedTexture[uiIndex+2] = ImageData[i+2];

                        if((ImageData[i] == (BYTE)(m_Mask.B)) && (ImageData[i+1] == (BYTE)(m_Mask.G)) && (ImageData[i+2] == (BYTE)(m_Mask.R)))
                                MaskedTexture[uiIndex + 3] = 0;
                        else
                                MaskedTexture[uiIndex + 3] = 255;

                        uiIndex+=4;
                }

                glTexImage2D(GL_TEXTURE_2D, 0, 4, ImageWidth, ImageHeight, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, MaskedTexture);
                delete[] MaskedTexture;
        }
        else
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, ImageWidth, ImageHeight, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, ImageData);


        if( (!CheckSize(GetWidth())) && (!CheckSize(GetHeight()))) // TEXTURE ISNT OF POWER OF 2
        {
                // CREATE MIPMAPS
                gluBuild2DMipmaps(GL_TEXTURE_2D, 
                        GetDepth(), 
                        GetWidth(), 
                        GetHeight(),
                        GL_BGR_EXT, 
                        GL_UNSIGNED_BYTE, 
                        m_pBitmap);
        }

        return 1;
}

void COpenGLTexture::Destroy()
{
        CTexture::Destroy();
}

bool COpenGLTexture::IsOfType(eEntityType eType)
{
        if(eType == Entity_OpenGLTexture)
                return true;

        return CTexture::IsOfType(eType);
}

// Function Format - bool CheckSize(GLuint)
//------------------------------------------------------------------
//  Description: This function checks if number is of power of 2
bool CheckSize(UINT Size)
{
        return  ( (Size & ((~Size)+1)) == Size) ? true : false;
}

---