//------------------------------------------------------------------------------------ OFS::ofs64 ExtractThread::generateList(OFS::FileList& list) { unsigned int list_max = list.size(); OFS::ofs64 file_size = 0; std::string tmpSaveCurrentDir; OFS::FileList subList; for(unsigned int i = 0;i < list_max;i++) { list[i].name = currentDir + list[i].name; file_size += list[i].file_size; if(list[i].flags & OFS::OFS_DIR) { tmpSaveCurrentDir = currentDir; currentDir = list[i].name + "/"; subList = ofsFile->listFiles(currentDir.c_str()); file_size += generateList(subList); for(unsigned int z = 0;z < subList.size();z++) list.push_back(subList[z]); currentDir = tmpSaveCurrentDir; } } return file_size; }
//----------------------------------------------------------------------------- void Ogitors::COFSSceneSerializer::_upgradeOgsceneFileFrom3To4(TiXmlNode* ogsceneRootNode) { TiXmlElement* element = ogsceneRootNode->FirstChildElement(); OFS::OfsPtr& mFile = OgitorsRoot::getSingletonPtr()->GetProjectFile(); OgitorsSystem *mSystem = OgitorsSystem::getSingletonPtr(); OFS::FileList list; mFile->listFilesRecursive("/", list); Ogre::StringVector terFiles; for( unsigned int i = 0;i < list.size(); i++ ) { if(list[i].flags && OFS::OFS_FILE) { if(list[i].name.substr(list[i].name.size() - 4, 4) == ".ogt") { terFiles.push_back( list[i].name ); } } } if( terFiles.size() > 0 ) { Ogre::SceneManager *pUpgSM = Ogre::Root::getSingletonPtr()->createSceneManager("OctreeSceneManager", "UpgradeSCM"); for( unsigned int i = 0;i < terFiles.size(); i++ ) { Ogre::String filenameorig = terFiles[i]; Ogre::String filenamebackup = filenameorig + ".backup"; mFile->renameFile( filenameorig.c_str(), filenamebackup.c_str() ); OFS::OFSHANDLE *filebackup = new OFS::OFSHANDLE(); OFS::OFSHANDLE *fileorig = new OFS::OFSHANDLE(); mFile->createFile(*fileorig, filenameorig.c_str()); mFile->openFile(*filebackup, filenamebackup.c_str(), OFS::OFS_READ); { OgreTerrainConverter conv; Ogre::DataStreamPtr stream_in = Ogre::DataStreamPtr(OGRE_NEW OfsDataStream(mFile, filebackup)); Ogre::DataStreamPtr stream_out = Ogre::DataStreamPtr(OGRE_NEW OfsDataStream(mFile, fileorig)); Ogre::DataStreamPtr compressStream(OGRE_NEW Ogre::DeflateStream(filenameorig, stream_in)); Ogre::StreamSerialiser ser_in(compressStream); Ogre::StreamSerialiser ser_out(stream_out); conv.Upgrade( ser_in, ser_out ); } } Ogre::Root::getSingletonPtr()->destroySceneManager(pUpgSM); } }
//---------------------------------------------------------------------------------------- void OfsTreeWidget::fillTree(QTreeWidgetItem *pItem, std::string path) { OFS::FileList list = mFile->listFiles(path.c_str(), OFS::OFS_DIR); std::sort(list.begin(), list.end(), OFS::FileEntry::Compare); for(unsigned int i = 0;i < list.size();i++) { Ogre::String name = list[i].name; QTreeWidgetItem* item = new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString(name.c_str()))); item->setIcon(0, mOgitorMainWindow->mIconProvider.icon(QFileIconProvider::Folder)); item->setTextColor(0, Qt::blue); std::string fullpath = path + name + "/"; item->setWhatsThis(0, QString(fullpath.c_str())); if(mCapabilities & CAP_SHOW_COLORS) { bool isReadOnly = (list[i].flags & OFS::OFS_READONLY) > 0; bool isHidden = (list[i].flags & OFS::OFS_HIDDEN) > 0; QColor textColor = Qt::black; if(isReadOnly && isHidden) textColor = QColor(255, 210, 210); else if(isReadOnly) textColor = QColor(255, 0, 0); else if(isHidden) textColor = QColor(210, 210, 210); if(list[i].flags & OFS::OFS_LINK) textColor.setBlue(255); item->setTextColor(0, textColor); } pItem->addChild(item); mItemMap.insert(NameTreeWidgetMap::value_type(fullpath, item)); fillTree(item, fullpath); } if(path != "/" && list.size() == 0) { QTreeWidgetItem* item = new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString("."))); item->setTextColor(0, Qt::black); item->setWhatsThis(0, QString(path.c_str())); pItem->addChild(item); } }
void ModularZoneFactory::loadZoneTemplates(void) { mZoneTemplates.clear(); if(OgitorsRoot::getSingletonPtr()->IsSceneLoaded()) { //scene is loaded, we can get the project directories //parse all the .zone files from the project directory //if I had a custom zone resmanager I could get them this way //pList = Ogre::ResourceGroupManager::getSingleton().findResourceNames(PROJECT_RESOURCE_GROUP,"*.zone",false); //maybe TODO: create .zone resourcemanager //Because my.zone files are not a resource I have to manaully get them: OFS::OfsPtr& ofsFile = OgitorsRoot::getSingletonPtr()->GetProjectFile(); OFS::FileList list; ofsFile->listFilesRecursive("/", list); //get rid of everthing except .zone files list.erase(std::remove_if(list.begin(),list.end(),not_a_zonefile),list.end()); int key = 0; OFS::FileList::iterator zonefile; for(zonefile = list.begin();zonefile!=list.end();++zonefile) { //load the .zone XML file and get the zone info //. ZoneInfo zone = this->_loadZoneDescription((*zonefile).name); if(!zone.mName.empty()) { //make sure dependencies are available bool resources = false; //mesh: resources = Ogre::ResourceGroupManager::getSingletonPtr()->resourceExistsInAnyGroup(zone.mMesh); if(resources) { //add to map mZoneTemplates.insert(ZoneInfoMap::value_type(key,zone)); ++key; } } } } }
//---------------------------------------------------------------------------- void extractOFS(Ogre::String path) { unsigned int MAX_BUFFER_SIZE = 16 * 1024 * 1024; char *tmp_buffer = new char[MAX_BUFFER_SIZE]; OFS::OfsPtr& ofsFile = OgitorsRoot::getSingletonPtr()->GetProjectFile(); OFS::FileList list; ofsFile->listFilesRecursive("/", list); std::sort(list.begin(), list.end(), OFS::FileEntry::Compare); std::ofstream out_handle; OFS::OFSHANDLE in_handle; for(unsigned int i = 0; i < list.size(); i++) { std::string file_path = path + list[i].name; if(list[i].flags & OFS::OFS_DIR) { OgitorsSystem::getSingletonPtr()->MakeDirectory(file_path); } else { std::string file_ofs_path = list[i].name; out_handle.open(file_path.c_str(), std::ofstream::out | std::ofstream::binary); if(out_handle.is_open()) { try { OFS::OfsResult ret = ofsFile->openFile(in_handle, file_ofs_path.c_str()); if(ret != OFS::OFS_OK) { out_handle.close(); continue; } unsigned int total = list[i].file_size; while(total > 0) { if(total < MAX_BUFFER_SIZE) { ofsFile->read(in_handle, tmp_buffer, total); out_handle.write(tmp_buffer, total); total = 0; } else { ofsFile->read(in_handle, tmp_buffer, MAX_BUFFER_SIZE); out_handle.write(tmp_buffer, MAX_BUFFER_SIZE); total -= MAX_BUFFER_SIZE; } } } catch(OFS::Exception&) { } out_handle.close(); ofsFile->closeFile(in_handle); } } } delete [] tmp_buffer; }
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 ExtractThread::extractFiles(QString path, const OFS::FileList& list) { std::ofstream out_handle; OFS::OFSHANDLE in_handle; unsigned int output_amount = 0; mutex.lock(); currentPos = 0.0f; msgProgress = ""; mutex.unlock(); for(unsigned int i = 0;i < list.size();i++) { if(list[i].flags & OFS::OFS_DIR) { QString dir_path = path + QString("/") + QString(list[i].name.c_str()); QDir directory(dir_path); directory.mkpath(dir_path); } else { std::string file_path = path.toStdString() + std::string("/") + list[i].name; std::string file_ofs_path = list[i].name; QFileInfo info(QString(file_path.c_str())); QDir directory(info.absolutePath()); directory.mkpath(info.absolutePath()); mutex.lock(); msgProgress = file_ofs_path.c_str(); mutex.unlock(); out_handle.open(file_path.c_str(), std::ofstream::out | std::ofstream::binary); if(out_handle.is_open()) { try { OFS::OfsResult ret = ofsFile->openFile(in_handle, file_ofs_path.c_str()); if(ret != OFS::OFS_OK) { out_handle.close(); continue; } unsigned int total = list[i].file_size; while(total > 0) { if(total < MAX_BUFFER_SIZE) { ofsFile->read(in_handle, tmp_buffer, total); out_handle.write(tmp_buffer, total); output_amount += total; total = 0; } else { ofsFile->read(in_handle, tmp_buffer, MAX_BUFFER_SIZE); out_handle.write(tmp_buffer, MAX_BUFFER_SIZE); total -= MAX_BUFFER_SIZE; output_amount += MAX_BUFFER_SIZE; } if(mTotalFileSize > 0) { mutex.lock(); currentPos = (float)output_amount / (float)mTotalFileSize; mutex.unlock(); } } } catch(OFS::Exception& e) { QMessageBox::information(QApplication::activeWindow(),"Ofs Exception:", tr("Error Extracting File : ") + QString(file_ofs_path.c_str()) + QString("\n") + QString(e.getDescription().c_str()), QMessageBox::Ok); } out_handle.close(); ofsFile->closeFile(in_handle); } } } mutex.lock(); currentPos = 1.0f; msgProgress = tr("Finished Extracting"); mutex.unlock(); }
//------------------------------------------------------------------------------------ void MainWindow::showFiles() { while(mFileListWidget->rowCount() > 0) mFileListWidget->removeRow(0); mCurrentFiles.clear(); QIcon folderIcon = mIconProvider.icon(QFileIconProvider::Folder); if(mOfsFile.valid()) { OFS::FileList dirs = mOfsFile->listFiles(mCurrentDir.c_str(), OFS::OFS_DIR); OFS::FileList files = mOfsFile->listFiles(mCurrentDir.c_str(), OFS::OFS_FILE); std::sort(dirs.begin(), dirs.end(), OFS::FileEntry::Compare); std::sort(files.begin(), files.end(), OFS::FileEntry::Compare); int current_row = 0; if(mCurrentDir.size() > 1) { mFileListWidget->insertRow(current_row); mFileListWidget->setRowHeight(current_row, mRowHeight); QTableWidgetItem *witem = new QTableWidgetItem(folderIcon, QString("..")); mFileListWidget->setItem(0, 0, witem); witem = new QTableWidgetItem(""); mFileListWidget->setItem(current_row, 1, witem); witem = new QTableWidgetItem(tr("Directory")); mFileListWidget->setItem(current_row, 2, witem); witem = new QTableWidgetItem(""); mFileListWidget->setItem(current_row, 3, witem); witem = new QTableWidgetItem(""); mFileListWidget->setItem(current_row, 4, witem); current_row++; OFS::FileEntry updata; updata.flags = OFS::OFS_DIR; updata.name = ".."; updata.file_size = 0; mCurrentFiles.push_back(updata); } mDirUpButton->setEnabled(mCurrentDir.size() > 1); for(unsigned int i = 0;i < dirs.size();i++) { mFileListWidget->insertRow(current_row); mFileListWidget->setRowHeight(current_row, mRowHeight); bool isReadOnly = (dirs[i].flags & OFS::OFS_READONLY) > 0; bool isHidden = (dirs[i].flags & OFS::OFS_HIDDEN) > 0; if(isHidden && (actViewShowHidden->isChecked() == false)) continue; QColor textColor = Qt::black; if(isReadOnly && isHidden) textColor = QColor(255, 210, 210); else if(isReadOnly) textColor = QColor(255, 0, 0); else if(isHidden) textColor = QColor(210, 210, 210); QTableWidgetItem *witem = new QTableWidgetItem(folderIcon, QString(dirs[i].name.c_str())); witem->setTextColor(textColor); mFileListWidget->setItem(current_row, 0, witem); witem = new QTableWidgetItem(""); mFileListWidget->setItem(current_row, 1, witem); witem = new QTableWidgetItem(tr("Directory")); witem->setTextColor(textColor); mFileListWidget->setItem(current_row, 2, witem); witem = new QTableWidgetItem(QDateTime::fromTime_t(dirs[i].create_time).toString()); witem->setTextColor(textColor); mFileListWidget->setItem(current_row, 3, witem); witem = new QTableWidgetItem(QString("{ ") + QString(dirs[i].uuid.toString().c_str()) + QString(" }")); witem->setTextColor(textColor); mFileListWidget->setItem(current_row, 4, witem); current_row++; mCurrentFiles.push_back(dirs[i]); } for(unsigned int i = 0;i < files.size();i++) { mFileListWidget->insertRow(current_row); mFileListWidget->setRowHeight(current_row, mRowHeight); std::string ext_name = files[i].name; bool isReadOnly = (files[i].flags & OFS::OFS_READONLY) > 0; bool isHidden = (files[i].flags & OFS::OFS_HIDDEN) > 0; if(isHidden && (actViewShowHidden->isChecked() == false)) continue; QColor textColor = Qt::black; if(isReadOnly && isHidden) textColor = QColor(255, 210, 210); else if(isReadOnly) textColor = QColor(255, 0, 0); else if(isHidden) textColor = QColor(210, 210, 210); QIcon icon = mUnknownFileIcon; int ext_pos = ext_name.find_last_of("."); if(ext_pos > 0) { ext_name.erase(0, ext_pos); FileIconMap::iterator it = mFileIconMap.find(ext_name); if(it == mFileIconMap.end()) { std::string filename = "./qtOfs_icontest"; filename += ext_name; std::fstream stream; stream.open(filename.c_str(), std::fstream::in | std::fstream::out | std::fstream::binary | std::fstream::trunc); stream.close(); QFileInfo info(QString(filename.c_str())); icon = mIconProvider.icon(info); if(icon.isNull()) icon = mUnknownFileIcon; mFileIconMap.insert(FileIconMap::value_type(ext_name, icon)); QFile::remove(QString(filename.c_str())); } else icon = it->second; } QTableWidgetItem *witem = new QTableWidgetItem(icon, QString(files[i].name.c_str())); witem->setTextColor(textColor); mFileListWidget->setItem(current_row, 0, witem); unsigned int file_size = files[i].file_size; QString size_str = QString("%1").arg(file_size); int len = size_str.length(); int runs = (len - 1) / 3; for(int j = 0;j < runs;j++) { size_str.insert(len - (3 * j) - 3, '.'); } witem = new QTableWidgetItem(size_str + QString(" ")); witem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter); witem->setTextColor(textColor); mFileListWidget->setItem(current_row, 1, witem); witem = new QTableWidgetItem(tr("File")); witem->setTextColor(textColor); mFileListWidget->setItem(current_row, 2, witem); witem = new QTableWidgetItem(QDateTime::fromTime_t(files[i].create_time).toString()); witem->setTextColor(textColor); mFileListWidget->setItem(current_row, 3, witem); witem = new QTableWidgetItem(QString("{ ") + QString(files[i].uuid.toString().c_str()) + QString(" }")); witem->setTextColor(textColor); mFileListWidget->setItem(current_row, 4, witem); ++current_row; mCurrentFiles.push_back(files[i]); } if(mCurrentDir.size() > 1) --current_row; mTotalEntriesLabel->setText(tr("Total Entries : ") + QString("%1").arg(current_row)); mDirectoryDisplay->setText(QString(mCurrentDir.c_str())); } }
//----------------------------------------------------------------------------------------- bool CTerrainGroupEditor::load(bool async) { if(mLoaded->get()) return true; if(!getParent()->load()) return false; Ogre::ResourceGroupManager *mngr = Ogre::ResourceGroupManager::getSingletonPtr(); Ogre::String terrainDir = OgitorsRoot::getSingletonPtr()->GetProjectOptions()->TerrainDirectory; terrainDir = mOgitorsRoot->GetProjectFile()->getFileSystemName() + "::/" + terrainDir + "/"; mngr->addResourceLocation(terrainDir + "textures/normalheight", "Ofs", "TerrainGroupNormalHeight"); mngr->initialiseResourceGroup("TerrainGroupNormalHeight"); mngr->addResourceLocation(terrainDir + "textures/diffusespecular", "Ofs", "TerrainGroupDiffuseSpecular"); mngr->initialiseResourceGroup("TerrainGroupDiffuseSpecular"); mngr->addResourceLocation(terrainDir + "plants", "Ofs", "TerrainGroupPlants"); mngr->initialiseResourceGroup("TerrainGroupPlants"); OgitorsRoot::getSingletonPtr()->PrepareTerrainResources(); OgitorsRoot::getSingletonPtr()->ReloadUserResources(); mDecalFrustum = OGRE_NEW Ogre::Frustum(); mDecalNode = getSceneManager()->getRootSceneNode()->createChildSceneNode("OgitorTerrainDecalNode"); mDecalNode->setPosition(99999, -99999, 99999); mDecalNode->attachObject(mDecalFrustum); mDecalFrustum->setProjectionType(Ogre::PT_ORTHOGRAPHIC); mDecalNode->setOrientation(Ogre::Quaternion(Ogre::Degree(-90), Ogre::Vector3::UNIT_X)); mDecalFrustum->setFOVy(Ogre::Degree(45)); mDecalFrustum->setNearClipDistance(10); mDecalFrustum->setOrthoWindow(10, 10); mDecalFrustum->setVisible(false); mDecalTexture = Ogre::TextureManager::getSingletonPtr()->createManual("OgitorDecalTexture", "TerrainResources", Ogre::TEX_TYPE_2D, 256, 256, 1, 1, Ogre::PF_A8R8G8B8, Ogre::TU_DYNAMIC_WRITE_ONLY, this); mBrushData = OGRE_ALLOC_T(float, BRUSH_DATA_SIZE * BRUSH_DATA_SIZE, Ogre::MEMCATEGORY_GEOMETRY); mTerrainGlobalOptions->setMaxPixelError(mMaxPixelError->get()); mTerrainGlobalOptions->setCompositeMapSize(mCompositeMapTextureSize->get()); mTerrainGlobalOptions->setCompositeMapDistance(mCompositeMapDistance->get()); mTerrainGlobalOptions->setLightMapSize(mLightMapTextureSize->get()); mTerrainGlobalOptions->setLayerBlendMapSize(mBlendMapTextureSize->get()); mTerrainGlobalOptions->setUseVertexCompressionWhenAvailable(false); mTerrainGlobalOptions->setSkirtSize(mSkirtSize->get()); mTerrainGlobalOptions->setUseRayBoxDistanceCalculation(mUseRayBoxDistanceCalculation->get()); if(mMaterialGeneratorType->get() == 1) { Ogre::TerrainMaterialGeneratorPtr matGenPtr(OGRE_NEW Ogre::TerrainMaterialGeneratorC(this, mDecalFrustum)); mTerrainGlobalOptions->setDefaultMaterialGenerator(matGenPtr); mMaxLayersAllowed = 10; } else { Ogre::TerrainMaterialGeneratorPtr matGenPtr(OGRE_NEW Ogre::TerrainMaterialGeneratorB(this, mDecalFrustum)); mTerrainGlobalOptions->setDefaultMaterialGenerator(matGenPtr); mMaxLayersAllowed = 6; } CSceneManagerEditor *mSceneMgr = static_cast<CSceneManagerEditor*>(mOgitorsRoot->GetSceneManagerEditor()); if(mSceneMgr->getShadowsEnabled()) { if(mMaterialGeneratorType->get() == 1) { Ogre::TerrainMaterialGeneratorC::SM2Profile* matProfile = static_cast<Ogre::TerrainMaterialGeneratorC::SM2Profile*>(mTerrainGlobalOptions->getDefaultMaterialGenerator()->getActiveProfile()); matProfile->setReceiveDynamicShadowsEnabled(true); matProfile->setReceiveDynamicShadowsLowLod(false); matProfile->setReceiveDynamicShadowsDepth(true); matProfile->setReceiveDynamicShadowsPSSM(static_cast<Ogre::PSSMShadowCameraSetup*>(mSceneMgr->getPSSMSetup().get())); } else { Ogre::TerrainMaterialGeneratorB::SM2Profile* matProfile = static_cast<Ogre::TerrainMaterialGeneratorB::SM2Profile*>(mTerrainGlobalOptions->getDefaultMaterialGenerator()->getActiveProfile()); matProfile->setReceiveDynamicShadowsEnabled(true); matProfile->setReceiveDynamicShadowsLowLod(false); matProfile->setReceiveDynamicShadowsDepth(true); matProfile->setReceiveDynamicShadowsPSSM(static_cast<Ogre::PSSMShadowCameraSetup*>(mSceneMgr->getPSSMSetup().get())); } } CONNECT_PROPERTY_MEMFN(mSceneMgr, "shadows::enabled", CTerrainGroupEditor, onShadowsChange, mShadowsConnection[0]); CONNECT_PROPERTY_MEMFN(mSceneMgr, "shadows::technique", CTerrainGroupEditor, onShadowsTechniqueChange, mShadowsConnection[1]); mHandle = OGRE_NEW Ogre::TerrainGroup(mOgitorsRoot->GetSceneManager(), Ogre::Terrain::ALIGN_X_Z, mMapSize->get(), mWorldSize->get()); mHandle->setOrigin(Ogre::Vector3::ZERO); mHandle->setResourceGroup("TerrainResources"); mHandle->setFilenameConvention(mPageNamePrefix->get(), "ogt"); StaticGroupPtr = mHandle; mPGHandle = new PagedGeometry(mOgitorsRoot->GetViewport()->getCameraEditor()->getCamera(), mPGPageSize->get()); mPGHandle->addDetailLevel<GrassPage>(mPGDetailDistance->get()); //Create a GrassLoader object mGrassLoaderHandle = new GrassLoader(mPGHandle); mGrassLoaderHandle->setVisibilityFlags(1 << mLayer->get()); //Assign the "grassLoader" to be used to load geometry for the PagedGrass instance mPGHandle->setPageLoader(mGrassLoaderHandle); //Supply a height function to GrassLoader so it can calculate grass Y values mGrassLoaderHandle->setHeightFunction(OgitorTerrainGroupHeightFunction); Ogre::Vector3 vDir; Ogre::ColourValue cDiffuse; Ogre::SceneManager::MovableObjectIterator mit = mOgitorsRoot->GetSceneManager()->getMovableObjectIterator("Light"); while(mit.hasMoreElements()) { Ogre::Light *l = static_cast<Ogre::Light*>(mit.getNext()); if(l->getType() == Ogre::Light::LT_DIRECTIONAL && l->getCastShadows()) { vDir = l->getDerivedDirection(); cDiffuse = l->getDiffuseColour(); break; } } mTerrainGlobalOptions->setLightMapDirection(vDir); mTerrainGlobalOptions->setCompositeMapAmbient(mOgitorsRoot->GetSceneManager()->getAmbientLight()); mTerrainGlobalOptions->setCompositeMapDiffuse(cDiffuse); terrainDir = OgitorsRoot::getSingletonPtr()->GetProjectOptions()->TerrainDirectory + "/terrain/"; OFS::FileList TGAList = mOgitorsRoot->GetProjectFile()->listFiles(terrainDir.c_str(), OFS::OFS_FILE); for(unsigned int t = 0; t < TGAList.size(); t++) { int pos = TGAList[t].name.find("_density.tga"); if(pos > 0) { Ogre::Image _img; Ogre::String sLoc = terrainDir + TGAList[t].name; // Block to ensure streams are freed when exiting the block { OFS::OFSHANDLE *iHandle = new OFS::OFSHANDLE(); mOgitorsRoot->GetProjectFile()->openFile( *iHandle, sLoc.c_str() ); Ogre::DataStreamPtr img_stream = Ogre::DataStreamPtr(OGRE_NEW OfsDataStream(mOgitorsRoot->GetProjectFile(), iHandle)); _img.load(img_stream); } Ogre::String nLoc = terrainDir + TGAList[t].name.substr(0, pos); nLoc += "_density.png"; OgitorsUtils::SaveImageOfs( _img, nLoc ); mOgitorsRoot->GetProjectFile()->deleteFile( sLoc.c_str() ); } } registerForUpdates(); mLoaded->set(true); return true; }
//---------------------------------------------------------------------------------------- void OfsTreeWidget::fillRecycleBin(QTreeWidgetItem *pItem) { OFS::FileList list = mFile->listRecycleBinFiles(); if( list.size() > 0 ) pItem->setIcon(0, QIcon(":/icons/recyclebin_full.svg")); else pItem->setIcon(0, QIcon(":/icons/recyclebin_empty.svg")); std::sort(list.begin(), list.end(), OFS::FileEntry::Compare); for(unsigned int i = 0;i < list.size();i++) { Ogre::String name = list[i].name; Ogre::String ext_name = name; QIcon icon = mUnknownFileIcon; if( list[i].flags & OFS::OFS_DIR ) icon = mOgitorMainWindow->mIconProvider.icon(QFileIconProvider::Folder); else { int ext_pos = ext_name.find_last_of("."); if(ext_pos > 0) { ext_name.erase(0, ext_pos); FileIconMap::iterator it = mOgitorMainWindow->mFileIconMap.find(ext_name); if(it == mOgitorMainWindow->mFileIconMap.end()) { std::string filename = "./qtOgitor_icontest"; filename += ext_name; std::fstream stream; stream.open(filename.c_str(), std::fstream::in | std::fstream::out | std::fstream::binary | std::fstream::trunc); stream.close(); QFileInfo info(QString(filename.c_str())); icon = mOgitorMainWindow->mIconProvider.icon(info); if(icon.isNull()) icon = mUnknownFileIcon; mOgitorMainWindow->mFileIconMap.insert(FileIconMap::value_type(ext_name, icon)); QFile::remove(QString(filename.c_str())); } else icon = it->second; } } QTreeWidgetItem* item = new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString(name.c_str()))); item->setIcon(0, icon); item->setTextColor(0, Qt::black); item->setWhatsThis(0, QString("%1").arg(list[i].id)); item->setToolTip(0, QString(name.c_str()) + QString(" (%1)").arg(list[i].id)); pItem->addChild(item); } }
//---------------------------------------------------------------------------------------- void OfsTreeWidget::fillTreeFiles(QTreeWidgetItem *pItem, std::string path) { OFS::FileList list = mFile->listFiles(path.c_str(), OFS::OFS_FILE); std::sort(list.begin(), list.end(), OFS::FileEntry::Compare); for(unsigned int i = 0;i < list.size();i++) { Ogre::String name = list[i].name; Ogre::String ext_name = name; QIcon icon = mUnknownFileIcon; int ext_pos = ext_name.find_last_of("."); if(ext_pos > 0) { ext_name.erase(0, ext_pos); FileIconMap::iterator it = mOgitorMainWindow->mFileIconMap.find(ext_name); if(it == mOgitorMainWindow->mFileIconMap.end()) { std::string filename = "./qtOgitor_icontest"; filename += ext_name; std::fstream stream; stream.open(filename.c_str(), std::fstream::in | std::fstream::out | std::fstream::binary | std::fstream::trunc); stream.close(); QFileInfo info(QString(filename.c_str())); icon = mOgitorMainWindow->mIconProvider.icon(info); if(icon.isNull()) icon = mUnknownFileIcon; mOgitorMainWindow->mFileIconMap.insert(FileIconMap::value_type(ext_name, icon)); QFile::remove(QString(filename.c_str())); } else icon = it->second; } QTreeWidgetItem* item = new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString(name.c_str()))); item->setIcon(0, icon); item->setTextColor(0, Qt::black); std::string fullpath = path + name; item->setWhatsThis(0, QString(fullpath.c_str())); if(mCapabilities & CAP_SHOW_COLORS) { bool isReadOnly = (list[i].flags & OFS::OFS_READONLY) > 0; bool isHidden = (list[i].flags & OFS::OFS_HIDDEN) > 0; QColor textColor = Qt::black; if(isReadOnly && isHidden) textColor = QColor(255, 210, 210); else if(isReadOnly) textColor = QColor(255, 0, 0); else if(isHidden) textColor = QColor(210, 210, 210); if(list[i].flags & OFS::OFS_LINK) textColor.setBlue(255); item->setTextColor(0, textColor); } pItem->addChild(item); mItemMap.insert(NameTreeWidgetMap::value_type(fullpath, item)); } }