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

#include "StdAfx.h"
#include "MaterialManager.h"

CMaterialManager::CMaterialManager()
{
        SetEntityType(Entity_MaterialManager);
        CGlobalLogger::GetSingleton().Write("Material Manager - Instantiated\n");
}

CMaterialManager::~CMaterialManager()
{
        Destroy();
        CGlobalLogger::GetSingleton().Write("Material Manager - Destroyed\n");
}

CMaterial *CMaterialManager::AddResource(CString strName, UINT uiID, eEntityType ResourceType)
{
        switch(ResourceType)
        {
        case Entity_Default:
        case Entity_Material:
        case Entity_OpenGLMaterial:
                CMaterial *pNewMaterial = new COpenGLMaterial;

                pNewMaterial->SetID(uiID);
                pNewMaterial->SetName(strName);

                push_back(pNewMaterial);

                return pNewMaterial;
                break;
        }

        return NULL;
}

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

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

        pXMLElement = m_pXMLElement;

        if(stricmp(pXMLElement->pcValue(), "material") == 0)
        {
                CXMLResource *AddedResource = LoadResource(pDataNode, strFilename);
                if(AddedResource !=NULL)
                {
                        CGlobalLogger::GetSingleton().Write("Material (Name: %s, ID: %d) has been added successfully.\n", AddedResource->GetName().GetBuffer(), AddedResource->GetID()); 
                        return 1;
                }
                else
                        return 0;
        }
        // LoadXML Materials
        UINT MaterialLoadedCount = 0;
        TiXmlNode *pIterXMLNode = pXMLElement->FirstChild();
        while(pIterXMLNode !=NULL)
        {
                if(stricmp(pIterXMLNode->pcValue(), "material") == 0)   // We have a Material
                {
                        CXMLResource *AddedResource = LoadResource(pIterXMLNode, "");
                        if(AddedResource !=NULL)
                        {
                                CGlobalLogger::GetSingleton().Write("Material (Name: %s, ID: %d) has been added successfully.\n", AddedResource->GetName().GetBuffer(), AddedResource->GetID()); 
                                MaterialLoadedCount++;
                        }
                }

                pIterXMLNode = pXMLElement->IterateChildren(pIterXMLNode);
        }

        return MaterialLoadedCount;
}

int CMaterialManager::SaveXML(TiXmlNode *pDataNode, CString strFilename)
{
        // Nowhere to save!                     Nothing to save!
        if(pDataNode == NULL && strFilename == "")
                return -1;

        char Buf[128] = "";
        TiXmlElement *pSaveXMLElement = NULL;

        if(pDataNode != NULL)
                pSaveXMLElement = pDataNode->ToElement();
        else
                pSaveXMLElement = new TiXmlElement("MaterialDatabase");

        CMaterial *pMaterial = (CMaterial *)begin();
        set_ptr(pMaterial);

        while(pMaterial !=NULL)
        {
                TiXmlElement MaterialXMLElement("Material");
                if(pMaterial->SaveXML(&MaterialXMLElement, ""))
                        pSaveXMLElement->InsertEndChild(MaterialXMLElement);

                pMaterial = (CMaterial *)next();
        }

        if(pDataNode == NULL && strFilename !="")
        {
                TiXmlDocument SaveDoc;
                SaveDoc.InsertEndChild(*pSaveXMLElement);
                int iRetValue = SaveDoc.SaveFile(strFilename);
                SAFEDEL(pSaveXMLElement)

                return iRetValue;
        }

        return 1;
}

CMaterial *CMaterialManager::LoadResource(TiXmlNode *pDataNode, CString strFilename, UINT uiID, CString strName)
{
        if(pDataNode != NULL)
        {
                const char *pcValue = NULL;
                TiXmlElement *pXMLElement = pDataNode->ToElement();

                pcValue = pXMLElement->Attribute("MatByID");
                if(pcValue !=NULL)
                {
                        CMaterial *ExistingMaterial = GetResource(-1, atoi(pcValue), "");
                        if(ExistingMaterial !=NULL)
                                return ExistingMaterial;
                        else
                                return NULL;
                }

                pcValue = pXMLElement->Attribute("MatByName");
                if(pcValue !=NULL)
                {
                        CMaterial *ExistingMaterial = GetResource(-1, -1, pcValue);
                        if(ExistingMaterial !=NULL)
                                return ExistingMaterial;
                        else
                                return NULL;
                }
        }

        if(stricmp(pDataNode->pcValue(), "material") == 0)
        {
                CMaterial *NewMaterial = NULL;

#ifdef OPENGL
                NewMaterial = new COpenGLMaterial;
#endif

                if(NewMaterial->LoadXML(pDataNode, strFilename))
                {
                        if(NewMaterial->GetID() == 0)
                                NewMaterial->SetID(uiID);

                        if(NewMaterial->GetName() == "")
                                NewMaterial->SetName(strName);

                        if(NewMaterial->GetName() !="")
                        {
                                if(GetResource(-1, -1, NewMaterial->GetName()) == NULL)
                                {
                                        push_back(NewMaterial);
                                        return NewMaterial;
                                }
                                else
                                {
                                        SAFEDEL(NewMaterial)
                                                return NULL;
                                }
                        }
                        else
                        {
                                push_back(NewMaterial);
                                return NewMaterial;
                        }
                }
                else
                        SAFEDEL(NewMaterial)
        }

        return NULL;
}

CMaterial *CMaterialManager::GetResource(int uiIndex, int uiID, CString strName, CString strFilename)
{
        if(uiID !=-1 && uiIndex == -1 && strName == "" && strFilename == "")    // get by uiID
        {
                CXMLResource *ResourcePtr = begin();
                set_ptr(ResourcePtr);

                while(ResourcePtr !=NULL)
                {
                        if(ResourcePtr->GetID() == uiID)
                                return (CMaterial *)ResourcePtr;

                        ResourcePtr = next();
                }
        }
        else if(strName !="" && uiIndex == -1 && uiID == -1 && strFilename == "")       // get by name
        {
                CXMLResource *ResourcePtr = begin();
                set_ptr(ResourcePtr);

                while(ResourcePtr !=NULL)
                {
                        if(stricmp(ResourcePtr->GetName().GetBuffer(), strName.GetBuffer()) == 0)
                                return (CMaterial *)ResourcePtr;

                        ResourcePtr = next();
                }
        }
        else if(uiIndex !=-1 && uiID == -1 && strName == "" && strFilename == "")       // get by index
        {
                if(uiIndex >=0 && uiIndex < size())
                        return (CMaterial *)at(uiIndex);
        }
        else if(strFilename !="" && uiIndex ==-1 && uiID == -1 && strName == "")
        {
                CXMLResource *ResourcePtr = begin();
                set_ptr(ResourcePtr);

                while(ResourcePtr !=NULL)
                {
                        if(stricmp(ResourcePtr->GetFilename().GetBuffer(), strFilename.GetBuffer()) == 0)
                                return (CMaterial *)ResourcePtr;

                        ResourcePtr = next();
                }
        }

        return NULL;
}

int CMaterialManager::RemoveResource(CMaterial *pMaterial)
{

        return 0;
}

void CMaterialManager::Destroy()
{
        CResourceManager::Destroy();
}

bool CMaterialManager::IsOfType(eEntityType eType)
{
        if(eType == Entity_MaterialManager)
                return true;

        return CResourceManager::IsOfType(eType);
}

---