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

#include "stdafx.h"
#include "Texture.h"

CTexture::CTexture()
{
        SetEntityType(Entity_Texture);

        m_pBitmap = NULL;
        m_Mask = tRGBA(-1, -1, -1, -1);
}

CTexture::~CTexture()
{
        Destroy();
}

UINT CTexture::Create()
{

        return 0;
}

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

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

        pXMLElement = m_pXMLElement;

        if(stricmp(pXMLElement->pcValue(), "Texture") !=0)
                return 0;

        if(pXMLElement !=NULL)
        {
                pcValue = pXMLElement->Attribute("Mask");
                if(pcValue !=NULL)
                {
                        int Color[3] = {0,0,0};
                        sscanf(pcValue, "%d,%d,%d", &Color[0], &Color[1], &Color[2]);
                        m_Mask.R = (float)Color[0]; m_Mask.G = (float)Color[1]; m_Mask.B = (float)Color[2];

                        pcValue = NULL;
                }

                pcValue = pXMLElement->Attribute("Image");
                if(pcValue !=NULL)
                {
                        if(LoadImage(GetFullPath(pcValue)))
                        {
                                m_strTextureFilename = pcValue;
                                return 1;
                        }
                }
        }
        else
                return LoadImage(strFilename);


        return 0;
}

int CTexture::LoadImage(CString strFilename)
{
        FREE_IMAGE_FORMAT FileType;

        FileType = FreeImage_GetFileType(strFilename.GetBuffer());// Get filetype
        if(FileType == FIF_UNKNOWN)
                return 0;

        m_pBitmap = FreeImage_Load(FileType, strFilename.GetBuffer());// LoadXML image
        if(m_pBitmap !=NULL)
        {
                m_strTextureFilename = strFilename;
                return 1;
        }
                
        return 0;
}

int CTexture::SaveXML(TiXmlNode *pDataNode, CString strFilename)
{
        TiXmlElement *pSaveElement = NULL;
        TiXmlDocument Doc;

        if(pDataNode !=NULL)
                pSaveElement = pDataNode->ToElement();
        else if(m_pXMLElement !=NULL)
                pSaveElement = m_pXMLElement;
        else
                pSaveElement = new TiXmlElement("Texture");

        char pcValue[256] = "";

        if(GetTextureFilename() !="")
                pSaveElement->SetAttribute("Image", GetTextureFilename().GetBuffer());

        if(GetName() !="")
                pSaveElement->SetAttribute("strName", GetName().GetBuffer());

        if(m_Mask.R !=-1 && m_Mask.G !=-1 && m_Mask.B !=-1)
        {
                int Color[3] = {(int)m_Mask.R, (int)m_Mask.G, (int)m_Mask.B};
                sprintf(pcValue, "%d,%d,%d", Color[0], Color[1], Color[2]);

                pSaveElement->SetAttribute("Mask", pcValue);
                memset(pcValue, 256, 0);
        }

        if(pDataNode == NULL)
        {
                if(strFilename == "")
                        return 0;

                Doc.InsertEndChild(*pSaveElement);
                SAFEDEL(pSaveElement)
                        return Doc.SaveFile(strFilename.GetBuffer());
        }
        else
        {
                if(strFilename == "")
                        return 1;

                Doc.InsertEndChild(*pSaveElement);
                return Doc.SaveFile(strFilename.GetBuffer());
        }

        return 0;
}

UINT CTexture::GetDepth()
{
        return FreeImage_GetBPP(m_pBitmap);
}

UINT CTexture::GetWidth()
{
        return FreeImage_GetWidth(m_pBitmap);
}

UINT CTexture::GetHeight()
{
        return FreeImage_GetHeight(m_pBitmap);
}

FIBITMAP *CTexture::GetBitmap()
{
        return m_pBitmap;
}

bool CTexture::IsMasked()
{
        if(m_Mask.R !=-1.0f && m_Mask.G !=-1.0f && m_Mask.B !=-1.0f)
                return true;

        return false;
}

tRGBA& CTexture::GetMask()
{
        return m_Mask;
}

void CTexture::SetMask(tRGBA Mask)
{
        m_Mask = Mask;
}


void CTexture::Bind()
{

}

void CTexture::GetPixel(tRGBA *pPixel, UINT x, UINT y)
{
        if(pPixel == NULL)
                return;

        RGBQUAD Pixel;

        if(m_pBitmap !=NULL)
        {
                FreeImage_GetPixelColor(m_pBitmap, x, y, &Pixel);

                pPixel->R = Pixel.rgbRed;
                pPixel->G = Pixel.rgbGreen;
                pPixel->B = Pixel.rgbBlue;
                pPixel->A = Pixel.rgbReserved;
        }
}

void CTexture::SetPixel(UINT x, UINT y, tRGBA color)
{
        RGBQUAD Pixel;

        if(m_pBitmap !=NULL)
        {
                Pixel.rgbRed = color.R;
                Pixel.rgbGreen = color.G;
                Pixel.rgbBlue = color.B;

                FreeImage_SetPixelColor(m_pBitmap, x, y, &Pixel);
        }
}

CString& CTexture::GetTextureFilename()
{
        return m_strTextureFilename;
}

void CTexture::Release()
{

}

void CTexture::Destroy()
{
        if(m_pBitmap !=NULL)
        {
                FreeImage_Unload(m_pBitmap);
                m_pBitmap = NULL;
        }
}

bool CTexture::IsOfType(eEntityType eType)
{
        if(eType == Entity_Texture)
                return true;

        return CXMLResource::IsOfType(eType);
}

---