const VectorString& OgreDataManager::getDataListNames(const std::string& _pattern, bool _fullpath) { static VectorString result; result.clear(); Ogre::FileInfoListPtr pFileInfo = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(mGroup, _pattern); result.reserve(pFileInfo->size()); for (Ogre::FileInfoList::iterator fi = pFileInfo->begin(); fi != pFileInfo->end(); ++fi ) { if (fi->path.empty()) { bool found = false; for (VectorString::iterator iter = result.begin(); iter != result.end(); ++iter) { if (*iter == fi->filename) { found = true; break; } } if (!found) { result.push_back(_fullpath ? fi->archive->getName() + "/" + fi->filename : fi->filename); } } } pFileInfo.setNull(); return result; }
void CMapPack::init() { if (m_bInitialised) {return;} Ogre::LogManager::getSingleton().logMessage("Creating map pack for " + m_sMapName); Ogre::ResourceGroupManager::getSingleton().createResourceGroup(m_sMapName); Ogre::FileInfoListPtr files = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo("level_user", m_sMapName + ".zip"); if (files->size() == 0) { throw Ogre::Exception(0, "Map zip file not found", __FILE__); } Ogre::String sZipFile = files->front().archive->getName() + "/" + files->front().filename; Ogre::LogManager::getSingleton().logMessage(" adding zip from " + sZipFile); #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID Ogre::ResourceGroupManager::getSingleton().addResourceLocation(sZipFile, "APKZip", m_sMapName, true); #else Ogre::ResourceGroupManager::getSingleton().addResourceLocation(sZipFile, "Zip", m_sMapName, true); #endif Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup(m_sMapName); m_bInitialised = true; try { loadLanguage(); } catch (const Ogre::Exception& e) { Ogre::LogManager::getSingleton().logMessage(Ogre::LML_CRITICAL, e.getFullDescription()); } if (!m_pMapInfo) { m_pMapInfo = shared_ptr<CMapInfo>(new CMapInfo(m_sMapName, m_sMapName)); } }
const VectorString& Ogre2DataManager::getDataListNames(const std::string& _pattern, bool _fullpath) { static VectorString result; result.clear(); VectorString search; if (mAllGroups) { Ogre::StringVector sp = Ogre::ResourceGroupManager::getSingleton().getResourceGroups(); search.reserve(sp.size()); for (size_t i = 0; i < sp.size(); i++) search.push_back(sp[i]); } else search.push_back(mGroup); std::vector<Ogre::FileInfoListPtr> pFileInfos; int resultSize = 0; for (size_t i = 0; i < search.size(); i++) { Ogre::FileInfoListPtr pFileInfo = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(search[i], _pattern); resultSize += pFileInfo->size(); if (!pFileInfo->empty()) pFileInfos.push_back(pFileInfo); else pFileInfo.setNull(); } result.reserve(resultSize); for (size_t i = 0; i < pFileInfos.size(); i++) { Ogre::FileInfoListPtr pFileInfo = pFileInfos[i]; for (Ogre::FileInfoList::iterator fi = pFileInfo->begin(); fi != pFileInfo->end(); ++fi ) { if (fi->path.empty()) { bool found = false; for (VectorString::iterator iter = result.begin(); iter != result.end(); ++iter) { if (*iter == fi->filename) { found = true; break; } } if (!found) { result.push_back(_fullpath ? fi->archive->getName() + "/" + fi->filename : fi->filename); } } } pFileInfo.setNull(); } return result; }
String ResourceManager::GetAssetPath(const String& FileName, const String& Group) { Ogre::FileInfoListPtr FileList = this->OgreResource->listResourceFileInfo(Group); for( Whole X = 0 ; X < FileList->size() ; ++X ) { if( FileName == FileList->at(X).filename ) { return FileList->at(X).path; } } return ""; }
OgreNetworkReply::OgreNetworkReply(const QNetworkRequest &request) { setOperation(QNetworkAccessManager::GetOperation); setRequest(request); setUrl(request.url()); QString path = request.url().toString(QUrl::RemoveScheme); // Remote slashes at the beginning while (path.startsWith('/')) path = path.mid(1); qDebug() << "Opening" << path << "from ogre resource."; Ogre::ResourceGroupManager &resourceManager = Ogre::ResourceGroupManager::getSingleton(); qRegisterMetaType<QNetworkReply::NetworkError>("QNetworkReply::NetworkError"); /* Is it a directory? */ Ogre::FileInfoListPtr fileInfo = resourceManager.findResourceFileInfo("General", path.toStdString(), true); if (fileInfo->size() > 0) { QString msg = QString("Cannot open %1: Path is a directory").arg(path); setError(ContentOperationNotPermittedError, msg); QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection, Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ContentOperationNotPermittedError)); QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection); return; } try { mDataStream = resourceManager.openResource(path.toStdString()); } catch (Ogre::FileNotFoundException &e) { qWarning("Couldn't find %s: %s", qPrintable(path), e.getFullDescription().c_str()); setError(ContentNotFoundError, "Couldn't find " + path); QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection, Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ContentNotFoundError)); QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection); return; } open(QIODevice::ReadOnly); setHeader(QNetworkRequest::ContentLengthHeader, mDataStream->size()); QMetaObject::invokeMethod(this, "metaDataChanged", Qt::QueuedConnection); QMetaObject::invokeMethod(this, "downloadProgress", Qt::QueuedConnection, Q_ARG(qint64, mDataStream->size()), Q_ARG(qint64, mDataStream->size())); QMetaObject::invokeMethod(this, "readyRead", Qt::QueuedConnection); QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection); }
const Ogre::StringVector& ManipulatorTerrain::GetAllLayerTexThumbnailNames() { m_vecLayerTex.clear(); Ogre::FileInfoListPtr fileinfo = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo( "TerrainTextures", "*.png"); int i = 0; m_vecLayerTex.resize(fileinfo->size()); for (auto iter=fileinfo->begin(); iter!=fileinfo->end(); ++iter) { const Ogre::FileInfo& info = (*iter); m_vecLayerTex[i++] = info.archive->getName() + "/" + info.filename; } return m_vecLayerTex; }
//----------------------------------------------------------------------- DataStreamPtr ZipArchive::open(const String& filename, bool readOnly) { // zziplib is not threadsafe OGRE_LOCK_AUTO_MUTEX; String lookUpFileName = filename; // Format not used here (always binary) ZZIP_FILE* zzipFile = zzip_file_open(mZzipDir, lookUpFileName.c_str(), ZZIP_ONLYZIP | ZZIP_CASELESS); if (!zzipFile) // Try if we find the file { const Ogre::FileInfoListPtr fileNfo = findFileInfo(lookUpFileName, true); if (fileNfo->size() == 1) // If there are more files with the same do not open anyone { Ogre::FileInfo info = fileNfo->at(0); lookUpFileName = info.path + info.basename; zzipFile = zzip_file_open(mZzipDir, lookUpFileName.c_str(), ZZIP_ONLYZIP | ZZIP_CASELESS); // When an error happens here we will catch it below } } if (!zzipFile) { int zerr = zzip_error(mZzipDir); String zzDesc = getZzipErrorDescription((zzip_error_t)zerr); LogManager::getSingleton().logMessage( mName + " - Unable to open file " + lookUpFileName + ", error was '" + zzDesc + "'", LML_CRITICAL); // return null pointer return DataStreamPtr(); } // Get uncompressed size too ZZIP_STAT zstat; zzip_dir_stat(mZzipDir, lookUpFileName.c_str(), &zstat, ZZIP_CASEINSENSITIVE); // Construct & return stream return DataStreamPtr(OGRE_NEW ZipDataStream(lookUpFileName, zzipFile, static_cast<size_t>(zstat.st_size))); }
gkBlendListIterator::gkBlendListIterator(List* list) : m_list(list), #if OGREKIT_USE_BPARSE m_index(0) #else m_index(list ? list->first : 0) #endif { } bool gkBlendListIterator::hasMoreElements() const { if (m_list == 0) return false; #if OGREKIT_USE_BPARSE return m_index < m_list->size(); #else return m_index != 0; #endif } gkBlendListIterator::ListItem* gkBlendListIterator::getNext(void) { #if OGREKIT_USE_BPARSE return m_list->at(m_index++); #else ListItem* item = m_index; m_index = m_index->next; return item; #endif } //-- gkBlendInternalFile::gkBlendInternalFile() : m_file(0) { } gkBlendInternalFile::~gkBlendInternalFile() { delete m_file; m_file = 0; } bool gkBlendInternalFile::parse(const gkString& fname) { if (fname.empty()) { gkLogMessage("BlendFile: File " << fname << " loading failed. File name is empty."); return false; } #if OGREKIT_USE_BPARSE utMemoryStream fs; fs.open(fname.c_str(), utStream::SM_READ); if (!fs.isOpen()) { gkLogMessage("BlendFile: File " << fname << " loading failed. No such file."); return false; } // Write contents and inflate. utMemoryStream buffer(utStream::SM_WRITE); fs.inflate(buffer); m_file = new bParse::bBlenderFile((char*)buffer.ptr(), buffer.size()); m_file->parse(false); if (!m_file->ok()) { gkLogMessage("BlendFile: File " << fname << " loading failed. Data error."); return false; } #else m_file = new fbtBlend(); int status = m_file->parse(fname.c_str(), fbtFile::PM_COMPRESSED); if (status != fbtFile::FS_OK) { delete m_file; m_file = 0; gkLogMessage("BlendFile: File " << fname << " loading failed. code: " << status); //return false; } else { gkLogMessage("BlendFile: File " << fname << " loading end1" ); return true; } //gkLogMessage("BlendFile: File " << fname << " loading end" ); m_file = new fbtBlend(); Ogre::DataStreamPtr stream; Ogre::ArchiveManager::ArchiveMapIterator beginItera = Ogre::ArchiveManager::getSingleton().getArchiveIterator(); while(beginItera.hasMoreElements()) { typedef std::map<Ogre::String, Ogre::Archive*>::iterator ArchiveIterator; ArchiveIterator arch = beginItera.current(); if (arch->second) { Ogre::FileInfoListPtr fileInfo = arch->second->findFileInfo(fname); if (fileInfo->size() > 0) { stream = arch->second->open(fname); gkLogMessage("BlendFile: File found create stream"); break; } } beginItera.moveNext(); } //gkLogMessage("malloc buffer"); unsigned char * buffer = new unsigned char[stream->size()]; //gkLogMessage(" stream->read "); long sizeCount = stream->read(buffer,stream->size()); //gkLogMessage(" m_file->parse"); if(m_file) m_file->parse(buffer,sizeCount); delete buffer; //gkLogMessage(" m_file->parse end"); #endif return true; } Blender::FileGlobal* gkBlendInternalFile::getFileGlobal() { GK_ASSERT(m_file); #if OGREKIT_USE_BPARSE return (Blender::FileGlobal*)m_file->getFileGlobal(); #else return m_file->m_fg; #endif } int gkBlendInternalFile::getVersion() { GK_ASSERT(m_file); #if OGREKIT_USE_BPARSE return m_file->getMain()->getVersion(); #else return m_file->getVersion(); #endif }
//------------------------------------------------------------------------------------- void SceneLoader::load(std::string filename, Scene* scene) { try { Ogre::FileInfoListPtr files = Ogre::ResourceGroupManager::getSingletonPtr()->findResourceFileInfo("Essential", filename); if(files->size() < 1) throw NHException("could not find the path to the specified scene"); std::string filePath = files->front().archive->getName() + "/" + files->front().filename; std::ifstream streamfile(filePath); rapidxml::xml_document<> doc; std::vector<char> buffer((std::istreambuf_iterator<char>(streamfile)), std::istreambuf_iterator<char>());//streamfile)), std::istreambuf_iterator<char>()); buffer.push_back('\0');//null terminating the buffer //std::cout << &buffer[0] << std::endl; //test the buffer doc.parse<0>(&buffer[0]); rapidxml::xml_node<>* root = doc.first_node(SCENE_STRING);//"scene"); scene->getSceneGraphicsManager()->setAmbientLight(getXMLColour(root, AMBIENT_RED_STRING, AMBIENT_GREEN_STRING, AMBIENT_BLUE_STRING)); //description attributes //north = boost::lexical_cast<float>(root->first_attribute(NORTH_STRING)->value()); //Architecture rapidxml::xml_node<>* architectureNode = root->first_node(ARCHITECTURE_STRING);//"architecture"); while(architectureNode != NULL) { int id = boost::lexical_cast<int>(architectureNode->first_attribute(ID_STRING)->value()); try { scene->addArchitecture(id, getXMLPosition(architectureNode), getXMLRotation(architectureNode), getXMLScale(architectureNode)); } catch(NHException e) { #ifdef _DEBUG std::cout << e.what() << std::endl; #endif } architectureNode = architectureNode->next_sibling(ARCHITECTURE_STRING); } scene->build();//building static geometry - must do here else we can't use the navigation mesh for creature placement //Lights rapidxml::xml_node<>* lightNode = root->first_node(LIGHT_STRING);//"light"); while(lightNode != NULL) { bool cast_shadows = boost::lexical_cast<bool>(lightNode->first_attribute(CAST_SHADOWS_STRING)->value()); float range = boost::lexical_cast<float>(lightNode->first_attribute(RANGE_STRING)->value()); Ogre::ColourValue colour = getXMLColour(lightNode); scene->addLight(-1, getXMLPosition(lightNode),cast_shadows,range);//TODO: use actual id rather than -1 lightNode = lightNode->next_sibling(LIGHT_STRING); } //Items rapidxml::xml_node<>* itemNode = root->first_node(ITEM_STRING); while(itemNode != NULL) { int id = boost::lexical_cast<int>(itemNode->first_attribute(ID_STRING)->value()); scene->addItem(id, getXMLPosition(itemNode), getXMLRotation(itemNode)); itemNode = itemNode->next_sibling(ITEM_STRING); } //Creatures rapidxml::xml_node<>* creatureNode = root->first_node(CREATURE_STRING); while(creatureNode != NULL) { int id = boost::lexical_cast<int>(creatureNode->first_attribute(ID_STRING)->value()); scene->addCreature(id, getXMLPosition(creatureNode)); creatureNode = creatureNode->next_sibling(CREATURE_STRING); } //Portals rapidxml::xml_node<>* portalNode = root->first_node(PORTAL_STRING); while(portalNode != NULL) { int id = boost::lexical_cast<int>(portalNode->first_attribute(ID_STRING)->value()); int targetSceneID = boost::lexical_cast<int>(portalNode->first_attribute(TARGET_SCENE_ID_STRING)->value()); int targetPortalID = boost::lexical_cast<int>(portalNode->first_attribute(TARGET_PORTAL_ID_STRING)->value()); scene->addPortal(id, getXMLPosition(portalNode), getXMLVector(portalNode, LOOK_AT_X_STRING, LOOK_AT_Y_STRING, LOOK_AT_Z_STRING), Id<Scene>(targetSceneID), Id<Portal>(targetPortalID), Id<Portal>(id)); portalNode = portalNode->next_sibling(PORTAL_STRING);//"portal"); } //Particles //TODO: change to emitter /* rapidxml::xml_node<>* particleNode = root->first_node(PARTICLE_STRING);//"particle"); while(particleNode != NULL) { scene->addParticles(particleNode->first_attribute(NAME_STRING)->value(), particleNode->first_attribute(TEMPLATE_NAME_STRING)->value(),getXMLPosition(particleNode)); particleNode = particleNode->next_sibling(PARTICLE_STRING); } */ } catch (rapidxml::parse_error e) { std::stringstream ss; ss << "could not load the xml scene '" << filename << "': " << e.what() << std::endl; throw NHException(ss.str().c_str()); } }