void realise (void) { if (--m_unrealised == 0) { GlobalFileSystem().initDirectory(GlobalRadiant().getFullGamePath()); GlobalFileSystem().initialise(); } }
void Doom3MapCompiler::dmapCmd(const cmd::ArgumentList& args) { if (args.size() != 1) { rWarning() << "Usage: dmap <mapFile>" << std::endl; return; } std::string mapFile = args[0].getString(); if (!boost::algorithm::iends_with(mapFile, ".map")) { mapFile.append(".map"); } std::string mapPath = mapFile; // Find the map file if (!path_is_absolute(mapPath.c_str())) { mapPath = GlobalFileSystem().findFile(mapFile); if (mapPath.empty()) { // Try again with maps/ prepended mapFile = "maps/" + mapFile; mapPath = GlobalFileSystem().findFile(mapFile); } mapPath += mapFile; } // Start the sequence runDmap(mapPath); }
bool SoundManager::playSound(const std::string& fileName, bool loopSound) { // Make a copy of the filename std::string name = fileName; // Try to open the file as it is ArchiveFilePtr file = GlobalFileSystem().openFile(name); rConsole() << "Trying: " << name << std::endl; if (file) { // File found, play it rConsole() << "Found file: " << name << std::endl; if (_soundPlayer) _soundPlayer->play(*file, loopSound); return true; } std::string root = name; // File not found, try to strip the extension if (name.rfind(".") != std::string::npos) { root = name.substr(0, name.rfind(".")); } // Try to open the .ogg variant name = root + ".ogg"; rConsole() << "Trying: " << name << std::endl; file = GlobalFileSystem().openFile(name); if (file) { rConsole() << "Found file: " << name << std::endl; if (_soundPlayer) _soundPlayer->play(*file, loopSound); return true; } // Try to open the file with .wav extension name = root + ".wav"; rConsole() << "Trying: " << name << std::endl; file = GlobalFileSystem().openFile(name); if (file) { rConsole() << "Found file: " << name << std::endl; if (_soundPlayer) _soundPlayer->play(*file, loopSound); return true; } // File not found return false; }
void ModelSelector::loadDirectory(const std::string& path) { if (path.empty()) return; // Modal dialog window to display progress gtkutil::ModalProgressDialog dialog(GlobalRadiant().getMainWindow(), string::format(_("Loading models %s"), path.c_str())); // Populate the treestore using the VFS callback functor ModelFileFunctor functor(_treeStore, dialog, DirectoryCleaned(path), _dirIterMap); functor.setDirectory(true); GlobalFileSystem().forEachDirectory(path, makeCallback1(functor), 1); functor.setDirectory(false); GlobalFileSystem().forEachFile(path, "*", makeCallback1(functor), 1); }
void EntityClassDoom3_destroy(){ EntityClassDoom3_unrealise(); g_EntityClassDoom3_bad->free( g_EntityClassDoom3_bad ); GlobalFileSystem().detach( g_EntityClassDoom3 ); }
GlyphSetPtr GlyphSet::createFromDatFile(const std::string& vfsPath, const std::string& fontname, const std::string& language, Resolution resolution) { ArchiveFilePtr file = GlobalFileSystem().openFile(vfsPath); // Check file size if (file->size() != sizeof(q3font::Q3FontInfo)) { rWarning() << "FontLoader: invalid file size of file " << vfsPath << ", expected " << sizeof(q3font::Q3FontInfo) << ", found " << file->size() << std::endl; return GlyphSetPtr(); } // Allocate a buffer with the Quake3 info structure q3font::Q3FontInfoPtr buf(new q3font::Q3FontInfo); InputStream& stream = file->getInputStream(); stream.read( reinterpret_cast<StreamBase::byte_type*>(buf.get()), sizeof(q3font::Q3FontInfo) ); // Construct a glyph set using the loaded info GlyphSetPtr glyphSet(new GlyphSet(*buf, fontname, language, resolution)); rMessage() << "FontLoader: " << vfsPath << " loaded successfully." << std::endl; return glyphSet; }
void SoundManager::initialiseModule(const ApplicationContext& ctx) { globalOutputStream() << "SoundManager::initialiseModule called\n"; // Pass a SoundFileLoader to the filesystem SoundFileLoader loader(*this); GlobalFileSystem().forEachFile( SOUND_FOLDER, // directory "*", // required extension loader, // loader callback 99 // max depth ); globalOutputStream() << _soundFiles.size() << " sound files found." << std::endl; // Create the SoundPlayer if sound is not disabled const ApplicationContext::ArgumentList& args = ctx.getCmdLineArgs(); ApplicationContext::ArgumentList::const_iterator found( std::find(args.begin(), args.end(), "--disable-sound") ); if (found == args.end()) { globalOutputStream() << "SoundManager: initialising sound playback" << std::endl; _soundPlayer = boost::shared_ptr<SoundPlayer>(new SoundPlayer); } else { globalOutputStream() << "SoundManager: sound ouput disabled" << std::endl; } }
NodeSmartReference ModelResource_load(ModelLoader* loader, const char* name) { ScopeDisableScreenUpdates disableScreenUpdates(path_get_filename_start(name), "Loading Model"); NodeSmartReference model(g_nullModel); { ArchiveFile* file = GlobalFileSystem().openFile(name); if(file != 0) { globalOutputStream() << "Loaded Model: \"" << name << "\"\n"; model = loader->loadModel(*file); file->release(); } else { globalErrorStream() << "Model load failed: \"" << name << "\"\n"; } } model.get().m_isRoot = true; return model; }
const char* misc_model_dialog(GtkWidget* parent) { StringOutputStream buffer(1024); buffer << g_qeglobals.m_userGamePath.c_str() << "models/"; if(!file_readable(buffer.c_str())) { // just go to fsmain buffer.clear(); buffer << g_qeglobals.m_userGamePath.c_str() << "/"; } const char *filename = file_dialog (parent, TRUE, "Choose Model", buffer.c_str(), ModelLoader::Name()); if (filename != 0) { // use VFS to get the correct relative path const char* relative = path_make_relative(filename, GlobalFileSystem().findRoot(filename)); if(relative == filename) { globalOutputStream() << "WARNING: could not extract the relative path, using full path instead\n"; } return relative; } return 0; }
void ShaderFileLoader::parseFiles() { for (std::size_t i = 0; i < _files.size(); ++i) { const std::string& fullPath = _files[i]; if (_currentOperation) { _currentOperation->setMessage((boost::format(_("Parsing material file %s")) % fullPath).str()); float progress = static_cast<float>(i) / _files.size(); _currentOperation->setProgress(progress); } // Open the file ArchiveTextFilePtr file = GlobalFileSystem().openTextFile(fullPath); if (file != NULL) { std::istream is(&(file->getInputStream())); parseShaderFile(is, fullPath); } else { throw std::runtime_error("Unable to read shaderfile: " + fullPath); } } }
void EntityClassScannerUFO::scanFile (EntityClassCollector& collector) { const std::string& filename = getFilename(); AutoPtr<ArchiveTextFile> file(GlobalFileSystem().openTextFile(filename)); if (!file) { std::string buffer = "Could not load " + filename; gtkutil::errorDialog(buffer); return; } const std::size_t size = file->size(); char* entities = (char*) malloc(size + 1); TextInputStream &stream = file->getInputStream(); const std::size_t realsize = stream.read(entities, size); entities[realsize] = '\0'; if (ED_Parse(entities) == ED_ERROR) { std::string buffer = "Parsing of entities definition file failed, returned error was " + std::string( ED_GetLastError()); gtkutil::errorDialog(buffer); } else { for (int i = 0; i < numEntityDefs; i++) { EntityClass *e = initFromDefinition(&entityDefs[i]); if (e) collector.insert(e); } } free(entities); ED_Free(); }
// Populate the tree view with models void ModelSelector::populateModels() { // Clear the treestore first _treeStore->Clear(); _treeStoreWithSkins->Clear(); // Create a VFSTreePopulator for the treestore wxutil::VFSTreePopulator pop(_treeStore); wxutil::VFSTreePopulator popSkins(_treeStoreWithSkins); // Use a ModelFileFunctor to add paths to the populator ModelFileFunctor functor(pop, popSkins); GlobalFileSystem().forEachFile(MODELS_FOLDER, "*", [&](const std::string& filename) { functor(filename); }, 0); // Fill in the column data (TRUE = including skins) ModelDataInserter inserterSkins(_columns, true); popSkins.forEachNode(inserterSkins); // Insert data into second model (FALSE = without skins) ModelDataInserter inserter(_columns, false); pop.forEachNode(inserter); // Sort the models _treeStore->SortModelFoldersFirst(_columns.filename, _columns.isFolder); _treeStoreWithSkins->SortModelFoldersFirst(_columns.filename, _columns.isFolder); // Setup the tree view setupTreeView(); // Set the flag, we're done _populated = true; }
void EClassManager::initialiseModule(const ApplicationContext& ctx) { rMessage() << "EntityClassDoom3::initialiseModule called." << std::endl; GlobalFileSystem().addObserver(*this); realise(); }
void Doom3ShaderSystem::loadMaterialFiles() { // Get the shaders path and extension from the XML game file xml::NodeList nlShaderPath = GlobalGameManager().currentGame()->getLocalXPath("/filesystem/shaders/basepath"); if (nlShaderPath.empty()) throw xml::MissingXMLNodeException(MISSING_BASEPATH_NODE); xml::NodeList nlShaderExt = GlobalGameManager().currentGame()->getLocalXPath("/filesystem/shaders/extension"); if (nlShaderExt.empty()) throw xml::MissingXMLNodeException(MISSING_EXTENSION_NODE); // Load the shader files from the VFS std::string sPath = nlShaderPath[0].getContent(); if (!boost::algorithm::ends_with(sPath, "/")) sPath += "/"; std::string extension = nlShaderExt[0].getContent(); // Load each file from the global filesystem ShaderFileLoader loader(sPath, _currentOperation); { ScopedDebugTimer timer("ShaderFiles parsed: "); GlobalFileSystem().forEachFile(sPath, extension, [&](const std::string& filename) { loader.addFile(filename); }, 0); loader.parseFiles(); } rMessage() << _library->getNumShaders() << " shaders found." << std::endl; }
ReferenceAPI() { g_nullModel = NewNullModel(); GlobalFileSystem().attach(g_referenceCache); m_reference = &GetReferenceCache(); }
void EntityClassDoom3_construct(){ GlobalFileSystem().attach( g_EntityClassDoom3 ); // start by creating the default unknown eclass g_EntityClassDoom3_bad = EClass_Create( "UNKNOWN_CLASS", Vector3( 0.0f, 0.5f, 0.0f ), "" ); EntityClassDoom3_realise(); }
void Doom3ShaderSystem::construct() { _library = ShaderLibraryPtr(new ShaderLibrary()); _textureManager = GLTextureManagerPtr(new GLTextureManager()); // Register this class as VFS observer GlobalFileSystem().addObserver(*this); }
void MaterialSystem::importMaterialFile (const std::string& name) { // Find the material AutoPtr<ArchiveTextFile> file(GlobalFileSystem().openTextFile(name)); if (!file) return; showMaterialDefinitionAndAppend(file->getString()); }
void QE_InitVFS() { // VFS initialization ----------------------- // we will call GlobalFileSystem().initDirectory, giving the directories to look in (for files in pk3's and for standalone files) // we need to call in order, the mod ones first, then the base ones .. they will be searched in this order // *nix systems have a dual filesystem in ~/.q3a, which is searched first .. so we need to add that too const char* gamename = gamename_get(); const char* basegame = basegame_get(); const char* userRoot = g_qeglobals.m_userEnginePath.c_str(); const char* globalRoot = EnginePath_get(); // if we have a mod dir if(!string_equal(gamename, basegame)) { // ~/.<gameprefix>/<fs_game> if ( userRoot ) { StringOutputStream userGamePath(256); userGamePath << userRoot << gamename << '/'; GlobalFileSystem().initDirectory(userGamePath.c_str()); } // <fs_basepath>/<fs_game> { StringOutputStream globalGamePath(256); globalGamePath << globalRoot << gamename << '/'; GlobalFileSystem().initDirectory(globalGamePath.c_str()); } } // ~/.<gameprefix>/<fs_main> if ( userRoot ) { StringOutputStream userBasePath(256); userBasePath << userRoot << basegame << '/'; GlobalFileSystem().initDirectory(userBasePath.c_str()); } // <fs_basepath>/<fs_main> { StringOutputStream globalBasePath(256); globalBasePath << globalRoot << basegame << '/'; GlobalFileSystem().initDirectory(globalBasePath.c_str()); } }
// Load the given model from the VFS path model::IModelPtr loadModelFromPath (const std::string& name) { // Open an ArchiveFile to load AutoPtr<ArchiveFile> file(GlobalFileSystem().openFile(name)); if (file) { // Load the model and return the RenderablePtr return loadIModel(m_module, *file); } return model::IModelPtr(); }
void EClassManager::initialiseModule(const ApplicationContext& ctx) { rMessage() << "EntityClassDoom3::initialiseModule called." << std::endl; GlobalFileSystem().addObserver(*this); realise(); GlobalCommandSystem().addCommand("ReloadDefs", boost::bind(&EClassManager::reloadDefsCmd, this, _1)); GlobalEventManager().addCommand("ReloadDefs", "ReloadDefs"); }
void ParticlesManager::initialiseModule(const ApplicationContext& ctx) { globalOutputStream() << "ParticlesManager::initialiseModule called\n"; // Use a ParticleFileLoader to load each file ParticleFileLoader loader(*this); ScopedDebugTimer timer("Particle definitions parsed: "); GlobalFileSystem().forEachFile(PARTICLES_DIR, PARTICLES_EXT, loader, 1); }
bool UMPFile::load () { AutoPtr<ArchiveTextFile> file(GlobalFileSystem().openTextFile(map::getMapsPath() + _fileName)); if (file) { AutoPtr<Tokeniser> reader(GlobalScriptLibrary().createScriptTokeniser(file->getInputStream())); parse(*reader); return true; } return false; }
void GuiManager::findGuis() { _errorList.clear(); // Traverse the file system, using this class as callback GlobalFileSystem().forEachFile(GUI_DIR, GUI_EXT, *this, 99); rMessage() << "[GuiManager]: Found " << _guis.size() << " guis." << std::endl; }
void ParticlesManager::reloadParticleDefs() { // Use a ParticleFileLoader to load each file ParticleFileLoader loader(*this); ScopedDebugTimer timer("Particle definitions parsed: "); GlobalFileSystem().forEachFile(PARTICLES_DIR, PARTICLES_EXT, loader, 1); // Notify observers about this event _particlesReloadedSignal.emit(); }
void MaterialSystem::loadMaterials () { if (GlobalMap().isUnnamed()) return; AutoPtr<ArchiveTextFile> file(GlobalFileSystem().openTextFile(getMaterialFilename())); if (file) { _material = file->getString(); _materialLoaded = true; } }
void Doom3ShaderSystem::destroy() { // De-register this class as VFS Observer GlobalFileSystem().removeObserver(*this); // Free the shaders if we're in realised state if (_realised) { freeShaders(); } // Don't destroy the GLTextureManager, it's called from // the CShader destructors. }
void EClassManager::parseDefFiles() { rMessage() << "searching vfs directory 'def' for *.def\n"; // Increase the parse stamp for this run _curParseStamp++; { ScopedDebugTimer timer("EntityDefs parsed: "); GlobalFileSystem().forEachFile("def/", "def", *this); } }
void RadiantModule::shutdownModule() { rMessage() << "RadiantModule::shutdownModule called." << std::endl; GlobalFileSystem().shutdown(); map::PointFile::Instance().destroy(); ui::OverlayDialog::destroy(); ui::TextureBrowser::destroy(); _radiantShutdown.clear(); }
void EntityClassDoom3_loadFile( const char* filename ){ globalOutputStream() << "parsing entity classes from " << makeQuoted( filename ) << "\n"; StringOutputStream fullname( 256 ); fullname << "def/" << filename; ArchiveTextFile* file = GlobalFileSystem().openTextFile( fullname.c_str() ); if ( file != 0 ) { EntityClassDoom3_parse( file->getInputStream(), fullname.c_str() ); file->release(); } }