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

#include "StdAfx.h"
#include "Material.h"

CMaterial::CMaterial()
{
        SetEntityType(Entity_Material);
        m_fShininess = 0;
        m_Ambient = m_Diffuse = m_Specular = m_Emissive = tRGBA(0, 0, 0, 0);
}

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

int CMaterial::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(), "Material") !=0)
                return 0;

        int Color[3] = {0, 0, 0};
        pcValue = pXMLElement->Attribute("Ambient");
        if(pcValue !=NULL)
        {
                
                sscanf(pcValue, "%d,%d,%d", &Color[0], &Color[1], &Color[2]);
                SetAmbient(tRGBA(Color[0], Color[1], Color[2], -1));
                pcValue = NULL;
        }

        pcValue = pXMLElement->Attribute("Diffuse");
        if(pcValue !=NULL)
        {
                int Color[3] = {0,0,0};
                sscanf(pcValue, "%d,%d,%d", &Color[0], &Color[1], &Color[2]);
                SetDiffuse(tRGBA(Color[0], Color[1], Color[2], -1));
                pcValue = NULL;
        }

        pcValue = pXMLElement->Attribute("Emissive");
        if(pcValue !=NULL)
        {
                int Color[3] = {0,0,0};
                sscanf(pcValue, "%d,%d,%d", &Color[0], &Color[1], &Color[2]);
                SetEmissive(tRGBA(Color[0], Color[1], Color[2], -1));
                pcValue = NULL;
        }

        pcValue = pXMLElement->Attribute("Specular");
        if(pcValue !=NULL)
        {
                int Color[3] = {0,0,0};
                sscanf(pcValue, "%d,%d,%d", &Color[0], &Color[1], &Color[2]);
                SetSpecular(tRGBA(Color[0], Color[1], Color[2], -1));
                pcValue = NULL;         
        }

        pcValue = pXMLElement->Attribute("Shininess");
        if(pcValue !=NULL)
        {
                int s = 0;
                sscanf(pcValue, "%d", &s);
                SetShininess((float)s);
                pcValue = NULL;
        }

        return 1;
}

int CMaterial::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("Material");

        char pcValue[256] = "";

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

        sprintf(pcValue, "%d,%d,%d", (int)m_Ambient.R, (int)m_Ambient.G, (int)m_Ambient.B);
        pSaveElement->SetAttribute("Ambient", pcValue);
        memset(pcValue, 0, sizeof(pcValue));

        sprintf(pcValue, "%d,%d,%d", (int)m_Diffuse.R, (int)m_Diffuse.G, (int)m_Diffuse.B);
        pSaveElement->SetAttribute("Diffuse", pcValue);
        memset(pcValue, 0, sizeof(pcValue));

        sprintf(pcValue, "%d,%d,%d", (int)m_Specular.R, (int)m_Specular.G, (int)m_Specular.B);
        pSaveElement->SetAttribute("Specular", pcValue);
        memset(pcValue, 0, sizeof(pcValue));

        sprintf(pcValue, "%d,%d,%d", (int)m_Emissive.R, (int)m_Emissive.G, (int)m_Emissive.B);
        pSaveElement->SetAttribute("Emissive", pcValue);
        memset(pcValue, 0, sizeof(pcValue));

        pSaveElement->SetAttribute("Shininess", m_fShininess);

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

void CMaterial::SetAmbient(tRGBA ambient)
{
        m_Ambient = ambient;
}

void CMaterial::SetDiffuse(tRGBA diffuse)
{
        m_Diffuse = diffuse;
}

void CMaterial::SetEmissive(tRGBA emissive)
{
        m_Emissive = emissive;
}

void CMaterial::SetSpecular(tRGBA specular)
{
        m_Specular = specular;
}

void CMaterial::SetShininess(float fShininess)
{
        m_fShininess = fShininess;
}

tRGBA& CMaterial::GetAmbient()
{
        return m_Ambient;
}

tRGBA& CMaterial::GetDiffuse()
{
        return m_Diffuse;
}

tRGBA& CMaterial::GetSpecular()
{
        return m_Specular;
}

tRGBA& CMaterial::GetEmissive()
{
        return m_Emissive;
}

float& CMaterial::GetShininess()
{
        return m_fShininess;
}

void CMaterial::Bind()
{

}

void CMaterial::Destroy()
{

}

bool CMaterial::IsOfType(eEntityType eType)
{
        if(eType == Entity_Material)
                return true;

        return CXMLResource::IsOfType(eType);
}

---