Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 2702


Ignore:
Timestamp:
Feb 27, 2009, 2:13:29 PM (15 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
Files:
21 edited
1 copied

Legend:

Unmodified
Added
Removed

  • code/branches/buildsystem3/CMakeLists.txt

    r2697 r2702  
    4545ENDIF()
    4646
    47 # Library Config
     47# Library finding
    4848INCLUDE(LibraryConfig)
    4949
    50 # Build Config
     50# General build and compiler options and configurations
    5151INCLUDE(BuildConfig)
    5252
    … …  
    5454ADD_SUBDIRECTORY(media)
    5555
     56# Remaining tardis hack
    5657ADD_SUBDIRECTORY(config)
    57 SET(ORXONOX_LOG_DEV_PATH ${CMAKE_CURRENT_BINARY_DIR})
    5858
    59 # Creates the actual project
     59# Create the actual project
    6060ADD_SUBDIRECTORY(src)
    6161
    62 # Configure the binary output directory
     62# Configure the binary output directory. Do this after src!
    6363ADD_SUBDIRECTORY(bin)
    6464

  • code/branches/buildsystem3/cmake/BuildConfig.cmake

    r2698 r2702  
    2727################# Misc Options ##################
    2828
    29 # Set binary output directories
    30 SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
    31 SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
    32 SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
     29# Standard path suffixes, might not hold everywhere though
     30SET(DEFAULT_RUNTIME_PATH bin)
     31SET(DEFAULT_LIBRARY_PATH lib)
     32SET(DEFAULT_ARCHIVE_PATH lib/static)
     33SET(DEFAULT_DOC_PATH     doc)
     34SET(DEFAULT_MEDIA_PATH   media)
     35SET(DEFAULT_CONFIG_PATH  config)
     36SET(DEFAULT_LOG_PATH     log)
     37
     38# Set output directories
     39SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${DEFAULT_RUNTIME_PATH})
     40SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${DEFAULT_LIBRARY_PATH})
     41SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${DEFAULT_ARCHIVE_PATH})
     42# Do not set doc and media, rather check in the two subdirectories
     43# whether they concur with the DEFAULT_..._PATH
     44SET(CMAKE_CONFIG_OUTPUT_DIRECTORY  ${CMAKE_BINARY_DIR}/${DEFAULT_CONFIG_PATH})
     45SET(CMAKE_LOG_OUTPUT_DIRECTORY     ${CMAKE_BINARY_DIR}/${DEFAULT_LOG_PATH})
    3346
    3447# Take care of some CMake 2.6.0 leftovers
    … …  
    117130############# Installation Settings #############
    118131
     132SET(_info_text "Puts all installed files in subfolders of the install prefix path. That root folder can then be moved, copied and renamed as you wish. The executable will not write to folders like ~/.orxonox or \"Applictation Data\"")
    119133IF(UNIX)
     134  OPTION(INSTALL_COPYABLE "${_info_text}" FALSE)
     135ELSE()
     136  OPTION(INSTALL_COPYABLE "${_info_text}" TRUE)
     137ENDIF()
     138
     139IF(INSTALL_COPYABLE)
     140  # Note the relative paths. They will be resolved at runtime.
     141  # For CMake operations CMAKE_INSTALL_PREFIX is always appended.
     142  SET(ORXONOX_RUNTIME_INSTALL_PATH ${DEFAULT_RUNTIME_PATH})
     143  SET(ORXONOX_LIBRARY_INSTALL_PATH ${DEFAULT_LIBRARY_PATH})
     144  SET(ORXONOX_ARCHIVE_INSTALL_PATH ${DEFAULT_ARCHIVE_PATH})
     145  SET(ORXONOX_DOC_INSTALL_PATH     ${DEFAULT_DOC_PATH})
     146  SET(ORXONOX_MEDIA_INSTALL_PATH   ${DEFAULT_MEDIA_PATH})
     147  SET(ORXONOX_CONFIG_INSTALL_PATH  ${DEFAULT_CONFIG_PATH})
     148  SET(ORXONOX_LOG_INSTALL_PATH     ${DEFAULT_LOG_PATH})
     149
     150ELSEIF(UNIX) # Apple too?
     151  # Using absolute paths
    120152  SET(ORXONOX_RUNTIME_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/bin)
    121153  SET(ORXONOX_LIBRARY_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/lib/orxonox)
    122154  SET(ORXONOX_ARCHIVE_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/lib/orxonox/static)
     155  SET(ORXONOX_DOC_INSTALL_PATH     ${CMAKE_INSTALL_PREFIX}/share/doc/orxonox)
    123156  SET(ORXONOX_MEDIA_INSTALL_PATH   ${CMAKE_INSTALL_PREFIX}/share/orxonox)
    124   SET(ORXONOX_DOC_INSTALL_PATH     ${CMAKE_INSTALL_PREFIX}/share/doc/orxonox)
    125   GET_FILENAME_COMPONENT(USER_DIR ~ ABSOLUTE)
    126   SET(ORXONOX_LOG_INSTALL_PATH     ${USER_DIR}/.orxonox/log)
    127   SET(ORXONOX_CONFIG_INSTALL_PATH  ${USER_DIR}/.orxonox/config)
    128 
    129   # Execution paths, either relative to the binary dir or absolute
    130   # For Windows copy&paste installs relative paths are much better
    131   SET(ORXONOX_MEDIA_INSTALL_PATH_EXEC  ${ORXONOX_MEDIA_INSTALL_PATH})
    132   SET(ORXONOX_CONFIG_INSTALL_PATH_EXEC ${ORXONOX_CONFIG_INSTALL_PATH})
    133   SET(ORXONOX_LOG_INSTALL_PATH_EXEC    ${ORXONOX_LOG_INSTALL_PATH})
     157  # These two paths are user and therefore runtime dependent --> only set relatively
     158  SET(ORXONOX_CONFIG_INSTALL_PATH  ${DEFAULT_CONFIG_PATH})
     159  SET(ORXONOX_LOG_INSTALL_PATH     ${DEFAULT_LOG_PATH})
     160
    134161ELSEIF(WIN32)
    135   SET(ORXONOX_RUNTIME_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/bin)
    136   SET(ORXONOX_LIBRARY_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/lib)
    137   SET(ORXONOX_ARCHIVE_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/lib/static)
    138   SET(ORXONOX_MEDIA_INSTALL_PATH   ${CMAKE_INSTALL_PREFIX}/media)
    139   SET(ORXONOX_DOC_INSTALL_PATH     ${CMAKE_INSTALL_PREFIX}/doc)
    140   SET(ORXONOX_LOG_INSTALL_PATH     ${CMAKE_INSTALL_PREFIX}/log)
    141   SET(ORXONOX_CONFIG_INSTALL_PATH  ${CMAKE_INSTALL_PREFIX}/config)
    142 
    143   # Execution paths, either relative to the binary dir or absolute
    144   # For Windows copy&paste installs relative paths are much better
    145   SET(ORXONOX_MEDIA_INSTALL_PATH_EXEC  ../media)
    146   SET(ORXONOX_CONFIG_INSTALL_PATH_EXEC ../config)
    147   SET(ORXONOX_LOG_INSTALL_PATH_EXEC    ../log)
     162  SET(ORXONOX_RUNTIME_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/${DEFAULT_RUNTIME_PATH})
     163  SET(ORXONOX_LIBRARY_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/${DEFAULT_LIBRARY_PATH})
     164  SET(ORXONOX_ARCHIVE_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/${DEFAULT_ARCHIVE_PATH})
     165  SET(ORXONOX_DOC_INSTALL_PATH     ${CMAKE_INSTALL_PREFIX}/${DEFAULT_DOC_PATH})
     166  SET(ORXONOX_MEDIA_INSTALL_PATH   ${CMAKE_INSTALL_PREFIX}/${DEFAULT_MEDIA_PATH})
     167  # Leave empty because it is user and therefore runtime dependent
     168  SET(ORXONOX_CONFIG_INSTALL_PATH  ${DEFAULT_CONFIG_PATH})
     169  SET(ORXONOX_LOG_INSTALL_PATH     ${DEFAULT_LOG_PATH})
    148170ENDIF()
    149171

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

    r2690 r2702  
    1818 #
    1919 
    20 SET(ORXONOX_CONFIG_DEV_PATH ${CMAKE_CURRENT_BINARY_DIR} PARENT_SCOPE)
    21 
    2220IF(TARDIS)
    2321  # OGRE can't find fonts to display config screen on Tardis,
    2422  # so providing default config file here (bug).
    2523  # Cause: Ogre 1.4.5 was compiled for an older debian version
    26   IF(NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/ogre.cfg)
    27     CONFIGURE_FILE(ogre.cfg ${CMAKE_CURRENT_BINARY_DIR}/ogre.cfg COPYONLY)
     24  IF(NOT EXISTS ${CMAKE_CONFIG_OUTPUT_DIRECTORY}/ogre.cfg)
     25    CONFIGURE_FILE(ogre.cfg ${CMAKE_CONFIG_OUTPUT_DIRECTORY}/ogre.cfg COPYONLY)
    2826  ENDIF()
    2927ENDIF(TARDIS)

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

    r2685 r2702  
    2424 #
    2525
     26# This directory has to concur with the name set in BuildConfig.cmake
     27IF(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}/${DEFAULT_MEDIA_PATH}")
     28  MESSAGE(FATAL_ERROR "Value of DEFAULT_MEDIA_PATH does not concur with the name of the media directory in the source tree")
     29ENDIF()
     30
    2631# Specify media directory
    2732GET_FILENAME_COMPONENT(_search_path_1 ${CMAKE_SOURCE_DIR}/../media ABSOLUTE)
    28 FIND_PATH(ORXONOX_MEDIA_DEV_PATH resources.cfg
     33FIND_PATH(CMAKE_MEDIA_OUTPUT_DIRECTORY resources.cfg
    2934  PATHS
    3035    ${CMAKE_CURRENT_SOURCE_DIR}
    3136    ${_search_path_1}
    3237)
    33 IF(NOT ORXONOX_MEDIA_DEV_PATH)
     38IF(NOT CMAKE_MEDIA_OUTPUT_DIRECTORY)
    3439  MESSAGE(STATUS "Warning: Media directory not found. If you want to compile while downloading the media files, you must specify the directory by Hand BEFORE compiling! Default location is orxonox_root/media")
    3540  # Temporary override to the default location.
    36   SET(ORXONOX_MEDIA_DEV_PATH ${CMAKE_SOURCE_DIR}/media)
    37   SET(ORXONOX_MEDIA_DEV_PATH ${CMAKE_SOURCE_DIR}/media PARENT_SCOPE)
     41  SET(CMAKE_MEDIA_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/media)
     42  SET(CMAKE_MEDIA_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/media PARENT_SCOPE)
    3843ENDIF()
    3944
    … …  
    4954
    5055INSTALL(
    51   DIRECTORY ${ORXONOX_MEDIA_DEV_PATH}/
     56  DIRECTORY ${CMAKE_MEDIA_OUTPUT_DIRECTORY}/
    5257  DESTINATION ${ORXONOX_MEDIA_INSTALL_PATH}
    5358  REGEX "\\.svn$|_svn$|backToPNG|${TCL_EXCLUDE_PATTERN}" EXCLUDE

  • 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.