Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Feb 27, 2009, 2:13:29 PM (16 years ago)
Author:
rgrieder
Message:

Completed work on installation:

  • The CMake switch INSTALL_COPYABLE tells whether you will be able to move the installed directory or not. If TRUE then all folders, including log and config directory, will be put into the CMAKE_INSTALL_PREFIX. Furthermore, relative paths are used, which get resolved at run time.
  • If INSTALL_COPYABLE is set to FALSE, the standard operating system directories will be used. That also means on Windows files get written to the Application Data/.orxonox folder instead of Program Files/Orxonox
  • Default configuration is INSTALL_COPYABLE=TRUE for Windows and FALSE for Unix
  • Split OrxonoxConfig.h.in in two to avoid complete recompiles when changing only a path or INSTALL_COPYABLE
  • Added a global constant character: CP_SLASH which stands for cross platform slash, meaning '/' on Unix and '
    ' on Windows
  • Core class now has methods getFooPath(), getFooPathString() and getFooPathPOSIXString() where Foo can be Media, Log or Config
  • getFooPathPOSIXString() will always return a directory formatted with slashes, even on Windows
  • getFooPath() returns a reference to the boost::filesystem::path
  • boost/filesystem.hpp does not get included to Core.h because it has a very large rat tail
  • The platform specific directory stuff gets done in Core::postMainInitialisation()
  • Adjusted all classes using the media path
Location:
code/branches/buildsystem3/src
Files:
17 edited
1 copied

Legend:

