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

#include "stdafx.h"
#include "TextureFrameAnimation.h"

CTextureFrameAnimation::CTextureFrameAnimation()
{
        SetEntityType(Entity_TextureFrameAnimation);
        m_pTextures = NULL;
}

CTextureFrameAnimation::~CTextureFrameAnimation()
{
        Destroy();

        for (UINT i=0; i<m_uiDataCount; i++)
                m_pTextures[i] = NULL;

        SAFEDEL_ARRAY(m_pTextures)
}

int CTextureFrameAnimation::Create(UINT uiFrameCount, UINT uiDataCount)
{
        if(!CFrameAnimation<tRect>::Create(uiFrameCount, uiDataCount))
                return 0;

        m_pTextures = new CTexture*[uiDataCount];
        for (UINT i=0; i<uiDataCount; i++)
                m_pTextures[i] = NULL;

        for (UINT j=0; j<uiFrameCount; j++)
                m_pAnimationData[j] = new tRect(0, 0, 0, 0);

        return 1;
}

int CTextureFrameAnimation::Animate(double fTimePerFrame)
{

        return 1;
}

int CTextureFrameAnimation::Pause(double fPauseTime)
{

        return 1;
}

int CTextureFrameAnimation::Resume(double fTimeToWait)
{

        return 1;
}

int CTextureFrameAnimation::Stop()
{


        return 1;
}

void CTextureFrameAnimation::SetFrameRect(UINT uiFrameIndex, tRect& Rect)
{
        if(uiFrameIndex >=0 && uiFrameIndex < m_uiFrameCount)
                *m_pAnimationData[uiFrameIndex] = Rect;
}

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

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

        pXMLElement = m_pXMLElement;

        UINT uiFrameCount = 0;

        pcValue = pXMLElement->Attribute("Type");
        if(pcValue !=NULL)
        {
                if(stricmp(pcValue, "Texture Frame") != 0)
                        return 0;

                pcValue = NULL;
        }

        pcValue = pXMLElement->Attribute("Looping");
        if(pcValue !=NULL)
        {
                m_bLoop = (int)atoi(pcValue);
                pcValue = NULL;
        }

        pcValue = pXMLElement->Attribute("Loops");
        if(pcValue !=NULL)
        {
                m_uiLoopsCount = atoi(pcValue);
                pcValue = NULL;
        }

        TiXmlNode *pIterXMLNode = pXMLElement->FirstChild();
        while(pIterXMLNode !=NULL)
        {
                if(stricmp(pIterXMLNode->pcValue(), "frame") == 0)
                        uiFrameCount++;

                pIterXMLNode = pXMLElement->IterateChildren(pIterXMLNode);
        }

        Create(uiFrameCount, uiFrameCount);

        UINT uiIndex = 0;
        pIterXMLNode = pXMLElement->FirstChild();
        while(pIterXMLNode !=NULL)
        {
                if(stricmp(pIterXMLNode->pcValue(), "frame") == 0)
                {
                        pcValue = pIterXMLNode->ToElement()->Attribute("Rect");
                        if(pcValue !=NULL)
                        {
                                sscanf( pcValue, "%d,%d,%d,%d", 
                                        &m_pAnimationData[uiIndex]->left, 
                                        &m_pAnimationData[uiIndex]->right,
                                        &m_pAnimationData[uiIndex]->top, 
                                        &m_pAnimationData[uiIndex]->bottom);

                                pcValue = NULL;
                        }

                        m_pTextures[uiIndex] = CTextureManager::GetSingleton().LoadResource(pIterXMLNode, "");

                        uiIndex++;
                }

                pIterXMLNode = pXMLElement->IterateChildren(pIterXMLNode);
        }

        return 1;
}

int CTextureFrameAnimation::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("Animation");

        pSaveElement->SetAttribute("Type", "Texture Frame");
        pSaveElement->SetAttribute("strName", GetName().GetBuffer());
        pSaveElement->SetAttribute("Looping", (int)m_bLoop);
        pSaveElement->SetAttribute("Loops", GetLoopCount());

        for (UINT i=0; i<m_uiFrameCount; i++)
        {
                TiXmlElement FrameElement("Frame");
                SaveFrame(&FrameElement, i);

                pSaveElement->InsertEndChild(FrameElement);
        }

        char pcValue[256] = "";

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

CTexture *CTextureFrameAnimation::GetTexture()
{
        return m_pTextures[GetFrameIndex()];
}

int CTextureFrameAnimation::SaveFrame(TiXmlNode *pDataNode, UINT uiIndex)
{
        if(pDataNode == NULL)
                return -1;

        TiXmlElement *pSaveElement = pDataNode->ToElement();

        char pcValue[256] = "";
        sprintf((char *)pcValue, "%d,%d,%d,%d", m_pAnimationData[uiIndex]->left, m_pAnimationData[uiIndex]->right, m_pAnimationData[uiIndex]->top, m_pAnimationData[uiIndex]->bottom);

        pSaveElement->SetAttribute("Rect", pcValue);

        if(m_pTextures[m_uipDataIndex[uiIndex]] !=NULL)
        {
                if(m_pTextures[m_uipDataIndex[uiIndex]]->GetName() !="")
                        pSaveElement->SetAttribute("TexByName", m_pTextures[m_uipDataIndex[uiIndex]]->GetName().GetBuffer());
        }
        return 1;
}

void CTextureFrameAnimation::SetTexture(UINT uiFrame, UINT uiTexIndex, CTexture *pTexture)
{
        if(uiFrame >=0 && uiFrame < m_uiFrameCount)
        {
                if(uiTexIndex >=0 && uiTexIndex < m_uiDataCount)
                {
                        if(pTexture !=NULL)
                                m_pTextures[uiTexIndex] = pTexture;

                        m_uipDataIndex[uiFrame] = uiTexIndex;
                }
        }
}

void CTextureFrameAnimation::Destroy()
{
        if(m_pAnimationData !=NULL)
        {
                for (UINT i=0; i<m_uiFrameCount; i++)
                        SAFEDEL(m_pAnimationData[i])
        }

        CFrameAnimation<tRect>::Destroy();
}

bool CTextureFrameAnimation::IsOfType(eEntityType eType)
{
        if(eType == Entity_TextureFrameAnimation)
                return true;

        return CFrameAnimation<tRect>::IsOfType(eType);
}

---