Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 6040 for sandbox_light


Ignore:
Timestamp:
Nov 5, 2009, 10:15:05 PM (15 years ago)
Author:
rgrieder
Message:

Also synchronised sandbox_light with current trunk.

Location:
sandbox_light
Files:
4 deleted
25 edited
6 copied

Legend:

Unmodified
Added
Removed

  • sandbox_light

  • sandbox_light/bin/vld.ini.in

    r3196 r6040  
    5656;   Default: None.
    5757;
    58 ForceIncludeModules =
     58ForceIncludeModules = boost_date_time-vc80-mt-gd-1_39.dll, boost_filesystem-vc80-mt-gd-1_39.dll, boost_system-vc80-mt-gd-1_39.dll, boost_thread-vc80-mt-gd-1_39.dll, enet_d.dll, lua_d.dll, ogg_d.dll, vorbis_d.dll, vorbifile_d.dll
    5959
    6060; Maximum number of data bytes to display for each leaked block. If zero, then
    … …  
    6666;   Default: 4294967295
    6767;
    68 MaxDataDump =
     68MaxDataDump = 0
    6969
    7070; Maximum number of call stack frames to trace back during leak detection.

  • sandbox_light/cmake/CompilerConfigMSVC.cmake

    r5695 r6040  
    7070
    7171# Overwrite CMake default flags here.
    72 SET_COMPILER_FLAGS("-MDd -Od -Zi -D_DEBUG -Gm -RTC1" Debug          CACHE)
    73 SET_COMPILER_FLAGS("-MD  -O2     -DNDEBUG -MP2"      Release        CACHE)
    74 SET_COMPILER_FLAGS("-MD  -O2 -Zi -DNDEBUG -MP2"      RelWithDebInfo CACHE)
    75 SET_COMPILER_FLAGS("-MD  -O1     -DNDEBUG -MP2"      MinSizeRel     CACHE)
     72SET_COMPILER_FLAGS("-MDd -Od -Zi -D_DEBUG -MP2 -RTC1" Debug          CACHE)
     73SET_COMPILER_FLAGS("-MD  -O2     -DNDEBUG -MP2"       Release        CACHE)
     74SET_COMPILER_FLAGS("-MD  -O2 -Zi -DNDEBUG -MP2"       RelWithDebInfo CACHE)
     75SET_COMPILER_FLAGS("-MD  -O1     -DNDEBUG -MP2"       MinSizeRel     CACHE)
    7676
    7777# Use Link time code generation for Release config if ORXONOX_RELEASE is defined

  • sandbox_light/cmake/LibraryConfig.cmake

    r5789 r6040  
    8888##### Boost #####
    8989# Expand the next statement if newer boost versions than 1.36.1 are released
    90 SET(Boost_ADDITIONAL_VERSIONS 1.37 1.37.0 1.38 1.38.0 1.39 1.39.0)
     90SET(Boost_ADDITIONAL_VERSIONS 1.37 1.37.0 1.38 1.38.0 1.39 1.39.0 1.40 1.40.0)
    9191FIND_PACKAGE(Boost 1.35 REQUIRED thread filesystem system date_time)
    9292# No auto linking, so this option is useless anyway

  • sandbox_light/cmake/PackageConfig.cmake

    r5789 r6040  
    2626
    2727# Check package version info
    28 # MAJOR: Interface breaking change somewhere (library version changed, etc.)
    29 # MINOR: Bug fix or small conformant changes
    30 SET(DEPENDENCY_VERSION_REQUIRED 3)
     28# MAJOR: Breaking change
     29# MINOR: No breaking changes by the dependency package
     30#        For example any code running on 3.0 should still run on 3.1
     31#        But you can specify that the code only runs on 3.1 and higher
     32#        or 4.0 and higher (so both 3.1 and 4.0 will work).
     33SET(ALLOWED_MINIMUM_VERSIONS 3.1 4.0)
     34
    3135IF(NOT EXISTS ${DEPENDENCY_PACKAGE_DIR}/version.txt)
    3236  SET(DEPENDENCY_VERSION 1.0)
    … …  
    4448
    4549INCLUDE(CompareVersionStrings)
    46 COMPARE_VERSION_STRINGS(${DEPENDENCY_VERSION} ${DEPENDENCY_VERSION_REQUIRED} _result TRUE)
    47 IF(NOT _result EQUAL 0)
     50SET(_version_match FALSE)
     51FOREACH(_version ${ALLOWED_MINIMUM_VERSIONS})
     52  # Get major version
     53  STRING(REGEX REPLACE "^([0-9]+)\\..*$" "\\1" _major_version "${_version}")
     54  COMPARE_VERSION_STRINGS(${DEPENDENCY_VERSION} ${_major_version} _result TRUE)
     55  IF(_result EQUAL 0)
     56    COMPARE_VERSION_STRINGS(${DEPENDENCY_VERSION} ${_version} _result FALSE)
     57    IF(NOT _result LESS 0)
     58      SET(_version_match TRUE)
     59    ENDIF()
     60  ENDIF()
     61ENDFOREACH(_version)
     62IF(NOT _version_match)
    4863  MESSAGE(FATAL_ERROR "Your dependency package version is ${DEPENDENCY_VERSION}\n"
    49           "Required version: ${DEPENDENCY_VERSION_REQUIRED}\n"
    50           "You can get a new version from www.orxonox.net")
     64          "Possible required versions: ${ALLOWED_MINIMUM_VERSIONS}\n"
     65          "You can get a new version from www.orxonox.net")
    5166ENDIF()
    5267

  • sandbox_light/cmake/ParseMacroArguments.cmake

    r5695 r6040  
    3939  # Using LIST(FIND ...) speeds up the process
    4040  SET(_keywords ${_switches} ${_list_names})
     41
     42  # Reset all arguments
     43  FOREACH(_arg ${_switches} ${_list_names})
     44    SET(_arg_${_arg})
     45  ENDFOREACH(_arg)
    4146
    4247  # Parse all the arguments and set the corresponding variable

  • sandbox_light/cmake/PrecompiledHeaderFiles.cmake

    r3251 r6040  
    110110    GET_GCC_COMPILER_FLAGS(${_target_name} _pch_gcc_flags)
    111111    # Make sure we recompile the pch file even if only the flags change
    112     IF(NOT "${_pch_gcc_flags}" STREQUAL "${_INTERNAL_${_target_name}_PCH_GCC_FLAGS}")
     112    IF(NOT "${_pch_gcc_flags}" STREQUAL "${_INTERNAL_${_target_name}_PCH_GCC_FLAGS}" OR NOT EXISTS "${_pch_dep_helper_file}")
    113113      SET(_INTERNAL_${_target_name}_PCH_GCC_FLAGS "${_pch_gcc_flags}" CACHE INTERNAL "")
    114114      FILE(WRITE ${_pch_dep_helper_file} "/* ${_pch_gcc_flags} */")

  • sandbox_light/cmake/SourceFileUtilities.cmake

    r2710 r6040  
    2424 #    [ADD/SET]_SOURCE_FILES - Writes source files to the cache by force and
    2525 #                             adds the current directory.
    26  #    GET_ALL_HEADER_FILES - Finds all header files recursively.
     26 #                             Also compiles multiple source files into a single
     27 #                             one by including them
     28 #                             Use COMPILATION_[BEGIN|END] in
     29 #                             [ADD|SET]_SOURCE_FILES and specify the name of
     30 #                             the new source file after COMPILATION_BEGIN
     31 #    GET_ALL_HEADER_FILES   - Finds all header files recursively.
    2732 #    GENERATE_SOURCE_GROUPS - Set Visual Studio source groups.
    2833 #
    2934
     35FUNCTION(PREPARE_SOURCE_FILES)
     36  SET(_fullpath_sources)
     37  FOREACH(_file ${ARGN})
     38    IF(_file STREQUAL "COMPILATION_BEGIN")
     39      SET(_compile TRUE)
     40      # Next file is the name of the compilation
     41      SET(_get_name TRUE)
     42    ELSEIF(_get_name)
     43      SET(_get_name FALSE)
     44      SET(_compilation_name ${_file})
     45    ELSEIF(_file STREQUAL "COMPILATION_END")
     46      IF(NOT _compilation_name)
     47        MESSAGE(FATAL_ERROR "No name provided for source file compilation")
     48      ENDIF()
     49      IF(NOT DISABLE_COMPILATIONS)
     50        SET(_compilation_file ${CMAKE_CURRENT_BINARY_DIR}/${_compilation_name})
     51        SET(_include_string)
     52        FOREACH(_file2 ${_compilation})
     53          SET(_include_string "${_include_string}#include \"${_file2}\"\n")
     54        ENDFOREACH(_file2)
     55        IF(EXISTS )
     56          FILE(READ ${_compilation_file} _include_string_file)
     57        ENDIF()
     58        IF(NOT _include_string STREQUAL "${_include_string_file}")
     59          FILE(WRITE ${_compilation_file} "${_include_string}")
     60        ENDIF()
     61        LIST(APPEND _fullpath_sources ${_compilation_file})
     62        # MSVC hack that excludes the compilations from the intellisense database
     63        # (There is a bug with the "-" instead of "/". Only works for "Zm#" argument)
     64        IF(MSVC)
     65          SET_SOURCE_FILES_PROPERTIES(${_compilation_file} PROPERTIES COMPILE_FLAGS "-Zm1000")
     66        ENDIF()
     67      ENDIF()
     68      SET(_compilation_name)
     69      SET(_compilation)
     70      SET(_compile FALSE)
     71    ELSE()
     72      # Prefix the full path
     73      GET_SOURCE_FILE_PROPERTY(_filepath ${_file} LOCATION)
     74      LIST(APPEND _fullpath_sources ${_filepath})
     75      IF(_compile AND NOT DISABLE_COMPILATIONS)
     76        LIST(APPEND _compilation ${_filepath})
     77        LIST(APPEND _fullpath_sources "H")
     78      ENDIF()
     79    ENDIF()
     80  ENDFOREACH(_file)
     81  SET(_fullpath_sources ${_fullpath_sources} PARENT_SCOPE)
     82ENDFUNCTION(PREPARE_SOURCE_FILES)
     83
     84
    3085# Adds source files with the full path to a list
    3186FUNCTION(ADD_SOURCE_FILES _varname)
    32   # Prefix the full path
    33   SET(_fullpath_sources)
    34   FOREACH(_file ${ARGN})
    35     GET_SOURCE_FILE_PROPERTY(_filepath ${_file} LOCATION)
    36     LIST(APPEND _fullpath_sources ${_filepath})
    37   ENDFOREACH(_file)
     87  PREPARE_SOURCE_FILES(${ARGN})
    3888  # Write into the cache to avoid variable scoping in subdirs
    3989  SET(${_varname} ${${_varname}} ${_fullpath_sources} CACHE INTERNAL "Do not edit")
    … …  
    4393# Sets source files with the full path
    4494FUNCTION(SET_SOURCE_FILES _varname)
    45   # Prefix the full path
    46   SET(_fullpath_sources)
    47   FOREACH(_file ${ARGN})
    48     GET_SOURCE_FILE_PROPERTY(_filepath ${_file} LOCATION)
    49     LIST(APPEND _fullpath_sources ${_filepath})
    50   ENDFOREACH(_file)
     95  PREPARE_SOURCE_FILES(${ARGN})
    5196  # Write into the cache to avoid variable scoping in subdirs
    5297  SET(${_varname} ${_fullpath_sources} CACHE INTERNAL "Do not edit")
    … …  
    66111    GET_SOURCE_FILE_PROPERTY(_full_filepath ${_file} LOCATION)
    67112    FILE(RELATIVE_PATH _relative_path ${CMAKE_CURRENT_SOURCE_DIR} ${_full_filepath})
    68     GET_FILENAME_COMPONENT(_relative_path ${_relative_path} PATH)
    69     STRING(REPLACE "/" "\\\\" _group_path "${_relative_path}")
    70     SOURCE_GROUP("Source\\${_group_path}" FILES ${_file})
     113    IF(NOT _relative_path MATCHES "^\\.\\.")
     114      GET_FILENAME_COMPONENT(_relative_path ${_relative_path} PATH)
     115      STRING(REPLACE "/" "\\\\" _group_path "${_relative_path}")
     116      SOURCE_GROUP("Source\\${_group_path}" FILES ${_file})
     117    ELSE()
     118      # Has to be a compilation
     119      SOURCE_GROUP("Compilations" FILES ${_file})
     120    ENDIF()
    71121  ENDFOREACH(_file)
    72122

  • sandbox_light/cmake/TargetUtilities.cmake

    r5789 r6040  
    6767ENDIF()
    6868
    69 FUNCTION(ORXONOX_ADD_LIBRARY _target_name)
     69MACRO(ORXONOX_ADD_LIBRARY _target_name)
    7070  TU_ADD_TARGET(${_target_name} LIBRARY "STATIC;SHARED" ${ARGN})
    71 ENDFUNCTION(ORXONOX_ADD_LIBRARY)
    72 
    73 FUNCTION(ORXONOX_ADD_EXECUTABLE _target_name)
     71ENDMACRO(ORXONOX_ADD_LIBRARY)
     72
     73MACRO(ORXONOX_ADD_EXECUTABLE _target_name)
    7474  TU_ADD_TARGET(${_target_name} EXECUTABLE "WIN32" ${ARGN})
    75 ENDFUNCTION(ORXONOX_ADD_EXECUTABLE)
    76 
    77 
    78 FUNCTION(TU_ADD_TARGET _target_name _target_type _additional_switches)
     75ENDMACRO(ORXONOX_ADD_EXECUTABLE)
     76
     77
     78MACRO(TU_ADD_TARGET _target_name _target_type _additional_switches)
    7979  CAPITALISE_NAME(${_target_name} _target_name_capitalised)
    8080
    … …  
    8888
    8989
    90   # GET_HEADER_FILES
     90  # Workaround: Source file properties get lost when leaving a subdirectory
     91  # Therefore an "H" after a file means we have to set it as HEADER_FILE_ONLY
     92  FOREACH(_file ${_arg_SOURCE_FILES})
     93    IF(_file STREQUAL "H")
     94      SET_SOURCE_FILES_PROPERTIES(${_last_file} PROPERTIES HEADER_FILE_ONLY TRUE)
     95    ELSE()
     96      SET(_last_file ${_file})
     97      LIST(APPEND _${_target_name}_source_files ${_file})
     98    ENDIF()
     99  ENDFOREACH(_file)
     100
     101  # Assemble all header files of the library
    91102  IF(_arg_FIND_HEADER_FILES)
    92     GET_ALL_HEADER_FILES(_${target_name}_header_files)
     103    GET_ALL_HEADER_FILES(_${_target_name}_header_files)
    93104  ENDIF()
    94105
    95106  # Remove potential duplicates
    96   SET(_${_target_name}_files ${_${target_name}_header_files} ${_arg_SOURCE_FILES})
     107  SET(_${_target_name}_files ${_${_target_name}_header_files} ${_${_target_name}_source_files})
    97108  LIST(REMOVE_DUPLICATES _${_target_name}_files)
    98109
    … …  
    141152  ENDIF()
    142153
     154  # No warnings needed from third party libraries
     155  IF(_arg_ORXONOX_EXTERNAL)
     156    REMOVE_COMPILER_FLAGS("-W3 -W4" MSVC)
     157    ADD_COMPILER_FLAGS("-w")
     158  ENDIF()
     159
    143160  # Set default linking if required
    144161  IF(NOT _arg_SHARED AND NOT _arg_STATIC)
    … …  
    156173    SET(_arg_STATIC)
    157174  ENDIF()
     175
     176  # Don't compile header files
     177  FOREACH(_file ${_${_target_name}_files})
     178    IF(NOT _file MATCHES "\\.(c|cc|cpp)")
     179      SET_SOURCE_FILES_PROPERTIES(${_file} PROPERTIES HEADER_FILE_ONLY TRUE)
     180    ENDIF()
     181  ENDFOREACH(_file)
     182
     183
    158184
    159185  # Add the library/executable
    … …  
    164190    ADD_EXECUTABLE(${_target_name} ${_arg_WIN32} ${_arg_EXCLUDE_FROM_ALL}
    165191                   ${_${_target_name}_files})
     192  ENDIF()
     193
     194
     195
     196  # Change library prefix to "lib"
     197  IF(MSVC AND ${_target_type} STREQUAL "LIBRARY")
     198    SET_TARGET_PROPERTIES(${_target_name} PROPERTIES
     199      PREFIX "lib"
     200    )
     201  ENDIF()
     202
     203  # MSVC hack to exclude external library sources from the intellisense database
     204  # (IntelliSense stops working when adding "-Zm1000" as compile flag. "/Zm1000"
     205  # would not work because of the slash)
     206  IF(_arg_ORXONOX_EXTERNAL AND MSVC)
     207    SET_TARGET_PROPERTIES(${_target_name} PROPERTIES COMPILE_FLAGS "-Zm1000")
    166208  ENDIF()
    167209
    … …  
    214256  ENDIF()
    215257
    216 ENDFUNCTION(TU_ADD_TARGET)
     258ENDMACRO(TU_ADD_TARGET)
    217259
    218260

  • sandbox_light/data/CMakeLists.txt

    r5789 r6040  
    2424 #
    2525
    26 # For dev runs we've got two data directory. The one from the other repository root folder
     26# For dev runs we've got two data directories. The one from the other repository root folder
    2727# is called EXTERNAL_DATA
    2828SET(DATA_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

  • sandbox_light/doc/api/doxy.config.in

    r3196 r6040  
    140140# explicit @brief command for a brief description.
    141141
    142 JAVADOC_AUTOBRIEF      = NO
     142JAVADOC_AUTOBRIEF      = YES
    143143
    144144# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen

  • sandbox_light/src/Orxonox.cc

    r5752 r6040  
    6363        for (int i = 1; i < argc; ++i)
    6464            strCmdLine += argv[i] + std::string(" ");
     65#endif
    6566
    6667        return orxonox::main(strCmdLine);
    67 #endif
    6868    }
    6969    catch (...)

  • sandbox_light/src/OrxonoxConfig.cmake

    r5695 r6040  
    3838  OPTION(PCH_ENABLE "Global PCH switch" TRUE)
    3939ENDIF()
     40
     41# Global switch to disable multiple file compilations
     42OPTION(DISABLE_COMPILATIONS "Global multi-file compilation switch" FALSE)
    4043
    4144# Use WinMain() or main()?

  • sandbox_light/src/external/ogremath/CMakeLists.txt

    r5789 r6040  
    1818 #
    1919
    20 SET(OGREMATH_SRC_FILES
     20SET_SOURCE_FILES(OGREMATH_SRC_FILES
     21COMPILATION_BEGIN OgreCompilation.cc
    2122  OgreColourValue.cpp
    2223  OgreMath.cpp
    … …  
    2728  OgreVector3.cpp
    2829  OgreVector4.cpp
     30COMPILATION_END
    2931)
    3032
    3133IF(WIN32)
    32   LIST(APPEND OGREMATH_SRC_FILES WIN32/OgreTimer.cpp)
     34  ADD_SOURCE_FILES(OGREMATH_SRC_FILES WIN32/OgreTimer.cpp)
    3335ELSEIF(APPLE)
    34   LIST(APPEND OGREMATH_SRC_FILES OSX/OgreTimer.cpp)
     36  ADD_SOURCE_FILES(OGREMATH_SRC_FILES OSX/OgreTimer.cpp)
    3537ELSEIF(UNIX)
    36   LIST(APPEND OGREMATH_SRC_FILES GLX/OgreTimer.cpp)
     38  ADD_SOURCE_FILES(OGREMATH_SRC_FILES GLX/OgreTimer.cpp)
    3739ENDIF()
    3840

  • sandbox_light/src/external/tolua/CMakeLists.txt

    r5738 r6040  
    2020################### Tolua++ library ###################
    2121
    22 SET(TOLUA++_FILES
     22SET_SOURCE_FILES(TOLUA++_FILES
    2323  tolua_event.h
    2424  tolua++.h
    25 
     25COMPILATION_BEGIN ToluaCompilation.c
    2626  tolua_event.c
    2727  tolua_is.c
    … …  
    2929  tolua_push.c
    3030  tolua_to.c
     31COMPILATION_END
    3132)
    32 GENERATE_SOURCE_GROUPS(${TOLUA++_FILES})
    33 
    34 # No warnings needed from third party libraries
    35 REMOVE_COMPILER_FLAGS("-W3 -W4" MSVC)
    36 ADD_COMPILER_FLAGS("-w")
    3733
    3834ORXONOX_ADD_LIBRARY(tolua++_orxonox

  • sandbox_light/src/libraries/CMakeLists.txt

    r5782 r6040  
    2525################ Sub Directories ################
    2626
     27ADD_SUBDIRECTORY(util)
    2728ADD_SUBDIRECTORY(core)
    28 ADD_SUBDIRECTORY(util)

  • sandbox_light/src/libraries/core/CMakeLists.txt

    r5789 r6040  
    1919
    2020SET_SOURCE_FILES(CORE_SRC_FILES
    21   Clock.cc
    22   CommandLine.cc
     21  CommandLineParser.cc
    2322  Core.cc
    2423  LuaState.cc
     24  PathConfig.cc
    2525)
    2626

  • sandbox_light/src/libraries/core/Core.cc

    r5789 r6040  
    3737
    3838#include <cassert>
    39 #include <fstream>
    40 #include <cstdlib>
    41 #include <cstdio>
    42 #include <boost/version.hpp>
    43 #include <boost/filesystem.hpp>
     39#include <ctime>
     40#include <vector>
    4441
    4542#ifdef ORXONOX_PLATFORM_WINDOWS
    … …  
    5047#  undef min
    5148#  undef max
    52 #elif defined(ORXONOX_PLATFORM_APPLE)
    53 #  include <sys/param.h>
    54 #  include <mach-o/dyld.h>
    55 #else /* Linux */
    56 #  include <sys/types.h>
    57 #  include <unistd.h>
    58 #endif
    59 
    60 #include "SpecialConfig.h"
     49#endif
     50
     51#include "util/Clock.h"
    6152#include "util/Debug.h"
    6253#include "util/Exception.h"
    6354#include "util/SignalHandler.h"
    64 #include "Clock.h"
    65 #include "CommandLine.h"
     55#include "PathConfig.h"
     56#include "CommandLineParser.h"
    6657#include "LuaState.h"
    67 
    68 // Boost 1.36 has some issues with deprecated functions that have been omitted
    69 #if (BOOST_VERSION == 103600)
    70 #  define BOOST_LEAF_FUNCTION filename
    71 #else
    72 #  define BOOST_LEAF_FUNCTION leaf
    73 #endif
    7458
    7559namespace orxonox
    … …  
    7862    Core* Core::singletonPtr_s  = 0;
    7963
    80     SetCommandLineOnlyArgument(writingPathSuffix, "").information("Additional subfolder for config and log files");
    8164    SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
    8265#ifdef ORXONOX_PLATFORM_WINDOWS
    … …  
    151134        int softDebugLevelShell_;                       //!< The debug level for the ingame shell
    152135        bool bInitializeRandomNumberGenerator_;         //!< If true, srand(time(0)) is called
    153 
    154         //! Path to the parent directory of the ones above if program was installed with relativ pahts
    155         boost::filesystem::path rootPath_;
    156         boost::filesystem::path executablePath_;        //!< Path to the executable
    157         boost::filesystem::path dataPath_;              //!< Path to the data file folder
    158         boost::filesystem::path configPath_;            //!< Path to the config file folder
    159         boost::filesystem::path logPath_;               //!< Path to the log file folder
    160136    };
    161137
    … …  
    164140        // Cleanup guard for identifier destruction (incl. XMLPort, configValues, consoleCommands)
    165141        : configuration_(new CoreConfiguration()) // Don't yet create config values!
    166         , bDevRun_(false)
    167142    {
    168143        // Set the hard coded fixed paths
    169         this->setFixedPaths();
     144        this->pathConfig_.reset(new PathConfig());
    170145
    171146        // Parse command line arguments AFTER the modules have been loaded (static code!)
    172         CommandLine::parseCommandLine(cmdLine);
     147        CommandLineParser::parseCommandLine(cmdLine);
    173148
    174149        // Set configurable paths like log, config and media
    175         this->setConfigurablePaths();
     150        this->pathConfig_->setConfigurablePaths();
    176151
    177152        // create a signal handler (only active for linux)
    178153        // This call is placed as soon as possible, but after the directories are set
    179154        this->signalHandler_.reset(new SignalHandler());
    180         this->signalHandler_->doCatch(configuration_->executablePath_.string(), Core::getLogPathString() + "orxonox_crash.log");
     155        this->signalHandler_->doCatch(PathConfig::getExecutablePathString(), PathConfig::getLogPathString() + "orxonox_crash.log");
    181156
    182157        // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% was used
    183         OutputHandler::getOutStream().setLogPath(Core::getLogPathString());
     158        OutputHandler::getOutStream().setLogPath(PathConfig::getLogPathString());
    184159
    185160        // Parse additional options file now that we know its path
    186         CommandLine::parseFile();
     161        CommandLineParser::parseFile();
    187162
    188163#ifdef ORXONOX_PLATFORM_WINDOWS
    … …  
    190165        // do this after ogre has initialised. Somehow Ogre changes the settings again (not through
    191166        // the timer though).
    192         int limitToCPU = CommandLine::getValue("limitToCPU");
     167        int limitToCPU = CommandLineParser::getValue("limitToCPU");
    193168        if (limitToCPU > 0)
    194169            setThreadAffinity(static_cast<unsigned int>(limitToCPU));
    … …  
    250225    }
    251226
    252     /*static*/ const boost::filesystem::path& Core::getDataPath()
    253     {
    254         return getInstance().configuration_->dataPath_;
    255     }
    256     /*static*/ std::string Core::getDataPathString()
    257     {
    258         return getInstance().configuration_->dataPath_.string() + '/';
    259     }
    260 
    261     /*static*/ const boost::filesystem::path& Core::getConfigPath()
    262     {
    263         return getInstance().configuration_->configPath_;
    264     }
    265     /*static*/ std::string Core::getConfigPathString()
    266     {
    267         return getInstance().configuration_->configPath_.string() + '/';
    268     }
    269 
    270     /*static*/ const boost::filesystem::path& Core::getLogPath()
    271     {
    272         return getInstance().configuration_->logPath_;
    273     }
    274     /*static*/ std::string Core::getLogPathString()
    275     {
    276         return getInstance().configuration_->logPath_.string() + '/';
    277     }
    278 
    279     /*static*/ const boost::filesystem::path& Core::getRootPath()
    280     {
    281         return getInstance().configuration_->rootPath_;
    282     }
    283     /*static*/ std::string Core::getRootPathString()
    284     {
    285         return getInstance().configuration_->rootPath_.string() + '/';
    286     }
    287 
    288227    /**
    289228    @note
    … …  
    331270#endif
    332271    }
    333 
    334     /**
    335     @brief
    336         Retrievs the executable path and sets all hard coded fixed path (currently only the module path)
    337         Also checks for "orxonox_dev_build.keep_me" in the executable diretory.
    338         If found it means that this is not an installed run, hence we
    339         don't write the logs and config files to ~/.orxonox
    340     @throw
    341         GeneralException
    342     */
    343     void Core::setFixedPaths()
    344     {
    345         //////////////////////////
    346         // FIND EXECUTABLE PATH //
    347         //////////////////////////
    348 
    349 #ifdef ORXONOX_PLATFORM_WINDOWS
    350         // get executable module
    351         TCHAR buffer[1024];
    352         if (GetModuleFileName(NULL, buffer, 1024) == 0)
    353             ThrowException(General, "Could not retrieve executable path.");
    354 
    355 #elif defined(ORXONOX_PLATFORM_APPLE)
    356         char buffer[1024];
    357         unsigned long path_len = 1023;
    358         if (_NSGetExecutablePath(buffer, &path_len))
    359             ThrowException(General, "Could not retrieve executable path.");
    360 
    361 #else /* Linux */
    362         /* written by Nicolai Haehnle <prefect_@gmx.net> */
    363 
    364         /* Get our PID and build the name of the link in /proc */
    365         char linkname[64]; /* /proc/<pid>/exe */
    366         if (snprintf(linkname, sizeof(linkname), "/proc/%i/exe", getpid()) < 0)
    367         {
    368             /* This should only happen on large word systems. I'm not sure
    369                what the proper response is here.
    370                Since it really is an assert-like condition, aborting the
    371                program seems to be in order. */
    372             assert(false);
    373         }
    374 
    375         /* Now read the symbolic link */
    376         char buffer[1024];
    377         int ret;
    378         ret = readlink(linkname, buffer, 1024);
    379         /* In case of an error, leave the handling up to the caller */
    380         if (ret == -1)
    381             ThrowException(General, "Could not retrieve executable path.");
    382 
    383         /* Ensure proper NUL termination */
    384         buffer[ret] = 0;
    385 #endif
    386 
    387         configuration_->executablePath_ = boost::filesystem::path(buffer);
    388 #ifndef ORXONOX_PLATFORM_APPLE
    389         configuration_->executablePath_ = configuration_->executablePath_.branch_path(); // remove executable name
    390 #endif
    391 
    392         /////////////////////
    393         // SET MODULE PATH //
    394         /////////////////////
    395 
    396         if (boost::filesystem::exists(configuration_->executablePath_ / "orxonox_dev_build.keep_me"))
    397         {
    398             COUT(1) << "Running from the build tree." << std::endl;
    399             Core::bDevRun_ = true;
    400         }
    401         else
    402         {
    403 
    404 #ifdef INSTALL_COPYABLE // --> relative paths
    405 
    406             // Also set the root path
    407             boost::filesystem::path relativeExecutablePath(specialConfig::defaultRuntimePath);
    408             configuration_->rootPath_ = configuration_->executablePath_;
    409             while (!boost::filesystem::equivalent(configuration_->rootPath_ / relativeExecutablePath, configuration_->executablePath_)
    410                    && !configuration_->rootPath_.empty())
    411                 configuration_->rootPath_ = configuration_->rootPath_.branch_path();
    412             if (configuration_->rootPath_.empty())
    413                 ThrowException(General, "Could not derive a root directory. Might the binary installation directory contain '..' when taken relative to the installation prefix path?");
    414 
    415 #endif
    416         }
    417     }
    418 
    419     /**
    420     @brief
    421         Sets config, log and media path and creates folders if necessary.
    422     @throws
    423         GeneralException
    424     */
    425     void Core::setConfigurablePaths()
    426     {
    427         if (Core::isDevelopmentRun())
    428         {
    429             configuration_->dataPath_  = specialConfig::dataDevDirectory;
    430             configuration_->configPath_ = specialConfig::configDevDirectory;
    431             configuration_->logPath_    = specialConfig::logDevDirectory;
    432         }
    433         else
    434         {
    435 
    436 #ifdef INSTALL_COPYABLE // --> relative paths
    437 
    438             // Using paths relative to the install prefix, complete them
    439             configuration_->dataPath_   = configuration_->rootPath_ / specialConfig::defaultDataPath;
    440             configuration_->configPath_ = configuration_->rootPath_ / specialConfig::defaultConfigPath;
    441             configuration_->logPath_    = configuration_->rootPath_ / specialConfig::defaultLogPath;
    442 
    443 #else
    444 
    445             configuration_->dataPath_  = specialConfig::dataInstallDirectory;
    446 
    447             // Get user directory
    448 #  ifdef ORXONOX_PLATFORM_UNIX /* Apple? */
    449             char* userDataPathPtr(getenv("HOME"));
    450 #  else
    451             char* userDataPathPtr(getenv("APPDATA"));
    452 #  endif
    453             if (userDataPathPtr == NULL)
    454                 ThrowException(General, "Could not retrieve user data path.");
    455             boost::filesystem::path userDataPath(userDataPathPtr);
    456             userDataPath /= ".orxonox";
    457 
    458             configuration_->configPath_ = userDataPath / specialConfig::defaultConfigPath;
    459             configuration_->logPath_    = userDataPath / specialConfig::defaultLogPath;
    460 
    461 #endif
    462 
    463         }
    464 
    465         // Option to put all the config and log files in a separate folder
    466         if (!CommandLine::getArgument("writingPathSuffix")->hasDefaultValue())
    467         {
    468             std::string directory(CommandLine::getValue("writingPathSuffix").getString());
    469             configuration_->configPath_ = configuration_->configPath_ / directory;
    470             configuration_->logPath_    = configuration_->logPath_    / directory;
    471         }
    472 
    473         // Create directories to avoid problems when opening files in non existent folders.
    474         std::vector<std::pair<boost::filesystem::path, std::string> > directories;
    475         directories.push_back(std::make_pair(boost::filesystem::path(configuration_->configPath_), "config"));
    476         directories.push_back(std::make_pair(boost::filesystem::path(configuration_->logPath_), "log"));
    477 
    478         for (std::vector<std::pair<boost::filesystem::path, std::string> >::iterator it = directories.begin();
    479             it != directories.end(); ++it)
    480         {
    481             if (boost::filesystem::exists(it->first) && !boost::filesystem::is_directory(it->first))
    482             {
    483                 ThrowException(General, std::string("The ") + it->second + " directory has been preoccupied by a file! \
    484                                          Please remove " + it->first.string());
    485             }
    486             if (boost::filesystem::create_directories(it->first)) // function may not return true at all (bug?)
    487             {
    488                 COUT(4) << "Created " << it->second << " directory" << std::endl;
    489             }
    490         }
    491     }
    492272}

  • sandbox_light/src/libraries/core/Core.h

    r5789 r6040  
    2828 */
    2929
    30 /**
    31 @file
    32 @brief
    33     Declaration of the Core class.
    34 @details
    35     The Core class is a singleton, only used to configure some variables
    36     in the core through the config-file.
    37 */
    38 
    3930#ifndef _Core_H__
    4031#define _Core_H__
    … …  
    5546    @brief
    5647        The Core class is a singleton used to configure the program basics.
    57     @details
    58         The class provides information about the data, config and log path.
    59         It determines those by the use of platform specific functions.
    6048    @remark
    6149        You should only create this singleton once because it destroys the identifiers!
    … …  
    8270            static void  setSoftDebugLevel(OutputHandler::OutputDevice device, int level);
    8371
    84             //! Returns the path to the data files as boost::filesystem::path
    85             static const boost::filesystem::path& getDataPath();
    86             //! Returns the path to the config files as boost::filesystem::path
    87             static const boost::filesystem::path& getConfigPath();
    88             //! Returns the path to the log files as boost::filesystem::path
    89             static const boost::filesystem::path& getLogPath();
    90             //! Returns the path to the root folder as boost::filesystem::path
    91             static const boost::filesystem::path& getRootPath();
    92             //! Returns the path to the data files as std::string
    93             static std::string getDataPathString();
    94             //! Returns the path to the config files as std::string
    95             static std::string getConfigPathString();
    96             //! Returns the path to the log files as std::string
    97             static std::string getLogPathString();
    98             //! Returns the path to the root folder as std::string
    99             static std::string getRootPathString();
    100 
    101             static bool isDevelopmentRun() { return getInstance().bDevRun_; }
    102 
    10372        private:
    10473            Core(const Core&); //!< Don't use (undefined symbol)
    10574
    106             void setFixedPaths();
    107             void setConfigurablePaths();
    10875            void setThreadAffinity(int limitToCPU);
    10976
    11077            // Mind the order for the destruction!
     78            scoped_ptr<PathConfig>        pathConfig_;
    11179            scoped_ptr<SignalHandler>     signalHandler_;
    11280            scoped_ptr<CoreConfiguration> configuration_;
    113 
    114             bool                          bDevRun_;             //!< True for runs in the build directory (not installed)
    11581
    11682            static Core* singletonPtr_s;

  • sandbox_light/src/libraries/core/CorePrereqs.h

    r5738 r6040  
    2828
    2929/**
    30   @file
    31   @brief Contains all the necessary forward declarations for all classes and structs.
     30@file
     31@brief
     32    Shared library macros, enums, constants and forward declarations for the core library
    3233*/
    3334
    … …  
    4041// Shared library settings
    4142//-----------------------------------------------------------------------
     43
    4244#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined( CORE_STATIC_BUILD )
    4345#  ifdef CORE_SHARED_BUILD
    … …  
    5658#endif
    5759
    58 
    59 //-----------------------------------------------------------------------
    60 // Forward declarations
    61 //-----------------------------------------------------------------------
     60//-----------------------------------------------------------------------
     61// Constants
     62//-----------------------------------------------------------------------
     63
     64namespace orxonox
     65{
     66    static const uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
     67}
     68
     69//-----------------------------------------------------------------------
     70// Enums
     71//-----------------------------------------------------------------------
     72
    6273namespace orxonox
    6374{
    … …  
    6677        enum Mode
    6778        {
     79            NOP,
    6880            LoadObject,
    6981            SaveObject,
    7082            ExpandObject
    7183        };
    72     }
     84}
    7385
    7486    namespace KeybindMode
    … …  
    8294        };
    8395    };
    84 
     96}
     97
     98//-----------------------------------------------------------------------
     99// Forward declarations
     100//-----------------------------------------------------------------------
     101
     102namespace orxonox
     103{
    85104    typedef std::string LanguageEntryLabel;
    86105
    87106    class ArgumentCompleter;
    88107    class ArgumentCompletionListElement;
    89     class BaseFactory;
    90     class BaseMetaObjectListElement;
    91108    class BaseObject;
    92109    template <class T>
    … …  
    98115    class ClassTreeMaskNode;
    99116    class ClassTreeMaskObjectIterator;
    100     class Clock;
    101117    class CommandEvaluation;
    102     class CommandExecutor;
    103     class CommandLine;
     118    class CommandLineParser;
    104119    class CommandLineArgument;
    105120    class ConfigFile;
    … …  
    109124    class ConfigFileManager;
    110125    class ConfigFileSection;
     126    struct ConfigFileType;
    111127    class ConfigValueContainer;
    112128    class ConsoleCommand;
    … …  
    115131    class DynLibManager;
    116132    struct Event;
    117     class EventContainer;
     133    class EventState;
    118134    class Executor;
    119135    template <class T>
    … …  
    125141    class FunctorMember;
    126142    class FunctorStatic;
     143    class Game;
     144    class GameState;
     145    struct GameStateInfo;
     146    struct GameStateTreeNode;
    127147    class GraphicsManager;
    128148    class GUIManager;
    … …  
    131151    template <class T>
    132152    class Iterator;
    133     class IteratorBase;
    134153    class Language;
    135     class LanguageEntry;
    136     class Loader;
    137154    class LuaState;
    138155    class MemoryArchive;
    … …  
    152169    class OgreWindowEventListener;
    153170    class OrxonoxClass;
     171    class PathConfig;
    154172    struct ResourceInfo;
    155173    class Shell;
    156174    class ShellListener;
    157175    template <class T>
     176    class SmartPtr;
     177    template <class T>
    158178    class SubclassIdentifier;
    159179    class TclBind;
    … …  
    163183    class TclThreadManager;
    164184    class Template;
     185    class Thread;
     186    class ThreadPool;
     187    template <class T>
     188    class WeakPtr;
    165189    class WindowEventListener;
    166190    class XMLFile;
    … …  
    173197    class XMLPortParamContainer;
    174198
    175     // game states
    176     class Game;
    177     class GameState;
    178     struct GameStateInfo;
    179     struct GameStateTreeNode;
    180 
    181     // input
     199    // Input
    182200    class BaseCommand;
    183201    class BufferedParamCommand;
    184202    class Button;
    185     class CalibratorCallback;
    186203    class HalfAxis;
    187204    class InputBuffer;
    … …  
    192209    class InputManager;
    193210    class InputState;
     211    struct InputStatePriority;
     212    class JoyStickQuantityListener;
    194213    class JoyStick;
     214    class KeyBinder;
     215    class KeyBinderManager;
     216    class Keyboard;
     217    class KeyDetector;
     218    class KeyEvent;
    195219    class Mouse;
    196     class Keyboard;
    197     class KeyBinder;
    198     class KeyDetector;
    199220    class ParamCommand;
    200221    class SimpleCommand;
    201 
    202 
    203     // multithreading
    204     class Thread;
    205     class ThreadPool;
    206222}
    207223
    … …  
    282298namespace orxonox
    283299{
    284     using ticpp::Document;
    285300    using ticpp::Element;
    286     using ticpp::Declaration;
    287     using ticpp::StylesheetReference;
    288     using ticpp::Text;
    289     using ticpp::Comment;
    290     using ticpp::Attribute;
    291 }
    292 
     301}
    293302
    294303#endif /* _CorePrereqs_H__ */

  • sandbox_light/src/libraries/core/LuaState.cc

    r5782 r6040  
    3838
    3939#include "util/Debug.h"
    40 #include "Core.h"
     40#include "PathConfig.h"
    4141#include "ToluaBindCore.h"
    4242
    … …  
    106106    shared_ptr<ResourceInfo> LuaState::getFileInfo(const std::string& filename)
    107107    {
    108         boost::filesystem::path filepath = Core::getDataPath() / "lua" / filename;
     108        boost::filesystem::path filepath = PathConfig::getDataPath() / "lua" / filename;
    109109        if (boost::filesystem::exists(filepath))
    110110        {

  • sandbox_light/src/libraries/core/PathConfig.cc

    r6039 r6040  
    7575        : rootPath_(*(new bf::path()))
    7676        , executablePath_(*(new bf::path()))
    77         , modulePath_(*(new bf::path()))
    7877        , dataPath_(*(new bf::path()))
    7978        , configPath_(*(new bf::path()))
    … …  
    136135            COUT(1) << "Running from the build tree." << std::endl;
    137136            PathConfig::bDevRun_ = true;
    138             modulePath_ = specialConfig::moduleDevDirectory;
    139137        }
    140138        else
    … …  
    151149                ThrowException(General, "Could not derive a root directory. Might the binary installation directory contain '..' when taken relative to the installation prefix path?");
    152150
    153             // Module path is fixed as well
    154             modulePath_ = rootPath_ / specialConfig::defaultModulePath;
    155 
    156151#else
    157152
    158153            // There is no root path, so don't set it at all
    159             // Module path is fixed as well
    160             modulePath_ = specialConfig::moduleInstallDirectory;
    161154
    162155#endif
    … …  
    168161        delete &rootPath_;
    169162        delete &executablePath_;
    170         delete &modulePath_;
    171163        delete &dataPath_;
    172164        delete &configPath_;
    … …  
    242234    }
    243235
    244     std::vector<std::string> PathConfig::getModulePaths()
    245     {
    246         std::vector<std::string> modulePaths;
    247 
    248         // We search for helper files with the following extension
    249         std::string moduleextension = specialConfig::moduleExtension;
    250         size_t moduleextensionlength = moduleextension.size();
    251 
    252         // Add that path to the PATH variable in case a module depends on another one
    253         std::string pathVariable = getenv("PATH");
    254         putenv(const_cast<char*>(("PATH=" + pathVariable + ";" + modulePath_.string()).c_str()));
    255 
    256         // Make sure the path exists, otherwise don't load modules
    257         if (!boost::filesystem::exists(modulePath_))
    258             return modulePaths;
    259 
    260         boost::filesystem::directory_iterator file(modulePath_);
    261         boost::filesystem::directory_iterator end;
    262 
    263         // Iterate through all files
    264         while (file != end)
    265         {
    266             std::string filename = file->BOOST_LEAF_FUNCTION();
    267 
    268             // Check if the file ends with the exension in question
    269             if (filename.size() > moduleextensionlength)
    270             {
    271                 if (filename.substr(filename.size() - moduleextensionlength) == moduleextension)
    272                 {
    273                     // We've found a helper file
    274                     std::string library = filename.substr(0, filename.size() - moduleextensionlength);
    275                     modulePaths.push_back((modulePath_ / library).file_string());
    276                 }
    277             }
    278             ++file;
    279         }
    280 
    281         return modulePaths;
    282     }
    283 
    284236    /*static*/ std::string PathConfig::getRootPathString()
    285237    {
    … …  
    306258        return getInstance().logPath_.string() + '/';
    307259    }
    308 
    309     /*static*/ std::string PathConfig::getModulePathString()
    310     {
    311         return getInstance().modulePath_.string() + '/';
    312     }
    313260}

  • sandbox_light/src/libraries/core/PathConfig.h

    r6039 r6040  
    4242        The PathConfig class is a singleton used to configure different paths.
    4343    @details
    44         The class provides information about the data, config, log, executable,
    45         root and module path.
     44        The class provides information about the data, config, log, executable
     45        and root path.
    4646        It determines those by the use of platform specific functions.
    4747    @remarks
    … …  
    8383            static const boost::filesystem::path& getLogPath()
    8484                { return getInstance().logPath_; }
    85             //! Returns the path to the modules as boost::filesystem::path
    86             static const boost::filesystem::path& getModulePath()
    87                 { return getInstance().modulePath_; }
    8885
    8986            //! Returns the path to the root folder as std::string
    … …  
    9794            //! Returns the path to the log files as std::string
    9895            static std::string getLogPathString();
    99             //! Returns the path to the modules as std::string
    100             static std::string getModulePathString();
    10196
    10297            //! Return trrue for runs in the build directory (not installed)
    … …  
    113108            */
    114109            void setConfigurablePaths();
    115             //! Returns a list with all modules declared by a *.module file in the module folder.
    116             std::vector<std::string> getModulePaths();
    117110
    118111            //! Path to the parent directory of the ones above if program was installed with relativ paths
    119112            boost::filesystem::path& rootPath_;
    120113            boost::filesystem::path& executablePath_;        //!< Path to the executable
    121             boost::filesystem::path& modulePath_;            //!< Path to the modules
    122114            boost::filesystem::path& dataPath_;              //!< Path to the data files folder
    123115            boost::filesystem::path& configPath_;            //!< Path to the config files folder

  • sandbox_light/src/libraries/util/CMakeLists.txt

    r5789 r6040  
    1919
    2020SET_SOURCE_FILES(UTIL_SRC_FILES
     21  Clock.cc
    2122  Exception.cc
    2223  Math.cc

  • sandbox_light/src/libraries/util/Clock.cc

    r6039 r6040  
    2828
    2929#include "Clock.h"
    30 #include <OgreTimer.h>
     30#include <ogremath/OgreTimer.h>
    3131
    3232namespace orxonox

  • sandbox_light/src/libraries/util/UtilPrereqs.h

    r5738 r6040  
    2828
    2929/**
    30   @file
    31   @brief Contains all the necessary forward declarations for all classes and structs.
     30@file
     31@brief
     32    Shared library macros, enums, constants and forward declarations for the util library
    3233*/
    3334
    … …  
    4041// Shared library settings
    4142//-----------------------------------------------------------------------
     43
    4244#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined( UTIL_STATIC_BUILD )
    4345#  ifdef UTIL_SHARED_BUILD
    … …  
    5658#endif
    5759
     60//-----------------------------------------------------------------------
     61// Enums
     62//-----------------------------------------------------------------------
     63
     64namespace orxonox
     65{
     66    namespace ScopeID
     67    {
     68        //!A list of available scopes for the Scope template.
     69        enum Value
     70        {
     71            Root,
     72            Graphics
     73        };
     74    }
     75}
    5876
    5977//-----------------------------------------------------------------------
    … …  
    6381namespace orxonox
    6482{
     83    class Clock;
    6584    class Exception;
    6685    class ExprParser;
    … …  
    7190    class OutputBufferListener;
    7291    class OutputHandler;
     92    template <ScopeID::Value>
     93    class Scope;
     94    template <class, ScopeID::Value>
     95    class ScopedSingleton;
     96    class ScopeListener;
    7397    class SignalHandler;
     98    template <class T>
     99    class Singleton;
    74100    class SubString;
    75101}

  • sandbox_light/src/orxonox/Main.cc

    r5789 r6040  
    3131@file
    3232@brief
    33     The main function of Orxonox.
     33    The main function of Orxonox (but not the entry point of the program!)
    3434*/
    3535
    3636#include "OrxonoxPrereqs.h"
    3737
    38 #include "core/CommandLine.h"
     38#include "util/Clock.h"
     39#include "core/CommandLineParser.h"
    3940#include "core/Core.h"
    40 #include "core/Clock.h"
    4141#include "core/LuaState.h"
    4242#include "ToluaBindOrxonox.h"
    … …  
    5353    /**
    5454    @brief
    55         Main method. Game starts here (except for static initialisations).
     55        Starting point of orxonox (however not the entry point of the program!)
    5656    */
    5757    int main(const std::string& strCmdLine)

  • sandbox_light/src/orxonox/OrxonoxPrereqs.h

    r5782 r6040  
    2828
    2929/**
    30   @file
    31   @brief Contains all the necessary forward declarations for all classes and structs.
     30@file
     31@brief
     32    Shared library macros, enums, constants and forward declarations for the orxonox library
    3233*/
    3334
    … …  
    3637
    3738#include "OrxonoxConfig.h"
    38 
    3939//-----------------------------------------------------------------------
    4040// Shared library settings
    4141//-----------------------------------------------------------------------
     42
    4243#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
    4344#  ifdef ORXONOX_SHARED_BUILD
    … …  
    6364{
    6465    class CameraManager;
     66    class Level;
    6567    class LevelManager;
    6668    class PawnManager;
    6769    class PlayerManager;
    68 
    69     class Level;
     70    class Radar;
    7071    class Scene;
    71     class Tickable;
     72
     73    // collisionshapes
     74    class CollisionShape;
     75    class CompoundCollisionShape;
     76    class WorldEntityCollisionShape;
     77
     78    // controllers
     79    class AIController;
     80    class ArtificialController;
     81    class Controller;
     82    class HumanController;
     83    class ScriptController;
     84    class WaypointController;
     85    class WaypointPatrolController;
     86
     87    // gametypes
     88    class Asteroids;
     89    class Deathmatch;
     90    class Gametype;
     91    class TeamBaseMatch;
     92    class TeamDeathmatch;
     93    class UnderAttack;
     94
     95    // graphics
     96    class Backlight;
     97    class Billboard;
     98    class BlinkingBillboard;
     99    class Camera;
     100    class FadingBillboard;
     101    class GlobalShader;
     102    class Light;
     103    class Model;
     104    class ParticleEmitter;
     105    class ParticleSpawner;
     106
     107    // infos
     108    class Bot;
     109    class GametypeInfo;
     110    class HumanPlayer;
     111    class Info;
     112    class PlayerInfo;
    72113
    73114    // interfaces
    74115    class GametypeMessageListener;
    75116    class NotificationListener;
    76     class PawnListener;
    77117    class PlayerTrigger;
    78118    class RadarListener;
    79119    class RadarViewable;
    80120    class Rewardable;
    81     class Teamcolourable;
    82 
    83     // worldentities
    84     class WorldEntity;
    85     class StaticEntity;
    86     class MobileEntity;
    87     class ControllableEntity;
    88     class MovableEntity;
    89 
    90     // graphics
    91     class Model;
    92     class Billboard;
    93     class BlinkingBillboard;
    94     class BigExplosion;
    95     class ExplosionChunk;
    96     class FadingBillboard;
    97     class GlobalShader;
    98     class Light;
    99     class Backlight;
    100     class ParticleEmitter;
    101     class ParticleSpawner;
    102     class Camera;
    103 
    104     // mixed
    105     class SpawnPoint;
    106     class TeamSpawnPoint;
    107 
    108     class CameraPosition;
    109     class Sublevel;
    110     class Radar;
    111 
    112     class Test;
    113 
    114     // pawns
    115     class Spectator;
    116     class Pawn;
    117     class SpaceShip;
    118     class TeamBaseMatchBase;
    119     class Destroyer;
    120 
    121     // gametypes
    122     class Gametype;
    123     class Deathmatch;
    124     class TeamDeathmatch;
    125     class Asteroids;
    126     class TeamBaseMatch;
    127     class UnderAttack;
    128 
    129     // pickups
     121    class TeamColourable;
     122
     123    // items
     124    class Engine;
     125    class Item;
     126    class MultiStateEngine;
     127
     128    // overlays
     129    class InGameConsole;
     130    class Map;
     131    class OrxonoxOverlay;
     132    class OverlayGroup;
     133
     134    // pickup
    130135    class BaseItem;
    131136    class DroppedItem;
    … …  
    137142    class PickupSpawner;
    138143    class UsableItem;
    139 
     144    // pickup, items
     145    class HealthImmediate;
     146    class HealthUsable;
    140147    class Jump;
    141     class HealthUsable;
    142     class PassiveItem;
    143 
    144     // items
    145     class Item;
    146     class Engine;
    147     class MultiStateEngine;
    148     class RotatingEngine;
     148
     149    //sound
     150    class AmbientSound;
     151    class BaseSound;
     152    class SoundManager;
     153    class WorldSound;
    149154
    150155    // weaponsystem
    151     class WeaponSystem;
     156    class DefaultWeaponmodeLink;
     157    class Munition;
     158    class Weapon;
     159    class WeaponMode;
     160    class WeaponPack;
    152161    class WeaponSet;
    153162    class WeaponSlot;
    154     class WeaponPack;
    155     class Weapon;
    156     class WeaponMode;
    157     class DefaultWeaponmodeLink;
    158     class Munition;
    159 
    160     // controller
    161     class Controller;
    162     class HumanController;
    163     class ArtificialController;
    164     class AIController;
    165     class ScriptController;
    166     class WaypointController;
    167     class WaypointPatrolController;
    168 
    169     // infos
    170     class Info;
    171     class PlayerInfo;
    172     class HumanPlayer;
    173     class Bot;
    174     class GametypeInfo;
    175 
    176     // collision
    177     class CollisionShape;
    178     class CompoundCollisionShape;
    179     class WorldEntityCollisionShape;
    180 
    181     // overlays
    182     class OverlayGroup;
    183     class OrxonoxOverlay;
    184     class Notification;
    185     class NotificationManager;
    186     class InGameConsole;
    187     class Map;
    188 
    189     //sound
    190     class SoundBase;
    191     class SoundManager;
    192     class SoundMainMenu;
     163    class WeaponSystem;
     164
     165    // worldentities
     166    class BigExplosion;
     167    class CameraPosition;
     168    class ControllableEntity;
     169    class ExplosionChunk;
     170    class MobileEntity;
     171    class MovableEntity;
     172    class SpawnPoint;
     173    class StaticEntity;
     174    class TeamSpawnPoint;
     175    class WorldEntity;
     176    // worldentities, pawns
     177    class Destroyer;
     178    class Pawn;
     179    class SpaceShip;
     180    class Spectator;
     181    class TeamBaseMatchBase;
    193182}
    194183
Note: See TracChangeset for help on using the changeset viewer.