Unmodified
Added
Removed

  • code/branches/buildsystem3/src/CMakeLists.txt

    r2690 r2702  
    6262CHECK_CXX_SOURCE_COMPILES("${_source}" HAVE_FORCEINLINE)
    6363
    64 # Check ciso646 include (operators in words)
     64# Check ciso646 include (literal operators)
    6565INCLUDE(CheckIncludeFileCXX)
    6666CHECK_INCLUDE_FILE_CXX(iso646.h HAVE_ISO646_H)
    … …  
    7878# Copy and configure OrxonoxConfig which gets included in every file
    7979CONFIGURE_FILE(OrxonoxConfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/OrxonoxConfig.h)
     80# This file only gets included by very few classes to avoid a large recompilation
     81CONFIGURE_FILE(SpecialConfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/SpecialConfig.h)
    8082
    8183

  • code/branches/buildsystem3/src/OrxonoxConfig.h.in

    r2688 r2702  
    180180 * Various Settings
    181181 *-------------------------------*/
    182 /* Set whether we must suffix "ceguilua/" for the CEGUILua.h include */
    183 #cmakedefine CEGUILUA_USE_INTERNAL_LIBRARY
    184 
    185 /* Defined if a precompiled depdency package was used. We then copy all libraries
    186    too when installing. */
    187 #cmakedefine DEPENDENCY_PACKAGE_ENABLE
    188 
    189 /* Using MSVC or XCode IDE */
    190 #cmakedefine CMAKE_CONFIGURATION_TYPES
    191 
    192 /* Macros used in the next section */
    193 #define MACRO_CONCATENATE(str1, str2) str1##str2
    194 #define MACRO_QUOTEME_AUX(x) #x
    195 #define MACRO_QUOTEME(x) MACRO_QUOTEME_AUX(x)
    196 
    197 /* Handle default ConfigValues */
     182/* Define a platform independent directory separator */
    198183namespace orxonox
    199184{
    200     const char* const ORXONOX_MEDIA_INSTALL_PATH ("@ORXONOX_MEDIA_INSTALL_PATH_EXEC@/");
    201     const char* const ORXONOX_CONFIG_INSTALL_PATH("@ORXONOX_CONFIG_INSTALL_PATH_EXEC@/");
    202     const char* const ORXONOX_LOG_INSTALL_PATH   ("@ORXONOX_LOG_INSTALL_PATH_EXEC@/");
    203 
    204     const char* const ORXONOX_MEDIA_DEV_PATH     ("@ORXONOX_MEDIA_DEV_PATH@/");
    205 #ifdef CMAKE_CONFIGURATION_TYPES
    206     const char* const ORXONOX_CONFIG_DEV_PATH    ("@ORXONOX_CONFIG_DEV_PATH@/" MACRO_QUOTEME(CMAKE_BUILD_TYPE) "/");
    207     const char* const ORXONOX_LOG_DEV_PATH       ("@ORXONOX_LOG_DEV_PATH@/"    MACRO_QUOTEME(CMAKE_BUILD_TYPE) "/");
     185#ifdef ORXONOX_PLATFORM_WINDOWS
     186    const char CP_SLASH('\\');
    208187#else
    209     const char* const ORXONOX_CONFIG_DEV_PATH    ("@ORXONOX_CONFIG_DEV_PATH@/");
    210     const char* const ORXONOX_LOG_DEV_PATH       ("@ORXONOX_LOG_DEV_PATH@/");
    211 #endif
    212    
    213     /* OGRE Plugins */
    214 #ifdef NDEBUG
    215     const char* const ORXONOX_OGRE_PLUGINS("@OGRE_PLUGINS_RELEASE@");
    216 #  ifdef DEPENDENCY_PACKAGE_ENABLE
    217     const char* const ORXONOX_OGRE_PLUGINS_FOLDER(".");
    218 #  else
    219     const char* const ORXONOX_OGRE_PLUGINS_FOLDER("@OGRE_PLUGINS_FOLDER_RELEASE@");
    220 #  endif
    221 #else
    222     const char* const ORXONOX_OGRE_PLUGINS("@OGRE_PLUGINS_DEBUG@");
    223 #  ifdef DEPENDENCY_PACKAGE_ENABLE
    224     const char* const ORXONOX_OGRE_PLUGINS_FOLDER(".");
    225 #  else
    226     const char* const ORXONOX_OGRE_PLUGINS_FOLDER("@OGRE_PLUGINS_FOLDER_DEBUG@");
    227 #  endif
     188    const char CP_SLASH('/')
    228189#endif
    229190}
    230191
     192
    231193#endif /* _OrxonoxConfig_H__ */

  • code/branches/buildsystem3/src/SpecialConfig.h.in

    r2699 r2702  
    2525 *      ...
    2626 *
    27  *   Original code: OgrePlatform.h, licensed under the LGPL. The code
    28  *   has changed almost completely though.
    29  *
    30  *   Caution: Do not configure this file CMake configuration (Debug, Release, etc.)
    31  *            dependent! XCode and Visual Studio have the same file for all.
    32  *
    3327 */
    3428
    … …  
    3630 @file
    3731 @brief
    38     Various constants for compiler, architecture and platform.
     32    Various constants and options that only affect very little code.
     33 @note
     34    This is merely to avoid recompiling everything when only a path changes.
    3935
    4036    @GENERATED_FILE_COMMENT@
    4137 */
    4238
    43 #ifndef _OrxonoxConfig_H__
    44 #define _OrxonoxConfig_H__
     39#ifndef _SpecialConfig_H__
     40#define _SpecialConfig_H__
    4541
    46 /*---------------------------------
    47  * Platform and compiler related options
    48  *-------------------------------*/
    49 #cmakedefine ORXONOX_PLATFORM_WINDOWS
    50 #cmakedefine ORXONOX_PLATFORM_LINUX
    51 #cmakedefine ORXONOX_PLATFORM_APPLE
    52 #cmakedefine ORXONOX_PLATFORM_UNIX /* Apple and Linux */
    53 
    54 /* Determine compiler and set ORXONOX_COMP_VER */
    55 #if defined( _MSC_VER )
    56 #  define ORXONOX_COMPILER_MSVC
    57 #  define ORXONOX_COMP_VER _MSC_VER
    58 
    59 #elif defined( __GNUC__ )
    60 #  define ORXONOX_COMPILER_GCC
    61 #  define ORXONOX_COMP_VER (((__GNUC__)*100) + \
    62         (__GNUC_MINOR__*10) + \
    63         __GNUC_PATCHLEVEL__)
    64 #  if defined(__MINGW32__)
    65 #    define ORXONOX_COMPILER_MINGW
    66 #  endif
    67 
    68 #elif defined( __BORLANDC__ )
    69 #  define ORXONOX_COMPILER_BORLAND
    70 #  define ORXONOX_COMP_VER __BCPLUSPLUS__
    71 
    72 #else
    73 #  pragma error "No known compiler. Abort!"
    74 
    75 #endif
    76 
    77 /* Endianness */
    78 #cmakedefine ORXONOX_BIG_ENDIAN
    79 #cmakedefine ORXONOX_LITTLE_ENDIAN
    80 
    81 /* Architecture */
    82 #cmakedefine ORXONOX_ARCH_32
    83 #cmakedefine ORXONOX_ARCH_64
    84 
    85 /* See if we can use __forceinline or if we need to use __inline instead */
    86 #cmakedefine HAVE_FORCEINLINE
    87 #ifdef HAVE_FORCEINLINE
    88 #  define FORCEINLINE __forceinline
    89 #else
    90 #  define FORCEINLINE __inline
    91 #endif
    92 
    93 /* Try to define function information */
    94 #ifndef __FUNCTIONNAME__
    95 #  ifdef ORXONOX_COMPILER_BORLAND
    96 #    define __FUNCTIONNAME__ __FUNC__
    97 #  elif defined(ORXONOX_COMPILER_GCC)
    98 #    define __FUNCTIONNAME__ __PRETTY_FUNCTION__
    99 #  elif defined(ORXONOX_COMPILER_MSVC)
    100 #    define __FUNCTIONNAME__ __FUNCTION__
    101 #  else
    102 #    define __FUNCTIONNAME__
    103 #  endif
    104 #endif
    105 
    106 
    107 /*---------------------------------
    108  * Version information
    109  *-------------------------------*/
    110 #define ORXONOX_VERSION_MAJOR @ORXONOX_VERSION_MAJOR@
    111 #define ORXONOX_VERSION_MINOR @ORXONOX_VERSION_MINOR@
    112 #define ORXONOX_VERSION_PATCH @ORXONOX_VERSION_PATCH@
    113 #define ORXONOX_VERSION_NAME "@ORXONOX_VERSION_NAME@"
    114 
    115 #define ORXONOX_VERSION ((ORXONOX_VERSION_MAJOR << 16) | (ORXONOX_VERSION_MINOR << 8) | ORXONOX_VERSION_PATCH)
    116 
    117 
    118 /*---------------------------------
    119  * Unix settings
    120  *-------------------------------*/
    121 #ifdef ORXONOX_PLATFORM_UNIX
    122 
    123 /* TODO: Check what this actually is and whether we need it or not */
    124 #if 0
    125 #  ifdef ORXONOX_PLATFORM_APPLE
    126 #    define ORXONOX_PLATFORM_LIB "OrxonoxPlatform.bundle"
    127 #  else
    128 /* ORXONOX_PLATFORM_LINUX */
    129 #    define ORXONOX_PLATFORM_LIB "libOrxonoxPlatform.so"
    130 #  endif
    131 #endif
    132 
    133 #endif /* Patform Unix */
    134 
    135 
    136 /*---------------------------------
    137  * Apple Settings
    138  *-------------------------------*/
    139 
    140 
    141 /*---------------------------------
    142  * Includes
    143  *-------------------------------*/
    144 /* Define the english written operators like and, or, xor
    145  * This is C++ standard, but the Microsoft compiler doesn't define them. */
    146 #cmakedefine HAVE_ISO646_H
    147 #ifdef HAVE_ISO646_H
    148 #  include <iso646.h>
    149 #endif
    150 
    151 #cmakedefine HAVE_STDINT_H
    152 #ifdef HAVE_STDINT_H
    153 #  include <stdint.h>
    154 #elif defined(ORXONOX_COMPILER_MSVC)
    155 typedef __int8            int8_t;
    156 typedef __int16           int16_t;
    157 typedef __int32           int32_t;
    158 typedef __int64           int64_t;
    159 typedef unsigned __int8   uint8_t;
    160 typedef unsigned __int16  uint16_t;
    161 typedef unsigned __int32  uint32_t;
    162 typedef unsigned __int64  uint64_t;
    163 #endif
    164 
    165 #cmakedefine HAVE_STDDEF_H
    166 /* Quite large, do not include unless necessary
    167 #ifdef HAVE_STDDEF_H
    168 #  include <stddef.h>
    169 #endif
    170 */
    171 
    172 /* Visual Leak Detector looks for memory leaks */
    173 #cmakedefine VISUAL_LEAK_DETECTOR_ENABLE
    174 #ifdef VISUAL_LEAK_DETECTOR_ENABLE
    175 #  include <vld.h>
    176 #endif
    177 
    178 
    179 /*---------------------------------
    180  * Various Settings
    181  *-------------------------------*/
    18242/* Set whether we must suffix "ceguilua/" for the CEGUILua.h include */
    18343#cmakedefine CEGUILUA_USE_INTERNAL_LIBRARY
    … …  
    18646   too when installing. */
    18747#cmakedefine DEPENDENCY_PACKAGE_ENABLE
     48
     49/* Orxonox either gets installed to the system or just into a folder.
     50   The latter uses relative paths. */
     51#cmakedefine INSTALL_COPYABLE
    18852
    18953/* Using MSVC or XCode IDE */
    … …  
    19862namespace orxonox
    19963{
    200     const char* const ORXONOX_MEDIA_INSTALL_PATH ("@ORXONOX_MEDIA_INSTALL_PATH_EXEC@/");
    201     const char* const ORXONOX_CONFIG_INSTALL_PATH("@ORXONOX_CONFIG_INSTALL_PATH_EXEC@/");
    202     const char* const ORXONOX_LOG_INSTALL_PATH   ("@ORXONOX_LOG_INSTALL_PATH_EXEC@/");
     64    const char* const ORXONOX_RUNTIME_INSTALL_PATH("@ORXONOX_RUNTIME_INSTALL_PATH@");
     65    const char* const ORXONOX_MEDIA_INSTALL_PATH  ("@ORXONOX_MEDIA_INSTALL_PATH@");
     66    /* Config and Log path might be relative because they could be user and therefore runtime dependent */
     67    const char* const ORXONOX_CONFIG_INSTALL_PATH ("@ORXONOX_CONFIG_INSTALL_PATH@");
     68    const char* const ORXONOX_LOG_INSTALL_PATH    ("@ORXONOX_LOG_INSTALL_PATH@");
    20369
    204     const char* const ORXONOX_MEDIA_DEV_PATH     ("@ORXONOX_MEDIA_DEV_PATH@/");
     70    const char* const ORXONOX_MEDIA_DEV_PATH      ("@CMAKE_MEDIA_OUTPUT_DIRECTORY@");
    20571#ifdef CMAKE_CONFIGURATION_TYPES
    206     const char* const ORXONOX_CONFIG_DEV_PATH    ("@ORXONOX_CONFIG_DEV_PATH@/" MACRO_QUOTEME(CMAKE_BUILD_TYPE) "/");
    207     const char* const ORXONOX_LOG_DEV_PATH       ("@ORXONOX_LOG_DEV_PATH@/"    MACRO_QUOTEME(CMAKE_BUILD_TYPE) "/");
     72    const char* const ORXONOX_CONFIG_DEV_PATH     ("@CMAKE_CONFIG_OUTPUT_DIRECTORY@/" MACRO_QUOTEME(CMAKE_BUILD_TYPE));
     73    const char* const ORXONOX_LOG_DEV_PATH        ("@CMAKE_LOG_OUTPUT_DIRECTORY@/"    MACRO_QUOTEME(CMAKE_BUILD_TYPE));
    20874#else
    209     const char* const ORXONOX_CONFIG_DEV_PATH    ("@ORXONOX_CONFIG_DEV_PATH@/");
    210     const char* const ORXONOX_LOG_DEV_PATH       ("@ORXONOX_LOG_DEV_PATH@/");
     75    const char* const ORXONOX_CONFIG_DEV_PATH     ("@CMAKE_CONFIG_OUTPUT_DIRECTORY@");
     76    const char* const ORXONOX_LOG_DEV_PATH        ("@CMAKE_LOG_OUTPUT_DIRECTORY@");
    21177#endif
    21278   
    … …  
    22995}
    23096
    231 #endif /* _OrxonoxConfig_H__ */
     97#endif /* _SpecialConfig_H__ */

  • code/branches/buildsystem3/src/core/ArgumentCompletionFunctions.cc

    r2664 r2702  
    2727 */
    2828
     29#include "ArgumentCompletionFunctions.h"
     30
    2931#include <iostream>
    3032#include <map>
    31 
    3233#include <boost/filesystem.hpp>
    3334
    34 #include "ArgumentCompletionFunctions.h"
    3535#include "CoreIncludes.h"
    3636#include "Identifier.h"
    … …  
    6868                    std::string dir = startdirectory.string();
    6969                    if (dir.size() > 0 && dir[dir.size() - 1] == ':')
    70                         startdirectory = dir + "/";
     70                        startdirectory = dir + CP_SLASH;
    7171                }
    7272#endif
    … …  
    7878                {
    7979                    if (boost::filesystem::is_directory(*file))
    80                         dirlist.push_back(ArgumentCompletionListElement((*file).string() + "/", getLowercase((*file).string()) + "/", (*file).leaf() + "/"));
     80                        dirlist.push_back(ArgumentCompletionListElement((*file).string() + CP_SLASH, getLowercase((*file).string()) + "/", (*file).leaf() + "/"));
    8181                    else
    8282                        filelist.push_back(ArgumentCompletionListElement((*file).string(), getLowercase((*file).string()), (*file).leaf()));

  • code/branches/buildsystem3/src/core/CommandLine.cc

    r2687 r2702  
    302302
    303303        std::string filename = CommandLine::getValue("optionsFile").getString();
    304         boost::filesystem::path folder(Core::getConfigPath());
    305         boost::filesystem::path filepath(folder/filename);
     304        boost::filesystem::path filepath(Core::getConfigPath() / filename);
    306305
    307306        // look for additional arguments in given file or start.ini as default

  • code/branches/buildsystem3/src/core/ConfigFileManager.cc

    r2690 r2702  
    227227
    228228        // Get default file if necessary and available
    229         boost::filesystem::path filepath(Core::getConfigPath());
    230         filepath /= this->filename_;
     229        boost::filesystem::path filepath(Core::getConfigPath() / this->filename_);
    231230        if (!boost::filesystem::exists(filepath))
    232231        {
    233232            // Try to get default one from the media folder
    234             boost::filesystem::path defaultFilepath(Core::getMediaPath());
    235             defaultFilepath = defaultFilepath / "defaultConfig" / this->filename_;
     233            boost::filesystem::path defaultFilepath(Core::getMediaPath() / "defaultConfig" / this->filename_);
    236234            if (boost::filesystem::exists(defaultFilepath))
    237235            {
    … …  
    345343    void ConfigFile::save() const
    346344    {
    347         boost::filesystem::path filepath(Core::getConfigPath());
    348         filepath /= this->filename_;
     345        boost::filesystem::path filepath(Core::getConfigPath() / this->filename_);
    349346
    350347        std::ofstream file;

  • code/branches/buildsystem3/src/core/Core.cc

    r2692 r2702  
    3333
    3434#include "Core.h"
     35
    3536#include <cassert>
    3637#include <fstream>
     38#include <cstdlib>
     39#include <cstdio>
    3740#include <boost/filesystem.hpp>
    3841
     42#ifdef ORXONOX_PLATFORM_WINDOWS
     43#  include <windows.h>
     44#elif defined(ORXONOX_PLATFORM_APPLE)
     45#  include <sys/param.h>
     46#  include <mach-o/dyld.h>
     47#else /* Linux */
     48#  include <sys/types.h>
     49#  include <unistd.h>
     50#endif
     51
     52#include "SpecialConfig.h"
    3953#include "util/Exception.h"
    4054#include "Language.h"
    … …  
    4660namespace orxonox
    4761{
     62    //! Path to the parent directory of the ones above if program was installed with relativ pahts
     63    static boost::filesystem::path rootPath_g;
     64    static boost::filesystem::path executablePath_g;            //!< Path to the executable
     65    static boost::filesystem::path mediaPath_g;                 //!< Path to the media file folder
     66    static boost::filesystem::path configPath_g;                //!< Path to the config file folder
     67    static boost::filesystem::path logPath_g;                   //!< Path to the log file folder
     68
    4869    bool Core::bShowsGraphics_s = false;
    4970    bool Core::bHasServer_s     = false;
    … …  
    5374
    5475    bool Core::isDevBuild_s     = false;
    55     std::string Core::configPath_s(ORXONOX_CONFIG_INSTALL_PATH); // from OrxonoxConfig.h
    56     std::string Core::logPath_s   (ORXONOX_LOG_INSTALL_PATH);    // from OrxonoxConfig.h
    57     std::string Core::mediaPath_s (ORXONOX_MEDIA_INSTALL_PATH);  // from OrxonoxConfig.h
    58 
    59     Core* Core::singletonRef_s = 0;
     76    Core* Core::singletonRef_s  = 0;
    6077
    6178    SetCommandLineArgument(mediaPath, "").information("PATH");
    … …  
    7693
    7794        // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% was used
    78         OutputHandler::getOutStream().setLogPath(Core::logPath_s);
     95        OutputHandler::getOutStream().setLogPath(Core::getLogPathString());
    7996
    8097        // Possible media path override by the command line
    8198        if (!CommandLine::getArgument("mediaPath")->hasDefaultValue())
    8299        {
    83             std::string mediaPath = CommandLine::getValue("mediaPath");
    84             Core::tsetMediaPath(mediaPath);
     100            //std::string mediaPath = CommandLine::getValue("mediaPath");
     101            Core::tsetMediaPath(CommandLine::getValue("mediaPath"));
    85102        }
    86103    }
    … …  
    119136        SetConfigValue(bInitializeRandomNumberGenerator_, true).description("If true, all random actions are different each time you start the game").callback(this, &Core::initializeRandomNumberGenerator);
    120137
    121         // Media path (towards config and log path) is ini-configurable
    122         const char* defaultMediaPath = ORXONOX_MEDIA_INSTALL_PATH;
    123         if (Core::isDevBuild())
    124             defaultMediaPath = ORXONOX_MEDIA_DEV_PATH;
    125 
    126         SetConfigValue(mediaPath_s, defaultMediaPath)
     138        SetConfigValue(mediaPathString_, Core::getMediaPathPOSIXString())
    127139            .description("Relative path to the game data.").callback(this, &Core::mediaPathChanged);
    128 
    129140    }
    130141
    … …  
    162173    void Core::mediaPathChanged()
    163174    {
    164         if (mediaPath_s != "" && mediaPath_s[mediaPath_s.size() - 1] != '/')
    165         {
    166             ModifyConfigValue(mediaPath_s, set, mediaPath_s + "/");
    167         }
    168 
    169         if (mediaPath_s == "")
    170         {
    171             ModifyConfigValue(mediaPath_s, set, "/");
    172             COUT(2) << "Warning: Data path set to \"/\", is that really correct?" << std::endl;
    173         }
     175        mediaPath_g = boost::filesystem::path(this->mediaPathString_);
    174176    }
    175177
    … …  
    248250    void Core::_tsetMediaPath(const std::string& path)
    249251    {
    250         if (*path.end() != '/' && *path.end() != '\\')
    251         {
    252             ModifyConfigValue(mediaPath_s, tset, path + "/");
    253         }
    254         else
    255         {
    256             ModifyConfigValue(mediaPath_s, tset, path);
    257         }
     252        ModifyConfigValue(mediaPathString_, tset, path);
     253    }
     254
     255    /*static*/ const boost::filesystem::path& Core::getMediaPath()
     256    {
     257        return mediaPath_g;
     258    }
     259    /*static*/ std::string Core::getMediaPathString()
     260    {
     261        return mediaPath_g.directory_string() + CP_SLASH;
     262    }
     263    /*static*/ std::string Core::getMediaPathPOSIXString()
     264    {
     265        return mediaPath_g.string() + '/';
     266       
     267    }
     268
     269    /*static*/ const boost::filesystem::path& Core::getConfigPath()
     270    {
     271        return configPath_g;
     272    }
     273    /*static*/ std::string Core::getConfigPathString()
     274    {
     275        return configPath_g.directory_string() + CP_SLASH;
     276    }
     277    /*static*/ std::string Core::getConfigPathPOSIXString()
     278    {
     279        return configPath_g.string() + '/';
     280    }
     281
     282    /*static*/ const boost::filesystem::path& Core::getLogPath()
     283    {
     284        return logPath_g;
     285    }
     286    /*static*/ std::string Core::getLogPathString()
     287    {
     288        return logPath_g.directory_string() + CP_SLASH;
     289    }
     290    /*static*/ std::string Core::getLogPathPOSIXString()
     291    {
     292        return logPath_g.string() + '/';
    258293    }
    259294
    … …  
    271306    /**
    272307    @brief
    273         Checks for "orxonox_dev_build.keep_me" in the working diretory.
     308        Performs the rather lower level operations just after
     309        int main() has been called.
     310    @remarks
     311        This gets called AFTER pre-main stuff like AddFactory,
     312        SetConsoleCommand, etc.
     313    */
     314    /*static*/ void Core::postMainInitialisation()
     315    {
     316        // set location of the executable
     317        Core::setExecutablePath();
     318
     319        // Determine whether we have an installed or a binary dir run
     320        // The latter occurs when simply running from the build directory
     321        Core::checkDevBuild();
     322
     323        // Make sure the directories we write in exist or else make them
     324        Core::createDirectories();
     325    }
     326
     327    /**
     328    @brief
     329        Compares the executable path with the working directory
     330    */
     331    /*static*/ void Core::setExecutablePath()
     332    {
     333#ifdef ORXONOX_PLATFORM_WINDOWS
     334        // get executable module
     335        TCHAR buffer[1024];
     336        if (GetModuleFileName(NULL, buffer, 1024) == 0)
     337            ThrowException(General, "Could not retrieve executable path.");
     338
     339#elif defined(ORXONOX_PLATFORM_APPLE)
     340        char buffer[1024];
     341        unsigned long path_len = 1023;
     342        if (_NSGetExecutablePath(buffer, &path_len))
     343            ThrowException(General, "Could not retrieve executable path.");
     344
     345#else /* Linux */
     346        /* written by Nicolai Haehnle <prefect_@gmx.net> */
     347
     348        /* Get our PID and build the name of the link in /proc */
     349        char linkname[64]; /* /proc/<pid>/exe */
     350        if (snprintf(linkname, sizeof(linkname), "/proc/%i/exe", getpid()) < 0)
     351        {
     352            /* This should only happen on large word systems. I'm not sure
     353               what the proper response is here.
     354               Since it really is an assert-like condition, aborting the
     355               program seems to be in order. */
     356            assert(false);
     357        }
     358
     359        /* Now read the symbolic link */
     360        char buffer[1024];
     361        int ret;
     362        ret = readlink(linkname, buffer, 1024);
     363        /* In case of an error, leave the handling up to the caller */
     364        if (ret == -1)
     365            ThrowException(General, "Could not retrieve executable path.");
     366
     367        /* Ensure proper NUL termination */
     368        buf[ret] = 0;
     369#endif
     370
     371        executablePath_g = boost::filesystem::path(buffer);
     372#ifndef ORXONOX_PLATFORM_APPLE
     373        executablePath_g = executablePath_g.branch_path(); // remove executable name
     374#endif
     375    }
     376
     377    /**
     378    @brief
     379        Checks for "orxonox_dev_build.keep_me" in the executable diretory.
    274380        If found it means that this is not an installed run, hence we
    275381        don't write the logs and config files to ~/.orxonox
    … …  
    277383    /*static*/ void Core::checkDevBuild()
    278384    {
    279         std::ifstream probe;
    280         probe.open("orxonox_dev_build.keep_me");
    281         if (probe)
    282         {
     385        if (boost::filesystem::exists(executablePath_g / "orxonox_dev_build.keep_me"))
     386        {
     387            COUT(1) << "Running from the build tree." << std::endl;
    283388            Core::isDevBuild_s = true;
    284             // Constants are taken from OrxonoxConfig.h
    285             Core::configPath_s = ORXONOX_CONFIG_DEV_PATH;
    286             Core::logPath_s    = ORXONOX_LOG_DEV_PATH;
    287             Core::mediaPath_s  = ORXONOX_MEDIA_DEV_PATH;
    288             probe.close();
     389            mediaPath_g  = ORXONOX_MEDIA_DEV_PATH;
     390            configPath_g = ORXONOX_CONFIG_DEV_PATH;
     391            logPath_g    = ORXONOX_LOG_DEV_PATH;
     392        }
     393        else
     394        {
     395#ifdef INSTALL_COPYABLE // --> relative paths
     396            // Also set the root path
     397            boost::filesystem::path relativeExecutablePath(ORXONOX_RUNTIME_INSTALL_PATH);
     398            rootPath_g = executablePath_g;
     399            while (!boost::filesystem::equivalent(rootPath_g / relativeExecutablePath, executablePath_g) || rootPath_g.empty())
     400                rootPath_g = rootPath_g.branch_path();
     401            if (rootPath_g.empty())
     402                ThrowException(General, "Could not derive a root directory. Might the binary installation directory contain '..' when taken relative to the installation prefix path?");
     403
     404            // Using paths relative to the install prefix, complete them
     405            mediaPath_g  = rootPath_g / ORXONOX_MEDIA_INSTALL_PATH;
     406            configPath_g = rootPath_g / ORXONOX_CONFIG_INSTALL_PATH;
     407            logPath_g    = rootPath_g / ORXONOX_LOG_INSTALL_PATH;
     408#else
     409            // There is no root path, so don't set it at all
     410
     411            mediaPath_g  = ORXONOX_MEDIA_INSTALL_PATH;
     412
     413            // Get user directory
     414#  ifdef ORXONOX_PLATFORM_UNIX /* Apple? */
     415            char* userDataPathPtr(getenv("HOME"));
     416#  else
     417            char* userDataPathPtr(getenv("APPDATA"));
     418#  endif
     419            if (userDataPathPtr == NULL)
     420                ThrowException(General, "Could not retrieve user data path.");
     421            boost::filesystem::path userDataPath(userDataPathPtr);
     422            userDataPath /= ".orxonox";
     423
     424            configPath_g = userDataPath / ORXONOX_CONFIG_INSTALL_PATH;
     425            logPath_g    = userDataPath / ORXONOX_LOG_INSTALL_PATH;
     426#endif
    289427        }
    290428    }
    … …  
    299437        std::vector<std::pair<boost::filesystem::path, std::string> > directories;
    300438        directories.push_back(std::pair<boost::filesystem::path, std::string>
    301             (boost::filesystem::path(Core::configPath_s), "config"));
     439            (boost::filesystem::path(configPath_g), "config"));
    302440        directories.push_back(std::pair<boost::filesystem::path, std::string>
    303             (boost::filesystem::path(Core::logPath_s),    "log"));
     441            (boost::filesystem::path(logPath_g),    "log"));
    304442
    305443        for (std::vector<std::pair<boost::filesystem::path, std::string> >::iterator it = directories.begin();

  • code/branches/buildsystem3/src/core/Core.h

    r2690 r2702  
    4444#include "util/OutputHandler.h"
    4545
    46 // Only allow main to access setDevBuild, so we need a forward declaration
     46// Only allow main to access postMainInitialisation, so we need a forward declaration
    4747int main(int, char**);
     48// boost::filesystem header has quite a large tail, use forward declaration
     49namespace boost { namespace filesystem
     50{
     51    struct path_traits;
     52    template<class String, class Traits> class basic_path;
     53    typedef basic_path< std::string, path_traits> path;
     54} }
    4855
    4956namespace orxonox
    … …  
    7077            static void tsetMediaPath(const std::string& path)
    7178            { assert(singletonRef_s); singletonRef_s->_tsetMediaPath(path); }
    72             static const std::string& getMediaPath()  { return mediaPath_s; }
    73             static const std::string& getConfigPath() { return configPath_s; }
    74             static const std::string& getLogPath()    { return logPath_s; }
     79            static const boost::filesystem::path& getMediaPath();
     80            static const boost::filesystem::path& getConfigPath();
     81            static const boost::filesystem::path& getLogPath();
     82            static std::string getMediaPathString();
     83            static std::string getConfigPathString();
     84            static std::string getLogPathString();
     85            static std::string getMediaPathPOSIXString();
     86            static std::string getConfigPathPOSIXString();
     87            static std::string getLogPathPOSIXString();
    7588
    7689            // fast access global variables.
    … …  
    95108            void _tsetMediaPath(const std::string& path);
    96109
     110            static void postMainInitialisation();
     111            static void checkDevBuild();
     112            static void setExecutablePath();
    97113            static void createDirectories();
    98             static void checkDevBuild();
    99114
    100115            int softDebugLevel_;                            //!< The debug level
    … …  
    104119            std::string language_;                          //!< The language
    105120            bool bInitializeRandomNumberGenerator_;         //!< If true, srand(time(0)) is called
     121            std::string mediaPathString_;                   //!< Path to the data/media file folder as string
    106122
    107123            static bool bShowsGraphics_s;                   //!< global variable that tells whether to show graphics
    … …  
    112128
    113129            static bool isDevBuild_s;                       //!< True for builds in the build directory (not installed)
    114             static std::string configPath_s;                //!< Path to the config file folder
    115             static std::string logPath_s;                   //!< Path to the log file folder
    116             static std::string mediaPath_s;                 //!< Path to the data/media file folder
    117130
    118131            static Core* singletonRef_s;

  • code/branches/buildsystem3/src/core/Language.cc

    r2687 r2702  
    206206        COUT(4) << "Read default language file." << std::endl;
    207207
    208         boost::filesystem::path folder(Core::getConfigPath());
    209         boost::filesystem::path filepath(folder/getFilename(this->defaultLanguage_));
     208        boost::filesystem::path filepath(Core::getConfigPath() / getFilename(this->defaultLanguage_));
    210209
    211210        // This creates the file if it's not existing
    … …  
    258257        COUT(4) << "Read translated language file (" << Core::getLanguage() << ")." << std::endl;
    259258
    260         boost::filesystem::path folder(Core::getConfigPath());
    261         boost::filesystem::path filepath(folder/getFilename(Core::getLanguage()));
     259        boost::filesystem::path filepath(Core::getConfigPath() / getFilename(Core::getLanguage()));
    262260
    263261        // Open the file
    … …  
    315313        COUT(4) << "Language: Write default language file." << std::endl;
    316314
    317         boost::filesystem::path folder(Core::getConfigPath());
    318         boost::filesystem::path filepath(folder/getFilename(this->defaultLanguage_));
     315        boost::filesystem::path filepath(Core::getConfigPath() / getFilename(this->defaultLanguage_));
    319316
    320317        // Open the file

  • code/branches/buildsystem3/src/core/LuaBind.cc

    r2687 r2702  
    5353    LuaBind::singletonRef_s = this;
    5454
    55     this->includePath_ = Core::getMediaPath();
     55    this->includePath_ = Core::getMediaPathPOSIXString();
    5656
    5757    luaState_ = lua_open();

  • code/branches/buildsystem3/src/core/TclBind.cc

    r1792 r2702  
    6262    void TclBind::setDataPath(const std::string& datapath)
    6363    {
    64         this->tclLibPath_ = datapath + "/tcl" + TCL_VERSION + "/";
     64        // String has POSIX slashes
     65        this->tclLibPath_ = datapath + "tcl" + TCL_VERSION + '/';
    6566        this->bSetTclLibPath_ = true;
    6667

  • code/branches/buildsystem3/src/orxonox/Main.cc

    r2690 r2702  
    9292    using namespace orxonox;
    9393
    94     // First, determine whether we have an installed or a binary dir run
    95     // The latter occurs when simply running from the build directory
    96     Core::checkDevBuild();
    97 
    98     // Make sure the directories we write in exist or else make them
    99     Core::createDirectories();
     94    Core::postMainInitialisation();
    10095
    10196    // create a signal handler (only active for linux)
    10297    SignalHandler signalHandler;
    103     signalHandler.doCatch(argv[0], Core::getLogPath() + "orxonox_crash.log");
     98    signalHandler.doCatch(argv[0], Core::getLogPathString() + "orxonox_crash.log");
    10499
    105100    // Parse command line arguments

  • code/branches/buildsystem3/src/orxonox/gamestates/GSGraphics.cc

    r2699 r2702  
    4545#include <OgreWindowEventUtilities.h>
    4646
     47#include "SpecialConfig.h"
    4748#include "util/Debug.h"
    4849#include "util/Exception.h"
    … …  
    135136        // load debug overlay
    136137        COUT(3) << "Loading Debug Overlay..." << std::endl;
    137         this->debugOverlay_ = new XMLFile(Core::getMediaPath() + "overlay/debug.oxo");
     138        this->debugOverlay_ = new XMLFile((Core::getMediaPath() / "overlay" / "debug.oxo").file_string());
    138139        Loader::open(debugOverlay_);
    139140
    … …  
    293294        }
    294295
    295         boost::filesystem::path ogreConfigFilepath(Core::getConfigPath());
    296         ogreConfigFilepath /= this->ogreConfigFile_;
    297         boost::filesystem::path ogreLogFilepath(Core::getLogPath());
    298         ogreLogFilepath /= this->ogreLogFile_;
     296        boost::filesystem::path ogreConfigFilepath(Core::getConfigPath() / this->ogreConfigFile_);
     297        boost::filesystem::path ogreLogFilepath(Core::getLogPath() / this->ogreLogFile_);
    299298
    300299        // create a new logManager
    … …  
    357356        try
    358357        {
    359             cf.load(Core::getMediaPath() + resourceFile_);
     358            cf.load((Core::getMediaPath() / resourceFile_).file_string());
    360359        }
    361360        catch (...)
    … …  
    383382
    384383                    Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
    385                         std::string(Core::getMediaPath() + archName), typeName, secName);
     384                        (Core::getMediaPath() / archName).directory_string(), typeName, secName);
    386385                }
    387386            }

  • code/branches/buildsystem3/src/orxonox/gamestates/GSLevel.cc

    r2690 r2702  
    202202        std::string levelName;
    203203        CommandLine::getValue("level", &levelName);
    204         startFile_ = new XMLFile(Core::getMediaPath() + std::string("levels/") + levelName);
     204        startFile_ = new XMLFile(Core::getMediaPathString() + "levels" + CP_SLASH + levelName);
    205205        Loader::open(startFile_);
    206206    }

  • code/branches/buildsystem3/src/orxonox/gamestates/GSRoot.cc

    r2693 r2702  
    111111
    112112        // initialise TCL
    113         this->tclBind_ = new TclBind(Core::getMediaPath());
     113        this->tclBind_ = new TclBind(Core::getMediaPathPOSIXString());
    114114        this->tclThreadManager_ = new TclThreadManager(tclBind_->getTclInterpreter());
    115115

  • code/branches/buildsystem3/src/orxonox/gui/GUIManager.cc

    r2687 r2702  
    4242#include <CEGUIDefaultLogger.h>
    4343#include <ogreceguirenderer/OgreCEGUIRenderer.h>
     44#include "SpecialConfig.h" // Configures the macro below
    4445#ifdef CEGUILUA_USE_INTERNAL_LIBRARY
    4546#   include <ceguilua/CEGUILua.h>
    … …  
    151152
    152153                // Create our own logger to specify the filepath
    153                 boost::filesystem::path ceguiLogFilepath(Core::getLogPath() + "cegui.log");
     154                boost::filesystem::path ceguiLogFilepath(Core::getLogPath() / "cegui.log");
    154155                this->ceguiLogger_ = new DefaultLogger();
    155156                this->ceguiLogger_->setLogFilename(ceguiLogFilepath.file_string());

  • code/branches/buildsystem3/src/orxonox/objects/Level.cc

    r2685 r2702  
    5555        this->xmlfilename_ = this->getFilename();
    5656
    57         if (this->xmlfilename_.length() >= Core::getMediaPath().length())
    58             this->xmlfilename_ = this->xmlfilename_.substr(Core::getMediaPath().length());
     57        if (this->xmlfilename_.length() >= Core::getMediaPathString().length())
     58            this->xmlfilename_ = this->xmlfilename_.substr(Core::getMediaPathString().length());
    5959    }
    6060
    … …  
    9797        mask.include(Class(OverlayGroup)); // HACK to include the ChatOverlay
    9898
    99         this->xmlfile_ = new XMLFile(Core::getMediaPath() + this->xmlfilename_, mask);
     99        this->xmlfile_ = new XMLFile(Core::getMediaPathString() + this->xmlfilename_, mask);
    100100
    101101        Loader::open(this->xmlfile_);

  • code/branches/buildsystem3/src/util/CMakeLists.txt

    r2664 r2702  
    5757  ${CMAKE_BINARY_DIR}/src/OrxonoxConfig.h
    5858  ${CMAKE_SOURCE_DIR}/src/OrxonoxConfig.h.in
     59  ${CMAKE_BINARY_DIR}/src/SpecialConfig.h
     60  ${CMAKE_SOURCE_DIR}/src/SpecialConfig.h.in
    5961)
    6062SOURCE_GROUP("" FILES
    6163  ${CMAKE_BINARY_DIR}/src/OrxonoxConfig.h
    6264  ${CMAKE_SOURCE_DIR}/src/OrxonoxConfig.h.in
     65  ${CMAKE_BINARY_DIR}/src/SpecialConfig.h
     66  ${CMAKE_SOURCE_DIR}/src/SpecialConfig.h.in
    6367)
    6468
Note: See TracChangeset for help on using the changeset viewer.