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

#include "StdAfx.h"
#include "AddMaterialSettings.h"

CAddMaterialSettings::CAddMaterialSettings()
{
        m_pCurrentMaterial = NULL;
        m_MaterialAmbient = m_MaterialDiffuse = m_MaterialSpecular = m_MaterialEmissive = m_iMaterialShininess = 0;
        m_iMaterialIndex = 0;
        m_iMaterialID = 1;
}

CAddMaterialSettings::~CAddMaterialSettings()
{

}

bool CAddMaterialSettings::PropertyChanging( const void* pvProperty , void* pvNewValue )
{
        bool bChangeOK = CAddResourceSettings::PropertyChanging(pvProperty, pvNewValue);

        if(CMaterialManager::GetSingletonPtr() == NULL)
                return false;

        if(pvProperty == &m_strResourceName)    // strName has been changed, see if there are duplicates
        {
                CMaterial *pMaterial = CMaterialManager::GetSingleton().GetResource(-1, -1, (*(CString *)pvNewValue), "");
                if(pMaterial !=NULL)
                        return false;
                else
                {
                        m_strResourceName = *(CString *)pvNewValue;
                        m_pCurrentMaterial->SetName(m_strResourceName);
                        
                        m_MaterialAmbient = RGB(m_pCurrentMaterial->GetAmbient().R, m_pCurrentMaterial->GetAmbient().G, m_pCurrentMaterial->GetAmbient().B);
                        m_MaterialDiffuse = RGB(m_pCurrentMaterial->GetDiffuse().R, m_pCurrentMaterial->GetDiffuse().G, m_pCurrentMaterial->GetDiffuse().B);
                        m_MaterialSpecular = RGB(m_pCurrentMaterial->GetSpecular().R, m_pCurrentMaterial->GetSpecular().G, m_pCurrentMaterial->GetSpecular().B);
                        m_MaterialEmissive = RGB(m_pCurrentMaterial->GetEmissive().R, m_pCurrentMaterial->GetEmissive().G, m_pCurrentMaterial->GetEmissive().B);
                        m_iMaterialShininess = (int)m_pCurrentMaterial->GetShininess();

                        for (int i=0; i<CMaterialManager::GetSingleton().size(); i++)
                        {
                                CMaterial *pMaterial = (CMaterial *)CMaterialManager::GetSingleton().at(i);
                                if(pMaterial == m_pCurrentMaterial)
                                {
                                        m_iMaterialIndex = i;
                                        break;
                                }
                        }
                        
                        m_bUpdateRequired = true;
                }
        }

        if(pvProperty == &m_strResourceXMLFilename)
        {
                CMaterial *pNewMaterial = NULL;
                if(m_pCurrentMaterial !=NULL)
                {
                        m_pCurrentMaterial->Destroy();

                        m_pCurrentMaterial->LoadXML(NULL, (*(CString *)pvNewValue));
                        pNewMaterial = m_pCurrentMaterial;
                }
                else
                {
                        pNewMaterial = CMaterialManager::GetSingleton().LoadResource(NULL, (*(CString *)pvNewValue));
                        m_pCurrentMaterial = pNewMaterial;
                }

                m_strResourceXMLFilename = *(CString *)pvNewValue;
                m_strResourceRawFilename = pNewMaterial->GetFilename();
                m_strResourceName = pNewMaterial->GetName();

                m_bUpdateRequired = true;
        }

        if(pvProperty == &m_strResourcesDatabaseFilename)
        {
                int iRetValue = CMaterialManager::GetSingleton().LoadXML(NULL, (*(CString *)pvNewValue));
                if(iRetValue > 0)
                        m_bUpdateRequired = true;

                return false;
        }

        if(pvProperty == &m_iMaterialIndex)
        {
                int iTempTexIndex = *(int *)pvNewValue;
                CMaterial *pMaterial = CMaterialManager::GetSingleton().GetResource(iTempTexIndex);
                if(iTempTexIndex == 1000)
                {
                        CString NewTexName;
                        NewTexName.Format("Material #%d", m_iMaterialID);

                        m_pCurrentMaterial = CMaterialManager::GetSingleton().AddResource(NewTexName);
                        m_pCurrentMaterial->SetName(NewTexName);

                        m_strResourceName = NewTexName;
                        m_iMaterialIndex = CMaterialManager::GetSingleton().size() - 1;
                        
                        m_MaterialAmbient = RGB(m_pCurrentMaterial->GetAmbient().R, m_pCurrentMaterial->GetAmbient().G, m_pCurrentMaterial->GetAmbient().B);
                        m_MaterialDiffuse = RGB(m_pCurrentMaterial->GetDiffuse().R, m_pCurrentMaterial->GetDiffuse().G, m_pCurrentMaterial->GetDiffuse().B);
                        m_MaterialSpecular = RGB(m_pCurrentMaterial->GetSpecular().R, m_pCurrentMaterial->GetSpecular().G, m_pCurrentMaterial->GetSpecular().B);
                        m_MaterialEmissive = RGB(m_pCurrentMaterial->GetEmissive().R, m_pCurrentMaterial->GetEmissive().G, m_pCurrentMaterial->GetEmissive().B);
                        m_iMaterialShininess = (int)m_pCurrentMaterial->GetShininess();

                        m_iMaterialID++;
                        m_bUpdateRequired = true;
                        return false;
                }
                else
                {
                        m_strResourceName = pMaterial->GetName();
                        m_iMaterialIndex = iTempTexIndex;
                        m_pCurrentMaterial = pMaterial;

                        m_MaterialAmbient = RGB(pMaterial->GetAmbient().R, pMaterial->GetAmbient().G, pMaterial->GetAmbient().B);
                        m_MaterialDiffuse = RGB(pMaterial->GetDiffuse().R, pMaterial->GetDiffuse().G, pMaterial->GetDiffuse().B);
                        m_MaterialSpecular = RGB(pMaterial->GetSpecular().R, pMaterial->GetSpecular().G, pMaterial->GetSpecular().B);
                        m_MaterialEmissive = RGB(pMaterial->GetEmissive().R, pMaterial->GetEmissive().G, pMaterial->GetEmissive().B);
                        m_iMaterialShininess = (int)pMaterial->GetShininess();
                }
        }

        if(pvProperty == &m_MaterialAmbient)
        {
                m_MaterialAmbient = *(COLORREF *)pvNewValue;
                m_pCurrentMaterial->SetAmbient(tRGBA(GetRValue(m_MaterialAmbient), GetGValue(m_MaterialAmbient), GetBValue(m_MaterialAmbient)));
        }

        if(pvProperty == &m_MaterialDiffuse)
        {
                m_MaterialDiffuse = *(COLORREF *)pvNewValue;
                m_pCurrentMaterial->SetDiffuse(tRGBA(GetRValue(m_MaterialDiffuse), GetGValue(m_MaterialDiffuse), GetBValue(m_MaterialDiffuse)));
        }

        if(pvProperty == &m_MaterialSpecular)
        {
                m_MaterialSpecular = *(COLORREF *)pvNewValue;
                m_pCurrentMaterial->SetSpecular(tRGBA(GetRValue(m_MaterialSpecular), GetGValue(m_MaterialSpecular), GetBValue(m_MaterialSpecular)));
        }

        if(pvProperty == &m_MaterialEmissive)
        {
                m_MaterialEmissive = *(COLORREF *)pvNewValue;
                m_pCurrentMaterial->SetEmissive(tRGBA(GetRValue(m_MaterialEmissive), GetGValue(m_MaterialEmissive), GetBValue(m_MaterialEmissive)));
        }

        if(pvProperty == &m_iMaterialShininess)
        {
                m_iMaterialShininess = *(int *)pvNewValue;
                m_pCurrentMaterial->SetShininess(m_iMaterialShininess);
        }

        return bChangeOK;
}

