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