Checksum Scenario::load(const string &path) { Checksum scenarioChecksum; try { scenarioChecksum.addFile(path); checksumValue.addFile(path); string name= cutLastExt(lastDir(path)); Logger::getInstance().add("Scenario: " + formatString(name), true); //parse xml XmlTree xmlTree; xmlTree.load(path); const XmlNode *scenarioNode= xmlTree.getRootNode(); const XmlNode *scriptsNode= scenarioNode->getChild("scripts"); for(int i= 0; i<scriptsNode->getChildCount(); ++i){ const XmlNode *scriptNode = scriptsNode->getChild(i); scripts.push_back(Script(getFunctionName(scriptNode), scriptNode->getText())); } } //Exception handling (conversions and so on); catch(const exception &e) { SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what()); throw runtime_error("Error: " + path + "\n" + e.what()); } return scenarioChecksum; }
void UnitParticleSystemType::load(const XmlNode *particleFileNode, const string &dir, const string &path, RendererInterface *renderer, std::map<string,vector<pair<string, string> > > &loadedFileList, string parentLoader, string techtreePath) { try{ XmlTree xmlTree; std::map<string,string> mapExtraTagReplacementValues; mapExtraTagReplacementValues["$COMMONDATAPATH"] = techtreePath + "/commondata/"; xmlTree.load(path, Properties::getTagReplacementValues(&mapExtraTagReplacementValues)); loadedFileList[path].push_back(make_pair(parentLoader,parentLoader)); const XmlNode *particleSystemNode= xmlTree.getRootNode(); if(particleFileNode){ // immediate children in the particleFileNode will override the particleSystemNode particleFileNode->setSuper(particleSystemNode); particleSystemNode= particleFileNode; } UnitParticleSystemType::load(particleSystemNode, dir, renderer, loadedFileList, parentLoader, techtreePath); } catch(const exception &e){ SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what()); throw megaglest_runtime_error("Error loading ParticleSystem: "+ path + "\n" +e.what()); } }
Object* ObjectLoader::loadObjectFromFile(const char* filename){ Object* object = NULL; //Leo el archivo y lo parseo en un arbol XmlTree* xmlTree = XmlParser::parse(string(WindowConnector::getBaseApplicationPath() + filename).c_str()); //***Transformo el arbol en un Object*** XmlTreeNode* root = xmlTree->getRootNode(); //Primiero busco la etiqueta de Object XmlTreeNode* objectNode = NULL; for(unsigned int i=0; i < root->getChildNodes().size(); i++){ objectNode = root->getChildNodes()[i]; if(objectNode->getName().compare("Object")==0){ //Cargo el mesh y le seteo los valores del xml object = initObject(objectNode); break; } } if(object == NULL){ if(xmlTree != NULL){ delete xmlTree; } return NULL; //Error } //Busco las etiquetas de Mesh y reemplazo los valores del xml Mesh* mesh = object->getMesh(); if(mesh->getChilds()->size() > 0){ loadMesh(mesh, objectNode); } //Busco las etiquetas de Light y las agrego a las luces del objeto loadLights(object, objectNode); //Guardo el path en el object object->setFilename(filename); delete xmlTree; return object; }
XmlTree* ScaenaAnimationWriter::animationsToXmlTree(list<AnimationDataTransfer*>* animations){ XmlTree* xmlTree = new XmlTree(); XmlTreeNode* rootNode = xmlTree->getRootNode(); // Agrego el tag inicial XmlTreeNode* safNode = new XmlTreeNode("ScaenaAnimationFile", rootNode); rootNode->addChild(safNode); // Agrego todas las animaciones list<AnimationDataTransfer*>::iterator animIt = animations->begin(); while( animIt != animations->end() ){ // Agrego el tag de animacion XmlTreeNode* animationNode = new XmlTreeNode("Animation", safNode); safNode->addChild(animationNode); // Agrego como atributo el nombre de la animacion AnimationDataTransfer* animationDataTransfer = *animIt; animationNode->addAttribute(new XmlNodeAttribute("Name", animationDataTransfer->name)); // Agrego cada uno de los keyframes list<KeyFrameDataTransfer*>::iterator keyIt = animationDataTransfer->keyframes->begin(); while(keyIt != animationDataTransfer->keyframes->end()){ keyFrameToXmlTree(animationNode, *keyIt); ++keyIt; } ++animIt; } return xmlTree; }
bool GenerationProcessor::processScaenaAnimationFile(string& inAnimationFile, string& outAnimationFile, string& keyFrameFBXFile, string& animationName, float keyDuration){ //Parseo el archivo de modelo FbxModelLoader* fbxLoader = new FbxModelLoader(); ModelDataTransfer* modelDataTransfer = fbxLoader->loadModel(keyFrameFBXFile.c_str()); KeyFrameDataTransfer* keyframe = getKeyFrameData(modelDataTransfer, 0); keyframe->animationTime = keyDuration; delete fbxLoader; // Si tengo SAF de entrada, lo cargo para agregarle la nueva animacion o keyframe if(!inAnimationFile.empty()){ Logger::getInstance()->logInfo(new Log("Procesando el SAF de salida...")); //Leo el archivo y lo parseo en un arbol XmlTree* xmlTree = XmlParser::parse(inAnimationFile.c_str()); XmlTreeNode* rootNode = xmlTree->getRootNode(); // Busco el nodo de archivo SAF XmlTreeNode* safNode = rootNode->searchDirectChild("ScaenaAnimationFile", 0); if(safNode != NULL){ // Busco si alguna animacion tiene el mismo nombre que la indicada, si no creo una nueva XmlTreeNode* animationNode = searchForAnimation(safNode, animationName); if(animationNode == NULL){ animationNode = new XmlTreeNode("Animation", safNode); animationNode->addAttribute(new XmlNodeAttribute("Name", animationName)); safNode->addChild(animationNode); } // Agrego el keyframe XmlTreeNode* keyFrameNode = new XmlTreeNode("KeyFrame", animationNode); keyFrameNode->addAttribute(new XmlNodeAttribute("DurationInSeconds", StringUtils::toString(keyframe->animationTime))); ScaenaAnimationWriter::skeletonToXmlTree(keyFrameNode, keyframe->getRootSkeleton()); animationNode->addChild(keyFrameNode); // Grabo en el archivo SAF (REVIEW: podria dejar de escribir cada cambio en disco) XmlParser::writeXmlToFile(outAnimationFile.c_str(), xmlTree); } else{ throw new AnimationLoadException("No se puede procesar el SAF de entrada"); } } // Si no tengo SAF de entrada, creo la estructura de cero else{ list<AnimationDataTransfer*> animations; AnimationDataTransfer* animation = new AnimationDataTransfer(); animation->name = animationName; animation->keyframes->push_back(keyframe); animations.push_back(animation); // Escribo el SAF e indico que ahora tengo archivo de entrada ScaenaAnimationWriter::writeAnimation(outAnimationFile, &animations); inAnimationFile = outAnimationFile; } delete modelDataTransfer; delete keyframe; return true; }
void UnitParticleSystemType::load(const string &dir, const string &path, RendererInterface *renderer){ try{ XmlTree xmlTree; xmlTree.load(path); const XmlNode *particleSystemNode= xmlTree.getRootNode(); UnitParticleSystemType::load(particleSystemNode, dir, renderer); } catch(const exception &e){ SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what()); throw runtime_error("Error loading ParticleSystem: "+ path + "\n" +e.what()); } }
XmlTree* ObjectLoader::objectToXlmTree(Object* object){ XmlTree* xmlTree = new XmlTree(); XmlTreeNode* node = xmlTree->getRootNode(); XmlTreeNode* objectNode = new XmlTreeNode("Object", node); node->addChild(objectNode); objectNode->createAttribute("id", object->getId()); objectNode->createAttribute("class", "Object"); objectNode->createAttribute("meshPath", object->getMesh()->getFilePath()); //Escribo el mesh asociado en nodos writeFullMeshToNodes(objectNode, object->getMesh()); //Escribo las luces asociadas al objeto writeAllLightsToNodes(objectNode, object->getAttachedLights()); return xmlTree; }
void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetChecksum, std::map<string,vector<pair<string, string> > > &loadedFileList) { if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); random.init(time(NULL)); if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); string name= lastDir(dir); tileset_name = name; string currentPath = dir; endPathWithSlash(currentPath); string path= currentPath + name + ".xml"; string sourceXMLFile = path; checksum->addFile(path); tilesetChecksum->addFile(path); checksumValue.addFile(path); try { char szBuf[8096]=""; snprintf(szBuf,8096,Lang::getInstance().get("LogScreenGameLoadingTileset","",true).c_str(),formatString(name).c_str()); Logger::getInstance().add(szBuf, true); Renderer &renderer= Renderer::getInstance(); if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //printf("About to load tileset [%s]\n",path.c_str()); //parse xml XmlTree xmlTree; xmlTree.load(path,Properties::getTagReplacementValues()); loadedFileList[path].push_back(make_pair(currentPath,currentPath)); if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); const XmlNode *tilesetNode= xmlTree.getRootNode(); if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //surfaces const XmlNode *surfacesNode= tilesetNode->getChild("surfaces"); int partsize= 0; for(int i=0; i < surfCount; ++i) { const XmlNode *surfaceNode; if(surfacesNode->hasChildAtIndex("surface",i)){ surfaceNode= surfacesNode->getChild("surface", i); } else { // cliff texture does not exist, use texture 2 instead surfaceNode= surfacesNode->getChild("surface", 2); } if(surfaceNode->hasAttribute("partsize")){ partsize=surfaceNode->getAttribute("partsize",true)->getIntValue(); } else{ partsize=0; } if(partsize==0){ int childCount= surfaceNode->getChildCount(); surfPixmaps[i].resize(childCount); surfProbs[i].resize(childCount); for(int j = 0; j < childCount; ++j) { surfPixmaps[i][j] = NULL; } for(int j = 0; j < childCount; ++j) { const XmlNode *textureNode= surfaceNode->getChild("texture", j); if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) { surfPixmaps[i][j] = new Pixmap2D(); surfPixmaps[i][j]->init(3); surfPixmaps[i][j]->load(textureNode->getAttribute("path")->getRestrictedValue(currentPath)); } loadedFileList[textureNode->getAttribute("path")->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,textureNode->getAttribute("path")->getRestrictedValue())); surfProbs[i][j]= textureNode->getAttribute("prob")->getFloatValue(); } } else { // read single big texture and cut it into pieces const XmlNode *textureNode= surfaceNode->getChild("texture", 0); Pixmap2D *pixmap=new Pixmap2D(); pixmap->init(3); pixmap->load(textureNode->getAttribute("path")->getRestrictedValue(currentPath)); loadedFileList[textureNode->getAttribute("path")->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,textureNode->getAttribute("path")->getRestrictedValue())); int width=pixmap->getW(); int heith=pixmap->getW(); assert(width==heith); assert(width%64==0); assert(width%partsize==0); int parts=width/partsize; int numberOfPieces=parts*parts; partsArray[i]=parts; surfPixmaps[i].resize(numberOfPieces); surfProbs[i].resize(numberOfPieces); int j=0; for(int x = 0; x < parts; ++x) { for(int y = 0; y < parts; ++y) { surfPixmaps[i][j] = new Pixmap2D(); surfPixmaps[i][j]->init(partsize,partsize,3); surfPixmaps[i][j]->copyImagePart(x*partsize,y*partsize,pixmap); surfProbs[i][j]=-1; j++; } } } } if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //object models const XmlNode *objectsNode= tilesetNode->getChild("objects"); for(int i=0; i<objCount; ++i){ const XmlNode *objectNode= objectsNode->getChild("object", i); int childCount= objectNode->getChildCount(); int objectHeight = 0; bool walkable = objectNode->getAttribute("walkable")->getBoolValue(); if(walkable == false) { const XmlAttribute *heightAttribute = objectNode->getAttribute("height",false); if(heightAttribute != NULL) { objectHeight = heightAttribute->getIntValue(); } } objectTypes[i].init(childCount, i, walkable,objectHeight); for(int j=0; j<childCount; ++j) { const XmlNode *modelNode= objectNode->getChild("model", j); const XmlAttribute *pathAttribute= modelNode->getAttribute("path"); TilesetModelType* tmt=objectTypes[i].loadModel(pathAttribute->getRestrictedValue(currentPath),&loadedFileList, sourceXMLFile); loadedFileList[pathAttribute->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,pathAttribute->getRestrictedValue())); if(modelNode->hasAttribute("anim-speed") == true) { int animSpeed= modelNode->getAttribute("anim-speed")->getIntValue(); tmt->setAnimSpeed(animSpeed); } if(modelNode->hasChild("particles")){ const XmlNode *particleNode= modelNode->getChild("particles"); bool particleEnabled= particleNode->getAttribute("value")->getBoolValue(); if(particleEnabled){ for(int k=0; k<particleNode->getChildCount(); ++k){ const XmlNode *particleFileNode= particleNode->getChild("particle-file", k); string path= particleFileNode->getAttribute("path")->getRestrictedValue(); ObjectParticleSystemType *objectParticleSystemType= new ObjectParticleSystemType(); objectParticleSystemType->load(particleFileNode, dir, currentPath + path, &Renderer::getInstance(), loadedFileList, sourceXMLFile,""); loadedFileList[currentPath + path].push_back(make_pair(sourceXMLFile,particleFileNode->getAttribute("path")->getRestrictedValue())); tmt->addParticleSystem(objectParticleSystemType); } } } //rotationAllowed if(modelNode->hasAttribute("rotationAllowed") == true) { tmt->setRotationAllowed(modelNode->getAttribute("rotationAllowed")->getBoolValue()); } else if(modelNode->hasChild("rotationAllowed")){ const XmlNode *rotationAllowedNode= modelNode->getChild("rotationAllowed"); tmt->setRotationAllowed(rotationAllowedNode->getAttribute("value")->getBoolValue()); } else{ tmt->setRotationAllowed(true); } //smoothTwoFrameAnim if(modelNode->hasAttribute("smoothTwoFrameAnim") == true) { tmt->setSmoothTwoFrameAnim(modelNode->getAttribute("smoothTwoFrameAnim")->getBoolValue()); } else{ tmt->setSmoothTwoFrameAnim(false); } } } // Now free up the pixmap memory for(int i=0; i<objCount; ++i){ objectTypes[i].deletePixels(); } if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //ambient sounds ambientSounds.load(dir, tilesetNode->getChild("ambient-sounds"), loadedFileList, sourceXMLFile); //parameters const XmlNode *parametersNode= tilesetNode->getChild("parameters"); //water const XmlNode *waterNode= parametersNode->getChild("water"); waterTex= renderer.newTexture3D(rsGame); if(waterTex) { waterTex->setMipmap(false); waterTex->setWrapMode(Texture::wmRepeat); } waterEffects= waterNode->getAttribute("effects")->getBoolValue(); if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); int waterFrameCount= waterNode->getChildCount(); if(waterTex) { waterTex->getPixmap()->init(waterFrameCount, 4); } for(int i=0; i<waterFrameCount; ++i){ const XmlNode *waterFrameNode= waterNode->getChild("texture", i); if(waterTex) { waterTex->getPixmap()->loadSlice(waterFrameNode->getAttribute("path")->getRestrictedValue(currentPath), i); } loadedFileList[waterFrameNode->getAttribute("path")->getRestrictedValue(currentPath)].push_back(make_pair(sourceXMLFile,waterFrameNode->getAttribute("path")->getRestrictedValue())); } if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //fog const XmlNode *fogNode= parametersNode->getChild("fog"); fog= fogNode->getAttribute("enabled")->getBoolValue(); if(fog){ fogMode= fogNode->getAttribute("mode")->getIntValue(1, 2); fogDensity= fogNode->getAttribute("density")->getFloatValue(); fogColor.x= fogNode->getAttribute("color-red")->getFloatValue(0.f, 1.f); fogColor.y= fogNode->getAttribute("color-green")->getFloatValue(0.f, 1.f); fogColor.z= fogNode->getAttribute("color-blue")->getFloatValue(0.f, 1.f); } if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //sun and moon light colors const XmlNode *sunLightColorNode= parametersNode->getChild("sun-light"); sunLightColor.x= sunLightColorNode->getAttribute("red")->getFloatValue(); sunLightColor.y= sunLightColorNode->getAttribute("green")->getFloatValue(); sunLightColor.z= sunLightColorNode->getAttribute("blue")->getFloatValue(); const XmlNode *moonLightColorNode= parametersNode->getChild("moon-light"); moonLightColor.x= moonLightColorNode->getAttribute("red")->getFloatValue(); moonLightColor.y= moonLightColorNode->getAttribute("green")->getFloatValue(); moonLightColor.z= moonLightColorNode->getAttribute("blue")->getFloatValue(); if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //weather const XmlNode *weatherNode= parametersNode->getChild("weather"); float sunnyProb= weatherNode->getAttribute("sun")->getFloatValue(0.f, 1.f); float rainyProb= weatherNode->getAttribute("rain")->getFloatValue(0.f, 1.f) + sunnyProb; if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); #ifdef USE_STREFLOP float rnd= streflop::fabs(static_cast<streflop::Simple>(random.randRange(-1.f, 1.f))); #else float rnd= fabs(random.randRange(-1.f, 1.f)); #endif if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); if(rnd < sunnyProb) { weather= wSunny; } else if(rnd < rainyProb) { weather= wRainy; } else { weather= wSnowy; } //printf("==> Weather is: %d rnd = %f [sun: %f rainyProb: %f]",weather,rnd,sunnyProb,rainyProb); if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); } //Exception handling (conversions and so on); catch(const exception &e) { SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what()); throw megaglest_runtime_error("Error: " + path + "\n" + e.what()); } Lang &lang = Lang::getInstance(); lang.loadTilesetStrings(name); }
MenuBackground::MenuBackground() : rps(NULL) { Renderer &renderer= Renderer::getInstance(); //load data string data_path = getGameReadWritePath(GameConstants::path_data_CacheLookupKey); XmlTree xmlTree; xmlTree.load(getGameCustomCoreDataPath(data_path, "data/core/menu/menu.xml"),Properties::getTagReplacementValues()); const XmlNode *menuNode= xmlTree.getRootNode(); //water const XmlNode *waterNode= menuNode->getChild("water"); water= waterNode->getAttribute("value")->getBoolValue(); if(water){ waterHeight= waterNode->getAttribute("height")->getFloatValue(); //water texture waterTexture= renderer.newTexture2D(rsMenu); if(waterTexture) { waterTexture->getPixmap()->init(4); waterTexture->getPixmap()->load(getGameCustomCoreDataPath(data_path, "data/core/menu/textures/water.tga")); } } //fog const XmlNode *fogNode= menuNode->getChild("fog"); fog= fogNode->getAttribute("value")->getBoolValue(); if(fog){ fogDensity= fogNode->getAttribute("density")->getFloatValue(); } //rain bool withRainEffect = Config::getInstance().getBool("RainEffectMenu","true"); if(withRainEffect == true) { rain= menuNode->getChild("rain")->getAttribute("value")->getBoolValue(); if(rain) { createRainParticleSystem(); } } else { rain = false; } //camera const XmlNode *cameraNode= menuNode->getChild("camera"); //position const XmlNode *positionNode= cameraNode->getChild("start-position"); Vec3f startPosition; startPosition.x= positionNode->getAttribute("x")->getFloatValue(); startPosition.y= positionNode->getAttribute("y")->getFloatValue(); startPosition.z= positionNode->getAttribute("z")->getFloatValue(); camera.setPosition(startPosition); //rotation const XmlNode *rotationNode= cameraNode->getChild("start-rotation"); Vec3f startRotation; startRotation.x= rotationNode->getAttribute("x")->getFloatValue(); startRotation.y= rotationNode->getAttribute("y")->getFloatValue(); startRotation.z= rotationNode->getAttribute("z")->getFloatValue(); camera.setOrientation(Quaternion(EulerAngles( degToRad(startRotation.x), degToRad(startRotation.y), degToRad(startRotation.z)))); //load main model mainModel= renderer.newModel(rsMenu); if(mainModel) { string mainModelFile = "data/core/menu/main_model/menu_main.g3d"; if(menuNode->hasChild("menu-background-model") == true) { //mainModel->load(data_path + "data/core/menu/main_model/menu_main.g3d"); const XmlNode *mainMenuModelNode= menuNode->getChild("menu-background-model"); mainModelFile = mainMenuModelNode->getAttribute("value")->getRestrictedValue(); } mainModel->load(getGameCustomCoreDataPath(data_path, mainModelFile)); } //models for(int i=0; i<5; ++i){ characterModels[i]= renderer.newModel(rsMenu); if(characterModels[i]) { characterModels[i]->load(getGameCustomCoreDataPath(data_path, "data/core/menu/about_models/character"+intToStr(i)+".g3d")); } } //about position positionNode= cameraNode->getChild("about-position"); aboutPosition.x= positionNode->getAttribute("x")->getFloatValue(); aboutPosition.y= positionNode->getAttribute("y")->getFloatValue(); aboutPosition.z= positionNode->getAttribute("z")->getFloatValue(); rotationNode= cameraNode->getChild("about-rotation"); targetCamera= NULL; t= 0.f; fade= 0.f; anim= 0.f; }
MenuBackground::MenuBackground(){ Renderer &renderer= Renderer::getInstance(); //load data XmlTree xmlTree; xmlTree.load("data/core/menu/menu.xml"); const XmlNode *menuNode= xmlTree.getRootNode(); //water const XmlNode *waterNode= menuNode->getChild("water"); water= waterNode->getAttribute("value")->getBoolValue(); if(water){ waterHeight= waterNode->getAttribute("height")->getFloatValue(); //water texture waterTexture= renderer.newTexture2D(ResourceScope::MENU); waterTexture->getPixmap()->init(4); waterTexture->getPixmap()->load("data/core/menu/textures/water.tga"); } //fog const XmlNode *fogNode= menuNode->getChild("fog"); fog= fogNode->getAttribute("value")->getBoolValue(); if(fog){ fogDensity= fogNode->getAttribute("density")->getFloatValue(); } // rain rain = menuNode->getChild("rain")->getAttribute("value")->getBoolValue(); if(rain){ RainParticleSystem *rps= new RainParticleSystem(); rps->setSpeed(12.f / WORLD_FPS); rps->setEmissionRate(25.f); rps->setWindSpeed2(-90.f, 4.f / WORLD_FPS); rps->setPos(Vec3f(0.f, 25.f, 0.f)); rps->setColor(Vec4f(1.f, 1.f, 1.f, 0.2f)); rps->setRadius(30.f); renderer.manageParticleSystem(rps, ResourceScope::MENU); for(int i=0; i<raindropCount; ++i){ raindropStates[i]= random.randRange(0.f, 1.f); raindropPos[i]= computeRaindropPos(); } } else if (menuNode->getOptionalBoolValue("snow")) { SnowParticleSystem *sps = new SnowParticleSystem(1200); sps->setSpeed(1.5f / WORLD_FPS); sps->setEmissionRate(2.f); sps->setWindSpeed2(-90.f, 0.5f / WORLD_FPS); sps->setPos(Vec3f(0.f, 25.f, 0.f)); sps->setRadius(30.f); sps->setTexture(g_coreData.getSnowTexture()); renderer.manageParticleSystem(sps, ResourceScope::MENU); } //camera const XmlNode *cameraNode= menuNode->getChild("camera"); //position const XmlNode *positionNode= cameraNode->getChild("start-position"); Vec3f startPosition; startPosition.x= positionNode->getAttribute("x")->getFloatValue(); startPosition.y= positionNode->getAttribute("y")->getFloatValue(); startPosition.z= positionNode->getAttribute("z")->getFloatValue(); camera.setPosition(startPosition); //rotation const XmlNode *rotationNode= cameraNode->getChild("start-rotation"); Vec3f startRotation; startRotation.x= rotationNode->getAttribute("x")->getFloatValue(); startRotation.y= rotationNode->getAttribute("y")->getFloatValue(); startRotation.z= rotationNode->getAttribute("z")->getFloatValue(); camera.setOrientation(Quaternion(EulerAngles( degToRad(startRotation.x), degToRad(startRotation.y), degToRad(startRotation.z)))); // load main model mainModel= renderer.newModel(ResourceScope::MENU); mainModel->load("data/core/menu/main_model/menu_main.g3d", 2, 2); // models for(int i=0; i<5; ++i){ characterModels[i]= renderer.newModel(ResourceScope::MENU); try { characterModels[i]->load("data/core/menu/about_models/character"+intToStr(i)+".g3d", 2, 2); } catch (runtime_error &e) { g_logger.logError(e.what()); } } // about position positionNode= cameraNode->getChild("about-position"); aboutPosition.x= positionNode->getAttribute("x")->getFloatValue(); aboutPosition.y= positionNode->getAttribute("y")->getFloatValue(); aboutPosition.z= positionNode->getAttribute("z")->getFloatValue(); rotationNode= cameraNode->getChild("about-rotation"); targetCamera = 0; t = 0.f; fade = 0.f; anim = 0.f; }
void UnitType::load(int id,const string &dir, const TechTree *techTree, const FactionType *factionType, Checksum* checksum){ this->id= id; string path; try{ Logger::getInstance().add("Unit type: " + formatString(name), true); //file load path= dir+"/"+name+".xml"; checksum->addFile(path); XmlTree xmlTree; xmlTree.load(path); const XmlNode *unitNode= xmlTree.getRootNode(); const XmlNode *parametersNode= unitNode->getChild("parameters"); //size size= parametersNode->getChild("size")->getAttribute("value")->getIntValue(); //height height= parametersNode->getChild("height")->getAttribute("value")->getIntValue(); //maxHp maxHp= parametersNode->getChild("max-hp")->getAttribute("value")->getIntValue(); //hpRegeneration hpRegeneration= parametersNode->getChild("max-hp")->getAttribute("regeneration")->getIntValue(); //maxEp maxEp= parametersNode->getChild("max-ep")->getAttribute("value")->getIntValue(); if(maxEp!=0){ //wpRegeneration epRegeneration= parametersNode->getChild("max-ep")->getAttribute("regeneration")->getIntValue(); } //armor armor= parametersNode->getChild("armor")->getAttribute("value")->getIntValue(); //armor type string string armorTypeName= parametersNode->getChild("armor-type")->getAttribute("value")->getRestrictedValue(); armorType= techTree->getArmorType(armorTypeName); //sight sight= parametersNode->getChild("sight")->getAttribute("value")->getIntValue(); //prod time productionTime= parametersNode->getChild("time")->getAttribute("value")->getIntValue(); //multi selection multiSelect= parametersNode->getChild("multi-selection")->getAttribute("value")->getBoolValue(); //cellmap const XmlNode *cellMapNode= parametersNode->getChild("cellmap"); bool hasCellMap= cellMapNode->getAttribute("value")->getBoolValue(); if(hasCellMap){ cellMap= new bool[size*size]; for(int i=0; i<size; ++i){ const XmlNode *rowNode= cellMapNode->getChild("row", i); string row= rowNode->getAttribute("value")->getRestrictedValue(); if(row.size()!=size){ throw runtime_error("Cellmap row has not the same length as unit size"); } for(int j=0; j<row.size(); ++j){ cellMap[i*size+j]= row[j]=='0'? false: true; } } } //levels const XmlNode *levelsNode= parametersNode->getChild("levels"); levels.resize(levelsNode->getChildCount()); for(int i=0; i<levels.size(); ++i){ const XmlNode *levelNode= levelsNode->getChild("level", i); levels[i].init( levelNode->getAttribute("name")->getRestrictedValue(), levelNode->getAttribute("kills")->getIntValue()); } //fields const XmlNode *fieldsNode= parametersNode->getChild("fields"); for(int i=0; i<fieldsNode->getChildCount(); ++i){ const XmlNode *fieldNode= fieldsNode->getChild("field", i); string fieldName= fieldNode->getAttribute("value")->getRestrictedValue(); if(fieldName=="land"){ fields[fLand]= true; } else if(fieldName=="air"){ fields[fAir]= true; } else{ throw runtime_error("Not a valid field: "+fieldName+": "+ path); } } //properties const XmlNode *propertiesNode= parametersNode->getChild("properties"); for(int i=0; i<propertiesNode->getChildCount(); ++i){ const XmlNode *propertyNode= propertiesNode->getChild("property", i); string propertyName= propertyNode->getAttribute("value")->getRestrictedValue(); bool found= false; for(int i=0; i<pCount; ++i){ if(propertyName==propertyNames[i]){ properties[i]= true; found= true; break; } } if(!found){ throw runtime_error("Unknown property: " + propertyName); } } //light const XmlNode *lightNode= parametersNode->getChild("light"); light= lightNode->getAttribute("enabled")->getBoolValue(); if(light){ lightColor.x= lightNode->getAttribute("red")->getFloatValue(0.f, 1.f); lightColor.y= lightNode->getAttribute("green")->getFloatValue(0.f, 1.f); lightColor.z= lightNode->getAttribute("blue")->getFloatValue(0.f, 1.f); } //unit requirements const XmlNode *unitRequirementsNode= parametersNode->getChild("unit-requirements"); for(int i=0; i<unitRequirementsNode->getChildCount(); ++i){ const XmlNode *unitNode= unitRequirementsNode->getChild("unit", i); string name= unitNode->getAttribute("name")->getRestrictedValue(); unitReqs.push_back(factionType->getUnitType(name)); } //upgrade requirements const XmlNode *upgradeRequirementsNode= parametersNode->getChild("upgrade-requirements"); for(int i=0; i<upgradeRequirementsNode->getChildCount(); ++i){ const XmlNode *upgradeReqNode= upgradeRequirementsNode->getChild("upgrade", i); string name= upgradeReqNode->getAttribute("name")->getRestrictedValue(); upgradeReqs.push_back(factionType->getUpgradeType(name)); } //resource requirements const XmlNode *resourceRequirementsNode= parametersNode->getChild("resource-requirements"); costs.resize(resourceRequirementsNode->getChildCount()); for(int i=0; i<costs.size(); ++i){ const XmlNode *resourceNode= resourceRequirementsNode->getChild("resource", i); string name= resourceNode->getAttribute("name")->getRestrictedValue(); int amount= resourceNode->getAttribute("amount")->getIntValue(); costs[i].init(techTree->getResourceType(name), amount); } //resources stored const XmlNode *resourcesStoredNode= parametersNode->getChild("resources-stored"); storedResources.resize(resourcesStoredNode->getChildCount()); for(int i=0; i<storedResources.size(); ++i){ const XmlNode *resourceNode= resourcesStoredNode->getChild("resource", i); string name= resourceNode->getAttribute("name")->getRestrictedValue(); int amount= resourceNode->getAttribute("amount")->getIntValue(); storedResources[i].init(techTree->getResourceType(name), amount); } //image const XmlNode *imageNode= parametersNode->getChild("image"); image= Renderer::getInstance().newTexture2D(rsGame); image->load(dir+"/"+imageNode->getAttribute("path")->getRestrictedValue()); //image cancel const XmlNode *imageCancelNode= parametersNode->getChild("image-cancel"); cancelImage= Renderer::getInstance().newTexture2D(rsGame); cancelImage->load(dir+"/"+imageCancelNode->getAttribute("path")->getRestrictedValue()); //meeting point const XmlNode *meetingPointNode= parametersNode->getChild("meeting-point"); meetingPoint= meetingPointNode->getAttribute("value")->getBoolValue(); if(meetingPoint){ meetingPointImage= Renderer::getInstance().newTexture2D(rsGame); meetingPointImage->load(dir+"/"+meetingPointNode->getAttribute("image-path")->getRestrictedValue()); } //selection sounds const XmlNode *selectionSoundNode= parametersNode->getChild("selection-sounds"); if(selectionSoundNode->getAttribute("enabled")->getBoolValue()){ selectionSounds.resize(selectionSoundNode->getChildCount()); for(int i=0; i<selectionSounds.getSounds().size(); ++i){ const XmlNode *soundNode= selectionSoundNode->getChild("sound", i); string path= soundNode->getAttribute("path")->getRestrictedValue(); StaticSound *sound= new StaticSound(); sound->load(dir + "/" + path); selectionSounds[i]= sound; } } //command sounds const XmlNode *commandSoundNode= parametersNode->getChild("command-sounds"); if(commandSoundNode->getAttribute("enabled")->getBoolValue()){ commandSounds.resize(commandSoundNode->getChildCount()); for(int i=0; i<commandSoundNode->getChildCount(); ++i){ const XmlNode *soundNode= commandSoundNode->getChild("sound", i); string path= soundNode->getAttribute("path")->getRestrictedValue(); StaticSound *sound= new StaticSound(); sound->load(dir + "/" + path); commandSounds[i]= sound; } } //skills const XmlNode *skillsNode= unitNode->getChild("skills"); skillTypes.resize(skillsNode->getChildCount()); for(int i=0; i<skillTypes.size(); ++i){ const XmlNode *sn= skillsNode->getChild("skill", i); const XmlNode *typeNode= sn->getChild("type"); string classId= typeNode->getAttribute("value")->getRestrictedValue(); SkillType *skillType= SkillTypeFactory::getInstance().newInstance(classId); skillType->load(sn, dir, techTree, factionType); skillTypes[i]= skillType; } //commands const XmlNode *commandsNode= unitNode->getChild("commands"); commandTypes.resize(commandsNode->getChildCount()); for(int i=0; i<commandTypes.size(); ++i){ const XmlNode *commandNode= commandsNode->getChild("command", i); const XmlNode *typeNode= commandNode->getChild("type"); string classId= typeNode->getAttribute("value")->getRestrictedValue(); CommandType *commandType= CommandTypeFactory::getInstance().newInstance(classId); commandType->load(i, commandNode, dir, techTree, factionType, *this); commandTypes[i]= commandType; } computeFirstStOfClass(); computeFirstCtOfClass(); if(getFirstStOfClass(scStop)==NULL){ throw runtime_error("Every unit must have at least one stop skill: "+ path); } if(getFirstStOfClass(scDie)==NULL){ throw runtime_error("Every unit must have at least one die skill: "+ path); } } //Exception handling (conversions and so on); catch(const exception &e){ throw runtime_error("Error loading UnitType: " + path + "\n" + e.what()); } }
bool Modification::load(const string &dir) { g_logger.logProgramEvent("Modification: " + dir, true); bool loadOk = true; string path = dir + "/" + m_name + ".xml"; name = m_name; XmlTree xmlTree; try { xmlTree.load(path); } catch (runtime_error e) { g_logger.logXmlError(path, e.what()); g_logger.logError("Fatal Error: could not load " + path); return false; } const XmlNode *modificationNode; try { modificationNode = xmlTree.getRootNode(); } catch (runtime_error e) { g_logger.logXmlError(path, e.what()); return false; } const XmlNode *parametersNode; try { parametersNode = modificationNode->getChild("parameters"); } catch (runtime_error e) { g_logger.logXmlError(path, e.what()); return false; } if (!RequirableType::load(parametersNode, dir)) { loadOk = false; } try { const XmlNode *serviceNode = parametersNode->getChild("service"); service = serviceNode->getAttribute("scope")->getRestrictedValue(); } catch (runtime_error e) { g_logger.logXmlError(dir, e.what()); loadOk = false; } try { const XmlNode *equipmentNode = parametersNode->getChild("equipment-types", 0, false); if(equipmentNode) { for(int i = 0; i < equipmentNode->getChildCount(); ++i) { try { const XmlNode *typeNode = equipmentNode->getChild("equipment-type", i); string ename = typeNode->getAttribute("name")->getRestrictedValue(); equipment.push_back(ename); } catch (runtime_error e) { g_logger.logXmlError(dir, e.what()); loadOk = false; } } } } catch (runtime_error e) { g_logger.logXmlError(dir, e.what()); loadOk = false; } try { const XmlNode *resourceRequirementsNode = parametersNode->getChild("resource-requirements", 0, false); if(resourceRequirementsNode) { costs.resize(resourceRequirementsNode->getChildCount()); for(int i = 0; i < costs.size(); ++i) { try { const XmlNode *resourceNode = resourceRequirementsNode->getChild("resource", i); string rname = resourceNode->getAttribute("name")->getRestrictedValue(); int amount = resourceNode->getAttribute("amount")->getIntValue(); int amount_plus = resourceNode->getAttribute("plus")->getIntValue(); fixed amount_multiply = resourceNode->getAttribute("multiply")->getFixedValue(); costs[i].init(g_world.getTechTree()->getResourceType(rname), amount, amount_plus, amount_multiply); } catch (runtime_error e) { g_logger.logXmlError(dir, e.what()); loadOk = false; } } } } catch (runtime_error e) { g_logger.logXmlError(dir, e.what()); loadOk = false; } try { const XmlNode *statisticsNode = parametersNode->getChild("statistics", 0, false); if (statisticsNode) { if (!statistics.load(statisticsNode, dir)) { loadOk = false; } } } catch (runtime_error e) { g_logger.logXmlError(dir, e.what()); loadOk = false; } const XmlNode *effectsNode = parametersNode->getChild("effects", 0, false); if (effectsNode) { effectTypes.resize(effectsNode->getChildCount()); for(int i=0; i < effectsNode->getChildCount(); ++i) { const XmlNode *effectNode = effectsNode->getChild("effect", i); EffectType *effectType = new EffectType(); effectType->load(effectNode, dir); effectTypes[i] = effectType; } } return loadOk; }
void Tileset::load(const string &dir, Checksum *checksum, Checksum *tilesetChecksum) { SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); random.init(time(NULL)); SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); string name= lastDir(dir); string path= dir + "/" + name + ".xml"; checksum->addFile(path); tilesetChecksum->addFile(path); checksumValue.addFile(path); try { Logger::getInstance().add("Tileset: "+formatString(name), true); Renderer &renderer= Renderer::getInstance(); SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //parse xml XmlTree xmlTree; xmlTree.load(path); SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); const XmlNode *tilesetNode= xmlTree.getRootNode(); SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //surfaces const XmlNode *surfacesNode= tilesetNode->getChild("surfaces"); for(int i=0; i<surfCount; ++i){ const XmlNode *surfaceNode= surfacesNode->getChild("surface", i); int childCount= surfaceNode->getChildCount(); surfPixmaps[i].resize(childCount); surfProbs[i].resize(childCount); for(int j=0; j<childCount; ++j){ const XmlNode *textureNode= surfaceNode->getChild("texture", j); surfPixmaps[i][j].init(3); surfPixmaps[i][j].load(dir +"/"+textureNode->getAttribute("path")->getRestrictedValue()); surfProbs[i][j]= textureNode->getAttribute("prob")->getFloatValue(); } } SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //object models const XmlNode *objectsNode= tilesetNode->getChild("objects"); for(int i=0; i<objCount; ++i){ const XmlNode *objectNode= objectsNode->getChild("object", i); int childCount= objectNode->getChildCount(); int objectHeight = 0; bool walkable = objectNode->getAttribute("walkable")->getBoolValue(); if(walkable == false) { const XmlAttribute *heightAttribute = objectNode->getAttribute("height",false); if(heightAttribute != NULL) { objectHeight = heightAttribute->getIntValue(); } } objectTypes[i].init(childCount, i, walkable,objectHeight); for(int j=0; j<childCount; ++j) { const XmlNode *modelNode= objectNode->getChild("model", j); const XmlAttribute *pathAttribute= modelNode->getAttribute("path"); objectTypes[i].loadModel(dir +"/"+ pathAttribute->getRestrictedValue()); } } // Now free up the pixmap memory for(int i=0; i<objCount; ++i){ objectTypes[i].deletePixels(); } SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //ambient sounds ambientSounds.load(dir, tilesetNode->getChild("ambient-sounds")); //parameters const XmlNode *parametersNode= tilesetNode->getChild("parameters"); //water const XmlNode *waterNode= parametersNode->getChild("water"); waterTex= renderer.newTexture3D(rsGame); waterTex->setMipmap(false); waterTex->setWrapMode(Texture::wmRepeat); waterEffects= waterNode->getAttribute("effects")->getBoolValue(); SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); int waterFrameCount= waterNode->getChildCount(); waterTex->getPixmap()->init(waterFrameCount, 4); for(int i=0; i<waterFrameCount; ++i){ const XmlNode *waterFrameNode= waterNode->getChild("texture", i); waterTex->getPixmap()->loadSlice(dir +"/"+ waterFrameNode->getAttribute("path")->getRestrictedValue(), i); } SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //fog const XmlNode *fogNode= parametersNode->getChild("fog"); fog= fogNode->getAttribute("enabled")->getBoolValue(); if(fog){ fogMode= fogNode->getAttribute("mode")->getIntValue(1, 2); fogDensity= fogNode->getAttribute("density")->getFloatValue(); fogColor.x= fogNode->getAttribute("color-red")->getFloatValue(0.f, 1.f); fogColor.y= fogNode->getAttribute("color-green")->getFloatValue(0.f, 1.f); fogColor.z= fogNode->getAttribute("color-blue")->getFloatValue(0.f, 1.f); } SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //sun and moon light colors const XmlNode *sunLightColorNode= parametersNode->getChild("sun-light"); sunLightColor.x= sunLightColorNode->getAttribute("red")->getFloatValue(); sunLightColor.y= sunLightColorNode->getAttribute("green")->getFloatValue(); sunLightColor.z= sunLightColorNode->getAttribute("blue")->getFloatValue(); const XmlNode *moonLightColorNode= parametersNode->getChild("moon-light"); moonLightColor.x= moonLightColorNode->getAttribute("red")->getFloatValue(); moonLightColor.y= moonLightColorNode->getAttribute("green")->getFloatValue(); moonLightColor.z= moonLightColorNode->getAttribute("blue")->getFloatValue(); SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); //weather const XmlNode *weatherNode= parametersNode->getChild("weather"); float sunnyProb= weatherNode->getAttribute("sun")->getFloatValue(0.f, 1.f); float rainyProb= weatherNode->getAttribute("rain")->getFloatValue(0.f, 1.f) + sunnyProb; SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); #ifdef USE_STREFLOP float rnd= streflop::fabs(random.randRange(-1.f, 1.f)); #else float rnd= fabs(random.randRange(-1.f, 1.f)); #endif SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); if(rnd < sunnyProb) { weather= wSunny; } else if(rnd < rainyProb) { weather= wRainy; } else { weather= wSnowy; } SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); } //Exception handling (conversions and so on); catch(const exception &e) { SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] Error [%s]\n",__FILE__,__FUNCTION__,__LINE__,e.what()); throw runtime_error("Error: " + path + "\n" + e.what()); } }
void ScaenaAnimationFileWriter::writeKeyFrameToFileSystem(string filename, SkinnedAnimationKeyFrame* keyframe){ XmlTree* xmlTree = new XmlTree(); XmlTreeNode* node = xmlTree->getRootNode(); this->keyFrameToXmlTree(node, keyframe); XmlParser::writeXmlToFile((WindowConnector::getBaseApplicationPath() + string(filename)).c_str(), xmlTree); }