//----------------------------------------------------------------------------
int CDotSceneSerializer::RecurseReadObjects(TiXmlElement *parentelement,CBaseEditor* parentobject)
{
CBaseEditor *newobj;
TiXmlElement* element = 0;
Ogre::String eType;
element = parentelement->FirstChildElement();
if(!element) return SCF_OK;
do
{
newobj = 0;
eType = element->Value();
if(eType == "node")
{
ReadSceneNode(element, parentobject, &newobj);
int ret = RecurseReadObjects(element, newobj);
if(ret != SCF_OK)
return ret;
NameObjectPairList& childlist = newobj->getChildren();
if(childlist.size() == 1)
{
CBaseEditor *childobj = childlist.begin()->second;
childobj->setParent(newobj->getParent());
OgitorsPropertyValueMap vmapn = newobj->getProperties()->getValueMap();
OgitorsPropertyValueMap vmapo;
OgitorsPropertyValueMap::iterator vit;
vit = vmapn.find("autotracktarget");
vmapo.insert(OgitorsPropertyValueMap::value_type(vit->first, vit->second));
vit = vmapn.find("position");
vmapo.insert(OgitorsPropertyValueMap::value_type(vit->first, vit->second));
vit = vmapn.find("scale");
vmapo.insert(OgitorsPropertyValueMap::value_type(vit->first, vit->second));
vit = vmapn.find("orientation");
vmapo.insert(OgitorsPropertyValueMap::value_type(vit->first, vit->second));
OgitorsRoot::getSingletonPtr()->DestroyEditorObject(newobj);
newobj = childobj;
childobj->getProperties()->setValueMap(vmapo);
}
}
else if(eType == "entity") ReadEntity(element, parentobject, &newobj);
else if(eType == "subentities") ReadSubEntity(element, parentobject, &newobj);
else if(eType == "light") ReadLight(element, parentobject, &newobj);
else if(eType == "camera") ReadCamera(element, parentobject, &newobj);
else if(eType == "particle") ReadParticle(element, parentobject, &newobj);
else if(eType == "plane") ReadPlane(element, parentobject, &newobj);
else
continue;
} while(element = element->NextSiblingElement());
return SCF_OK;
}
//----------------------------------------------------------------------------------
bool PropertyUndo::apply()
{
CBaseEditor *object = OgitorsRoot::getSingletonPtr()->FindObject(mObjectID);
if(!object)
return false;
if(mValue.propType == PROP_UNSIGNED_LONG && mPropertyName == "parent")
{
CBaseEditor *parent = OgitorsRoot::getSingletonPtr()->FindObject(Ogre::any_cast<unsigned long>(mValue.val));
if(!parent)
return false;
mValue.val = Ogre::Any((unsigned long)parent);
}
OgitorsPropertyValueMap map;
map.insert(OgitorsPropertyValueMap::value_type(mPropertyName, mValue));
if(mSetType == PROPSET_OBJECT)
{
object->getProperties()->setValueMap(map);
return true;
}
else if(mSetType == PROPSET_CUSTOM)
{
object->getCustomProperties()->setValueMap(map);
return true;
}
return false;
}
int COFSSceneSerializer::Import(Ogre::String importfile)
{
OgitorsRoot *ogRoot = OgitorsRoot::getSingletonPtr();
OgitorsSystem *mSystem = OgitorsSystem::getSingletonPtr();
OFS::OfsPtr& mFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
if(importfile == "")
{
UTFStringVector extlist;
extlist.push_back(OTR("Ogitor File System File"));
extlist.push_back("*.ofs");
extlist.push_back(OTR("Ogitor Scene File"));
extlist.push_back("*" + Globals::OGSCENE_FORMAT_EXTENSION);
importfile = mSystem->GetSetting("system", "oldOpenPath", "");
importfile = mSystem->DisplayOpenDialog(OTR("Open"), extlist, importfile);
if(importfile == "")
return SCF_CANCEL;
mSystem->SetSetting("system", "oldOpenPath", importfile);
}
importfile = OgitorsUtils::QualifyPath(importfile);
Ogre::String filePath = OgitorsUtils::ExtractFilePath(importfile);
Ogre::String fileName = OgitorsUtils::ExtractFileName(importfile);
bool testpassed = false;
try
{
std::ofstream test((filePath + "test.dat").c_str());
if(test.is_open())
testpassed = true;
test.close();
mSystem->DeleteFile(filePath + "test.dat");
}
catch(...)
{
testpassed = false;
}
if(!testpassed)
{
mSystem->DisplayMessageDialog("The path is read-only. Ogitor can not work with read-only project paths!", DLGTYPE_OK);
return SCF_CANCEL;
}
Ogre::UTFString loadmsg = "";
int typepos = importfile.find_last_of(".");
if(typepos != -1 && (importfile.substr(typepos, 4) != ".ofs"))
importfile = filePath;
OFS::OfsResult oRet;
if((oRet = mFile.mount(importfile.c_str(), OFS::OFS_MOUNT_OPEN | OFS::OFS_MOUNT_RECOVER)) != OFS::OFS_OK)
{
if(oRet == OFS::OFS_PREVIOUS_VERSION)
{
mSystem->DisplayMessageDialog("The OFS file is a previous version, please use qtOFS to upgrade it to new file version.", DLGTYPE_OK);
}
loadmsg = mSystem->Translate("Please load a Scene File...");
mSystem->UpdateLoadProgress(-1, loadmsg);
return SCF_ERRPARSE;
}
OFS::FileSystemStats fsStats;
mFile->getFileSystemStats(fsStats);
PROJECTOPTIONS *pOpt = ogRoot->GetProjectOptions();
pOpt->CreatedIn = "";
pOpt->ProjectDir = filePath;
typepos = fileName.find_last_of(".");
if(typepos != -1)
fileName.erase(typepos, fileName.length() - typepos);
pOpt->ProjectName = fileName;
fileName += Globals::OGSCENE_FORMAT_EXTENSION;
OFS::ofs64 file_size = 0;
if(mFile->getFileSize(fileName.c_str(), file_size) != OFS::OFS_OK)
{
// OGSCENE file name needs to match OFS container file name. If the later was renamed, we
// need to automatically adapt the OGSCENE file name now.
OFS::FileList files = mFile->listFiles("/", OFS::OFS_FILE);
unsigned int ogsceneFileExtensionLength = strlen(Globals::OGSCENE_FORMAT_EXTENSION.c_str());
for(OFS::FileList::iterator iter = files.begin(); iter != files.end(); iter++)
{
// Filter out too short names
if(iter->name.size() <= ogsceneFileExtensionLength)
continue;
if(stricmp(iter->name.c_str() + (iter->name.size() - (ogsceneFileExtensionLength)), Globals::OGSCENE_FORMAT_EXTENSION.c_str()) == 0)
{
mFile->renameFile(iter->name.c_str(), fileName.c_str());
break;
}
}
if(mFile->getFileSize(fileName.c_str(), file_size) != OFS::OFS_OK)
return SCF_ERRFILE;
}
char *file_data = new char[(unsigned int)file_size + 1];
OFS::OFSHANDLE projHandle;
if(mFile->openFile(projHandle, fileName.c_str(), OFS::OFS_READ) != OFS::OFS_OK)
{
delete [] file_data;
return SCF_ERRFILE;
}
mFile->read(projHandle, file_data, file_size);
mFile->closeFile(projHandle);
TiXmlDocument docImport;
if(!docImport.LoadFromMemory(file_data, file_size))
{
delete [] file_data;
return SCF_ERRFILE;
}
delete [] file_data;
loadmsg = mSystem->Translate("Parsing Scene File");
mSystem->UpdateLoadProgress(1, loadmsg);
TiXmlNode* ogitorSceneNode = 0;
TiXmlNode* projectNode;
TiXmlElement* element = 0;
bool upgradeExecuted = false;
ogitorSceneNode = docImport.FirstChild("OGITORSCENE");
if(!ogitorSceneNode)
return SCF_ERRPARSE;
element = ogitorSceneNode->ToElement();
// Old OGSCENE version check and attempt to fix/update
int version = Ogre::StringConverter::parseInt(ValidAttr(element->Attribute("version"), "0"));
if(Ogre::StringConverter::toString(version) < Globals::OGSCENE_FORMAT_VERSION)
{
mSystem->DisplayMessageDialog(mSystem->Translate("Old OGSCENE file version detected. Ogitor will now attempt to upgrade the format and will also create a backup version of your OFS file."), DLGTYPE_OK);
loadmsg = mSystem->Translate("Upgrading OGSCENE file.");
mSystem->UpdateLoadProgress(10, loadmsg);
if(version == 0)
{
mSystem->DisplayMessageDialog(mSystem->Translate("OGSCENE files contains no version number set and therefore cannot be loaded."), DLGTYPE_OK);
return SCF_ERRPARSE;
}
else if(version == 1)
{
mSystem->DisplayMessageDialog(mSystem->Translate("OGSCENE files with version 1 cannot be upgraded automatically. Please contact the Ogitor team for further details."), DLGTYPE_OK);
return SCF_ERRPARSE;
}
if(version > 1)
{
if((mFile->getFileSystemType() == OFS::OFS_PACKED) && (!mSystem->CopyFile(importfile, importfile + ".backup")))
mSystem->DisplayMessageDialog(mSystem->Translate("Error while trying to create backup file."), DLGTYPE_OK);
}
switch(version)
{
case 2:
_upgradeOgsceneFileFrom2To3(ogitorSceneNode);
_upgradeOgsceneFileFrom3To4(ogitorSceneNode);
break;
case 3:
_upgradeOgsceneFileFrom3To4(ogitorSceneNode);
break;
}
upgradeExecuted = true;
}
projectNode = ogitorSceneNode->FirstChild("PROJECT");
if(projectNode)
{
loadmsg = mSystem->Translate("Parsing project options");
mSystem->UpdateLoadProgress(5, loadmsg);
ogRoot->LoadProjectOptions(projectNode->ToElement());
ogRoot->PrepareProjectResources();
}
element = ogitorSceneNode->FirstChildElement();
loadmsg = mSystem->Translate("Creating scene objects");
mSystem->UpdateLoadProgress(10, loadmsg);
unsigned int obj_count = 0;
Ogre::String objecttype;
OgitorsPropertyValueMap params;
OgitorsPropertyValue tmpPropVal;
Ogre::String objAttValue;
Ogre::String elementName;
TiXmlElement* properties = 0;
Ogre::String attID;
Ogre::String attValue;
CBaseEditor* result = 0;
TiXmlElement* customprop = 0;
Ogre::StringVector invalidEditorTypes;
do
{
// Make sure its NON-ZERO
if(pOpt->ObjectCount)
{
++obj_count;
mSystem->UpdateLoadProgress(10 + ((obj_count * 70) / pOpt->ObjectCount), loadmsg);
}
params.clear();
objAttValue = ValidAttr(element->Attribute("object_id"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_UNSIGNED_INT;
tmpPropVal.val = Ogre::Any(Ogre::StringConverter::parseUnsignedInt(objAttValue));
params.insert(OgitorsPropertyValueMap::value_type("object_id", tmpPropVal));
}
objAttValue = ValidAttr(element->Attribute("parentnode"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("parentnode", tmpPropVal));
}
objAttValue = ValidAttr(element->Attribute("name"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("name", tmpPropVal));
}
else
continue;
objAttValue = ValidAttr(element->Attribute("typename"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("typename", tmpPropVal));
}
else
continue;
properties = element->FirstChildElement();
if(properties)
{
do
{
elementName = properties->Value();
if(elementName != "PROPERTY")
continue;
attID = ValidAttr(properties->Attribute("id"), "");
int attType = Ogre::StringConverter::parseInt(ValidAttr(properties->Attribute("type"), ""));
attValue = ValidAttr(properties->Attribute("value"), "");
params.insert(OgitorsPropertyValueMap::value_type(attID, OgitorsPropertyValue::createFromString((OgitorsPropertyType)attType, attValue)));
} while(properties = properties->NextSiblingElement());
}
objecttype = Ogre::any_cast<Ogre::String>(params["typename"].val);
result = ogRoot->CreateEditorObject(0, objecttype, params, false, false);
if(result)
{
customprop = element->FirstChildElement("CUSTOMPROPERTIES");
if(customprop)
{
OgitorsUtils::ReadCustomPropertySet(customprop, result->getCustomProperties());
}
}
else
invalidEditorTypes.push_back(objecttype);
} while(element = element->NextSiblingElement());
// Print out invalid/unsupported editor types (= types where no factory could be found)
if(invalidEditorTypes.size() > 0)
{
std::sort(invalidEditorTypes.begin(), invalidEditorTypes.end());
invalidEditorTypes.erase(std::unique(invalidEditorTypes.begin(), invalidEditorTypes.end()), invalidEditorTypes.end());
Ogre::String invalidTypesResultString;
for(unsigned int i = 0; i < invalidEditorTypes.size(); i++)
{
invalidTypesResultString += invalidEditorTypes.at(i) + "\n";
}
mSystem->DisplayMessageDialog(mSystem->Translate("Could not create objects of types:\n" + invalidTypesResultString), DLGTYPE_OK);
}
//// Save directly after upgrade
//if(upgradeExecuted)
// Export(false, importfile);
ogRoot->AfterLoadScene();
return SCF_OK;
}
//---------------------------------------------------------------------------------
void OgitorsClipboardManager::addTemplateFromFile(Ogre::String filename, bool isGeneralScope)
{
TiXmlDocument docImport;
if(isGeneralScope)
{
if(!docImport.LoadFile(filename.c_str()))
return;
}
else
{
OFS::OfsPtr& mFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
unsigned int file_size = 0;
if(mFile->getFileSize(filename.c_str(), file_size) != OFS::OFS_OK)
return;
char *file_data = new char[file_size + 1];
OFS::OFSHANDLE fileHandle;
if(mFile->openFile(fileHandle, filename.c_str(), OFS::OFS_READ) != OFS::OFS_OK)
{
delete [] file_data;
return;
}
mFile->read(fileHandle, file_data, file_size);
mFile->closeFile(fileHandle);
if(!docImport.LoadFromMemory(file_data, file_size))
{
delete [] file_data;
return;
}
delete [] file_data;
}
TiXmlElement* templates = 0;
templates = docImport.FirstChildElement("TEMPLATES");
if(!templates)
return;
templates = templates->FirstChildElement("OBJECTTEMPLATE");
if(!templates)
return;
Ogre::String objecttype;
Ogre::String templatename;
OgitorsPropertyValueMap params;
OgitorsPropertyValue tmpPropVal;
do
{
templatename = ValidAttr(templates->Attribute("name"));
if(templatename == "")
continue;
TiXmlElement *element = templates->FirstChildElement("OBJECT");
if(!element)
continue;
ObjectTemplateMap::iterator rit;
if(isGeneralScope)
{
std::pair<ObjectTemplateMap::iterator, bool> retPair = mGeneralTemplates.insert(ObjectTemplateMap::value_type(templatename, ObjectTemplate()));
if(!retPair.second)
continue;
rit = retPair.first;
}
else
{
std::pair<ObjectTemplateMap::iterator, bool> retPair = mProjectTemplates.insert(ObjectTemplateMap::value_type(templatename, ObjectTemplate()));
if(!retPair.second)
continue;
rit = retPair.first;
}
do
{
params.clear();
Ogre::String objAttValue;
objAttValue = ValidAttr(element->Attribute("parentnode"),"");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("parentnode", tmpPropVal));
}
objAttValue = ValidAttr(element->Attribute("name"),"");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("name", tmpPropVal));
}
else
continue;
objAttValue = ValidAttr(element->Attribute("typename"),"");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("typename", tmpPropVal));
}
else
continue;
TiXmlElement *properties = element->FirstChildElement();
if(properties)
{
Ogre::String elementName;
do
{
elementName = properties->Value();
if(elementName != "PROPERTY")
continue;
Ogre::String attID = ValidAttr(properties->Attribute("id"),"");
int attType = Ogre::StringConverter::parseInt(ValidAttr(properties->Attribute("type"),""));
Ogre::String attValue = ValidAttr(properties->Attribute("value"),"");
params.insert(OgitorsPropertyValueMap::value_type(attID, OgitorsPropertyValue::createFromString((OgitorsPropertyType)attType, attValue)));
} while(properties = properties->NextSiblingElement());
}
objecttype = Ogre::any_cast<Ogre::String>(params["typename"].val);
rit->second.push_back(ObjectTemplateData());
rit->second[rit->second.size() - 1].mObjectProperties = params;
rit->second[rit->second.size() - 1].mCustomProperties = OGRE_NEW OgitorsCustomPropertySet();
rit->second[rit->second.size() - 1].mTypeName = objecttype;
TiXmlElement *customprop = element->FirstChildElement("CUSTOMPROPERTIES");
if(customprop)
{
OgitorsUtils::ReadCustomPropertySet(customprop, rit->second[rit->second.size() - 1].mCustomProperties);
}
} while (element = element->NextSiblingElement());
if(rit->second.size() == 0)
{
if(isGeneralScope)
mGeneralTemplates.erase(rit);
else
mProjectTemplates.erase(rit);
}
} while(templates = templates->NextSiblingElement());
}