bool CRenderableObjectTechniqueManager::LoadFile()
{
CXMLTreeNode newFile;
if (!newFile.LoadFile(m_FileName.c_str()))
{
std::string msg_error = "CRenderableObjectTechniqueManager::Load->Error al intentar leer el archivo de renderable objects techniques: " + m_FileName;
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
return false;
}
CXMLTreeNode l_ROTs = newFile["renderable_object_techniques"];
if( l_ROTs.Exists() )
{
uint16 l_Count = l_ROTs.GetNumChildren();
for( uint16 i=0; i < l_Count; ++i)
{
std::string l_Type = l_ROTs(i).GetName();
if( l_Type == "pool_renderable_object_technique" )
{
std::string l_PROTName = l_ROTs(i).GetPszProperty("name", "");
CPoolRenderableObjectTechnique *l_PoolROT = new CPoolRenderableObjectTechnique(l_ROTs(i));
l_PoolROT->SetName(l_PROTName);
m_PoolRenderableObjectTechniques.AddResource(l_PROTName, l_PoolROT);
uint16 l_Child = l_ROTs(i).GetNumChildren();
for(uint16 j=0; j < l_Child; ++j)
{
l_Type = l_ROTs(i)(j).GetName();
if( l_Type == "default_technique" )
{
int l_VertexType = l_ROTs(i)(j).GetIntProperty("vertex_type", 0);
std::string l_Technique = l_ROTs(i)(j).GetPszProperty("technique", "");
std::string l_Name = GetRenderableObjectTechniqueNameByVertexType( static_cast<uint32>(l_VertexType) );
InsertRenderableObjectTechnique(l_Name, l_Technique);
l_PoolROT->AddElement(l_Name, l_Technique, GetResource(l_Name) );
}
else if( l_Type == "technique" )
{
std::string l_Name = l_ROTs(i)(j).GetPszProperty("name", "");
std::string l_Technique = l_ROTs(i)(j).GetPszProperty("technique", "");
InsertRenderableObjectTechnique(l_Name, l_Technique);
l_PoolROT->AddElement(l_Name, l_Technique, GetResource(l_Name) );
}
}
}
}
}
else
{
return false;
}
return true;
}
bool CTriggerManager::LoadXML( const std::string& FileName )
{
mConfigPath = FileName;
CXMLTreeNode newFile;
if ( !newFile.LoadFile( FileName.c_str() ) )
{
LOG_ERROR_APPLICATION( "CTriggerManager::LoadXML=> ERROR loading the file %s.\n", FileName.c_str() );
return false;
}
CXMLTreeNode m = newFile["triggers"];
if ( m.Exists() )
{
int count = m.GetNumChildren();
for ( int i = 0; i < count; ++i )
{
const std::string l_TagName = m( i ).GetName();
if ( l_TagName == "trigger" )
{
CTrigger* l_Trigger = new CTrigger( m( i ) );
if(!AddResource(l_Trigger->GetName(), l_Trigger))
{
CHECKED_DELETE(l_Trigger);
}
}
}
}
return true;
}
/// <summary>
/// Carga el .xml de triggers.
/// </summary>
///<param name="FileName">Ubicación del archivo xml.</param>
bool CTriggerManager::Load(const std::string &FileName)
{
m_bIsOk = true;
m_FileName = FileName;
CXMLTreeNode filexml;
if (!filexml.LoadFile(FileName.c_str()))
{
//Guardar el mensaje de error en el LOGGER
LOGGER->AddNewLog(ELL_ERROR, "CTriggerManager::Load ---Error al cargar el XML---");
m_bIsOk = false;
}
else
{
CXMLTreeNode triggers = filexml["triggers"];
int numNodes = triggers.GetNumChildren();
if (triggers.Exists())
{
//<triggers>
//<trigger name="Trigger_EntradaPuerta" entity="character" position="13.4664 0.0 -3.93624" max="-0.600954 4.70389 -1.79946"
//min="0.600954 0.0 1.79946" active="true" onEnter="testEnter" onLeave="testLeave" rotation="" size="1.0"/>
//</triggers>
CTrigger* l_Trigger;
for (int i = 0; i < numNodes; ++i)
{
if (!triggers(i).IsComment())
{
//crea trigger info
l_Trigger = new CTrigger();
l_Trigger->Init();
l_Trigger->SetName(triggers(i).GetPszProperty("name", ""));
l_Trigger->SetEntity(triggers(i).GetPszProperty("entity", ""));
l_Trigger->SetPosition(triggers(i).GetVect3fProperty("position", Vect3f(0.0f,0.0f,0.0f)));
l_Trigger->SetMax(triggers(i).GetVect3fProperty("max", Vect3f(0.0f,0.0f,0.0f)));
l_Trigger->SetMin(triggers(i).GetVect3fProperty("min", Vect3f(0.0f,0.0f,0.0f)));
l_Trigger->SetActive(triggers(i).GetBoolProperty("active", false));
l_Trigger->SetTriggerActive(triggers(i).GetBoolProperty("active", false));
l_Trigger->SetOnEnterCode(triggers(i).GetPszProperty("onEnter", ""));
l_Trigger->SetOnLeaveCode(triggers(i).GetPszProperty("onLeave", ""));
l_Trigger->SetRotationX(triggers(i).GetFloatProperty("rotationX"));
l_Trigger->SetRotationY(triggers(i).GetFloatProperty("rotationY"));
l_Trigger->SetRotationZ(triggers(i).GetFloatProperty("rotationZ"));
l_Trigger->SetSize(triggers(i).GetVect3fProperty("size", Vect3f(0.0f,0.0f,0.0f)));
l_Trigger->SetDimensions(triggers(i).GetVect3fProperty("size", Vect3f(0.0f,0.0f,0.0f)));
GeneraTrigger(l_Trigger->GetName(), l_Trigger, false);
m_vTriggers.push_back(l_Trigger);
}
}
}
else
{
m_bIsOk = false;
}
}
return m_bIsOk;
}
bool CParticleEmitterSystemManager::Reload()
{
CXMLTreeNode newFile;
if (!newFile.LoadFile(m_Filename.c_str()))
{
std::string msg_error = "CParticleEmitterSystemManager::Load->Error al intentar leer el archivo xml: " + m_Filename;
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
return false;
}
CXMLTreeNode l_xml = newFile["particle_emitters_systems"];
if( l_xml.Exists() )
{
uint16 l_Count = l_xml.GetNumChildren();
for(uint16 i=0; i<l_Count; ++i)
{
std::string l_Type = l_xml(i).GetName();
if( l_Type == "emitter_system" )
{
std::string name = l_xml(i).GetPszProperty("name", "", true);
assert(this->GetResource(name) == NULL);
CParticleEmitterSystem* pes = new CParticleEmitterSystem(name);
uint16 l_CountEmitters = l_xml(i).GetNumChildren();
CXMLTreeNode childs = l_xml(i);
for(uint16 j=0; j<l_CountEmitters; ++j)
{
std::string l_ChildType = childs(j).GetName();
if(l_ChildType == "emitter")
{
std::string nameEmitter = childs(j).GetPszProperty("name", "", true);
CParticleEmitter* pe = CORE->GetParticleEmitterManager()->GetResource(nameEmitter);
pes->AddParticleEmitter(nameEmitter, pe);
}
}
this->AddResource(name, pes);
}
}
}
else
{
return false;
}
return true;
}
void CLanguageManager::LoadXML (const std::string& pathFile)
{
CXMLTreeNode parser;
if (!parser.LoadFile(pathFile.c_str()))
{
std::string msg_error = "LanguageManager::LoadXML->Error al intentar leer el archivo de lenguaje: " + pathFile;
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
throw CException(__FILE__, __LINE__, msg_error);
}
/*<Language id="english">
<literal id="xfiles" font="X-Files" color="0.5 0.5 0.5 0.5" value="Hi World"/>
<literal id="xfiles" font="X-Files" color="0.1 0.1 0.1 0.8" value="Exit"/>
</Language>*/
LOGGER->AddNewLog(ELL_INFORMATION, "LanguageManager::LoadXML-> Parseando fichero de lenguaje: %s", pathFile.c_str());
CXMLTreeNode m = parser["Language"];
std::string id_language = m.GetPszProperty("id");
TLanguage language;
if (m.Exists())
{
int count = m.GetNumChildren();
for (int i = 0; i < count; ++i)
{
//for each literal:
SLiteral l_literal;
std::string id = m(i).GetPszProperty("id");
l_literal.m_sFontId = m(i).GetPszProperty("font");
Vect4f vecColor = m(i).GetVect4fProperty("color", Vect4f(0.f,0.f,0.f,0.f));
l_literal.m_value = m(i).GetPszISOProperty("value", "nothing");
l_literal.m_cColor = CColor(vecColor.x, vecColor.y, vecColor.z, vecColor.w);
language.insert(std::pair<std::string,SLiteral>(id, l_literal));
LOGGER->AddNewLog(ELL_INFORMATION, "LanguageManager::LoadXML-> Añadido literal(%s,%s,[%f,%f,%f,%f],%s)",
id.c_str(), l_literal.m_sFontId.c_str(),vecColor.x,vecColor.y,vecColor.z,vecColor.w, l_literal.m_value.c_str());
}
}
if (m_Languages.find(id_language) != m_Languages.end())
{
//Ya está registrado el identificador id_language
LOGGER->AddNewLog(ELL_WARNING, "LanguageManager::LoadXML-> EYa se ha registrado un language con identificador %s", id_language.c_str());
}
else
{
m_Languages.insert(std::pair<std::string, TLanguage>(id_language, language));
}
}
bool CParticleSystemManager::Reload()
{
CXMLTreeNode newFile;
if (!newFile.LoadFile(m_Filename.c_str()))
{
std::string msg_error = "CParticleSystemManager::Load->Error al intentar leer el archivo xml: " + m_Filename;
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
return false;
}
CXMLTreeNode l_xml = newFile["particle_systems"];
if( l_xml.Exists() )
{
uint16 l_Count = l_xml.GetNumChildren();
for(uint16 i=0; i<l_Count; ++i)
{
std::string l_Type = l_xml(i).GetName();
if( l_Type == "system" )
{
std::string name = l_xml(i).GetPszProperty("name", "", true);
std::string settingsName = l_xml(i).GetPszProperty("settings_name", "", true);
TParticleSystemSettings* settings = CORE->GetParticleSettingsManager()->GetResource(settingsName);
assert(settings);
CParticleSystem* system = new CParticleSystem(name, settings);
bool isOk = this->AddResource(name, system);
assert(isOk);
}
}
}
else
{
return false;
}
return true;
}
///<summary>
/// CParticleManager:: LoadXML : Lectura de Particles.xml.
///</summary>
///<param name="fileName">Ruta del XML.</param>
///<returns name="result">Booleano que indica si la lectura se ha realizado con éxito.</returns>
bool CParticleManager::LoadXML (const std::string & fileName)
{
bool l_bIsOk = true;
CXMLTreeNode filexml;
if (!filexml.LoadFile(fileName.c_str()))
{
LOGGER->AddNewLog(ELL_ERROR, "ParticleManager::LoadXML ---Error al cargar el XML---");
l_bIsOk = false;
}
else
{
CXMLTreeNode l_pManager = filexml["ParticleManager"];
if (l_pManager.Exists())
{
//<ParticleEmitter name="pEmitter1">
// <color color1="0.0 0.0 1.0 1.0" color2="0.0 1.0 0.0 1.0" time="0.0">
// <time t="2.0" col1="0.0 1.0 0.0 1.0" col2="0.0 1.0 0.0 1.0"/>
// </color>
CXMLTreeNode l_pEmitters = l_pManager["ParticleEmitters"];
int numNodes = l_pEmitters.GetNumChildren();
for (int i = 0; i<numNodes; ++i)
{
CXMLTreeNode l_pEmitter = l_pEmitters(i)["ParticleEmitter"];
if (l_pEmitter.Exists() && !l_pEmitter.IsComment())
{
m_stInfo.sName = l_pEmitter.GetPszProperty("name");
CXMLTreeNode l_pColor = l_pEmitter["color"];
if (l_pColor.Exists() && !l_pColor.IsComment())
{
m_stColor.color1 = l_pColor.GetVect4fProperty("color1", Vect4f(0.f, 0.f, 0.f, 0.f));
m_stColor.color2 = l_pColor.GetVect4fProperty("color2", Vect4f(0.f, 0.f, 0.f, 0.f));
m_stColor.time = l_pColor.GetFloatProperty("time");
m_stInfo.vColor.push_back(m_stColor);
}
int num = l_pColor.GetNumChildren();
for (int j=0; j<num; ++j)
{
CXMLTreeNode l_pTime = l_pColor(j)["time"];
if (l_pTime.Exists() && !l_pTime.IsComment())
{
m_stColor.time = l_pTime.GetFloatProperty("t");
m_stColor.color1 = l_pTime.GetVect4fProperty("col1", Vect4f(0.f, 0.f, 0.f, 0.f));
m_stColor.color2 = l_pTime.GetVect4fProperty("col2", Vect4f(0.f, 0.f, 0.f, 0.f));
}
m_stInfo.vColor.push_back(m_stColor);
}//end for color
//<direction d1="0.0 5.0 0.0" d2="0.0 6.0 0.0" time="0.0">
// <time t="2.0" dir1="1.0 5.0 0.0" dir2="2.0 9.0 0.0"/>
//</direction>
CXMLTreeNode l_pDir = l_pEmitter["direction"];
if (l_pDir.Exists() && !l_pDir.IsComment())
{
m_stDir.dir1 = l_pDir.GetVect3fProperty("d1", Vect3f(0.f, 0.f, 0.f));
m_stDir.dir2 = l_pDir.GetVect3fProperty("d2", Vect3f(0.f, 0.f, 0.f));
m_stDir.time = l_pDir.GetFloatProperty("time");
m_stInfo.vDir.push_back(m_stDir);
}
int cont = l_pDir.GetNumChildren();
for (int k=0; k<cont; ++k)
{
CXMLTreeNode l_pTime = l_pDir(k)["time"];
if (l_pTime.Exists() && !l_pTime.IsComment())
{
m_stDir.time = l_pTime.GetFloatProperty("t");
m_stDir.dir1 = l_pTime.GetVect3fProperty("dir1", Vect3f(0.f, 0.f, 0.f));
m_stDir.dir2 = l_pTime.GetVect3fProperty("dir2", Vect3f(0.f, 0.f, 0.f));
}
m_stInfo.vDir.push_back(m_stDir);
}//end for direction
//<size mins="0.1" maxs="0.1" time="0.0">
// <time t="0.5" siz1="0.3" siz2="0.3"/>
//</size>
CXMLTreeNode l_pSize = l_pEmitter["size"];
if (l_pSize.Exists() && !l_pSize.IsComment())
{
m_stSize.sizeMin = l_pSize.GetFloatProperty("mins");
m_stSize.sizeMax = l_pSize.GetFloatProperty("maxs");
m_stSize.time = l_pSize.GetFloatProperty("time");
m_stInfo.vSize.push_back(m_stSize);
}
int size = l_pSize.GetNumChildren();
for (int m=0; m<size; ++m)
{
CXMLTreeNode l_pTime = l_pSize(m)["time"];
if (l_pTime.Exists() && !l_pTime.IsComment())
{
m_stSize.time = l_pTime.GetFloatProperty("t");
m_stSize.sizeMin = l_pTime.GetFloatProperty("siz1");
m_stSize.sizeMax = l_pTime.GetFloatProperty("siz2");
}
m_stInfo.vSize.push_back(m_stSize);
}//end for size
//<life_time life1="1.0" life2="5.0"/>
CXMLTreeNode l_pLife = l_pEmitter["life_time"];
if (l_pLife.Exists() && !l_pLife.IsComment())
{
m_stInfo.fLifeMin = l_pLife.GetFloatProperty("life1");
m_stInfo.fLifeMax = l_pLife.GetFloatProperty("life2");
}
//<emit_rate er1="20.0" er2="30.0"/>
CXMLTreeNode l_pEmitRate = l_pEmitter["emit_rate"];
if (l_pEmitRate.Exists() && !l_pEmitRate.IsComment())
{
m_stInfo.fEmitRate1 = l_pEmitRate.GetFloatProperty("er1");
m_stInfo.fEmitRate2 = l_pEmitRate.GetFloatProperty("er2");
}
//<gravity gr="true"/>
CXMLTreeNode l_pGravity = l_pEmitter["gravity"];
if(l_pGravity.Exists() && !l_pGravity.IsComment())
{
m_stInfo.bGravity = l_pGravity.GetBoolProperty("gr");
}
//<velocity vel="1.0 1.0 1.0" time="0.0">
// <time t="1.0" v="0.1 0.4 -0.2"/>
//</velocity>
CXMLTreeNode l_pVelocity = l_pEmitter["velocity"];
if(l_pVelocity.Exists() && !l_pVelocity.IsComment())
{
m_stVelocity.velocity = l_pVelocity.GetVect3fProperty("vel", (0.0f, 0.0f, 0.0f));
m_stVelocity.time = l_pVelocity.GetFloatProperty("time");
m_stInfo.vVelocity.push_back(m_stVelocity);
}
int tam = l_pVelocity.GetNumChildren();
for (int j=0; j<tam; ++j)
{
CXMLTreeNode l_pTime = l_pVelocity(j)["time"];
if (l_pTime.Exists() && !l_pTime.IsComment())
{
m_stVelocity.time = l_pTime.GetFloatProperty("t");
m_stVelocity.velocity = l_pTime.GetVect3fProperty("v", (0.0f, 0.0f, 0.0f));
}
m_stInfo.vVelocity.push_back(m_stVelocity);
}//end for velocity
//<angle ang="0.5" time="0.0">
// <time t="0.6" a="-0.5"/>
//</angle>
CXMLTreeNode l_pAngle = l_pEmitter["angle"];
if(l_pAngle.Exists() && !l_pAngle.IsComment())
{
m_stAngle.angle = l_pAngle.GetFloatProperty("ang");
m_stAngle.time = l_pAngle.GetFloatProperty("time");
m_stInfo.vAngle.push_back(m_stAngle);
}
int ang = l_pAngle.GetNumChildren();
for (int j=0; j<ang; ++j)
{
CXMLTreeNode l_pTime = l_pAngle(j)["time"];
if (l_pTime.Exists() && !l_pTime.IsComment())
{
m_stAngle.time = l_pTime.GetFloatProperty("t");
m_stAngle.angle = l_pTime.GetFloatProperty("a");
}
m_stInfo.vAngle.push_back(m_stAngle);
}//end for angle
//<texture tex="Data/Textures/Punto_Alfa.dds" />
CXMLTreeNode l_pText = l_pEmitter["texture"];
if (l_pText.Exists() && !l_pText.IsComment())
{
m_stInfo.pTexture = CORE->GetTextureManager()->GetTexture(l_pText.GetPszProperty("tex", ""));
}
m_vInfo.push_back(m_stInfo);
m_stInfo.vColor.clear();
m_stInfo.vDir.clear();
m_stInfo.vSize.clear();
m_stInfo.vVelocity.clear();
m_stInfo.vAngle.clear();
}//end ParticleEmitter
}
//<Instance id="pEmitter1" pos1="0.0 0.0 0.0" pos2="8.0 0.0 0.0"/>
CXMLTreeNode l_pInstance = l_pManager["Instances"];
int numNodesInst = l_pInstance.GetNumChildren();
for (int i = 0; i<numNodesInst; i++)
{
CXMLTreeNode l_pInst = l_pInstance(i)["Instance"];
if (l_pInst.Exists() && !l_pInst.IsComment())
{
m_stInstance.id = l_pInst.GetPszProperty("id",0);
m_stInstance.vPos1 = l_pInst.GetVect3fProperty("pos1", Vect3f(0.f,0.f,0.f));
m_stInstance.vPos2 = l_pInst.GetVect3fProperty("pos2", Vect3f(0.f,0.f,0.f));
m_stInfo.vInstance.push_back(m_stInstance);
}
}
for (unsigned int c=0; c<m_vInfo.size(); c++)
{
int cont = -1;
for (unsigned int i = 0; i<m_stInfo.vInstance.size(); i++)
{
if (m_stInfo.vInstance[i].id == m_vInfo[c].sName)
{
cont++;
m_vInfo[c].vInstance.push_back(m_stInfo.vInstance[i]);
SetProperties(c,cont);
}
}
}
}
}
LOGGER->AddNewLog(ELL_INFORMATION, "ParticleManager::LoadXML ---XML cargado correctamente---");
SetPEmitterByInstance();
return l_bIsOk;
}
// Carreguem el fitxer d'emissors de partícules
bool CSteeringBehaviorsSeetingsManager::LoadXML ( void )
{
LOGGER->AddNewLog( ELL_INFORMATION, "CSteeringBehaviorsSeetingsManager::LoadXML --> Loading steering behaviors properties." );
CXMLTreeNode newFile;
if ( !newFile.LoadFile ( m_szFilename.c_str ( ) ) )
{
std::string msg_error = "CSteeringBehaviorsSeetingsManager::LoadXML->Error when trying to load the steering behaviors properties file: " + m_szFilename;
LOGGER->AddNewLog( ELL_ERROR, msg_error.c_str() );
return false;
}
CXMLTreeNode l_XMLPropertiesNode = newFile ["steering_properties"];
if ( l_XMLPropertiesNode.Exists ( ) )
{
uint16 l_TotalNodes = l_XMLPropertiesNode.GetNumChildren ();
// Recorro las propiedades
for ( uint16 i = 0; i < l_TotalNodes; ++i )
{
std::string l_PropertyField = l_XMLPropertiesNode(i).GetName();
if( l_PropertyField == "ObstacleWallDetectionFeelerLength" )
{
m_ObstacleWallDetectionFeelerLength = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "ObstacleWallDetectionFeelerLength", 2.f ) );
}
else if ( l_PropertyField == "ObstacleWallDetectionFeelerAngle" )
{
m_ObstacleWallDetectionFeelerAngle = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "ObstacleWallDetectionFeelerAngle", 60.f ) );
}
else if ( l_PropertyField == "DetectionFeelerAngleIncrement" )
{
m_DetectionFeelerAngleIncrement = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "DetectionFeelerAngleIncrement", 2.f ) );
}
else if ( l_PropertyField == "CollisionDetectionFeelerLength" )
{
m_CollisionDetectionFeelerLength = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "CollisionDetectionFeelerLength", 40.f ) );
}
else if ( l_PropertyField == "CollisionDetectionFeelerAngle" )
{
m_CollisionDetectionFeelerAngle = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "CollisionDetectionFeelerAngle", 60.f ) );
}
else if ( l_PropertyField == "SeparationDetectionFeelerLength" )
{
m_SeparationDetectionFeelerLength = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "SeparationDetectionFeelerLength", 40.f ) );
}
else if ( l_PropertyField == "SeparationDecayCoefficient" )
{
m_SeparationDecayCoefficient = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "SeparationDecayCoefficient", 40.f ) );
}
else if ( l_PropertyField == "ArriveDeceleration" )
{
std::string l_ArriveDecelaration = static_cast<std::string> ( l_XMLPropertiesNode(i).GetPszKeyword( "ArriveDeceleration", "normal" ) );
if ( l_ArriveDecelaration == "slow" )
m_ArriveDecelaration = ::slow;
if ( l_ArriveDecelaration == "normal" )
m_ArriveDecelaration = ::normal;
if ( l_ArriveDecelaration == "fast" )
m_ArriveDecelaration = ::fast;
}
else if ( l_PropertyField == "ArriveDecelerationDistance" )
{
m_ArriveDecelarationDistance = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "ArriveDecelerationDistance", 2.f ) );
}
else if ( l_PropertyField == "DecelerationTweaker" )
{
m_ArriveDecelarationTweaker = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "DecelerationTweaker", 2.f ) );
}
else if ( l_PropertyField == "flockingNeightbourRadius" )
{
m_NeightbourRadius = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "flockingNeightbourRadius", 2.f ) );
}
else if ( l_PropertyField == "WanderRefreshRate" )
{
m_WanderRefreshRate = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "WanderRefreshRate", 0.5f ) );
}
else if ( l_PropertyField == "WanderMinimumDistance" )
{
m_WanderMinimumDistance = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "WanderMinimumDistance", 0.5f ) );
}
else if ( l_PropertyField == "WanderDistance" )
{
m_WanderDistance = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "WanderDistance", 2.f ) );
}
else if ( l_PropertyField == "WanderRadius" )
{
m_WanderRadius = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "WanderRadius", 2.f ) );
}
else if ( l_PropertyField == "SeparationWeight" )
{
m_SeparationWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "SeparationWeight", 1.f ) );
}
else if ( l_PropertyField == "AlignmentWeight" )
{
m_AlignmentWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "AlignmentWeight", 1.f ) );
}
else if ( l_PropertyField == "CohesionWeight" )
{
m_CohesionWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "CohesionWeight", 2.f ) );
}
else if ( l_PropertyField == "CollisionAvoidanceWeight" )
{
m_CollisionAvoidanceWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "CollisionAvoidanceWeight", 10.f ) );
}
else if ( l_PropertyField == "ObstacleWallAvoidanceWeight" )
{
m_ObstacleObstacleWallAvoidanceWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "ObstacleWallAvoidanceWeight", 10.f ) );
}
else if ( l_PropertyField == "WanderWeight" )
{
m_WanderWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "WanderWeight", 1.f ) );
}
else if ( l_PropertyField == "SeekWeight" )
{
m_SeekWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "SeekWeight", 1.f ) );
}
else if ( l_PropertyField == "FleeWeight" )
{
m_FleeWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "FleeWeight", 1.f ) );
}
else if ( l_PropertyField == "ArriveWeight" )
{
m_ArriveWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "ArriveWeight", 1.f ) );
}
else if ( l_PropertyField == "PursuitWeight" )
{
m_PursuitWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "PursuitWeight", 1.f ) );
}
else if ( l_PropertyField == "OffsetPursuitWeight" )
{
m_OffsetPursuitWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "OffsetPursuitWeight", 1.f ) );
}
else if ( l_PropertyField == "InterposeWeight" )
{
m_InterposeWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "InterposeWeight", 1.f ) );
}
else if ( l_PropertyField == "HideWeight" )
{
m_HideWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "HideWeight", 1.f ) );
}
else if ( l_PropertyField == "EvadeWeight" )
{
m_EvadeWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "EvadeWeight", 0.01f ) );
}
else if ( l_PropertyField == "FollowPathWeight" )
{
m_FollowPathWeight = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "FollowPathWeight", 0.05f ) );
}
else if ( l_PropertyField == "NumberEnemiesCanAttack" )
{
m_NumberEnemiesToAttackAtSameTime = static_cast<int> ( l_XMLPropertiesNode(i).GetIntKeyword( "NumberEnemiesCanAttack", 3 ) );
}
else if ( l_PropertyField == "MinNumberEnemiesCanHelp" )
{
m_MinNumberEnemiesCanHelp = static_cast<int> ( l_XMLPropertiesNode(i).GetIntKeyword( "MinNumberEnemiesCanHelp", 2 ) );
}
else if ( l_PropertyField == "MaxNumberEnemiesCanHelp" )
{
m_MaxNumberEnemiesCanHelp = static_cast<int> ( l_XMLPropertiesNode(i).GetIntKeyword( "MaxNumberEnemiesCanHelp", 5 ) );
}
else if ( l_PropertyField == "CamaraRangeAngleForPrepared" )
{
m_CamaraRangeAngleForPrepared = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "CamaraRangeAngleForPrepared", 120 ) );
}
else if ( l_PropertyField == "CamaraRangeAngleForAttack" )
{
m_CamaraRangeAngleForAttack = static_cast<float> ( l_XMLPropertiesNode(i).GetFloatKeyword( "CamaraRangeAngleForAttack", 120 ) );
}
else if ( l_PropertyField != "comment" )
{
std::string msg_error = "CSteeringBehaviorsSeetingsManager::LoadXML->Error when trying to load a node : " + l_PropertyField + " from file: " + m_szFilename;
LOGGER->AddNewLog( ELL_ERROR, msg_error.c_str() );
}
}
}
return true;
}
void CSceneRendererCommandManager::Load(const std::string &FileName)
{
CXMLTreeNode parser;
if (!parser.LoadFile(FileName.c_str()))
{
std::string msg_error = "CSceneRendererCommandManager::Load->Error al intentar leer el archivo: " + FileName;
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
throw CException(__FILE__, __LINE__, msg_error);
}
m_FileName = FileName;
// Obtenemos el nodo "scene_renderer_commands"
CXMLTreeNode l_SceneRendererCommandManagerNode = parser["scene_renderer_commands"];
if (l_SceneRendererCommandManagerNode.Exists())
{
// Obtenemos los datos para todos los scene renderer commands
int l_count_objects = l_SceneRendererCommandManagerNode.GetNumChildren();
for (int i = 0; i < l_count_objects; ++i)
{
if (!l_SceneRendererCommandManagerNode(i).IsComment())
{
CSceneRendererCommand* l_RendererSceneCommand = NULL;
std::string l_CommandName = l_SceneRendererCommandManagerNode(i).GetName();
if (l_CommandName=="begin_scene")
{
l_RendererSceneCommand = new CBeginRenderSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="clear_scene")
{
l_RendererSceneCommand = new CClearSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="enable_z_write")
{
l_RendererSceneCommand = new CEnableZWriteSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="enable_z_test")
{
l_RendererSceneCommand = new CEnableZTestSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="disable_z_test")
{
l_RendererSceneCommand = new CDisableZTestSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_scene")
{
l_RendererSceneCommand = new CRenderSceneSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="disable_z_write")
{
l_RendererSceneCommand = new CDisableZWriteSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="end_scene")
{
l_RendererSceneCommand = new CEndRenderSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="present")
{
l_RendererSceneCommand = new CPresentSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="set_pool_renderable_objects_technique")
{
l_RendererSceneCommand = new CRenderableObjectTechniquesSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="setup_matrices")
{
l_RendererSceneCommand = new CSetupMatricesSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="set_render_target")
{
l_RendererSceneCommand = new CSetRenderTargetSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="unset_render_target")
{
std::string l_RenderTarget = l_SceneRendererCommandManagerNode(i).GetPszProperty("render_target","");
CSetRenderTargetSceneRendererCommand * l_SetRenderer=NULL;
l_SetRenderer = (CSetRenderTargetSceneRendererCommand *)m_SceneRendererCommands.GetResource(l_RenderTarget);
if (l_SetRenderer!=NULL)
{
l_RendererSceneCommand = new CUnsetRenderTargetSceneRendererCommand(l_SetRenderer, l_SceneRendererCommandManagerNode(i));
}
}
else if (l_CommandName=="generate_shadow_maps")
{
l_RendererSceneCommand = new CGenerateShadowMapsSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="blurH_shadow_maps")
{
l_RendererSceneCommand = new CBlurHShadowMapsSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="blurV_shadow_maps")
{
l_RendererSceneCommand = new CBlurVShadowMapsSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="capture_frame_buffer")
{
l_RendererSceneCommand = new CCaptureFrameBufferSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_draw_quad")
{
l_RendererSceneCommand = new CDrawQuadRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_deferred_shading")
{
l_RendererSceneCommand = new CDeferredShadingSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="set_scissor_rect")
{
l_RendererSceneCommand = new CScissorRectSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="unset_scissor_rect")
{
l_RendererSceneCommand = new CUnsetScissorRectSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_gui")
{
l_RendererSceneCommand = new CRenderGUISceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_particles")
{
l_RendererSceneCommand = new CRenderParticlesSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_mirrors")
{
l_RendererSceneCommand = new CRenderMirrorsSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
// DEBUG:
else if (l_CommandName=="render_debug_scene")
{
l_RendererSceneCommand = new CRenderDebugSceneSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_debug_lights")
{
l_RendererSceneCommand = new CRenderDebugLightsSceneSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_debug_info")
{
l_RendererSceneCommand = new CRenderDebugInfoSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_debug_camera")
{
l_RendererSceneCommand = new CRenderDebugCameraSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
else if (l_CommandName=="render_debug_physX")
{
l_RendererSceneCommand = new CRenderDebugPhysXSceneRendererCommand(l_SceneRendererCommandManagerNode(i));
}
if (l_RendererSceneCommand!=NULL)
{
std::string l_Name = l_SceneRendererCommandManagerNode(i).GetPszProperty("name","");
if (l_Name=="")
l_Name = l_CommandName + "_" + GetNextName();
l_RendererSceneCommand->SetName(l_Name);
m_SceneRendererCommands.AddResource(l_Name, l_RendererSceneCommand);
}
}
}
}
}
bool CSpirit::LoadXML(std::string fileName)
{
m_pFileName = fileName;
CXMLTreeNode header;
if(!header.LoadFile(fileName.c_str()))
{
//Guardar el mensaje de error en el LOGGER
std::string msg_error = " CSpirit::Load->Error al intentar abrir el archivo: ";
msg_error.append(fileName.c_str());
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
//throw CException(__FILE__, __LINE__, msg_error);
return false;
}
else
{
//<spirit>
//<parameters posini="3 2 -3" apertura="0.2" speedup="3.3" speeddown="0.5" heightflymax="3.0" heightflymin="1.9"
//speedslow="1.0" speedfast="1.5" distnear="4.0" distfar="6.0"
//timeidle="5.0" timechase="5.0"
//numlaps="2" speedcontento="4.0"
///>
//</spirit>
//solo un spirit****
CXMLTreeNode tag = header["spirit"];
if(tag.Exists())
{
if (!tag.IsComment())
{
CXMLTreeNode params = tag(0)["parameters"];
if (params.Exists())
{
m_V3PosIni = params.GetVect3fProperty("posini", Vect3f(3.0f, 1.5f, -3.8f));
// m_V3Pos = params.GetVect3fProperty("posini", Vect3f(3.0f, 1.5f, -3.8f)); //quitado para dejar estatico el espiritu
m_fSpeed_YUp = params.GetFloatProperty("speedup",3.3f);
m_fSpeed_YDown = params.GetFloatProperty("speeddown",0.5f);
m_fPosYMax = params.GetFloatProperty("heightflymax",3.f);
m_fPosYMin = params.GetFloatProperty("heightflymin",1.9f);
m_fAperturaEmisor = params.GetFloatProperty("apertura",0.2f);
m_fSpeedMax = params.GetFloatProperty("speedfast",1.5f);
m_fSpeedMin = params.GetFloatProperty("speedslow",1.f);
m_fDistFar = params.GetFloatProperty("distfar",6.f);
m_fDistNear = params.GetFloatProperty("distnear",10.f);
m_fDelayTimeIdle = params.GetFloatProperty("timeidle",5.f);
m_fDelayTimeChase = params.GetFloatProperty("timechase",5.f);
m_uiNumeroVueltasContento = params.GetIntProperty("numlaps",1);
m_fSpeedRotationContento = params.GetFloatProperty("speedcontento",3.f);
m_pLight = CORE->GetLigthManager()->GetResource(params.GetPszProperty("light", ""));
}
}
}
else
{
//Guardar el mensaje de error en el LOGGER
std::string msg_error = " CSpirit::Load->Parametros mal configurados ";
msg_error.append(fileName.c_str());
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
//throw CException(__FILE__, __LINE__, msg_error);
return false;
}
}
return true;
}
bool CWayPointManager::Reload()
{
CXMLTreeNode newFile;
if (!newFile.LoadFile(m_Filename.c_str()))
{
std::string msg_error = "WayPointManager::Load->Error al intentar leer el archivo xml: " + m_Filename;
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
return false;
}
CXMLTreeNode l_wps = newFile["waypoints"];
if( l_wps.Exists() )
{
uint16 l_Count = l_wps.GetNumChildren();
for(uint16 i=0; i<l_Count; ++i)
{
std::string l_Type = l_wps(i).GetName();
if( l_Type == "group" )
{
CXMLTreeNode groupChild = l_wps(i);
std::string groupName = groupChild.GetPszProperty("name", "", true);
if(m_WPGroups.find(groupName) == m_WPGroups.end())
{
m_WPGroups[groupName] = WayPointList();
}
uint16 l_CountGroup = groupChild.GetNumChildren();
for(uint16 j = 0; j < l_CountGroup; ++j)
{
std::string l_TypeChild = groupChild(j).GetName();
if(l_TypeChild == "waypoint")
{
std::string wpName = groupChild(j).GetPszProperty("name", "", true);
Vect3f wpPos = groupChild(j).GetVect3fProperty("position", Vect3f(0.0f, 0.0f, 0.0f), true);
CWayPoint* wp = new CWayPoint(wpName, wpPos);
m_WPGroups[groupName].push_back(wp);
}
if(l_TypeChild == "Brothers")
{
CXMLTreeNode broChild = groupChild(j);
uint16 broChildCount = broChild.GetNumChildren();
std::string wpName = broChild.GetPszProperty("wave_point_name", "", true);
CWayPoint* wp = GetWayPoint(groupName, wpName);
assert(wp);
for (uint16 x = 0; x < broChildCount; ++x)
{
std::string l_TypeBroChild = broChild(x).GetName();
if(l_TypeBroChild == "Brother")
{
std::string broName = broChild(x).GetPszProperty("name", "", true);
CWayPoint* wpBro = GetWayPoint(groupName, broName);
assert(wpBro);
wp->AddBrother(wpBro);
}
}
}
}
}
}
}
else
{
return false;
}
return true;
}
bool CParticleSettingsManager::Reload()
{
CXMLTreeNode newFile;
if (!newFile.LoadFile(m_Filename.c_str()))
{
std::string msg_error = "CParticleSettingsManager::Load->Error al intentar leer el archivo xml: " + m_Filename;
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
return false;
}
CXMLTreeNode l_xml = newFile["particle_settings"];
if( l_xml.Exists() )
{
uint16 l_Count = l_xml.GetNumChildren();
for(uint16 i=0; i<l_Count; ++i)
{
std::string l_Type = l_xml(i).GetName();
if( l_Type == "settings" )
{
CXMLTreeNode child = l_xml(i);
TParticleSystemSettings* settings = new TParticleSystemSettings();
settings->m_Name = child.GetPszProperty("name", "", true);
uint16 l_CountChild = child.GetNumChildren();
for(uint16 j = 0; j < l_CountChild; ++j)
{
std::string l_TypeChild = child(j).GetName();
if(l_TypeChild == "TextureName")
{
settings->m_TextureName = child(j).GetPszProperty("value", "", true);
}
else if(l_TypeChild == "MaxParticles")
{
uint32 maxPart = (uint32)child(j).GetIntProperty("value", 0, true) / CORE->GetConfig().particle_level;
maxPart = maxPart == 0 ? 1 : maxPart;
settings->m_MaxParticles = maxPart;
}
else if(l_TypeChild == "Duration")
{
settings->m_Duration = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "DurationRandomness")
{
settings->m_DurationRandomness = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "EmitterVelocitySensitivity")
{
settings->m_EmitterVelocitySensitivity = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MinHorizontalVelocity")
{
settings->m_MinHorizontalVelocity = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MaxHorizontalVelocity")
{
settings->m_MaxHorizontalVelocity = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MinVerticalVelocity")
{
settings->m_MinVerticalVelocity = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MaxVerticalVelocity")
{
settings->m_MaxVerticalVelocity = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "Gravity")
{
settings->m_Gravity = child(j).GetVect3fProperty("value", Vect3f(0, 0, 0), true);
}
else if(l_TypeChild == "EndVelocity")
{
settings->m_EndVelocity = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MinColor")
{
Vect4f temp = child(j).GetVect4fProperty("value", Vect4f(0, 0, 0, 0), true) / 255.0f;
settings->m_MinColor = CColor(temp);
}
else if(l_TypeChild == "MaxColor")
{
Vect4f temp = child(j).GetVect4fProperty("value", Vect4f(0, 0, 0, 0), true) / 255.0f;
settings->m_MaxColor = CColor(temp);
}
else if(l_TypeChild == "MinRotateSpeed")
{
settings->m_MinRotateSpeed = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MaxRotateSpeed")
{
settings->m_MaxRotateSpeed = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MinStartSize")
{
settings->m_MinStartSize = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MaxStartSize")
{
settings->m_MaxStartSize = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MinEndSize")
{
settings->m_MinEndSize = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "MaxEndSize")
{
settings->m_MaxEndSize = child(j).GetFloatProperty("value", 0, true);
}
else if(l_TypeChild == "BlendState")
{
std::string type = child(j).GetPszProperty("value", 0, true);
settings->m_BlendName = type;
if(type.compare("NonPremultiplied") == 0)
{
settings->m_BlendState = TGraphicBlendStates::NonPremultiplied;
}
else if (type.compare("Additive") == 0)
{
settings->m_BlendState = TGraphicBlendStates::Additive;
}
else if (type.compare("DefaultState") == 0)
{
settings->m_BlendState = TGraphicBlendStates::DefaultState;
}
}
}
bool isOk = this->AddResource(settings->m_Name, settings);
assert(isOk);
}
}
}
else
{
return false;
}
return true;
}
bool COptions::LoadFile()
{
CXMLTreeNode newFile;
if ( !newFile.LoadFile ( m_Filename.c_str ( ) ) )
{
std::string msg_error = "COptions::LoadFile->Error al leer el fichero de opciones: " + m_Filename;
LOGGER->AddNewLog( ELL_ERROR, msg_error.c_str() );
return false;
}
CXMLTreeNode l_RootNode = newFile ["Options"];
if ( l_RootNode.Exists() )
{
uint8 l_TotalNodes = l_RootNode.GetNumChildren();
for ( uint8 i = 0; i < l_TotalNodes; ++i )
{
CXMLTreeNode l_OptionNode = l_RootNode(i);
std::string l_TypeOptions = l_OptionNode.GetName();
uint8 l_NumNodes = l_OptionNode.GetNumChildren();
for(uint8 j=0; j<l_NumNodes; ++j)
{
std::string l_OptionField = l_OptionNode(j).GetName();
if( l_OptionField == "generic_volume")
{
float volume = l_OptionNode(j).GetFloatKeyword("generic_volume", 100.f);
if(l_TypeOptions == "Default")
m_fDefaultGenericVolume = volume;
else
m_fCustomGenericVolume = volume;
}
else if( l_OptionField == "music_volume" )
{
float volume = l_OptionNode(j).GetFloatKeyword("music_volume", 100.f);
if(l_TypeOptions == "Default")
m_fDefaultMusicVolume = volume;
else
m_fCustomMusicVolume = volume;
}
else if( l_OptionField == "effect_volume" )
{
float volume = l_OptionNode(j).GetFloatKeyword("effect_volume", 100.f);
if(l_TypeOptions == "Default")
m_fDefaultEffectsVolume = volume;
else
m_fCustomEffectsVolume = volume;
}
else if( l_OptionField == "mouse_invert" )
{
bool value = l_OptionNode(j).GetBoolKeyword("mouse_invert", false);
if(l_TypeOptions == "Default")
m_bCustomInvertedMouse = value;
else
m_bCustomInvertedMouse = value;
}
}
}
}
return true;
}
CFont::CFont(CXMLTreeNode& fontNode, CGUI* gui)
: CNamed(fontNode)
, m_glyphs( MAX_GLYPHS_BATCH )
, m_gui(gui)
, m_textAlign(Rectf::Alignment::TOP_LEFT)
{
auto mm = CEngine::GetSingleton().getMaterialManager();
auto tm = CEngine::GetSingleton().getTextureManager();
std::string fontFile = fontNode.GetPszProperty("path", "", false);
std::string fontName = fontNode.GetPszProperty("name", "", false);
DEBUG_ASSERT(fontFile.size() != 0 && fontName.size() != 0);
if (fontFile.size() == 0 || fontName.size() == 0)
{
return;
}
for (int i = 0; i < fontNode.GetNumChildren(); ++i)
{
auto matNode = fontNode(i);
if (matNode.GetName() == std::string("material"))
{
std::string matName = "font-material-" + fontName;
CMaterial *mat = new CMaterial(matNode);
mat->setName(matName);
mm->add(matName, mat);
m_material = mat;
break;
}
}
std::string fontPath;
size_t pathEnd = fontFile.find_last_of('\\');
if (pathEnd == fontFile.npos)
{
pathEnd = fontFile.find_last_of('/');
}
if (pathEnd != fontFile.npos)
{
fontPath = fontFile.substr(0, pathEnd+1);
}
CXMLTreeNode ff;
if (!ff.LoadFile(fontFile.c_str()))
{
DEBUG_ASSERT(false);
return;
}
CXMLTreeNode font = ff["font"];
CXMLTreeNode common = font["common"];
CXMLTreeNode info = font["info"];
Vect2f pageSize(common.GetFloatProperty("scaleW", 0, false), common.GetFloatProperty("scaleH", 0, false));
m_fontSize = info.GetFloatProperty( "size", 0, false );
DEBUG_ASSERT( m_fontSize != 0);
m_lineHeight = common.GetFloatProperty( "lineHeight", m_fontSize, false );
m_base = common.GetFloatProperty( "base", m_fontSize, false );
CXMLTreeNode pages = font["pages"];
for (int i = 0; i < pages.GetNumChildren(); ++i)
{
auto page = pages(i);
if (page.GetName() == std::string("page"))
{
std::string texFile = page.GetPszProperty("file", "", false);
DEBUG_ASSERT(texFile.size() > 0);
texFile = fontPath + texFile;
CTexture *tex = new CTexture();
tex->load(texFile, false);
tm->add(tex->getName(), tex);
m_pages.push_back(tex);
}
}
auto chars = font["chars"];
for (int i = 0; i < chars.GetNumChildren(); ++i)
{
auto ch = chars(i);
if (ch.GetName() != std::string("char"))
{
continue;
}
uchar chId = ch.GetIntProperty("id");
CharDesc_t cdesc;
cdesc.offset = Vect2f(ch.GetFloatProperty("xoffset", 0, false), ch.GetFloatProperty("yoffset", 0, false));
cdesc.page = ch.GetIntProperty("page");
cdesc.size = Vect2f(ch.GetFloatProperty("width", 0, false), ch.GetFloatProperty("height", 0, false));
cdesc.xAdvance = ch.GetFloatProperty("xadvance", 0, false);
cdesc.uvRect.position = Vect2f(ch.GetFloatProperty("x", 0, false), ch.GetFloatProperty("y", 0, false));
cdesc.uvRect.position = Vect2f(cdesc.uvRect.position.x / pageSize.x, cdesc.uvRect.position.y / pageSize.y);
cdesc.uvRect.size = Vect2f(cdesc.size.x / pageSize.x, cdesc.size.y / pageSize.y);
m_chars[chId] = cdesc;
}
auto kerns = font["kernings"];
if (kerns.Exists())
{
for (int i = 0; i < kerns.GetNumChildren(); ++i)
{
auto k = kerns(i);
uchar f = k.GetIntProperty("first", 0, false);
uchar s = k.GetIntProperty("second", 0, false);
uchar a = k.GetIntProperty("amount", 0, false);
m_kernings[std::make_pair(f, s)] = a;
}
}
m_glyphsVtxs = new CPointsListRenderableVertexs<GUI_TEXT_VERTEX>(m_glyphs.data(), MAX_GLYPHS_BATCH, MAX_GLYPHS_BATCH, true);
}
bool CGUIWindow::LoadXML( const std::string &xmlGuiFile, const Vect2i& screenResolution)
{
//Read the xml gui file
LOGGER->AddNewLog(ELL_INFORMATION, "CGUIWindow:: Iniciando el parseo del fichero %s", xmlGuiFile.c_str());
bool isOK = false;
CXMLTreeNode newFile;
if (!newFile.LoadFile(xmlGuiFile.c_str()))
{
LOGGER->AddNewLog(ELL_ERROR, "CGUIWindow:: No se ha podido leer correctamente el fichero ->%s", xmlGuiFile.c_str());
isOK = false;
}
else
{
CTextureManager* textureM = CORE->GetTextureManager();
CXMLTreeNode windows = newFile["Windows"];
m_sLuaCode_OnLoadWindows = windows.GetPszProperty("OnLoadWindows");
m_sLuaCode_OnSaveWindows = windows.GetPszProperty("OnSaveWindows");
m_sLuaCode_OnUpdateWindows = windows.GetPszProperty("OnUpdateWindows");
if (windows.Exists())
{
int count = windows.GetNumChildren();
for (int i = 0; i < count; ++i)
{
CXMLTreeNode pNewNode = windows(i);
//Para cada guielement leemos su informacion comun-->
std::string name = pNewNode.GetPszProperty("name", "defaultGuiElement");
float posx = pNewNode.GetFloatProperty("posx", 0.f);
float posy = pNewNode.GetFloatProperty("posy", 0.f);
float w = pNewNode.GetFloatProperty("width", 50.f);
float h = pNewNode.GetFloatProperty("height", 50.f);
bool visible = pNewNode.GetBoolProperty("visible", true);
bool activated = pNewNode.GetBoolProperty("active", true);
std::string tagName = pNewNode.GetName();
if (tagName.compare("Button")==0)
{
CButton* newButton = NULL;
LoadButton(&newButton,pNewNode,screenResolution, textureM);
AddGuiElement(newButton);
}
else if (tagName.compare("CheckButton")==0)
{
CCheckButton* new_checkButton = NULL;
LoadCheckButton(&new_checkButton,pNewNode,screenResolution, textureM);
AddGuiElement(new_checkButton);
}
else if (tagName.compare("Slider")==0)
{
CSlider* new_slider = NULL;
LoadSlider(&new_slider,pNewNode,screenResolution, textureM);
AddGuiElement(new_slider);
}
else if (tagName.compare("DialogBox")==0)
{
CDialogBox* new_dialogBox = NULL;
LoadDialogBox(&new_dialogBox,pNewNode,screenResolution, textureM);
AddGuiElement(new_dialogBox);
}
else if (tagName.compare("EditableTextBox")==0)
{
CEditableTextBox* new_editableTextBox = NULL;
LoadEditableTextBox(&new_editableTextBox,pNewNode,screenResolution, textureM);
AddGuiElement(new_editableTextBox);
}
else if (tagName.compare("RadioBox")==0)
{
CRadioBox* new_radioBox = NULL;
LoadRadioBox(&new_radioBox,pNewNode,screenResolution, textureM);
AddGuiElement(new_radioBox);
}
else if (tagName.compare("Image")==0)
{
CImage* new_image = NULL;
_LoadImage(&new_image,pNewNode,screenResolution, textureM);
AddGuiElement(new_image);
}
else if (tagName.compare("AnimatedImage")==0)
{
CAnimatedImage* new_image = NULL;
LoadAnimatedImage(&new_image,pNewNode,screenResolution, textureM);
AddGuiElement(new_image);
}
else if (tagName.compare("ProgressBar")==0)
{
CProgressBar* new_progressBar = NULL;
LoadProgressBar(&new_progressBar,pNewNode,screenResolution, textureM);
AddGuiElement(new_progressBar);
}
else if (tagName.compare("StaticText")==0)
{
CStaticText* new_staticText = NULL;
LoadStaticText(&new_staticText,pNewNode,screenResolution, textureM);
AddGuiElement(new_staticText);
}
else if (tagName.compare("KeyBoard_Back")==0)
{
//<KeyBoard_Back input="DIK_A" OnKeyDown="blablaLua"/>
m_sLuaCode_OnKeyDown = pNewNode.GetPszProperty("OnKeyDown", "");
m_uInputKeyDown = pNewNode.GetIntProperty("input", 0);
}
else
{
//Warning
LOGGER->AddNewLog(ELL_WARNING, "GUIWindow:: No se reconoce el tag %s del fichero %s", tagName.c_str(), xmlGuiFile.c_str());
}
}
isOK = true;
}
else
{
LOGGER->AddNewLog(ELL_ERROR, "GUIWindow:: No se ha podido leer el tag Windows del fichero ->%s", xmlGuiFile.c_str());
isOK = false;
}
}//END else de if (!newFile.LoadFile(xmlGuiFile.c_str()))
if (!isOK)
{
LOGGER->AddNewLog(ELL_ERROR, "GUIWindow:: No se ha podido leer correctamente el fichero -->%s", xmlGuiFile.c_str());
isOK = false;
}
else
{
LOGGER->AddNewLog(ELL_INFORMATION, "GUIWindow:: Finalizado correctamente el parseo el fichero %s", xmlGuiFile.c_str());
}
return isOK;
}
/// <summary>
/// Carga el .xml de sonido.
/// </summary>
///<param name="&FileName">Ubicación del archivo xml.</param>
bool CSoundManager::Load(const std::string &FileName)
{
SSoundData soundData;
bool l_bIsOk = true;
m_FileName = FileName;
CXMLTreeNode filexml;
if (!filexml.LoadFile(m_FileName.c_str()))
{
// Guarda mensaje de error en el log
std::string msg_error = "CSoundManager::Load->Error al intentar abrir el archivo: ";
msg_error.append(m_FileName.c_str());
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
throw CException(__FILE__, __LINE__, msg_error);
l_bIsOk = false;
}
else
{
CXMLTreeNode cores = filexml["sounds"];
if (cores.Exists())
{
m_iMaxChannels = cores.GetIntProperty("maxChannels");
// Asignando número de canales de acuerdo al parametro extraído del .xml
m_Channels.resize(m_iMaxChannels);
if (!cores.IsComment())
{
int32 numNodes = cores.GetNumChildren();
for(int i=0; i < numNodes; i++)
{
if (!cores(i).IsComment())
{
// Recibe parametros de los sonidos
std::string l_sCoreName = cores(i).GetPszProperty("name");
std::string l_sCoreType = cores(i).GetPszProperty("type");
std::string l_sCorePath = cores(i).GetPszProperty("path");
bool l_bCoreLoop = cores(i).GetBoolProperty("loop");
bool l_bCore3D = cores(i).GetBoolProperty("threeDimensional");
std::string l_sCorePriority = cores(i).GetPszProperty("priority");
std::string l_sCoreEffect = cores(i).GetPszProperty("effect");
float l_fCoreVolume = cores(i).GetFloatProperty("volume");
int iMask = 0;
int PathLastCharacters = l_sCorePath.length() - 3;
std::string substring = l_sCorePath.substr(PathLastCharacters,3);
if (substring != "wav")
{
// Convert the sample (MP3/MP2/MP1 only) to mono, if it's not already.
iMask = BASS_SAMPLE_MONO;
}
// Asigna propiedad de loop
if (l_bCoreLoop)
{
iMask |= BASS_SAMPLE_LOOP;
soundData.m_Loop = true;
}
else
{
soundData.m_Loop = false;
}
// Asigna propiedad 3D y posición 3D
if (l_bCore3D)
{
iMask |= BASS_SAMPLE_3D;
soundData.m_ThreeDimensional = true;
soundData.m_Position = cores(i).GetVect3fProperty("position", Vect3f(0.0, 0.0, 0.0));
}
else
{
soundData.m_ThreeDimensional = false;
}
if (l_sCoreType == "sample")
{
// Genera identificador para sonido
soundData.m_type = SAMPLER;
soundData.m_Id = BASS_SampleLoad(false, l_sCorePath.c_str(), 0, 0, m_iMaxChannels, iMask);
}
else
{
// Genera identificador para música
soundData.m_Id = BASS_StreamCreateFile(false, l_sCorePath.c_str(), 0, 0, iMask);
soundData.m_type = BGM;
}
// Añadiendo volumen
soundData.m_Volume = l_fCoreVolume;
// Añade sonido al mapa
m_Resources[l_sCoreName] = soundData;
}
}
}
}
else
{
l_bIsOk = false;
}
}
return l_bIsOk;
}
bool CEnemyManager::Init(const char* _pcFile)
{
CXMLTreeNode FileXML;
FileXML.LoadFile(_pcFile);
//CXMLTreeNode Enemies = fileXML(0);
{
CXMLTreeNode Templates = FileXML["templates"];
int iNumChildren = Templates.GetNumChildren();
for(int i = 0; i < iNumChildren; i++) {
CXMLTreeNode EnemyTemplate = Templates(i);
const char* pcId = EnemyTemplate.GetPszProperty("id");
const char* pcMesh = EnemyTemplate.GetPszProperty("mesh");
CEnemyResource* pResource = new CEnemyResource();
std::string szId = pcId;
//TODO comprovar errors
pResource->Init(pcId,pcMesh);
m_Resources[szId] = pResource;
}
}
{
Vect3f Default(0,0,0);
CXMLTreeNode Instances = FileXML["instances"];
int iNumChildren = Instances.GetNumChildren();
for(int i = 0; i < iNumChildren; i++) {
CXMLTreeNode EnemyInstance = Instances(i);
const char* pcType = EnemyInstance.GetPszProperty("type");
const Vect3f vPos = EnemyInstance.GetVect3fProperty("pos",Default);
const Vect3f vRot = EnemyInstance.GetVect3fProperty("rot",Default);
const float fMoveSpeed = EnemyInstance.GetFloatProperty("move_speed");
const float fRotateSpeed = EnemyInstance.GetFloatProperty("rotate_speed");
const float fHealth = EnemyInstance.GetFloatProperty("health");
if(strcmp(pcType,"PATROLLER") == 0)
{
const char* pcPaths = EnemyInstance.GetPszProperty("paths");
CPatroller* pPatroller = new CPatroller();
pPatroller->Init(vPos,vRot,fMoveSpeed,fRotateSpeed,fHealth,pcPaths);
m_Instances.push_back(pPatroller);
} else if(strcmp(pcType,"SNIPER") == 0)
{
float fAimDistance = EnemyInstance.GetFloatProperty("aim_distance");
CSniper* pSniper = new CSniper();
pSniper->Init(vPos,vRot,fMoveSpeed,fRotateSpeed,fHealth,fAimDistance);
m_Instances.push_back(pSniper);
} else if(strcmp(pcType,"TURRET") == 0)
{
Vect3f vMaxAngle = EnemyInstance.GetVect3fProperty("max_angle",Default);
Vect3f vMinAngle = EnemyInstance.GetVect3fProperty("min_angle",Default);
CTurret* pTurret = new CTurret();
pTurret->Init(vPos,vRot,fMoveSpeed,fRotateSpeed,fHealth,vMaxAngle,vMinAngle);
m_Instances.push_back(pTurret);
} else if(strcmp(pcType,"CAMERA") == 0)
{
Vect3f vMaxAngle = EnemyInstance.GetVect3fProperty("max_angle",Default);
Vect3f vMinAngle = EnemyInstance.GetVect3fProperty("min_angle",Default);
CCamera* pCamera = new CCamera();
pCamera->Init(vPos,vRot,fMoveSpeed,fRotateSpeed,fHealth,vMaxAngle,vMinAngle);
m_Instances.push_back(pCamera);
} else {
//TODO errors
}
}
}
return true;
}
bool CParticleEmitterManager::Reload()
{
CXMLTreeNode newFile;
if (!newFile.LoadFile(m_Filename.c_str()))
{
std::string msg_error = "CParticleEmitterManager::Load->Error al intentar leer el archivo xml: " + m_Filename;
LOGGER->AddNewLog(ELL_ERROR, msg_error.c_str());
return false;
}
CXMLTreeNode l_xml = newFile["particle_emitters"];
if( l_xml.Exists() )
{
uint16 l_Count = l_xml.GetNumChildren();
for(uint16 i=0; i<l_Count; ++i)
{
std::string l_Type = l_xml(i).GetName();
if( l_Type == "emitter" )
{
std::string name = l_xml(i).GetPszProperty("name", "", true);
std::string systemName = l_xml(i).GetPszProperty("system_name", "", true);
std::string type = l_xml(i).GetPszProperty("type", "", true);
Vect3f initPos = l_xml(i).GetVect3fProperty("initialPosition", Vect3f(0, 0, 0), true);
bool onLoop = l_xml(i).GetBoolProperty("on_loop", true, false);
bool useDis = l_xml(i).GetBoolProperty("use_dis", true, false);
float particlesPerSecond = l_xml(i).GetFloatProperty("particlesPerSecond", 0, true) / CORE->GetConfig().particle_level;
uint32 pej = (uint32)l_xml(i).GetIntProperty("ejection_count", 0, !onLoop) / CORE->GetConfig().particle_level;
particlesPerSecond = particlesPerSecond == 0.0f ? 1.0f : particlesPerSecond;
pej = pej == 0 ? 1 : pej;
CParticleSystem* system = CORE->GetParticleSystemManager()->GetResource(systemName);
assert(system);
CParticleEmitter* emitter = NULL;
if(type == "point")
{
CParticleEmitterPoint* point = new CParticleEmitterPoint(name, system, particlesPerSecond, initPos, useDis);
emitter = point;
}
else if(type == "ring")
{
bool horizontal = l_xml(i).GetBoolProperty("horizontal", false, true);
float radius = l_xml(i).GetFloatProperty("radius", 0, true);
float height = l_xml(i).GetFloatProperty("height", 0, true);
float width = l_xml(i).GetFloatProperty("width", 0, true);
CParticleEmitterRing* ring = new CParticleEmitterRing(name, system, particlesPerSecond, initPos, useDis, horizontal, radius, height, width);
emitter = ring;
}
else if(type == "line")
{
Vect3f lineStart = l_xml(i).GetVect3fProperty("line_start", v3fZERO);
Vect3f lineEnd = l_xml(i).GetVect3fProperty("line_end", v3fZERO);
CParticleEmitterLine* line = new CParticleEmitterLine(name, system, particlesPerSecond, initPos, useDis, lineStart, lineEnd);
emitter = line;
}
else if(type == "box")
{
Vect3f boxMin = l_xml(i).GetVect3fProperty("box_min", v3fZERO);
Vect3f boxMax = l_xml(i).GetVect3fProperty("box_max", v3fZERO);
CParticleEmitterBox* box = new CParticleEmitterBox(name, system, particlesPerSecond, initPos, useDis, boxMin, boxMax);
emitter = box;
}
else if(type == "sphere")
{
float radius = l_xml(i).GetFloatProperty("radius", 1.f);
CParticleEmitterSphere *sphere = new CParticleEmitterSphere(name, system, particlesPerSecond, initPos, useDis, radius);
emitter = sphere;
}
assert(emitter);
emitter->SetOnLoop(onLoop);
emitter->SetParticlesEjectionCount(pej);
bool isOk = this->AddResource(name, emitter);
assert(isOk);
}
}
}
else
{
return false;
}
return true;
}