void CAddMaterialSettings::GetProperties( EPropList& PropList )
{
        CAddResourceSettings::GetProperties(PropList);
        
        if(CMaterialManager::GetSingletonPtr() == NULL)
                return;

        PropList.AddTab("Material(s)");
        PropList.AddPropSeparator(this, "Tools");

        EPropertyCombo *pMaterialCombo = PropList.AddPropCombo(this, "Material", &m_iMaterialIndex);
        pMaterialCombo->AddString("New Material", 1000);
        for (int i=0; i<CMaterialManager::GetSingleton().size(); i++)
        {
                CMaterial *pMaterial = (CMaterial *)CMaterialManager::GetSingleton().at(i);
                pMaterialCombo->AddString(pMaterial->GetName(), i);
        }
        
        PropList.AddPropFile(this, "XML File", &m_strResourceXMLFilename, "XML Files (*.xml)|*.xml|All Files (*.*)|*.*||")->SetComment("Material XML File");
        PropList.AddPropFile(this, "XML Database", &m_strResourcesDatabaseFilename, "XML Files (*.xml)|*.xml|All Files (*.*)|*.*||")->SetComment("Materials Database XML File");
        
        PropList.AddPropSeparator(this, "Attributes");
        PropList.AddPropString(this, "strName", &m_strResourceName, true)->SetComment("Material strName");
        PropList.AddPropColor(this, "Ambient", &m_MaterialAmbient, true)->SetComment("Material' Ambient component");
        PropList.AddPropColor(this, "Diffuse", &m_MaterialDiffuse, true)->SetComment("Material' Diffuse component");
        PropList.AddPropColor(this, "Specular", &m_MaterialSpecular, true)->SetComment("Material' Specular component");
        PropList.AddPropColor(this, "Emissive", &m_MaterialEmissive, true)->SetComment("Material' Emissive component");
        PropList.AddPropInt(this, "Shininess", &m_iMaterialShininess, "", true)->SetComment("Material' Shininess component");
}

---