Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Sep 30, 2009, 12:00:16 AM (15 years ago)
Author:
rgrieder
Message:

Extracted path related parts of Core into a new PathConfig class. This should decrease the mess in Core.cc a little bit.

File:
1 copied

Legend:

Unmodified
Added
Removed

  • code/branches/core5/src/libraries/core/PathConfig.cc

    r5832 r5836  
    2121 *
    2222 *   Author:
    23  *      Fabian 'x3n' Landau
    2423 *      Reto Grieder
    2524 *   Co-authors:
    … …  
    2827 */
    2928
    30 /**
    31 @file
    32 @brief
    33     Implementation of the Core singleton with its global variables (avoids boost include)
    34 */
    35 
    36 #include "Core.h"
     29#include "PathConfig.h"
    3730
    3831#include <cassert>
    39 #include <fstream>
    4032#include <cstdlib>
    4133#include <cstdio>
     34#include <vector>
    4235#include <boost/version.hpp>
    4336#include <boost/filesystem.hpp>
    … …  
    6154#include "util/Debug.h"
    6255#include "util/Exception.h"
    63 #include "util/SignalHandler.h"
    64 #include "Clock.h"
    65 #include "CommandExecutor.h"
    6656#include "CommandLine.h"
    67 #include "ConfigFileManager.h"
    68 #include "ConfigValueIncludes.h"
    69 #include "CoreIncludes.h"
    70 #include "DynLibManager.h"
    71 #include "GameMode.h"
    72 #include "GraphicsManager.h"
    73 #include "GUIManager.h"
    74 #include "Identifier.h"
    75 #include "Language.h"
    76 #include "LuaState.h"
    77 #include "Shell.h"
    78 #include "TclBind.h"
    79 #include "TclThreadManager.h"
    80 #include "input/InputManager.h"
    8157
    8258// Boost 1.36 has some issues with deprecated functions that have been omitted
    … …  
    8965namespace orxonox
    9066{
     67    namespace bf = boost::filesystem;
     68
    9169    //! Static pointer to the singleton
    92     Core* Core::singletonPtr_s  = 0;
     70    PathConfig* PathConfig::singletonPtr_s  = 0;
    9371
    9472    SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");
    9573    SetCommandLineOnlyArgument(writingPathSuffix, "").information("Additional subfolder for config and log files");
    96     SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
    97 #ifdef ORXONOX_PLATFORM_WINDOWS
    98     SetCommandLineArgument(limitToCPU, 0).information("Limits the program to one cpu/core (1, 2, 3, etc.). 0 turns it off (default)");
    99 #endif
    100 
    101     /**
    102     @brief
    103         Helper class for the Core singleton: we cannot derive
    104         Core from OrxonoxClass because we need to handle the Identifier
    105         destruction in the Core destructor.
    106     */
    107     class CoreConfiguration : public OrxonoxClass
    108     {
    109     public:
    110         CoreConfiguration()
    111         {
    112         }
    113 
    114         void initialise()
    115         {
    116             RegisterRootObject(CoreConfiguration);
    117             this->setConfigValues();
    118 
    119             // External data directory only exists for dev runs
    120             if (Core::isDevelopmentRun())
    121             {
    122                 // Possible data path override by the command line
    123                 if (!CommandLine::getArgument("externalDataPath")->hasDefaultValue())
    124                     tsetExternalDataPath(CommandLine::getValue("externalDataPath"));
    125             }
    126         }
    127 
    128         /**
    129             @brief Function to collect the SetConfigValue-macro calls.
    130         */
    131         void setConfigValues()
    132         {
    133 #ifdef NDEBUG
    134             const unsigned int defaultLevelConsole = 1;
    135             const unsigned int defaultLevelLogfile = 3;
    136             const unsigned int defaultLevelShell   = 1;
    137 #else
    138             const unsigned int defaultLevelConsole = 3;
    139             const unsigned int defaultLevelLogfile = 4;
    140             const unsigned int defaultLevelShell   = 3;
    141 #endif
    142             SetConfigValue(softDebugLevelConsole_, defaultLevelConsole)
    143                 .description("The maximal level of debug output shown in the console")
    144                 .callback(this, &CoreConfiguration::debugLevelChanged);
    145             SetConfigValue(softDebugLevelLogfile_, defaultLevelLogfile)
    146                 .description("The maximal level of debug output shown in the logfile")
    147                 .callback(this, &CoreConfiguration::debugLevelChanged);
    148             SetConfigValue(softDebugLevelShell_, defaultLevelShell)
    149                 .description("The maximal level of debug output shown in the ingame shell")
    150                 .callback(this, &CoreConfiguration::debugLevelChanged);
    151 
    152             SetConfigValue(language_, Language::getInstance().defaultLanguage_)
    153                 .description("The language of the ingame text")
    154                 .callback(this, &CoreConfiguration::languageChanged);
    155             SetConfigValue(bInitializeRandomNumberGenerator_, true)
    156                 .description("If true, all random actions are different each time you start the game")
    157                 .callback(this, &CoreConfiguration::initializeRandomNumberGenerator);
    158         }
    159 
    160         /**
    161             @brief Callback function if the debug level has changed.
    162         */
    163         void debugLevelChanged()
    164         {
    165             // softDebugLevel_ is the maximum of the 3 variables
    166             this->softDebugLevel_ = this->softDebugLevelConsole_;
    167             if (this->softDebugLevelLogfile_ > this->softDebugLevel_)
    168                 this->softDebugLevel_ = this->softDebugLevelLogfile_;
    169             if (this->softDebugLevelShell_ > this->softDebugLevel_)
    170                 this->softDebugLevel_ = this->softDebugLevelShell_;
    171 
    172             OutputHandler::setSoftDebugLevel(OutputHandler::LD_All,     this->softDebugLevel_);
    173             OutputHandler::setSoftDebugLevel(OutputHandler::LD_Console, this->softDebugLevelConsole_);
    174             OutputHandler::setSoftDebugLevel(OutputHandler::LD_Logfile, this->softDebugLevelLogfile_);
    175             OutputHandler::setSoftDebugLevel(OutputHandler::LD_Shell,   this->softDebugLevelShell_);
    176         }
    177 
    178         /**
    179             @brief Callback function if the language has changed.
    180         */
    181         void languageChanged()
    182         {
    183             // Read the translation file after the language was configured
    184             Language::getInstance().readTranslatedLanguageFile();
    185         }
    186 
    187         /**
    188             @brief Sets the language in the config-file back to the default.
    189         */
    190         void resetLanguage()
    191         {
    192             ResetConfigValue(language_);
    193         }
    194 
    195         /**
    196         @brief
    197             Temporary sets the external data path
    198         @param path
    199             The new data path
    200         */
    201         void tsetExternalDataPath(const std::string& path)
    202         {
    203             externalDataPath_ = boost::filesystem::path(path);
    204         }
    205 
    206         void initializeRandomNumberGenerator()
    207         {
    208             static bool bInitialized = false;
    209             if (!bInitialized && this->bInitializeRandomNumberGenerator_)
    210             {
    211                 srand(static_cast<unsigned int>(time(0)));
    212                 rand();
    213                 bInitialized = true;
    214             }
    215         }
    216 
    217         int softDebugLevel_;                            //!< The debug level
    218         int softDebugLevelConsole_;                     //!< The debug level for the console
    219         int softDebugLevelLogfile_;                     //!< The debug level for the logfile
    220         int softDebugLevelShell_;                       //!< The debug level for the ingame shell
    221         std::string language_;                          //!< The language
    222         bool bInitializeRandomNumberGenerator_;         //!< If true, srand(time(0)) is called
    223 
    224         //! Path to the parent directory of the ones above if program was installed with relativ pahts
    225         boost::filesystem::path rootPath_;
    226         boost::filesystem::path executablePath_;        //!< Path to the executable
    227         boost::filesystem::path modulePath_;            //!< Path to the modules
    228         boost::filesystem::path dataPath_;              //!< Path to the data file folder
    229         boost::filesystem::path externalDataPath_;      //!< Path to the external data file folder
    230         boost::filesystem::path configPath_;            //!< Path to the config file folder
    231         boost::filesystem::path logPath_;               //!< Path to the log file folder
    232     };
    233 
    234 
    235     Core::Core(const std::string& cmdLine)
    236         // Cleanup guard for identifier destruction (incl. XMLPort, configValues, consoleCommands)
    237         : identifierDestroyer_(Identifier::destroyAllIdentifiers)
    238         // Cleanup guard for external console commands that don't belong to an Identifier
    239         , consoleCommandDestroyer_(CommandExecutor::destroyExternalCommands)
    240         , configuration_(new CoreConfiguration()) // Don't yet create config values!
     74
     75    PathConfig::PathConfig()
     76        : rootPath_(*(new bf::path()))
     77        , executablePath_(*(new bf::path()))
     78        , modulePath_(*(new bf::path()))
     79        , dataPath_(*(new bf::path()))
     80        , externalDataPath_(*(new bf::path()))
     81        , configPath_(*(new bf::path()))
     82        , logPath_(*(new bf::path()))
    24183        , bDevRun_(false)
    242         , bGraphicsLoaded_(false)
    243     {
    244         // Set the hard coded fixed paths
    245         this->setFixedPaths();
    246 
    247         // Create a new dynamic library manager
    248         this->dynLibManager_.reset(new DynLibManager());
    249 
    250         // Load modules
    251         try
    252         {
    253             // We search for helper files with the following extension
    254             std::string moduleextension = specialConfig::moduleExtension;
    255             size_t moduleextensionlength = moduleextension.size();
    256 
    257             // Search in the directory of our executable
    258             boost::filesystem::path searchpath = this->configuration_->modulePath_;
    259 
    260             // Add that path to the PATH variable in case a module depends on another one
    261             std::string pathVariable = getenv("PATH");
    262             putenv(const_cast<char*>(("PATH=" + pathVariable + ";" + configuration_->modulePath_.string()).c_str()));
    263 
    264             boost::filesystem::directory_iterator file(searchpath);
    265             boost::filesystem::directory_iterator end;
    266 
    267             // Iterate through all files
    268             while (file != end)
    269             {
    270                 std::string filename = file->BOOST_LEAF_FUNCTION();
    271 
    272                 // Check if the file ends with the exension in question
    273                 if (filename.size() > moduleextensionlength)
    274                 {
    275                     if (filename.substr(filename.size() - moduleextensionlength) == moduleextension)
    276                     {
    277                         // We've found a helper file - now load the library with the same name
    278                         std::string library = filename.substr(0, filename.size() - moduleextensionlength);
    279                         boost::filesystem::path librarypath = searchpath / library;
    280 
    281                         try
    282                         {
    283                             DynLibManager::getInstance().load(librarypath.string());
    284                         }
    285                         catch (...)
    286                         {
    287                             COUT(1) << "Couldn't load module \"" << librarypath.string() << "\": " << Exception::handleMessage() << std::endl;
    288                         }
    289                     }
    290                 }
    291 
    292                 ++file;
    293             }
    294         }
    295         catch (...)
    296         {
    297             COUT(1) << "An error occurred while loading modules: " << Exception::handleMessage() << std::endl;
    298         }
    299 
    300         // Parse command line arguments AFTER the modules have been loaded (static code!)
    301         CommandLine::parseCommandLine(cmdLine);
    302 
    303         // Set configurable paths like log, config and media
    304         this->setConfigurablePaths();
    305 
    306         // create a signal handler (only active for linux)
    307         // This call is placed as soon as possible, but after the directories are set
    308         this->signalHandler_.reset(new SignalHandler());
    309         this->signalHandler_->doCatch(configuration_->executablePath_.string(), Core::getLogPathString() + "orxonox_crash.log");
    310 
    311         // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% was used
    312         OutputHandler::getOutStream().setLogPath(Core::getLogPathString());
    313 
    314         // Parse additional options file now that we know its path
    315         CommandLine::parseFile();
    316 
    317 #ifdef ORXONOX_PLATFORM_WINDOWS
    318         // limit the main thread to the first core so that QueryPerformanceCounter doesn't jump
    319         // do this after ogre has initialised. Somehow Ogre changes the settings again (not through
    320         // the timer though).
    321         int limitToCPU = CommandLine::getValue("limitToCPU");
    322         if (limitToCPU > 0)
    323             setThreadAffinity(static_cast<unsigned int>(limitToCPU));
    324 #endif
    325 
    326         // Manage ini files and set the default settings file (usually orxonox.ini)
    327         this->configFileManager_.reset(new ConfigFileManager());
    328         this->configFileManager_->setFilename(ConfigFileType::Settings,
    329             CommandLine::getValue("settingsFile").getString());
    330 
    331         // Required as well for the config values
    332         this->languageInstance_.reset(new Language());
    333 
    334         // creates the class hierarchy for all classes with factories
    335         Identifier::createClassHierarchy();
    336 
    337         // Do this soon after the ConfigFileManager has been created to open up the
    338         // possibility to configure everything below here
    339         this->configuration_->initialise();
    340 
    341         // Load OGRE excluding the renderer and the render window
    342         this->graphicsManager_.reset(new GraphicsManager(false));
    343 
    344         // initialise Tcl
    345         this->tclBind_.reset(new TclBind(Core::getDataPathString()));
    346         this->tclThreadManager_.reset(new TclThreadManager(tclBind_->getTclInterpreter()));
    347 
    348         // create a shell
    349         this->shell_.reset(new Shell());
    350     }
    351 
    352     /**
    353     @brief
    354         All destruction code is handled by scoped_ptrs and ScopeGuards.
    355     */
    356     Core::~Core()
    357     {
    358     }
    359 
    360     void Core::loadGraphics()
    361     {
    362         // Any exception should trigger this, even in upgradeToGraphics (see its remarks)
    363         Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics);
    364 
    365         // Upgrade OGRE to receive a render window
    366         graphicsManager_->upgradeToGraphics();
    367 
    368         // Calls the InputManager which sets up the input devices.
    369         inputManager_.reset(new InputManager());
    370 
    371         // load the CEGUI interface
    372         guiManager_.reset(new GUIManager(graphicsManager_->getRenderWindow(),
    373             inputManager_->getMousePosition(), graphicsManager_->isFullScreen()));
    374 
    375         unloader.Dismiss();
    376 
    377         bGraphicsLoaded_ = true;
    378     }
    379 
    380     void Core::unloadGraphics()
    381     {
    382         this->guiManager_.reset();;
    383         this->inputManager_.reset();;
    384         this->graphicsManager_.reset();
    385 
    386         // Load Ogre::Root again, but without the render system
    387         try
    388             { this->graphicsManager_.reset(new GraphicsManager(false)); }
    389         catch (...)
    390         {
    391             COUT(0) << "An exception occurred during 'unloadGraphics':" << Exception::handleMessage() << std::endl
    392                     << "Another exception might be being handled which may lead to undefined behaviour!" << std::endl
    393                     << "Terminating the program." << std::endl;
    394             abort();
    395         }
    396 
    397         bGraphicsLoaded_ = false;
    398     }
    399 
    400     /**
    401         @brief Returns the softDebugLevel for the given device (returns a default-value if the class is right about to be created).
    402         @param device The device
    403         @return The softDebugLevel
    404     */
    405     /*static*/ int Core::getSoftDebugLevel(OutputHandler::OutputDevice device)
    406     {
    407         switch (device)
    408         {
    409         case OutputHandler::LD_All:
    410             return Core::getInstance().configuration_->softDebugLevel_;
    411         case OutputHandler::LD_Console:
    412             return Core::getInstance().configuration_->softDebugLevelConsole_;
    413         case OutputHandler::LD_Logfile:
    414             return Core::getInstance().configuration_->softDebugLevelLogfile_;
    415         case OutputHandler::LD_Shell:
    416             return Core::getInstance().configuration_->softDebugLevelShell_;
    417         default:
    418             assert(0);
    419             return 2;
    420         }
    421     }
    422 
    423      /**
    424         @brief Sets the softDebugLevel for the given device. Please use this only temporary and restore the value afterwards, as it overrides the configured value.
    425         @param device The device
    426         @param level The level
    427     */
    428     /*static*/ void Core::setSoftDebugLevel(OutputHandler::OutputDevice device, int level)
    429     {
    430         if (device == OutputHandler::LD_All)
    431             Core::getInstance().configuration_->softDebugLevel_ = level;
    432         else if (device == OutputHandler::LD_Console)
    433             Core::getInstance().configuration_->softDebugLevelConsole_ = level;
    434         else if (device == OutputHandler::LD_Logfile)
    435             Core::getInstance().configuration_->softDebugLevelLogfile_ = level;
    436         else if (device == OutputHandler::LD_Shell)
    437             Core::getInstance().configuration_->softDebugLevelShell_ = level;
    438 
    439         OutputHandler::setSoftDebugLevel(device, level);
    440     }
    441 
    442     /**
    443         @brief Returns the configured language.
    444     */
    445     /*static*/ const std::string& Core::getLanguage()
    446     {
    447         return Core::getInstance().configuration_->language_;
    448     }
    449 
    450     /**
    451         @brief Sets the language in the config-file back to the default.
    452     */
    453     /*static*/ void Core::resetLanguage()
    454     {
    455         Core::getInstance().configuration_->resetLanguage();
    456     }
    457 
    458     /*static*/ void Core::tsetExternalDataPath(const std::string& path)
    459     {
    460         getInstance().configuration_->tsetExternalDataPath(path);
    461     }
    462 
    463     /*static*/ const boost::filesystem::path& Core::getDataPath()
    464     {
    465         return getInstance().configuration_->dataPath_;
    466     }
    467     /*static*/ std::string Core::getDataPathString()
    468     {
    469         return getInstance().configuration_->dataPath_.string() + '/';
    470     }
    471 
    472     /*static*/ const boost::filesystem::path& Core::getExternalDataPath()
    473     {
    474         return getInstance().configuration_->externalDataPath_;
    475     }
    476     /*static*/ std::string Core::getExternalDataPathString()
    477     {
    478         return getInstance().configuration_->externalDataPath_.string() + '/';
    479     }
    480 
    481     /*static*/ const boost::filesystem::path& Core::getConfigPath()
    482     {
    483         return getInstance().configuration_->configPath_;
    484     }
    485     /*static*/ std::string Core::getConfigPathString()
    486     {
    487         return getInstance().configuration_->configPath_.string() + '/';
    488     }
    489 
    490     /*static*/ const boost::filesystem::path& Core::getLogPath()
    491     {
    492         return getInstance().configuration_->logPath_;
    493     }
    494     /*static*/ std::string Core::getLogPathString()
    495     {
    496         return getInstance().configuration_->logPath_.string() + '/';
    497     }
    498 
    499     /*static*/ const boost::filesystem::path& Core::getRootPath()
    500     {
    501         return getInstance().configuration_->rootPath_;
    502     }
    503     /*static*/ std::string Core::getRootPathString()
    504     {
    505         return getInstance().configuration_->rootPath_.string() + '/';
    506     }
    507 
    508     /**
    509     @note
    510         The code of this function has been copied and adjusted from OGRE, an open source graphics engine.
    511             (Object-oriented Graphics Rendering Engine)
    512         For the latest info, see http://www.ogre3d.org/
    513 
    514         Copyright (c) 2000-2008 Torus Knot Software Ltd
    515 
    516         OGRE is licensed under the LGPL. For more info, see OGRE license.
    517     */
    518     void Core::setThreadAffinity(int limitToCPU)
    519     {
    520 #ifdef ORXONOX_PLATFORM_WINDOWS
    521 
    522         if (limitToCPU <= 0)
    523             return;
    524 
    525         unsigned int coreNr = limitToCPU - 1;
    526         // Get the current process core mask
    527         DWORD procMask;
    528         DWORD sysMask;
    529 #  if _MSC_VER >= 1400 && defined (_M_X64)
    530         GetProcessAffinityMask(GetCurrentProcess(), (PDWORD_PTR)&procMask, (PDWORD_PTR)&sysMask);
    531 #  else
    532         GetProcessAffinityMask(GetCurrentProcess(), &procMask, &sysMask);
    533 #  endif
    534 
    535         // If procMask is 0, consider there is only one core available
    536         // (using 0 as procMask will cause an infinite loop below)
    537         if (procMask == 0)
    538             procMask = 1;
    539 
    540         // if the core specified with coreNr is not available, take the lowest one
    541         if (!(procMask & (1 << coreNr)))
    542             coreNr = 0;
    543 
    544         // Find the lowest core that this process uses and coreNr suggests
    545         DWORD threadMask = 1;
    546         while ((threadMask & procMask) == 0 || (threadMask < (1u << coreNr)))
    547             threadMask <<= 1;
    548 
    549         // Set affinity to the first core
    550         SetThreadAffinityMask(GetCurrentThread(), threadMask);
    551 #endif
    552     }
    553 
    554     /**
    555     @brief
    556         Retrievs the executable path and sets all hard coded fixed path (currently only the module path)
    557         Also checks for "orxonox_dev_build.keep_me" in the executable diretory.
    558         If found it means that this is not an installed run, hence we
    559         don't write the logs and config files to ~/.orxonox
    560     @throw
    561         GeneralException
    562     */
    563     void Core::setFixedPaths()
    56484    {
    56585        //////////////////////////
    … …  
    605125#endif
    606126
    607         configuration_->executablePath_ = boost::filesystem::path(buffer);
     127        executablePath_ = bf::path(buffer);
    608128#ifndef ORXONOX_PLATFORM_APPLE
    609         configuration_->executablePath_ = configuration_->executablePath_.branch_path(); // remove executable name
     129        executablePath_ = executablePath_.branch_path(); // remove executable name
    610130#endif
    611131
    … …  
    614134        /////////////////////
    615135
    616         if (boost::filesystem::exists(configuration_->executablePath_ / "orxonox_dev_build.keep_me"))
     136        if (bf::exists(executablePath_ / "orxonox_dev_build.keep_me"))
    617137        {
    618138            COUT(1) << "Running from the build tree." << std::endl;
    619             Core::bDevRun_ = true;
    620             configuration_->modulePath_ = specialConfig::moduleDevDirectory;
     139            PathConfig::bDevRun_ = true;
     140            modulePath_ = specialConfig::moduleDevDirectory;
    621141        }
    622142        else
    … …  
    626146
    627147            // Also set the root path
    628             boost::filesystem::path relativeExecutablePath(specialConfig::defaultRuntimePath);
    629             configuration_->rootPath_ = configuration_->executablePath_;
    630             while (!boost::filesystem::equivalent(configuration_->rootPath_ / relativeExecutablePath, configuration_->executablePath_)
    631                    && !configuration_->rootPath_.empty())
    632                 configuration_->rootPath_ = configuration_->rootPath_.branch_path();
    633             if (configuration_->rootPath_.empty())
     148            bf::path relativeExecutablePath(specialConfig::defaultRuntimePath);
     149            rootPath_ = executablePath_;
     150            while (!bf::equivalent(rootPath_ / relativeExecutablePath, executablePath_) && !rootPath_.empty())
     151                rootPath_ = rootPath_.branch_path();
     152            if (rootPath_.empty())
    634153                ThrowException(General, "Could not derive a root directory. Might the binary installation directory contain '..' when taken relative to the installation prefix path?");
    635154
    636155            // Module path is fixed as well
    637             configuration_->modulePath_ = configuration_->rootPath_ / specialConfig::defaultModulePath;
     156            modulePath_ = rootPath_ / specialConfig::defaultModulePath;
    638157
    639158#else
    … …  
    641160            // There is no root path, so don't set it at all
    642161            // Module path is fixed as well
    643             configuration_->modulePath_ = specialConfig::moduleInstallDirectory;
    644 
    645 #endif
    646         }
    647     }
    648 
    649     /**
    650     @brief
    651         Sets config, log and media path and creates folders if necessary.
    652     @throws
    653         GeneralException
    654     */
    655     void Core::setConfigurablePaths()
    656     {
    657         if (Core::isDevelopmentRun())
    658         {
    659             configuration_->dataPath_  = specialConfig::dataDevDirectory;
    660             configuration_->externalDataPath_ = specialConfig::externalDataDevDirectory;
    661             configuration_->configPath_ = specialConfig::configDevDirectory;
    662             configuration_->logPath_    = specialConfig::logDevDirectory;
     162            modulePath_ = specialConfig::moduleInstallDirectory;
     163
     164#endif
     165        }
     166    }
     167
     168    PathConfig::~PathConfig()
     169    {
     170        delete &rootPath_;
     171        delete &executablePath_;
     172        delete &modulePath_;
     173        delete &dataPath_;
     174        delete &externalDataPath_;
     175        delete &configPath_;
     176        delete &logPath_;
     177    }
     178
     179    void PathConfig::setConfigurablePaths()
     180    {
     181        if (bDevRun_)
     182        {
     183            dataPath_         = specialConfig::dataDevDirectory;
     184            configPath_       = specialConfig::configDevDirectory;
     185            logPath_          = specialConfig::logDevDirectory;
     186
     187            // Check for data path override by the command line
     188            if (!CommandLine::getArgument("externalDataPath")->hasDefaultValue())
     189                externalDataPath_ = CommandLine::getValue("externalDataPath").getString();
     190            else
     191                externalDataPath_ = specialConfig::externalDataDevDirectory;
    663192        }
    664193        else
    … …  
    668197
    669198            // Using paths relative to the install prefix, complete them
    670             configuration_->dataPath_   = configuration_->rootPath_ / specialConfig::defaultDataPath;
    671             configuration_->configPath_ = configuration_->rootPath_ / specialConfig::defaultConfigPath;
    672             configuration_->logPath_    = configuration_->rootPath_ / specialConfig::defaultLogPath;
     199            dataPath_   = rootPath_ / specialConfig::defaultDataPath;
     200            configPath_ = rootPath_ / specialConfig::defaultConfigPath;
     201            logPath_    = rootPath_ / specialConfig::defaultLogPath;
    673202
    674203#else
    675204
    676             configuration_->dataPath_  = specialConfig::dataInstallDirectory;
     205            dataPath_  = specialConfig::dataInstallDirectory;
    677206
    678207            // Get user directory
    … …  
    684213            if (userDataPathPtr == NULL)
    685214                ThrowException(General, "Could not retrieve user data path.");
    686             boost::filesystem::path userDataPath(userDataPathPtr);
     215            bf::path userDataPath(userDataPathPtr);
    687216            userDataPath /= ".orxonox";
    688217
    689             configuration_->configPath_ = userDataPath / specialConfig::defaultConfigPath;
    690             configuration_->logPath_    = userDataPath / specialConfig::defaultLogPath;
     218            configPath_ = userDataPath / specialConfig::defaultConfigPath;
     219            logPath_    = userDataPath / specialConfig::defaultLogPath;
    691220
    692221#endif
    … …  
    698227        {
    699228            std::string directory(CommandLine::getValue("writingPathSuffix").getString());
    700             configuration_->configPath_ = configuration_->configPath_ / directory;
    701             configuration_->logPath_    = configuration_->logPath_    / directory;
     229            configPath_ = configPath_ / directory;
     230            logPath_    = logPath_    / directory;
    702231        }
    703232
    704233        // Create directories to avoid problems when opening files in non existent folders.
    705         std::vector<std::pair<boost::filesystem::path, std::string> > directories;
    706         directories.push_back(std::make_pair(boost::filesystem::path(configuration_->configPath_), "config"));
    707         directories.push_back(std::make_pair(boost::filesystem::path(configuration_->logPath_), "log"));
    708 
    709         for (std::vector<std::pair<boost::filesystem::path, std::string> >::iterator it = directories.begin();
     234        std::vector<std::pair<bf::path, std::string> > directories;
     235        directories.push_back(std::make_pair(bf::path(configPath_), "config"));
     236        directories.push_back(std::make_pair(bf::path(logPath_), "log"));
     237
     238        for (std::vector<std::pair<bf::path, std::string> >::iterator it = directories.begin();
    710239            it != directories.end(); ++it)
    711240        {
    712             if (boost::filesystem::exists(it->first) && !boost::filesystem::is_directory(it->first))
     241            if (bf::exists(it->first) && !bf::is_directory(it->first))
    713242            {
    714243                ThrowException(General, std::string("The ") + it->second + " directory has been preoccupied by a file! \
    715244                                         Please remove " + it->first.string());
    716245            }
    717             if (boost::filesystem::create_directories(it->first)) // function may not return true at all (bug?)
     246            if (bf::create_directories(it->first)) // function may not return true at all (bug?)
    718247            {
    719248                COUT(4) << "Created " << it->second << " directory" << std::endl;
    … …  
    722251    }
    723252
    724     void Core::preUpdate(const Clock& time)
    725     {
    726         if (this->bGraphicsLoaded_)
    727         {
    728             // process input events
    729             this->inputManager_->update(time);
    730             // process gui events
    731             this->guiManager_->update(time);
    732         }
    733         // process thread commands
    734         this->tclThreadManager_->update(time);
    735     }
    736 
    737     void Core::postUpdate(const Clock& time)
    738     {
    739         if (this->bGraphicsLoaded_)
    740         {
    741             // Render (doesn't throw)
    742             this->graphicsManager_->update(time);
    743         }
     253    std::vector<std::string> PathConfig::getModulePaths()
     254    {
     255        std::vector<std::string> modulePaths;
     256
     257        // We search for helper files with the following extension
     258        std::string moduleextension = specialConfig::moduleExtension;
     259        size_t moduleextensionlength = moduleextension.size();
     260
     261        // Add that path to the PATH variable in case a module depends on another one
     262        std::string pathVariable = getenv("PATH");
     263        putenv(const_cast<char*>(("PATH=" + pathVariable + ";" + modulePath_.string()).c_str()));
     264
     265        boost::filesystem::directory_iterator file(modulePath_);
     266        boost::filesystem::directory_iterator end;
     267
     268        // Iterate through all files
     269        while (file != end)
     270        {
     271            std::string filename = file->BOOST_LEAF_FUNCTION();
     272
     273            // Check if the file ends with the exension in question
     274            if (filename.size() > moduleextensionlength)
     275            {
     276                if (filename.substr(filename.size() - moduleextensionlength) == moduleextension)
     277                {
     278                    // We've found a helper file
     279                    std::string library = filename.substr(0, filename.size() - moduleextensionlength);
     280                    modulePaths.push_back((modulePath_ / library).string());
     281                }
     282            }
     283            ++file;
     284        }
     285
     286        return modulePaths;
     287    }
     288
     289    /*static*/ std::string PathConfig::getRootPathString()
     290    {
     291        return getInstance().rootPath_.string() + '/';
     292    }
     293
     294    /*static*/ std::string PathConfig::getExecutablePathString()
     295    {
     296        return getInstance().executablePath_.string() + '/';
     297    }
     298
     299    /*static*/ std::string PathConfig::getDataPathString()
     300    {
     301        return getInstance().dataPath_.string() + '/';
     302    }
     303
     304    /*static*/ std::string PathConfig::getExternalDataPathString()
     305    {
     306        return getInstance().externalDataPath_.string() + '/';
     307    }
     308
     309    /*static*/ std::string PathConfig::getConfigPathString()
     310    {
     311        return getInstance().configPath_.string() + '/';
     312    }
     313
     314    /*static*/ std::string PathConfig::getLogPathString()
     315    {
     316        return getInstance().logPath_.string() + '/';
     317    }
     318
     319    /*static*/ std::string PathConfig::getModulePathString()
     320    {
     321        return getInstance().modulePath_.string() + '/';
    744322    }
    745323}
Note: See TracChangeset for help on using the changeset viewer.